Changeset 238 for trunk


Ignore:
Timestamp:
05/16/14 05:48:01 (11 years ago)
Author:
epyon
Message:
  • mesh data interface and usage
  • new wavefront importer (old pending removal)
  • updates to test projects
Location:
trunk
Files:
1 added
12 edited

Legend:

Unmodified
Added
Removed

  • trunk/nv/formats/obj_loader.hh

    r236 r238  
    1616#include <nv/common.hh>
    1717#include <nv/interface/mesh_loader.hh>
     18#include <nv/interface/mesh_data.hh>
    1819
    1920namespace nv
    … …  
    3435        };
    3536
     37        class wavefront_loader
     38        {
     39        public:
     40                wavefront_loader( bool normals = true, bool tangents = false );
     41                virtual bool load( stream& source );
     42                mesh_data* release_mesh_data();
     43                ~wavefront_loader();
     44        private:
     45                vertex_descriptor m_descriptor;
     46                bool              m_normals;
     47                bool              m_tangents;
     48                mesh_data*        m_mesh;
     49        };
     50
     51
    3652}
    3753

  • trunk/nv/gfx/mesh_data.hh

    r236 r238  
    55// For conditions of distribution and use, see copyright notice in nv.hh
    66
    7 #ifndef NV_MESH_DATA_HH
    8 #define NV_MESH_DATA_HH
     7#ifndef NV_MESH_DATA_OLD_HH
     8#define NV_MESH_DATA_OLD_HH
    99
    1010#include <nv/common.hh>
    … …  
    9595}
    9696
    97 #endif // NV_MESH_DATA_HH
     97#endif // NV_MESH_DATA_OLD_HH

  • trunk/nv/interface/device.hh

    r237 r238  
    1616#include <nv/string.hh>
    1717#include <nv/interface/mesh.hh>
     18#include <nv/interface/mesh_data.hh>
    1819#include <nv/interface/vertex_buffer.hh>
    1920#include <nv/interface/texture2d.hh>
    … …  
    112113                }
    113114
     115                // TODO: HINTS ARE DIFFERENT!
     116                vertex_array* create_vertex_array( const mesh_data* data, buffer_hint hint )
     117                {
     118                        vertex_array*  va = create_vertex_array();
     119                        for ( uint32 ch = 0; ch < data->get_channel_data().size(); ++ch )
     120                        {
     121                                const mesh_raw_channel* channel = data->get_channel_data()[ch];
     122                                vertex_buffer* vb = create_vertex_buffer( hint, channel->size, channel->data );
     123                                for ( uint32 s = 0; s < channel->desc.count; ++s )
     124                                {
     125                                        const vertex_descriptor_slot& slot = channel->desc.slots[s];
     126                                        const datatype_info&          info = get_datatype_info(slot.etype);
     127                                        va->add_vertex_buffer( slot.vslot, vb, info.base , info.elements, slot.offset, channel->desc.size, false );
     128                                }
     129                        }
     130                        if ( data->get_index_channel() != nullptr )
     131                        {
     132                                const mesh_raw_index_channel* index = data->get_index_channel();
     133                                index_buffer* ib = create_index_buffer( hint, index->size, index->data );
     134                                va->set_index_buffer( ib, index->etype, true );
     135                        }
     136                        return va;
     137                }
     138
     139
    114140                virtual ~device() {}
    115141        };

  • trunk/nv/interface/vertex.hh

    r237 r238  
    273273                                slots[ count ].vslot  = SLOT;
    274274                                slots[ count ].offset = slot_info::offset;
    275                                 count++
     275                                count++;
    276276                        }
    277277                }

  • trunk/nv/math.hh

    r237 r238  
    104104                BYTE_VECTOR_3,
    105105                BYTE_VECTOR_4,
    106         };
     106                DATATYPE_COUNT,
     107        };
     108
     109        struct datatype_info
     110        {
     111                size_t   size;
     112                datatype base;
     113                size_t   elements;
     114        };
     115
     116        inline const datatype_info& get_datatype_info( datatype dt )
     117        {
     118                static datatype_info info[ DATATYPE_COUNT ] = {
     119                        { 0, NONE, 0 },   // NONE 
     120                        { 4, INT, 1 },    // INT,
     121                        { 1, BYTE, 1 },   // BYTE,
     122                        { 2, SHORT, 1 },  // SHORT,
     123                        { 4, UINT, 1 },   // UINT,
     124                        { 1, UBYTE, 1 },  // UBYTE,
     125                        { 2, USHORT, 1 }, // USHORT,
     126                        { 4, FLOAT, 1 },  // FLOAT
     127                        { 4 * 2,  FLOAT, 2 },  // FLOAT_VECTOR_2,
     128                        { 4 * 3,  FLOAT, 3 },  // FLOAT_VECTOR_3,
     129                        { 4 * 4,  FLOAT, 4 },  // FLOAT_VECTOR_4,
     130                        { 4 * 4,  FLOAT, 4 },  // FLOAT_MATRIX_2,
     131                        { 4 * 9,  FLOAT, 9 },  // FLOAT_MATRIX_3,
     132                        { 4 * 16, FLOAT, 16 }, // FLOAT_MATRIX_4,
     133                        { 4 * 2,  INT, 2 },  // INT_VECTOR_2,
     134                        { 4 * 3,  INT, 3 },  // INT_VECTOR_3,
     135                        { 4 * 4,  INT, 4 },  // INT_VECTOR_4,
     136                        // unsupported gl conversion, remove?
     137                        { 1 * 2,  BYTE, 2 },  // BYTE_VECTOR_2,
     138                        { 1 * 3,  BYTE, 3 },  // BYTE_VECTOR_3,
     139                        { 1 * 4,  BYTE, 4 },  // BYTE_VECTOR_4,
     140                };
     141                return info[dt];
     142        }
    107143
    108144        template < datatype EnumType > struct enum_to_type {};
    … …  
    181217
    182218
     219
    183220} // namespace nv
    184221

  • trunk/src/formats/obj_loader.cc

    r225 r238  
    1111using namespace nv;
    1212
     13struct obj_vertex_vt
     14{
     15        vec3 position;
     16        vec2 texcoord;
     17
     18        obj_vertex_vt( vec3 a_position, vec2 a_texcoord )
     19                : position( a_position ), texcoord( a_texcoord ) {}
     20};
     21
     22struct obj_vertex_vtn
     23{
     24        vec3 position;
     25        vec2 texcoord;
     26        vec3 normal;
     27
     28        obj_vertex_vtn( vec3 a_position, vec2 a_texcoord, vec3 a_normal )
     29                : position( a_position ), texcoord( a_texcoord ), normal( a_normal ) {}
     30};
     31
     32
     33struct obj_vertex_vtnt
     34{
     35        vec3 position;
     36        vec2 texcoord;
     37        vec3 normal;
     38        vec4 tangent;
     39
     40        obj_vertex_vtnt( vec3 a_position, vec2 a_texcoord, vec3 a_normal )
     41                : position( a_position ), texcoord( a_texcoord ), normal( a_normal ) {}
     42};
     43
    1344struct obj_reader
    1445{
    … …  
    2455        obj_reader();
    2556        bool read_stream( std::istream& stream );
    26 
    27         virtual std::size_t add_face( uint32* vi, uint32* ti, uint32* ni, size_t count ) = 0;
     57        virtual size_t add_face( uint32* vi, uint32* ti, uint32* ni, size_t count ) = 0;
     58        virtual size_t raw_size() { return 0; }
     59        virtual const uint8* raw_pointer() { return nullptr; }
     60        virtual void calculate_tangents() {}
     61
    2862        virtual ~obj_reader(){}
    2963};
    … …  
    120154{
    121155        mesh_obj_reader( mesh_data_creator* m ) : m_mesh( m ) {}
    122         virtual std::size_t add_face( uint32* v, uint32* t, uint32* n, size_t count );
     156        virtual std::size_t add_face( uint32* vi, uint32* ti, uint32* ni, size_t count );
    123157        virtual void calculate_tangents();
    124158
    … …  
    238272bool nv::obj_loader::load( stream& source )
    239273{
    240         if ( m_mesh != nullptr )
    241         {
    242                 delete m_mesh;
    243         }
     274        if ( m_mesh != nullptr ) delete m_mesh;
    244275        mesh_data_creator creator;
    245276        mesh_obj_reader reader( &creator );
    … …  
    254285        return true;
    255286}
     287
     288struct mesh_data_reader_vt : public obj_reader
     289{
     290        mesh_data_reader_vt()  {}
     291        virtual std::size_t add_face( uint32* vi, uint32* ti, uint32*, size_t count )
     292        {
     293                if ( count < 3 ) return 0; // TODO : report error?
     294                // TODO : support if normals not present;
     295                std::size_t result = 0;
     296                // Simple triangulation - obj's shouldn't have more than quads anyway
     297                for ( size_t i = 2; i < count; ++i )
     298                {
     299                        result++;
     300                        m_data.emplace_back( v[ vi[ 0 ]   ], t[ ti[ 0   ] ] );
     301                        m_data.emplace_back( v[ vi[ i-1 ] ], t[ ti[ i-1 ] ] );
     302                        m_data.emplace_back( v[ vi[ i ]   ], t[ ti[ i   ] ] );
     303                }
     304                return result;
     305        }
     306        std::vector< obj_vertex_vt > m_data;
     307        virtual size_t raw_size() { return m_data.size() * sizeof( obj_vertex_vt ); }
     308        virtual const uint8* raw_pointer() { return (const uint8*)m_data.data(); }
     309};
     310
     311struct mesh_data_reader_vtn : public obj_reader
     312{
     313        mesh_data_reader_vtn()  {}
     314        virtual std::size_t add_face( uint32* vi, uint32* ti, uint32* ni, size_t count )
     315        {
     316                if ( count < 3 ) return 0; // TODO : report error?
     317                // TODO : support if normals not present;
     318                std::size_t result = 0;
     319                // Simple triangulation - obj's shouldn't have more than quads anyway
     320                for ( size_t i = 2; i < count; ++i )
     321                {
     322                        result++;
     323                        m_data.emplace_back( v[ vi[ 0 ]   ], t[ ti[ 0   ] ], n[ ni[ 0   ] ] );
     324                        m_data.emplace_back( v[ vi[ i-1 ] ], t[ ti[ i-1 ] ], n[ ni[ i-1 ] ] );
     325                        m_data.emplace_back( v[ vi[ i ]   ], t[ ti[ i   ] ], n[ ni[ i   ] ] );
     326                }
     327                return result;
     328        }
     329        std::vector< obj_vertex_vtn > m_data;
     330        virtual size_t raw_size() { return m_data.size() * sizeof( obj_vertex_vtn ); }
     331        virtual const uint8* raw_pointer() { return (const uint8*)m_data.data(); }
     332};
     333
     334struct mesh_data_reader_vtnt : public obj_reader
     335{
     336        mesh_data_reader_vtnt()  {}
     337        virtual std::size_t add_face( uint32* vi, uint32* ti, uint32* ni, size_t count )
     338        {
     339                if ( count < 3 ) return 0; // TODO : report error?
     340                // TODO : support if normals not present;
     341                std::size_t result = 0;
     342                // Simple triangulation - obj's shouldn't have more than quads anyway
     343                for ( size_t i = 2; i < count; ++i )
     344                {
     345                        result++;
     346                        m_data.emplace_back( v[ vi[ 0 ]   ], t[ ti[ 0   ] ], n[ ni[ 0   ] ] );
     347                        m_data.emplace_back( v[ vi[ i-1 ] ], t[ ti[ i-1 ] ], n[ ni[ i-1 ] ] );
     348                        m_data.emplace_back( v[ vi[ i ]   ], t[ ti[ i   ] ], n[ ni[ i   ] ] );
     349                }
     350                return result;
     351        }
     352        std::vector< obj_vertex_vtnt > m_data;
     353        virtual size_t raw_size() { return m_data.size() * sizeof( obj_vertex_vtnt ); }
     354        virtual const uint8* raw_pointer() { return (const uint8*)m_data.data(); }
     355
     356        // based on http://www.terathon.com/code/tangent.html
     357        void calculate_tangents()
     358        {
     359                //              const std::vector< vec3 >& vp = m_mesh->get_positions();
     360                //              const std::vector< vec2 >& vt = m_mesh->get_texcoords();
     361                //              const std::vector< vec3 >& vn = m_mesh->get_normals();
     362                //              std::vector< vec3 >& tg = m_mesh->get_tangents();
     363
     364                size_t count  = m_data.size();
     365                size_t tcount = count / 3;
     366
     367                std::vector< vec3 > tan1( count );
     368                std::vector< vec3 > tan2( count );
     369
     370                for (size_t a = 0; a < tcount; ++a )
     371                {
     372                        size_t i1 = a * 3;
     373                        size_t i2 = a * 3 + 1;
     374                        size_t i3 = a * 3 + 2;
     375                        obj_vertex_vtnt& vtx1 = m_data[ i1 ];
     376                        obj_vertex_vtnt& vtx2 = m_data[ i2 ];
     377                        obj_vertex_vtnt& vtx3 = m_data[ i3 ];
     378
     379                        // TODO: simplify
     380                        vec3 xyz1 = vtx2.position - vtx1.position;
     381                        vec3 xyz2 = vtx3.position - vtx1.position;
     382                        //vec2 st1  = w2 - w1;
     383                        //vec2 st2  = w3 - w1;
     384
     385                        float s1 = vtx2.texcoord.x - vtx1.texcoord.x;
     386                        float t1 = vtx2.texcoord.y - vtx1.texcoord.y;
     387                        float s2 = vtx3.texcoord.x - vtx1.texcoord.x;
     388                        float t2 = vtx3.texcoord.y - vtx1.texcoord.y;
     389
     390                        float stst = s1 * t2 - s2 * t1;
     391                        float r = 0.0f;
     392                        if (stst > 0.0f || stst < 0.0f) r = 1.0f / stst;
     393
     394                        vec3 sdir = ( t2 * xyz1 - t1 * xyz2 ) * r;
     395                        vec3 tdir = ( s1 * xyz2 - s2 * xyz1 ) * r;
     396
     397                        // the += below obviously doesn't make sense in this case, but I'll
     398                        // leave it here for when I move to indices
     399                        tan1[i1] += sdir;
     400                        tan1[i2] += sdir;
     401                        tan1[i3] += sdir;
     402
     403                        // tan2 not needed anymore??
     404                        tan2[i1] += tdir;
     405                        tan2[i2] += tdir;
     406                        tan2[i3] += tdir;
     407                }
     408
     409                for (std::size_t a = 0; a < count; ++a )
     410                {
     411                        const vec3& n = m_data[a].normal;
     412                        const vec3& t = tan1[a];
     413                        if ( ! (t.x == 0.0f && t.y == 0.0f && t.z == 0.0f) )
     414                        {
     415                                m_data[a].tangent    = vec4( glm::normalize(t - n * glm::dot( n, t )), 0.0f );
     416                                m_data[a].tangent[3] = (glm::dot(glm::cross(n, t), tan2[a]) < 0.0f) ? -1.0f : 1.0f;
     417                        }
     418                }
     419
     420        }
     421
     422
     423};
     424
     425nv::wavefront_loader::wavefront_loader( bool normals /*= true*/, bool tangents /*= false */ )
     426        : m_normals( normals ), m_tangents( tangents ), m_mesh( nullptr )
     427{
     428        if ( normals )
     429        {
     430                if ( tangents )
     431                        m_descriptor.initialize<obj_vertex_vtnt>();
     432                else
     433                        m_descriptor.initialize<obj_vertex_vtn>();
     434        }
     435        else
     436                m_descriptor.initialize<obj_vertex_vt>();
     437}
     438
     439bool nv::wavefront_loader::load( stream& source )
     440{
     441        if ( m_mesh ) delete m_mesh;
     442       
     443        obj_reader* reader = nullptr;
     444        if ( m_normals )
     445        {
     446                if ( m_tangents )
     447                        reader = new mesh_data_reader_vtnt();
     448                else
     449                        reader = new mesh_data_reader_vtn();
     450        }
     451        else
     452                reader = new mesh_data_reader_vt();
     453        std_stream sstream( &source );
     454        reader->read_stream( sstream );
     455
     456        if ( m_tangents )
     457        {
     458                reader->calculate_tangents();
     459        }
     460       
     461
     462        mesh_raw_channel* channel = new mesh_raw_channel();
     463        nv::uint8* data = nullptr;
     464        if ( reader->raw_size() > 0 )
     465        {
     466                data = new uint8[ reader->raw_size() ];
     467                std::copy_n( reader->raw_pointer(), reader->raw_size(), data );
     468        }
     469        channel->data  = data;
     470        channel->desc  = m_descriptor;
     471        channel->count = reader->size * 3;
     472        channel->size  = reader->raw_size();
     473        delete reader;
     474
     475        m_mesh = new mesh_data();
     476        m_mesh->add_channel( channel );
     477        return true;
     478
     479}
     480
     481mesh_data* nv::wavefront_loader::release_mesh_data()
     482{
     483        mesh_data* result = m_mesh;
     484        m_mesh = nullptr;
     485        return result;
     486}
     487
     488nv::wavefront_loader::~wavefront_loader()
     489{
     490        if ( m_mesh ) delete m_mesh;
     491}

  • trunk/tests/objload_test/objload_test.cc

    r237 r238  
    3232        nv::vertex_array* m_va;
    3333        nv::program*      m_program;
    34         nv::mesh_data_old* m_mesh;
    35         nv::uint32        m_count;
     34        nv::mesh_data*    m_mesh;
    3635};
    3736
    … …  
    6463        nv::c_file_system fs;
    6564        nv::stream* mesh_file = fs.open( "mesh.obj" );
    66         nv::mesh_loader* loader = new nv::obj_loader();
     65
     66//              nv::mesh_loader* loader = new nv::obj_loader();
     67//              loader->load( *mesh_file );
     68//              nv::mesh_data_old* mesh = loader->release_mesh_data();
     69//              m_count = loader->get_size();
     70//              delete mesh_file;
     71//              delete loader;
     72
     73        nv::wavefront_loader* loader = new nv::wavefront_loader();
    6774        loader->load( *mesh_file );
    6875        m_mesh = loader->release_mesh_data();
    69         m_count = loader->get_size();
    7076        delete mesh_file;
    7177        delete loader;
    … …  
    7379        m_program = m_device->create_program( nv::slurp( "obj.vert" ), nv::slurp( "obj.frag" ) );
    7480
    75         nv::vertex_buffer* vb = nullptr;
    76         m_va = m_device->create_vertex_array();
    77         vb = m_device->create_vertex_buffer( nv::STATIC_DRAW, m_mesh->get_vertex_count() * sizeof( nv::vec3 ), m_mesh->get_positions().data() );
    78         m_va->add_vertex_buffer( nv::slot::POSITION, vb, nv::FLOAT, 3 );
    79         vb = m_device->create_vertex_buffer( nv::STATIC_DRAW, m_mesh->get_vertex_count() * sizeof( nv::vec3 ), m_mesh->get_normals().data() );
    80         m_va->add_vertex_buffer( nv::slot::NORMAL, vb, nv::FLOAT, 3 );
    81         vb = m_device->create_vertex_buffer( nv::STATIC_DRAW, m_mesh->get_vertex_count() * sizeof( nv::vec2 ), m_mesh->get_texcoords().data() );
    82         m_va->add_vertex_buffer( nv::slot::TEXCOORD, vb, nv::FLOAT, 2 );
     81//      nv::vertex_buffer* vb = nullptr;
     82        m_va = m_device->create_vertex_array( m_mesh, nv::STATIC_DRAW );
     83
    8384        return true;
    8485}
    … …  
    113114                m_program->set_uniform( "diffuse", 0 );
    114115                m_program->set_uniform( "specular", 1 );
    115                 m_window->get_context()->draw( nv::TRIANGLES, m_render_state, m_program, m_va, m_count * 3 );
     116                m_window->get_context()->draw( nv::TRIANGLES, m_render_state, m_program, m_va, m_mesh->get_count() );
    116117                m_window->swap_buffers();
    117118
    … …  
    147148application::~application()
    148149{
     150        delete m_mesh;
    149151        delete m_program;
    150         delete m_mesh;
    151152        delete m_diffuse;
    152153        delete m_specular;

  • trunk/tests/render_test/box.frag

    r46 r238  
    44varying vec3 f_material;
    55varying float f_diffuse_value;
    6 uniform sampler2D tex;
     6uniform sampler2D nv_t_diffuse;
    77uniform vec3 light;
    88 
    … …  
    1616
    1717        if (secondary)
    18                 gl_FragColor = texture2D(tex, vec2((fract(f_coord.z - f_coord.x) + modulus ), ( fract(-f_coord.y) + remmod) )  / 16.0);
     18                gl_FragColor = texture2D(nv_t_diffuse, vec2((fract(f_coord.z - f_coord.x) + modulus ), ( fract(-f_coord.y) + remmod) )  / 16.0);
    1919        else
    20                 gl_FragColor = texture2D(tex, vec2((fract(f_coord.z) + modulus ), ( fract(f_coord.x) + remmod) )  / 16.0);
     20                gl_FragColor = texture2D(nv_t_diffuse, vec2((fract(f_coord.z) + modulus ), ( fract(f_coord.x) + remmod) )  / 16.0);
    2121        gl_FragColor = vec4( gl_FragColor.xyz * (f_diffuse_value + 0.4), 1.0 );
    2222}

  • trunk/tests/render_test/box.vert

    r46 r238  
    11#version 120
    2 attribute vec3 coords;
    3 attribute vec3 material;
     2attribute vec3 nv_position;
     3attribute vec3 nv_color;
     4uniform mat4 nv_m_mvp;
     5
    46varying vec3 f_coord;
    57varying vec3 f_normal;
    68varying vec3 f_material;
    79varying float f_diffuse_value;
    8 uniform mat4 matrix_mvp;
    910uniform vec3 light;
    1011
    1112void main(void) {
    1213        f_normal = vec3(0,0,0);
    13         f_normal[int(abs(material.y)-1)] = sign( material.y );
     14        f_normal[int(abs(nv_color.y)-1)] = sign( nv_color.y );
    1415        vec3 vnormal  = normalize(f_normal);
    15         vec3 vlight   = normalize(light - coords);
     16        vec3 vlight   = normalize(light - nv_position);
    1617        float diffuse = max(dot(vlight, vnormal), 0.0);
    1718        f_diffuse_value = diffuse;
    18         f_coord = coords;
    19         f_material = material;
    20         gl_Position = matrix_mvp * vec4(coords, 1.0);
     19        f_coord = nv_position;
     20        f_material = nv_color;
     21        gl_Position = nv_m_mvp * vec4(nv_position, 1.0);
    2122}

  • trunk/tests/render_test/char.frag

    r46 r238  
    22varying vec3 f_coord;
    33varying vec3 f_material;
    4 uniform sampler2D tex;
     4uniform sampler2D nv_t_diffuse;
    55 
    66void main(void) {
    … …  
    99        float modulus = w - remmod * 16;
    1010
    11         gl_FragColor = texture2D(tex, vec2((fract(f_coord.x) + modulus ), ( fract(f_coord.z) + remmod) )  / 16.0);
     11        gl_FragColor = texture2D(nv_t_diffuse, vec2((fract(f_coord.x) + modulus ), ( fract(f_coord.z) + remmod) )  / 16.0);
    1212
    13 //      gl_FragColor = texture2D(tex, vec2((fract(f_coord.z - f_coord.x) + modulus ), ( fract(-f_coord.y) + remmod) )  / 16.0);
     13//      gl_FragColor = texture2D(nv_t_diffuse, vec2((fract(f_coord.z - f_coord.x) + modulus ), ( fract(-f_coord.y) + remmod) )  / 16.0);
    1414}

  • trunk/tests/render_test/char.vert

    r46 r238  
    11#version 120
    2 attribute vec3 coords;
    3 attribute vec3 material;
     2attribute vec3 nv_position;
     3attribute vec3 nv_color;
     4uniform mat4 nv_m_mvp;
     5
    46varying vec3 f_coord;
    57varying vec3 f_material;
    6 uniform mat4 matrix_mvp;
    78uniform vec3 pos;
    89
    910void main(void) {
    10         f_coord = coords;
    11         f_material = material;
    12         gl_Position = matrix_mvp * vec4(coords + pos, 1.0);
     11        f_coord = nv_position;
     12        f_material = nv_color;
     13        gl_Position = nv_m_mvp * vec4(nv_position + pos, 1.0);
    1314}

  • trunk/tests/render_test/rl.cc

    r231 r238  
    6767        nv::window* m_window;
    6868        nv::texture2d* m_texture;
    69         nv::clear_state m_clear_state;
     69
     70        nv::clear_state  m_clear_state;
    7071        nv::render_state m_render_state;
     72        nv::scene_state  m_scene_state;
    7173
    7274        nv::program* m_char_program;
    … …  
    7577        nv::vertex_array* m_box_va;
    7678        unsigned int m_count;
     79};
     80
     81struct vtx
     82{
     83        nv::i8vec3 position;
     84        nv::i8vec3 color;
     85
     86        vtx( const nv::i8vec3& a_position, const nv::i8vec3& a_color )
     87                : position( a_position ), color( a_color ) {}
    7788};
    7889
    … …  
    99110{
    100111        { // CHARACTER
    101                 nv::mesh cmesh;
    102                 nv::vertex_attribute<nv::i8vec3>::list& vtx = cmesh.add_attribute<nv::i8vec3>("coords")->get();
    103                 nv::vertex_attribute<nv::i8vec3>::list& mat = cmesh.add_attribute<nv::i8vec3>("material")->get();
     112                std::vector< vtx > v;
    104113                int m = 16;     int x = 0; int y = 0; int h = 0;
    105                 vtx.emplace_back( x,   h, y ); 
    106                 vtx.emplace_back( x,   h, y+1 );
    107                 vtx.emplace_back( x+1, h, y+1 );
    108                 vtx.emplace_back( x+1, h, y+1 );
    109                 vtx.emplace_back( x+1, h, y ); 
    110                 vtx.emplace_back( x,   h, y ); 
    111                 mat.insert( mat.end(), 6, nv::i8vec3( m, 1, 0 ) );
     114                nv::i8vec3 mt( m, 1, 0 );
     115                v.emplace_back( nv::i8vec3( x,   h, y ), mt ); 
     116                v.emplace_back( nv::i8vec3( x,   h, y+1 ), mt );
     117                v.emplace_back( nv::i8vec3( x+1, h, y+1 ), mt );
     118                v.emplace_back( nv::i8vec3( x+1, h, y+1 ), mt );
     119                v.emplace_back( nv::i8vec3( x+1, h, y ), mt ); 
     120                v.emplace_back( nv::i8vec3( x,   h, y ), mt ); 
    112121                m_char_program = m_device->create_program( nv::slurp( "char.vert" ), nv::slurp( "char.frag" ) );
    113                 m_char_va      = m_device->create_vertex_array( &cmesh, &(m_char_program->get_attributes()), nv::STATIC_DRAW );
     122                m_char_va      = m_device->create_vertex_array( v, nv::STATIC_DRAW );
    114123        }
    115124
    116125        { // WORLD
    117                 nv::mesh wmesh;
    118                 nv::vertex_attribute<nv::i8vec3>::list& vtx = wmesh.add_attribute<nv::i8vec3>("coords")->get();
    119                 nv::vertex_attribute<nv::i8vec3>::list& mat = wmesh.add_attribute<nv::i8vec3>("material")->get();
    120 
     126                std::vector< vtx > v;
     127                nv::i8vec3 mt;
    121128                for (int i = 0; i < size_x * size_y; ++i )
    122129                {
    … …  
    124131                        int y = i / size_x;
    125132
    126                         vtx.emplace_back( x,   height[i], y   );
    127                         vtx.emplace_back( x,   height[i], y+1 );
    128                         vtx.emplace_back( x+1, height[i], y+1 );
    129                         vtx.emplace_back( x+1, height[i], y+1 );
    130                         vtx.emplace_back( x+1, height[i], y );   
    131                         vtx.emplace_back( x,   height[i], y );   
    132                         mat.insert( mat.end(), 6, nv::i8vec3( map[i], 2, 0 ) );
     133                        mt = nv::i8vec3( map[i], 2, 0 );
     134                        v.emplace_back( nv::i8vec3( x,   height[i], y   ), mt );
     135                        v.emplace_back( nv::i8vec3( x,   height[i], y+1 ), mt );
     136                        v.emplace_back( nv::i8vec3( x+1, height[i], y+1 ), mt );
     137                        v.emplace_back( nv::i8vec3( x+1, height[i], y+1 ), mt );
     138                        v.emplace_back( nv::i8vec3( x+1, height[i], y ), mt );
     139                        v.emplace_back( nv::i8vec3( x,   height[i], y ), mt );
    133140
    134141                        if (i > 0 && height[i-1] != height[i])
    … …  
    139146                                {
    140147                                        m_count += 6;
    141                                         vtx.emplace_back( x, h,     y );   
    142                                         vtx.emplace_back( x, h,     y+1 );
    143                                         vtx.emplace_back( x, h+dir, y+1 );
    144                                         vtx.emplace_back( x, h+dir, y+1 );
    145                                         vtx.emplace_back( x, h+dir, y );   
    146                                         vtx.emplace_back( x, h,     y );   
    147                                         mat.insert( mat.end(), 6, nv::i8vec3( m, -dir, 0 ) );
     148                                        mt = nv::i8vec3( m, -dir, 0 );
     149                                        v.emplace_back( nv::i8vec3( x, h,     y ), mt );
     150                                        v.emplace_back( nv::i8vec3( x, h,     y+1 ), mt );
     151                                        v.emplace_back( nv::i8vec3( x, h+dir, y+1 ), mt );
     152                                        v.emplace_back( nv::i8vec3( x, h+dir, y+1 ), mt );
     153                                        v.emplace_back( nv::i8vec3( x, h+dir, y ), mt );
     154                                        v.emplace_back( nv::i8vec3( x, h,     y ), mt );
    148155                                }
    149156                        }
    … …  
    155162                                for ( int h = height[i-size_x]; h != height[i]; h = h + dir )
    156163                                {
    157                                         vtx.emplace_back( x,   h,     y );
    158                                         vtx.emplace_back( x,   h+dir, y );
    159                                         vtx.emplace_back( x+1, h+dir, y );
    160 
    161                                         vtx.emplace_back( x+1, h+dir, y );
    162                                         vtx.emplace_back( x+1, h,     y );
    163                                         vtx.emplace_back( x,   h,     y );
    164                                         mat.insert( mat.end(), 6, nv::i8vec3( m, -3*dir, 0 ) );
     164                                        mt = nv::i8vec3( m, -3*dir, 0 );
     165                                        v.emplace_back( nv::i8vec3( x,   h,     y ), mt );
     166                                        v.emplace_back( nv::i8vec3( x,   h+dir, y ), mt );
     167                                        v.emplace_back( nv::i8vec3( x+1, h+dir, y ), mt );
     168
     169                                        v.emplace_back( nv::i8vec3( x+1, h+dir, y ), mt );
     170                                        v.emplace_back( nv::i8vec3( x+1, h,     y ), mt );
     171                                        v.emplace_back( nv::i8vec3( x,   h,     y ), mt );
    165172                                }
    166173                        }
    … …  
    168175                }
    169176
    170                 m_count       = vtx.size();
     177                m_count       = v.size();
    171178                m_box_program = m_device->create_program( nv::slurp( "box.vert" ), nv::slurp( "box.frag" ) );
    172                 m_box_va      = m_device->create_vertex_array( &wmesh, &(m_box_program->get_attributes()), nv::STATIC_DRAW );
     179                m_box_va      = m_device->create_vertex_array( v, nv::STATIC_DRAW );
    173180        }
    174181
    … …  
    181188
    182189        glm::vec3 move( 0, 0, 0 );
     190        m_scene_state.get_camera().set_perspective(25.0f, 1.0f*800.0f/600.0f, 0.1f, 100.0f);
    183191
    184192        while(!keypress)
    185193        {
     194                m_scene_state.set_model( glm::translate(glm::mat4(1.0f), glm::vec3(-8.5, 0.0, -8.0)) );
     195                m_scene_state.get_camera().set_lookat(glm::vec3(0.0, 20.0, 5.0) + move, glm::vec3(0.0, 4.0, 0.0) + move, glm::vec3(0.0, 1.0, 0.0));
     196
    186197                m_window->get_context()->clear( m_clear_state );
    187 
    188                 glm::mat4 model = glm::translate(glm::mat4(1.0f), glm::vec3(-8.5, 0.0, -8.0));
    189                 glm::mat4 view  = glm::lookAt(glm::vec3(0.0, 20.0, 5.0) + move, glm::vec3(0.0, 4.0, 0.0) + move, glm::vec3(0.0, 1.0, 0.0));
    190                 glm::mat4 projection = glm::perspective(25.0f, 1.0f*800.0f/600.0f, 0.1f, 100.0f);
    191                 glm::mat4 mv         = view * model;
    192 
    193198                m_texture->bind( 0 );
    194                 m_box_program->set_uniform( "matrix_mvp", projection * mv );
    195199                m_box_program->set_uniform( "light", glm::vec3(8.5, 4.5, 6.5) + move );
    196                 m_box_program->set_uniform( "tex", 0 );
    197                 m_window->get_context()->draw( nv::TRIANGLES, m_render_state, m_box_program, m_box_va, m_count );
    198 
    199                 m_char_program->set_uniform( "matrix_mvp", projection * mv );
     200                m_window->get_context()->draw( nv::TRIANGLES, m_render_state, m_scene_state, m_box_program, m_box_va, m_count );
     201
    200202                m_char_program->set_uniform( "pos", move + glm::vec3( 8, 4.1, 6 ) );
    201                 m_char_program->set_uniform( "tex", 0 );
    202                 m_window->get_context()->draw( nv::TRIANGLES, m_render_state, m_char_program, m_char_va, 6 );
     203                m_window->get_context()->draw( nv::TRIANGLES, m_render_state, m_scene_state, m_char_program, m_char_va, 6 );
    203204                m_window->swap_buffers();
    204205
Note: See TracChangeset for help on using the changeset viewer.