Changeset 472


Ignore:
Timestamp:
09/28/15 12:44:21 (10 years ago)
Author:
epyon
Message:
  • additional uniforms
  • R16F and R32F format support
  • error fixes (clang)
Location:
trunk
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • trunk/nv/core/position.hh

    r454 r472  
    187187                 * @see expand
    188188                 */
    189                 rectangle expanded( int value ) { position p(value,value); return rectangle(ul-p, lr+p); }
     189                rectangle expanded( int value ) const { position p(value,value); return rectangle(ul-p, lr+p); }
    190190
    191191                /**
    … …  
    196196                 * @see shrink
    197197                 */
    198                 rectangle shrinked( int value ) { position p(value,value); return rectangle(ul+p, lr-p); }
    199 
    200                 rectangle shrinked( dimension value ) { return rectangle(ul+value, lr-value); }
     198                rectangle shrinked( int value ) const { position p(value,value); return rectangle(ul+p, lr-p); }
     199
     200                rectangle shrinked( dimension value ) const { return rectangle(ul+value, lr-value); }
    201201
    202202                /**

  • trunk/nv/gui/gui_element.hh

    r442 r472  
    3131                        // TODO: change to small_vector once implemented!
    3232                        typedef vector< handle > child_list;
    33                         shash64 m_id;              ///< id type of the object
    34                         handle    m_parent;          ///< pointer to parent
    35                         flags     m_flags;
    36                         child_list m_children;        ///< children objects
    37                         size_t    m_child_count;     ///< number of children
    38                         shash64    m_class; ///< Class name.
    39                         string_buffer m_text; ///< Displayed label or text.
    40                         rectangle m_relative; ///< Position relative to parent.
    41                         rectangle m_absolute; ///< Position relative to window/screen.
    42                         render_data* m_render_data; ///<   -?-
     33                        shash64       m_id;                   ///< id type of the object
     34                        handle        m_parent;              ///< pointer to parent
     35                        flags         m_flags;
     36                        child_list    m_children;          ///< children objects
     37                        size_t        m_child_count;      ///< number of children
     38                        shash64       m_class;          ///< Class name.
     39                        string_buffer m_text;           ///< Displayed label or text.
     40                        rectangle     m_relative;      ///< Position relative to parent.
     41                        rectangle     m_absolute;    ///< Position relative to window/screen.
     42                        render_data*  m_render_data; ///<   -?-
    4343                };
    4444

  • trunk/nv/interface/camera.hh

    r462 r472  
    7979                mat4 get_mvp()        const { return m_camera.get_projection() * get_modelview(); }
    8080
    81                 mat4 get_view_inv()      const { return math::inverse( get_view() ); }
    82                 mat4 get_model_inv()     const { return math::inverse( get_model() ); }
    83                 mat4 get_modelview_inv() const { return math::inverse( get_modelview() ); }
    84                 mat3 get_normal()        const { return math::transpose( math::inverse( mat3( get_modelview() ) ) ); }
     81                mat4 get_view_inv()       const { return math::inverse( get_view() ); }
     82                mat4 get_model_inv()      const { return math::inverse( get_model() ); }
     83                mat4 get_modelview_inv()  const { return math::inverse( get_modelview() ); }
     84                mat4 get_projection_inv() const { return math::inverse( get_projection() ); }
     85                mat4 get_mvp_inv()        const { return math::inverse( get_mvp() ); }
     86                mat3 get_normal()         const { return math::transpose( math::inverse( mat3( get_modelview() ) ) ); }
    8587        protected:
    8688                mat4   m_model;

  • trunk/nv/interface/device.hh

    r463 r472  
    281281                        factory_map[ "nv_m_modelview_inv" ] = new engine_uniform_factory< engine_uniform_m_modelview_inv >();
    282282                        factory_map[ "nv_m_projection" ]    = new engine_uniform_factory< engine_uniform_m_projection >();
     283                        factory_map[ "nv_m_projection_inv"] = new engine_uniform_factory< engine_uniform_m_projection_inv >();
    283284                        factory_map[ "nv_m_normal" ]        = new engine_uniform_factory< engine_uniform_m_normal >();
    284285                        factory_map[ "nv_m_mvp" ]           = new engine_uniform_factory< engine_uniform_m_mvp >();
     286                        factory_map[ "nv_m_mvp_inv"]        = new engine_uniform_factory< engine_uniform_m_mvp_inv >();
    285287                        factory_map[ "nv_v_camera_position" ]  = new engine_uniform_factory< engine_uniform_v_camera_position >();
    286288                        factory_map[ "nv_v_camera_direction" ] = new engine_uniform_factory< engine_uniform_v_camera_direction >();

  • trunk/nv/interface/image_data.hh

    r462 r472  
    3131                BGRA,
    3232                RED,
     33                R16F,
     34                R32F,
    3335                DEPTH16,
    3436                DEPTH24,
    … …  
    5456                const ivec2 get_size() const { return m_size; }
    5557                // TODO : better depth check (template?)
    56                 size_t get_depth() const { return m_format.format == RGB || m_format.format == BGR ? 3 : ( m_format.format == RED ? 1 : 4 ); }
     58                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 ); }
    5759                image_format get_format() const { return m_format; }
    5860                ~image_data() { if (m_data) delete[] m_data; }

  • trunk/nv/interface/uniform.hh

    r462 r472  
    196196        public:
    197197                engine_uniform_m_modelview_inv( uniform_base* u ) : engine_uniform( u ) {}
    198                 virtual void set( const context*, const scene_state* s ) { m_uniform->set_value( s->get_modelview() ); }
     198                virtual void set( const context*, const scene_state* s ) { m_uniform->set_value( s->get_modelview_inv() ); }
    199199        };
    200200
    … …  
    206206        };
    207207
     208        class engine_uniform_m_projection_inv : public engine_uniform< mat4 >
     209        {
     210        public:
     211                engine_uniform_m_projection_inv( uniform_base* u ) : engine_uniform( u ) {}
     212                virtual void set( const context*, const scene_state* s ) { m_uniform->set_value( s->get_projection_inv() ); }
     213        };
     214
    208215        class engine_uniform_m_normal : public engine_uniform< mat3 >
    209216        {
    … …  
    218225                engine_uniform_m_mvp( uniform_base* u ) : engine_uniform( u ) {}
    219226                virtual void set( const context* , const scene_state* s ) { m_uniform->set_value( s->get_mvp() ); }
     227        };
     228
     229        class engine_uniform_m_mvp_inv : public engine_uniform< mat4 >
     230        {
     231        public:
     232                engine_uniform_m_mvp_inv( uniform_base* u ) : engine_uniform( u ) {}
     233                virtual void set( const context*, const scene_state* s ) { m_uniform->set_value( s->get_mvp_inv() ); }
    220234        };
    221235

  • trunk/nv/stl/algorithm/heap.hh

    r446 r472  
    1616#include <nv/stl/algorithm/common.hh>
    1717#include <nv/stl/utility/common.hh>
     18#include <nv/stl/functional/comparisons.hh>
    1819#include <nv/stl/iterator.hh>
    1920

  • trunk/nv/stl/functional/hash.hh

    r431 r472  
    178178                constexpr bool valid() const { return m_value != 0; }
    179179
    180                 template < typename H, typename Tag >
    181                 friend constexpr bool operator==( hash_value< H, Tag > lhs, hash_value< H, Tag > rhs );
    182                 template < typename H, typename Tag >
    183                 friend constexpr bool operator!=( hash_value< H, Tag > lhs, hash_value< H, Tag > rhs );
     180                template < typename H2, typename Tag2 >
     181                friend constexpr bool operator==( hash_value< H2, Tag2 > lhs, hash_value< H2, Tag2 > rhs );
     182                template < typename H2, typename Tag2 >
     183                friend constexpr bool operator!=( hash_value< H2, Tag2 > lhs, hash_value< H2, Tag2 > rhs );
    184184
    185185                constexpr H value() const { return m_value; }

  • trunk/nv/stl/math/matrix_transform.hh

    r471 r472  
    4040                        tvec3<T> temp( ( T( 1 ) - c ) * axis );
    4141
    42                         tmat4<T> Rotate( no_init );
    43                         Rotate[0][0] = c + temp[0] * axis[0];
    44                         Rotate[0][1] = 0 + temp[0] * axis[1] + s * axis[2];
    45                         Rotate[0][2] = 0 + temp[0] * axis[2] - s * axis[1];
    46 
    47                         Rotate[1][0] = 0 + temp[1] * axis[0] - s * axis[2];
    48                         Rotate[1][1] = c + temp[1] * axis[1];
    49                         Rotate[1][2] = 0 + temp[1] * axis[2] + s * axis[0];
    50 
    51                         Rotate[2][0] = 0 + temp[2] * axis[0] + s * axis[1];
    52                         Rotate[2][1] = 0 + temp[2] * axis[1] - s * axis[0];
    53                         Rotate[2][2] = c + temp[2] * axis[2];
     42                        tmat4<T> rmatrix( no_init );
     43                        rmatrix[0][0] = c + temp[0] * axis[0];
     44                        rmatrix[0][1] = 0 + temp[0] * axis[1] + s * axis[2];
     45                        rmatrix[0][2] = 0 + temp[0] * axis[2] - s * axis[1];
     46
     47                        rmatrix[1][0] = 0 + temp[1] * axis[0] - s * axis[2];
     48                        rmatrix[1][1] = c + temp[1] * axis[1];
     49                        rmatrix[1][2] = 0 + temp[1] * axis[2] + s * axis[0];
     50
     51                        rmatrix[2][0] = 0 + temp[2] * axis[0] + s * axis[1];
     52                        rmatrix[2][1] = 0 + temp[2] * axis[1] - s * axis[0];
     53                        rmatrix[2][2] = c + temp[2] * axis[2];
    5454
    5555                        tmat4<T> result( no_init );
    56                         result[0] = m[0] * Rotate[0][0] + m[1] * Rotate[0][1] + m[2] * Rotate[0][2];
    57                         result[1] = m[0] * Rotate[1][0] + m[1] * Rotate[1][1] + m[2] * Rotate[1][2];
    58                         result[2] = m[0] * Rotate[2][0] + m[1] * Rotate[2][1] + m[2] * Rotate[2][2];
     56                        result[0] = m[0] * rmatrix[0][0] + m[1] * rmatrix[0][1] + m[2] * rmatrix[0][2];
     57                        result[1] = m[0] * rmatrix[1][0] + m[1] * rmatrix[1][1] + m[2] * rmatrix[1][2];
     58                        result[2] = m[0] * rmatrix[2][0] + m[1] * rmatrix[2][1] + m[2] * rmatrix[2][2];
    5959                        result[3] = m[3];
    6060                        return result;

  • trunk/nv/stl/memory.hh

    r445 r472  
    1616#define NV_STL_MEMORY_HH
    1717
    18 #include <nv/common.hh>
     18#include <nv/stl/memory/common.hh>
    1919#include <nv/stl/type_traits/properties.hh>
    2020#include <nv/stl/type_traits/alignment.hh>
    … …  
    3030        using constructor_t = void(*)( void* );
    3131        using destructor_t  = void(*)( void* );
    32 
    33        
    34         namespace mem_flags
    35         {
    36                 static constexpr uint16 is_const  = 0x0001;
    37                 static constexpr uint16 is_static = 0x0002;
    38                 static constexpr uint16 read_only = 0x0004;
    39                 static constexpr uint16 temporary = 0x0008;
    40         }
    4132
    4233        template< typename T >

  • trunk/nv/stl/string/short_string.hh

    r469 r472  
    2323                typedef string_buffer_base< Storage >               this_type;
    2424                typedef string_base< Storage >                      base_type;
     25                typedef typename string_base< Storage >::size_type  size_type;
    2526                typedef typename Storage::iterator                  iterator;
    2627                typedef typename Storage::const_iterator            const_iterator;
    2728
    2829                constexpr string_buffer_base() : base_type() {}
    29                 inline string_buffer_base( const char* data, size_t sz )
     30                inline string_buffer_base( const char* data, size_type sz )
    3031                        : base_type()
    3132                {
    … …  
    4445                inline string_buffer_base& operator=( string_buffer_base&& other ) = default;
    4546
    46                 void assign( const char* data, size_t sz )
    47                 {
    48                         clear();
     47                using Storage::clear;
     48
     49                void assign( const char* data, size_type sz )
     50                {
     51                        Storage::clear();
    4952                        append( data, sz );
    5053                }
    … …  
    5356                void assign( const T& value )
    5457                {
    55                         clear();
     58                        Storage::clear();
    5659                        append( value );
    5760                }
    5861
    59                 size_t append( const char* data, size_t sz )
     62                size_type append( const char* data, size_type sz )
    6063                {
    6164                        if ( !data ) return 0;
    62                         size_t pos    = size();
    63                         size_t amount = expand_by( sz );
     65                        size_type pos    = this->size();
     66                        size_type amount = expand_by( sz );
    6467                        raw_copy_n( data, amount, this->begin() + pos );
    6568                        return amount;
    6669                }
    6770
    68                 size_t append( const string_twine& twine )
    69                 {
    70                         size_t pos = size();
    71                         size_t dump_size = twine.dump_size();
     71                size_type append( const string_twine& twine )
     72                {
     73                        size_type pos = this->size();
     74                        size_type dump_size = twine.dump_size();
    7275                        expand_by( dump_size );
    73                         twine.dump( array_ref< char >( data() + pos, size() - pos ) );
    74                         return size() - pos;
    75                 }
    76 
    77                 size_t append( const_iterator first, const_iterator last )
     76                        twine.dump( array_ref< char >( this->data() + pos, this->size() - pos ) );
     77                        return this->size() - pos;
     78                }
     79
     80                size_type append( const_iterator first, const_iterator last )
    7881                {
    7982                        return append( first, last - first );
    8083                }
    8184
    82                 size_t append( const string_view& s )
     85                size_type append( const string_view& s )
    8386                {
    8487                        return append( s.data(), s.size() );
    … …  
    8689
    8790                template < typename S >
    88                 size_t append( const string_base<S>& s )
     91                size_type append( const string_base<S>& s )
    8992                {
    9093                        return append( s.data(), s.size() );
    9194                }
    9295
    93                 size_t append( sint32 s )
     96                size_type append( sint32 s )
    9497                {
    9598                        char buffer[8];
    96                         size_t result = sint32_to_buffer( array_ref< char >( buffer ), s );
    97                         return ( result > 0 ? append( buffer, result ) : 0 );
    98                 }
    99 
    100                 size_t append( uint32 u )
     99                        size_type result = sint32_to_buffer( array_ref< char >( buffer ), s );
     100                        return ( result > 0 ? append( buffer, result ) : 0 );
     101                }
     102
     103                size_type append( uint32 u )
    101104                {
    102105                        char buffer[8];
    103                         size_t result = uint32_to_buffer( array_ref< char >( buffer ), u );
    104                         return ( result > 0 ? append( buffer, result ) : 0 );
    105                 }
    106 
    107                 size_t append( sint64 s )
     106                        size_type result = uint32_to_buffer( array_ref< char >( buffer ), u );
     107                        return ( result > 0 ? append( buffer, result ) : 0 );
     108                }
     109
     110                size_type append( sint64 s )
    108111                {
    109112                        char buffer[16];
    110                         size_t result = sint64_to_buffer( array_ref< char >( buffer ), s );
    111                         return ( result > 0 ? append( buffer, result ) : 0 );
    112                 }
    113 
    114                 size_t append( uint64 u )
     113                        size_type result = sint64_to_buffer( array_ref< char >( buffer ), s );
     114                        return ( result > 0 ? append( buffer, result ) : 0 );
     115                }
     116
     117                size_type append( uint64 u )
    115118                {
    116119                        char buffer[16];
    117                         size_t result = uint64_to_buffer( array_ref< char >( buffer ), u );
    118                         return ( result > 0 ? append( buffer, result ) : 0 );
    119                 }
    120 
    121                 size_t append( f32 u )
     120                        size_type result = uint64_to_buffer( array_ref< char >( buffer ), u );
     121                        return ( result > 0 ? append( buffer, result ) : 0 );
     122                }
     123
     124                size_type append( f32 f )
    122125                {
    123126                        char buffer[64];
    124                         size_t result = uint64_to_buffer( array_ref< char >( buffer ), u );
    125                         return ( result > 0 ? append( buffer, result ) : 0 );
    126                 }
    127 
    128                 size_t append( f64 s )
     127                        size_type result = f32_to_buffer( array_ref< char >( buffer ), f );
     128                        return ( result > 0 ? append( buffer, result ) : 0 );
     129                }
     130
     131                size_type append( f64 f )
    129132                {
    130133                        char buffer[64];
    131                         size_t result = uint64_to_buffer( array_ref< char >( buffer ), u );
     134                        size_type result = f64_to_buffer( array_ref< char >( buffer ), f );
    132135                        return ( result > 0 ? append( buffer, result ) : 0 );
    133136                }
    … …  
    162165        protected:
    163166
    164                 size_t expand_by( size_t sz )
    165                 {
    166                         size_t result = 0;
     167                size_type expand_by( size_type sz )
     168                {
     169                        size_type result = 0;
    167170                        if ( Storage::try_grow( sz, 1 ) )
    168171                                result = sz;
    169172                        else
    170173                        {
    171                                 result = capacity() - size() - 1;
     174                                result = capacity() - this->size() - 1;
    172175                                Storage::try_resize( capacity() - 1, true, 1 );
    173176                        }

  • trunk/nv/stl/string/string_base.hh

    r445 r472  
    1010#include <nv/stl/string/common.hh>
    1111#include <nv/stl/functional/hash.hh>
     12#include <nv/stl/algorithm.hh>
    1213#include <nv/stl/memory.hh> // TODO: /stl/memory/array_ref?
    1314

  • trunk/src/gl/gl_enum.cc

    r463 r472  
    187187        case BGRA    : return GL_BGRA;
    188188        case RED     : return GL_RED;
     189        case R16F    : return GL_RED;
     190        case R32F    : return GL_RED;
    189191        case DEPTH16 : return GL_DEPTH_COMPONENT;
    190192        case DEPTH24 : return GL_DEPTH_COMPONENT;
    … …  
    206208        case BGR     : return GL_RGB8;
    207209        case BGRA    : return GL_RGBA8;
    208         case RED     : return 0x8040; // GL_LUMINANCE8; // TODO: change to GL_R8!
     210        case RED     : return GL_R8;
     211        case R16F    : return GL_R16F;
     212        case R32F    : return GL_R32F;
    209213        case DEPTH16 : return GL_DEPTH_COMPONENT16;
    210214        case DEPTH24 : return GL_DEPTH_COMPONENT24;

  • trunk/src/gui/gui_gfx_renderer.cc

    r471 r472  
    1212
    1313static const char *nv_gui_vertex_shader = R"(
    14 #version 120
    15 attribute vec2 nv_position;
    16 attribute vec2 nv_texcoord;
    17 attribute vec4 nv_color;
    18 varying vec4 v_color;
    19 varying vec2 v_texcoord;
     14#version 130
     15in vec2 nv_position;
     16in vec2 nv_texcoord;
     17in vec4 nv_color;
     18out vec4 v_color;
     19out vec2 v_texcoord;
    2020uniform mat4 nv_m_projection;
    2121void main(void)
    … …  
    2828
    2929static const char *nv_gui_fragment_shader = R"(
    30 #version 120
    31 varying vec4 v_color;
    32 varying vec2 v_texcoord;
     30#version 130
     31in vec4 v_color;
     32in vec2 v_texcoord;
    3333uniform sampler2D nv_t_diffuse;
    3434void main(void)
Note: See TracChangeset for help on using the changeset viewer.