Index: trunk/nv/core/position.hh =================================================================== --- trunk/nv/core/position.hh (revision 471) +++ trunk/nv/core/position.hh (revision 472) @@ -187,5 +187,5 @@ * @see expand */ - rectangle expanded( int value ) { position p(value,value); return rectangle(ul-p, lr+p); } + rectangle expanded( int value ) const { position p(value,value); return rectangle(ul-p, lr+p); } /** @@ -196,7 +196,7 @@ * @see shrink */ - rectangle shrinked( int value ) { position p(value,value); return rectangle(ul+p, lr-p); } - - rectangle shrinked( dimension value ) { return rectangle(ul+value, lr-value); } + rectangle shrinked( int value ) const { position p(value,value); return rectangle(ul+p, lr-p); } + + rectangle shrinked( dimension value ) const { return rectangle(ul+value, lr-value); } /** Index: trunk/nv/gui/gui_element.hh =================================================================== --- trunk/nv/gui/gui_element.hh (revision 471) +++ trunk/nv/gui/gui_element.hh (revision 472) @@ -31,14 +31,14 @@ // TODO: change to small_vector once implemented! typedef vector< handle > child_list; - shash64 m_id; ///< id type of the object - handle m_parent; ///< pointer to parent - flags m_flags; - child_list m_children; ///< children objects - size_t m_child_count; ///< number of children - shash64 m_class; ///< Class name. - string_buffer m_text; ///< Displayed label or text. - rectangle m_relative; ///< Position relative to parent. - rectangle m_absolute; ///< Position relative to window/screen. - render_data* m_render_data; ///< -?- + shash64 m_id; ///< id type of the object + handle m_parent; ///< pointer to parent + flags m_flags; + child_list m_children; ///< children objects + size_t m_child_count; ///< number of children + shash64 m_class; ///< Class name. + string_buffer m_text; ///< Displayed label or text. + rectangle m_relative; ///< Position relative to parent. + rectangle m_absolute; ///< Position relative to window/screen. + render_data* m_render_data; ///< -?- }; Index: trunk/nv/interface/camera.hh =================================================================== --- trunk/nv/interface/camera.hh (revision 471) +++ trunk/nv/interface/camera.hh (revision 472) @@ -79,8 +79,10 @@ mat4 get_mvp() const { return m_camera.get_projection() * get_modelview(); } - mat4 get_view_inv() const { return math::inverse( get_view() ); } - mat4 get_model_inv() const { return math::inverse( get_model() ); } - mat4 get_modelview_inv() const { return math::inverse( get_modelview() ); } - mat3 get_normal() const { return math::transpose( math::inverse( mat3( get_modelview() ) ) ); } + mat4 get_view_inv() const { return math::inverse( get_view() ); } + mat4 get_model_inv() const { return math::inverse( get_model() ); } + mat4 get_modelview_inv() const { return math::inverse( get_modelview() ); } + mat4 get_projection_inv() const { return math::inverse( get_projection() ); } + mat4 get_mvp_inv() const { return math::inverse( get_mvp() ); } + mat3 get_normal() const { return math::transpose( math::inverse( mat3( get_modelview() ) ) ); } protected: mat4 m_model; Index: trunk/nv/interface/device.hh =================================================================== --- trunk/nv/interface/device.hh (revision 471) +++ trunk/nv/interface/device.hh (revision 472) @@ -281,6 +281,8 @@ factory_map[ "nv_m_modelview_inv" ] = new engine_uniform_factory< engine_uniform_m_modelview_inv >(); factory_map[ "nv_m_projection" ] = new engine_uniform_factory< engine_uniform_m_projection >(); + factory_map[ "nv_m_projection_inv"] = new engine_uniform_factory< engine_uniform_m_projection_inv >(); factory_map[ "nv_m_normal" ] = new engine_uniform_factory< engine_uniform_m_normal >(); factory_map[ "nv_m_mvp" ] = new engine_uniform_factory< engine_uniform_m_mvp >(); + factory_map[ "nv_m_mvp_inv"] = new engine_uniform_factory< engine_uniform_m_mvp_inv >(); factory_map[ "nv_v_camera_position" ] = new engine_uniform_factory< engine_uniform_v_camera_position >(); factory_map[ "nv_v_camera_direction" ] = new engine_uniform_factory< engine_uniform_v_camera_direction >(); Index: trunk/nv/interface/image_data.hh =================================================================== --- trunk/nv/interface/image_data.hh (revision 471) +++ trunk/nv/interface/image_data.hh (revision 472) @@ -31,4 +31,6 @@ BGRA, RED, + R16F, + R32F, DEPTH16, DEPTH24, @@ -54,5 +56,5 @@ const ivec2 get_size() const { return m_size; } // TODO : better depth check (template?) - size_t get_depth() const { return m_format.format == RGB || m_format.format == BGR ? 3 : ( m_format.format == RED ? 1 : 4 ); } + size_t get_depth() const { return m_format.format == RGB || m_format.format == BGR ? 3 : ( m_format.format == RED || m_format.format == R32F || m_format.format == R16F ? 1 : 4 ); } image_format get_format() const { return m_format; } ~image_data() { if (m_data) delete[] m_data; } Index: trunk/nv/interface/uniform.hh =================================================================== --- trunk/nv/interface/uniform.hh (revision 471) +++ trunk/nv/interface/uniform.hh (revision 472) @@ -196,5 +196,5 @@ public: engine_uniform_m_modelview_inv( uniform_base* u ) : engine_uniform( u ) {} - virtual void set( const context*, const scene_state* s ) { m_uniform->set_value( s->get_modelview() ); } + virtual void set( const context*, const scene_state* s ) { m_uniform->set_value( s->get_modelview_inv() ); } }; @@ -206,4 +206,11 @@ }; + class engine_uniform_m_projection_inv : public engine_uniform< mat4 > + { + public: + engine_uniform_m_projection_inv( uniform_base* u ) : engine_uniform( u ) {} + virtual void set( const context*, const scene_state* s ) { m_uniform->set_value( s->get_projection_inv() ); } + }; + class engine_uniform_m_normal : public engine_uniform< mat3 > { @@ -218,4 +225,11 @@ engine_uniform_m_mvp( uniform_base* u ) : engine_uniform( u ) {} virtual void set( const context* , const scene_state* s ) { m_uniform->set_value( s->get_mvp() ); } + }; + + class engine_uniform_m_mvp_inv : public engine_uniform< mat4 > + { + public: + engine_uniform_m_mvp_inv( uniform_base* u ) : engine_uniform( u ) {} + virtual void set( const context*, const scene_state* s ) { m_uniform->set_value( s->get_mvp_inv() ); } }; Index: trunk/nv/stl/algorithm/heap.hh =================================================================== --- trunk/nv/stl/algorithm/heap.hh (revision 471) +++ trunk/nv/stl/algorithm/heap.hh (revision 472) @@ -16,4 +16,5 @@ #include #include +#include #include Index: trunk/nv/stl/functional/hash.hh =================================================================== --- trunk/nv/stl/functional/hash.hh (revision 471) +++ trunk/nv/stl/functional/hash.hh (revision 472) @@ -178,8 +178,8 @@ constexpr bool valid() const { return m_value != 0; } - template < typename H, typename Tag > - friend constexpr bool operator==( hash_value< H, Tag > lhs, hash_value< H, Tag > rhs ); - template < typename H, typename Tag > - friend constexpr bool operator!=( hash_value< H, Tag > lhs, hash_value< H, Tag > rhs ); + template < typename H2, typename Tag2 > + friend constexpr bool operator==( hash_value< H2, Tag2 > lhs, hash_value< H2, Tag2 > rhs ); + template < typename H2, typename Tag2 > + friend constexpr bool operator!=( hash_value< H2, Tag2 > lhs, hash_value< H2, Tag2 > rhs ); constexpr H value() const { return m_value; } Index: trunk/nv/stl/math/matrix_transform.hh =================================================================== --- trunk/nv/stl/math/matrix_transform.hh (revision 471) +++ trunk/nv/stl/math/matrix_transform.hh (revision 472) @@ -40,21 +40,21 @@ tvec3 temp( ( T( 1 ) - c ) * axis ); - tmat4 Rotate( no_init ); - Rotate[0][0] = c + temp[0] * axis[0]; - Rotate[0][1] = 0 + temp[0] * axis[1] + s * axis[2]; - Rotate[0][2] = 0 + temp[0] * axis[2] - s * axis[1]; - - Rotate[1][0] = 0 + temp[1] * axis[0] - s * axis[2]; - Rotate[1][1] = c + temp[1] * axis[1]; - Rotate[1][2] = 0 + temp[1] * axis[2] + s * axis[0]; - - Rotate[2][0] = 0 + temp[2] * axis[0] + s * axis[1]; - Rotate[2][1] = 0 + temp[2] * axis[1] - s * axis[0]; - Rotate[2][2] = c + temp[2] * axis[2]; + tmat4 rmatrix( no_init ); + rmatrix[0][0] = c + temp[0] * axis[0]; + rmatrix[0][1] = 0 + temp[0] * axis[1] + s * axis[2]; + rmatrix[0][2] = 0 + temp[0] * axis[2] - s * axis[1]; + + rmatrix[1][0] = 0 + temp[1] * axis[0] - s * axis[2]; + rmatrix[1][1] = c + temp[1] * axis[1]; + rmatrix[1][2] = 0 + temp[1] * axis[2] + s * axis[0]; + + rmatrix[2][0] = 0 + temp[2] * axis[0] + s * axis[1]; + rmatrix[2][1] = 0 + temp[2] * axis[1] - s * axis[0]; + rmatrix[2][2] = c + temp[2] * axis[2]; 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]; - result[2] = m[0] * Rotate[2][0] + m[1] * Rotate[2][1] + m[2] * Rotate[2][2]; + result[0] = m[0] * rmatrix[0][0] + m[1] * rmatrix[0][1] + m[2] * rmatrix[0][2]; + result[1] = m[0] * rmatrix[1][0] + m[1] * rmatrix[1][1] + m[2] * rmatrix[1][2]; + result[2] = m[0] * rmatrix[2][0] + m[1] * rmatrix[2][1] + m[2] * rmatrix[2][2]; result[3] = m[3]; return result; Index: trunk/nv/stl/memory.hh =================================================================== --- trunk/nv/stl/memory.hh (revision 471) +++ trunk/nv/stl/memory.hh (revision 472) @@ -16,5 +16,5 @@ #define NV_STL_MEMORY_HH -#include +#include #include #include @@ -30,13 +30,4 @@ using constructor_t = void(*)( void* ); using destructor_t = void(*)( void* ); - - - namespace mem_flags - { - static constexpr uint16 is_const = 0x0001; - static constexpr uint16 is_static = 0x0002; - static constexpr uint16 read_only = 0x0004; - static constexpr uint16 temporary = 0x0008; - } template< typename T > Index: trunk/nv/stl/string/short_string.hh =================================================================== --- trunk/nv/stl/string/short_string.hh (revision 471) +++ trunk/nv/stl/string/short_string.hh (revision 472) @@ -23,9 +23,10 @@ typedef string_buffer_base< Storage > this_type; typedef string_base< Storage > base_type; + typedef typename string_base< Storage >::size_type size_type; typedef typename Storage::iterator iterator; typedef typename Storage::const_iterator const_iterator; constexpr string_buffer_base() : base_type() {} - inline string_buffer_base( const char* data, size_t sz ) + inline string_buffer_base( const char* data, size_type sz ) : base_type() { @@ -44,7 +45,9 @@ inline string_buffer_base& operator=( string_buffer_base&& other ) = default; - void assign( const char* data, size_t sz ) - { - clear(); + using Storage::clear; + + void assign( const char* data, size_type sz ) + { + Storage::clear(); append( data, sz ); } @@ -53,32 +56,32 @@ void assign( const T& value ) { - clear(); + Storage::clear(); append( value ); } - size_t append( const char* data, size_t sz ) + size_type append( const char* data, size_type sz ) { if ( !data ) return 0; - size_t pos = size(); - size_t amount = expand_by( sz ); + size_type pos = this->size(); + size_type amount = expand_by( sz ); raw_copy_n( data, amount, this->begin() + pos ); return amount; } - size_t append( const string_twine& twine ) - { - size_t pos = size(); - size_t dump_size = twine.dump_size(); + size_type append( const string_twine& twine ) + { + size_type pos = this->size(); + size_type dump_size = twine.dump_size(); expand_by( dump_size ); - twine.dump( array_ref< char >( data() + pos, size() - pos ) ); - return size() - pos; - } - - size_t append( const_iterator first, const_iterator last ) + twine.dump( array_ref< char >( this->data() + pos, this->size() - pos ) ); + return this->size() - pos; + } + + size_type append( const_iterator first, const_iterator last ) { return append( first, last - first ); } - size_t append( const string_view& s ) + size_type append( const string_view& s ) { return append( s.data(), s.size() ); @@ -86,48 +89,48 @@ template < typename S > - size_t append( const string_base& s ) + size_type append( const string_base& s ) { return append( s.data(), s.size() ); } - size_t append( sint32 s ) + size_type append( sint32 s ) { char buffer[8]; - size_t result = sint32_to_buffer( array_ref< char >( buffer ), s ); - return ( result > 0 ? append( buffer, result ) : 0 ); - } - - size_t append( uint32 u ) + size_type result = sint32_to_buffer( array_ref< char >( buffer ), s ); + return ( result > 0 ? append( buffer, result ) : 0 ); + } + + size_type append( uint32 u ) { char buffer[8]; - size_t result = uint32_to_buffer( array_ref< char >( buffer ), u ); - return ( result > 0 ? append( buffer, result ) : 0 ); - } - - size_t append( sint64 s ) + size_type result = uint32_to_buffer( array_ref< char >( buffer ), u ); + return ( result > 0 ? append( buffer, result ) : 0 ); + } + + size_type append( sint64 s ) { char buffer[16]; - size_t result = sint64_to_buffer( array_ref< char >( buffer ), s ); - return ( result > 0 ? append( buffer, result ) : 0 ); - } - - size_t append( uint64 u ) + size_type result = sint64_to_buffer( array_ref< char >( buffer ), s ); + return ( result > 0 ? append( buffer, result ) : 0 ); + } + + size_type append( uint64 u ) { char buffer[16]; - size_t result = uint64_to_buffer( array_ref< char >( buffer ), u ); - return ( result > 0 ? append( buffer, result ) : 0 ); - } - - size_t append( f32 u ) + size_type result = uint64_to_buffer( array_ref< char >( buffer ), u ); + return ( result > 0 ? append( buffer, result ) : 0 ); + } + + size_type append( f32 f ) { char buffer[64]; - size_t result = uint64_to_buffer( array_ref< char >( buffer ), u ); - return ( result > 0 ? append( buffer, result ) : 0 ); - } - - size_t append( f64 s ) + size_type result = f32_to_buffer( array_ref< char >( buffer ), f ); + return ( result > 0 ? append( buffer, result ) : 0 ); + } + + size_type append( f64 f ) { char buffer[64]; - size_t result = uint64_to_buffer( array_ref< char >( buffer ), u ); + size_type result = f64_to_buffer( array_ref< char >( buffer ), f ); return ( result > 0 ? append( buffer, result ) : 0 ); } @@ -162,12 +165,12 @@ protected: - size_t expand_by( size_t sz ) - { - size_t result = 0; + size_type expand_by( size_type sz ) + { + size_type result = 0; if ( Storage::try_grow( sz, 1 ) ) result = sz; else { - result = capacity() - size() - 1; + result = capacity() - this->size() - 1; Storage::try_resize( capacity() - 1, true, 1 ); } Index: trunk/nv/stl/string/string_base.hh =================================================================== --- trunk/nv/stl/string/string_base.hh (revision 471) +++ trunk/nv/stl/string/string_base.hh (revision 472) @@ -10,4 +10,5 @@ #include #include +#include #include // TODO: /stl/memory/array_ref? Index: trunk/src/gl/gl_enum.cc =================================================================== --- trunk/src/gl/gl_enum.cc (revision 471) +++ trunk/src/gl/gl_enum.cc (revision 472) @@ -187,4 +187,6 @@ case BGRA : return GL_BGRA; case RED : return GL_RED; + case R16F : return GL_RED; + case R32F : return GL_RED; case DEPTH16 : return GL_DEPTH_COMPONENT; case DEPTH24 : return GL_DEPTH_COMPONENT; @@ -206,5 +208,7 @@ case BGR : return GL_RGB8; case BGRA : return GL_RGBA8; - case RED : return 0x8040; // GL_LUMINANCE8; // TODO: change to GL_R8! + case RED : return GL_R8; + case R16F : return GL_R16F; + case R32F : return GL_R32F; case DEPTH16 : return GL_DEPTH_COMPONENT16; case DEPTH24 : return GL_DEPTH_COMPONENT24; Index: trunk/src/gui/gui_gfx_renderer.cc =================================================================== --- trunk/src/gui/gui_gfx_renderer.cc (revision 471) +++ trunk/src/gui/gui_gfx_renderer.cc (revision 472) @@ -12,10 +12,10 @@ static const char *nv_gui_vertex_shader = R"( -#version 120 -attribute vec2 nv_position; -attribute vec2 nv_texcoord; -attribute vec4 nv_color; -varying vec4 v_color; -varying vec2 v_texcoord; +#version 130 +in vec2 nv_position; +in vec2 nv_texcoord; +in vec4 nv_color; +out vec4 v_color; +out vec2 v_texcoord; uniform mat4 nv_m_projection; void main(void) @@ -28,7 +28,7 @@ static const char *nv_gui_fragment_shader = R"( -#version 120 -varying vec4 v_color; -varying vec2 v_texcoord; +#version 130 +in vec4 v_color; +in vec2 v_texcoord; uniform sampler2D nv_t_diffuse; void main(void)