source: trunk/src/gfx/gfx_terminal.cc

// Copyright (C) 2016-2016 ChaosForge Ltd
// http://chaosforge.org/
//
// This file is part of Nova libraries. 
// For conditions of distribution and use, see copying.txt file in root folder.

#include "nv/gfx/gfx_terminal.hh"

#include "nv/core/logging.hh"

using namespace nv;

static const char *nv_gfx_terminal_vs = R"(
#version 330
in vec2 nv_position;
in vec2 nv_texcoord;
out vec2 v_texcoord;
void main(void)
{
        gl_Position = vec4(nv_position, 0.0, 1.0);
        v_texcoord  = nv_texcoord;
};
)";
static const char *nv_gfx_terminal_fs = R"(
#version 330
in  vec2 v_texcoord;
out vec4 o_frag_color;

uniform vec2 term_size;
uniform vec2 dev_size;
//uniform vec2 gylph_size;
uniform sampler2D nv_t_diffuse;

struct term_data
{
        uint fg;
        uint bg;
        uint gylph;
        uint pad;
};

layout(std140) uniform terminal_block
{
        term_data term[80*50];
};

void main(void)
{
        vec2 coord   = v_texcoord * term_size;
        ivec2 icoord = ivec2( coord );
        vec2 tc      = coord - vec2( icoord );
        tc.y = 1.0f - tc.y;

        coord.y = term_size.y - coord.y;
        
        int index = int( coord.x ) + int( term_size.x ) * int( coord.y );
        uint fg   = term[ index ].fg;
        int gylph = int( term[ index ].gylph );
        ivec2 gxy = ivec2( gylph % 16, gylph / 16 );
        vec2 gpos = vec2( ( float(gxy.x) + tc.x ) / 16.0f, ( float(gxy.y) + tc.y ) / 16.0f );
        vec4 tt   = texture( nv_t_diffuse, gpos );


    vec4 color = vec4(
        float( ( fg & uint(0x00FF0000) ) >> 16 ) / 255.0f,
        float( ( fg & uint(0x0000FF00) ) >> 8 ) / 255.0f,
        float(   fg & uint(0x000000FF) ) / 255.0f,
        1.0 //fg & uint(0xFF000000)
        );
        o_frag_color = vec4( color.xyz * tt.xyz + vec3( 0.0, 0.2, 0.0 ) * ( 1.0 - tt.xyz ), 1.0 * tt.x );
//      o_frag_color = vec4( fg, 0.0, 0.0, 1.0) ;
}
)";

struct gfx_terminal_uniform_block
{
        uint32 fgcolor = 0;
        uint32 bgcolor = 0;
        uint32 gylph   = 0;
        uint32 pad;

        void set( term_color fg, term_color bg, char ch )
        {
                fgcolor = fg.get_argb32();
                bgcolor = bg.get_argb32();
                gylph   = uint32( uint8(ch) );
        }
};

struct nv::gfx_terminal_data
{
        gfx_terminal_uniform_block* data;
        dimension                   size;
        buffer                      buffer;

        gfx_terminal_data( dimension dim )
        {
                size = dim;
                data = new gfx_terminal_uniform_block[dim.x * dim.y];
        }

        gfx_terminal_uniform_block& operator[]( position p )
        {
                int index = size.x * p.y + p.x;
                return data[index];
        }

        ~gfx_terminal_data()
        {
                delete[] data;
        }
};

gfx_terminal::gfx_terminal( context* ctx, texture t, dimension tsize, dimension /*psize*/ )
        : terminal( tsize ), m_context( ctx )
{
        m_data = new gfx_terminal_data( tsize );
        
        struct qvtx
        {
                vec2 position;
                vec2 texcoord;
        };

        qvtx quad[] = {
                qvtx{ vec2( -1.0f,-1.0f ), vec2( 0.0f, 0.0f ) },
                qvtx{ vec2( 1.0f,-1.0f ),  vec2( 1.0f, 0.0f ) },
                qvtx{ vec2( 1.0f,1.0f ),   vec2( 1.0f, 1.0f ) },
                qvtx{ vec2( 1.0f,1.0f ),   vec2( 1.0f, 1.0f ) },
                qvtx{ vec2( -1.0f,1.0f ),  vec2( 0.0f, 1.0f ) },
                qvtx{ vec2( -1.0f,-1.0f ), vec2( 0.0f, 0.0f ) },
        };
        m_dc.va       = m_context->create_vertex_array( quad, 6, nv::STATIC_DRAW );
        m_dc.va_count = 6;
        m_dc.image    = t;

        m_dc.p = m_context->create_program( nv_gfx_terminal_vs, nv_gfx_terminal_fs );

        m_data->buffer = m_context->create_buffer( nv::UNIFORM_BUFFER, nv::STREAM_DRAW, tsize.x * tsize.y * sizeof( gfx_terminal_uniform_block ), m_data->data );
        m_context->bind( m_data->buffer, 7 );
        m_context->get_device()->set_opt_uniform( m_dc.p, "term_size", vec2( tsize ) );
//      m_context->get_device()->set_opt_uniform( m_dc.p, "dev_size", vec2( psize ) );
        m_context->get_device()->set_opt_uniform( m_dc.p, "gylph_size", vec2( 8,8 ) );
        m_context->get_device()->set_opt_uniform( m_dc.p, "nv_t_diffuse", int( nv::TEX_DIFFUSE ) );
        m_context->get_device()->bind_block( m_dc.p, "terminal_block", 7 );
        m_update_needed = false;
}

void gfx_terminal::update()
{
        if ( m_update_needed )
        {
                m_context->bind( m_data->buffer, 7 );
                m_context->update( m_data->buffer, m_data->data, 0, m_data->size.x * m_data->size.y * sizeof( gfx_terminal_uniform_block ) );
                m_update_needed = false;
        }
}

void gfx_terminal::print( position p, term_color fgcolor, term_color bgcolor, char ch )
{
        m_update_needed = true;
        ( *m_data )[position( p.x - 1, p.y - 1)].set( fgcolor, bgcolor, ch );
}

void gfx_terminal::clear( rectangle r, term_color fgcolor, term_color bgcolor )
{
        m_update_needed = true;
        for ( int x = r.ul.x - 1; x <= r.lr.x - 1; ++x )
                for ( int y = r.ul.y - 1; y <= r.lr.y - 1; ++y )
                        (*m_data)[ position( x, y ) ].set( fgcolor, bgcolor, ' ' );
}

void gfx_terminal::clear()
{
        m_update_needed = true;
        for ( int i = 0; i < m_data->size.x * m_data->size.y; ++i )
                m_data->data[i].set( term_color::LIGHTGRAY, term_color::TRANSPARENT, ' ' );
}

bool gfx_terminal::poll( io_event & /*kevent*/ )
{
        return false;
}

void gfx_terminal::set_cursor( position /*p*/ )
{
}

void gfx_terminal::show_cursor()
{
}

void gfx_terminal::hide_cursor()
{
}

gfx_terminal::~gfx_terminal()
{
        delete m_data;
}