world_sfd.h

   1 #ifndef SFD_H
   2 #define SFD_H
   3
   4 #include "world.h"
   5
   6 #include "shaders/scoretext.h"
   7 #include "shaders/vblend.h"
   8
   9 vg_tex2d tex_scoretext = { .path = "textures/scoretext.qoi",
  10                            .flags = VG_TEXTURE_CLAMP|VG_TEXTURE_NEAREST };
  11
  12 /*
  13  * TODO: utf-8 -> ascii
  14  */
  15
  16 float sfd_encode_glyph( char c )
  17 {
  18    int value = 0;
  19    if( c >= 'a' && c <= 'z' )
  20       value = c-'a'+11;
  21    else if( c >= '0' && c <= '9' )
  22       value = c-'0'+1;
  23    else if( c >= 'A' && c <= 'Z' )
  24       value = c-'A'+11;
  25    else if( c >= '\x01' && c <= '\x01'+10 )
  26       value = 63-c;
  27    else
  28    {
  29       int base = 11+26;
  30
  31       switch( c )
  32       {
  33          case '!': value=base+0; break;
  34          case '?': value=base+1; break;
  35          case ',': value=base+2; break;
  36          case '.': value=base+3; break;
  37          case '#': value=base+4; break;
  38          case '$': value=base+5; break;
  39          case '%': value=base+6; break;
  40          case '*': value=base+7; break;
  41          case '+': value=base+8; break;
  42          case '-': value=base+9; break;
  43          case '/': value=base+10; break;
  44          case ':': value=base+11; break;
  45          default: value=0; break;
  46       }
  47    }
  48
  49    return (float)value;
  50 }
  51
  52 static void sfd_encode( struct sfd_instance *display, u32 row, const char *str )
  53 {
  54    int end=0;
  55    for( int i=0; i<display->w; i++ )
  56    {
  57       if( end )
  58       {
  59          display->buffer[display->w*row + i] = 0.0f;
  60       }
  61       else
  62       {
  63          if( !str[i] )
  64             end = 1;
  65
  66          display->buffer[display->w*row + i] = sfd_encode_glyph( str[i] );
  67       }
  68    }
  69 }
  70
  71 static void sfd_new( struct sfd_instance *display, u32 w, u32 h )
  72 {
  73    display->w = w;
  74    display->h = h;
  75    display->buffer = vg_alloc( w*h*sizeof(float)*2 );
  76
  77    for( int i=0; i<w*h*2; i++ )
  78       display->buffer[i] = 0.0f;
  79 }
  80
  81 static void sfd_update( struct sfd_instance *display )
  82 {
  83    for( int i=0; i<display->w*display->h; i++ )
  84    {
  85       float *target = &display->buffer[i],
  86             *cur = target+display->w*display->h;
  87
  88       float const rate = ktimestep*15.2313131414f;
  89       float d1 = *target-*cur;
  90
  91       if( fabsf(d1) > rate )
  92       {
  93          *cur += rate;
  94          if( *cur > 60.0f )
  95             *cur -= 60.0f;
  96       }
  97       else
  98          *cur = *target;
  99    }
 100 }
 101
 102 static void sfd_render( struct sfd_instance *display,
 103                         m4x4f projection, v3f camera, m4x3f transform )
 104 {
 105    struct subworld_sfd *sfd = &world.sfd;
 106    scene_bind( &sfd->mesh );
 107
 108    shader_scoretext_use();
 109    shader_scoretext_uTexGarbage(0);
 110    shader_scoretext_uTexGradients(1);
 111    shader_link_standard_ub( _shader_scoretext.id, 2 );
 112    bind_terrain_textures();
 113    vg_tex2d_bind( &tex_scoretext, 1 );
 114
 115    shader_scoretext_uPv( projection );
 116    shader_scoretext_uMdl( transform );
 117    shader_scoretext_uCamera( camera );
 118
 119    for( int y=0;y<display->h; y++ )
 120    {
 121       for( int x=0; x<display->w; x++ )
 122       {
 123          float value = display->buffer[display->h*display->w+y*display->w+x];
 124          shader_scoretext_uInfo( (v3f){ x,y, value } );
 125          scene_draw( &sfd->mesh );
 126       }
 127    }
 128
 129    shader_vblend_use();
 130    shader_vblend_uTexGarbage(0);
 131    shader_vblend_uTexGradients(1);
 132    shader_link_standard_ub( _shader_vblend.id, 2 );
 133    bind_terrain_textures();
 134
 135    shader_vblend_uPv( projection );
 136    shader_vblend_uMdl( transform );
 137    shader_vblend_uCamera( camera );
 138
 139    mesh_bind( &sfd->temp );
 140    mesh_draw( &sfd->temp );
 141 }
 142
 143 static int world_sfd_test( int argc, const char *argv[] )
 144 {
 145    struct subworld_sfd *sfd = &world.sfd;
 146
 147    if( argc == 2 )
 148    {
 149       int row = vg_min(vg_max(atoi(argv[0]),0),sfd->tester.h);
 150       sfd_encode( &sfd->tester, row, argv[1] );
 151    }
 152
 153    return 0;
 154 }
 155
 156 static void world_sfd_init(void)
 157 {
 158    vg_info( "world_sfd_init\n" );
 159    shader_scoretext_register();
 160
 161    struct subworld_sfd *sfd = &world.sfd;
 162
 163         vg_function_push( (struct vg_cmd){
 164                 .name = "sfd",
 165                 .function = world_sfd_test
 166         });
 167
 168    mdl_header *mboard = mdl_load( "models/rs_scoretext.mdl" );
 169    scene_init( &sfd->mesh );
 170
 171    mdl_node *pn_backer = mdl_node_from_name( mboard, "backer" );
 172    mdl_submesh *backer = mdl_submesh_from_id( mboard, pn_backer->submesh_start);
 173    mdl_node *pn_card = mdl_node_from_name( mboard, "score_card" );
 174    mdl_submesh *card = mdl_submesh_from_id( mboard, pn_card->submesh_start );
 175
 176    m4x3f identity;
 177    m4x3_identity( identity );
 178
 179    for( int i=0;i<8;i++ )
 180    {
 181       u32 vert_start = sfd->mesh.vertex_count;
 182       scene_add_submesh( &sfd->mesh, mboard, card, identity );
 183
 184       for( int j=0; j<card->vertex_count; j++ )
 185       {
 186          mdl_vert *vert = &sfd->mesh.verts[ vert_start+j ];
 187
 188          float const k_glyph_uvw = 1.0f/64.0f;
 189          vert->uv[0] -= k_glyph_uvw * (float)(i-4);
 190          vert->colour[0] = 0.0f;
 191          vert->colour[1] = i*36;
 192       }
 193    }
 194
 195    vg_acquire_thread_sync();
 196    {
 197       vg_tex2d_init( (vg_tex2d *[]){ &tex_scoretext }, 1 );
 198
 199       scene_upload( &sfd->mesh );
 200       mdl_unpack_submesh( mboard, &sfd->temp, backer );
 201    }
 202    vg_release_thread_sync();
 203
 204    scene_free_offline_buffers( &sfd->mesh );
 205    sfd_new( &sfd->tester, 27, 13 );
 206    vg_free( mboard );
 207 }
 208
 209
 210 static void world_sfd_free(void *_)
 211 {
 212    mesh_free( &world.sfd.mesh.mesh );
 213    vg_tex2d_free( (vg_tex2d *[]){ &tex_scoretext }, 1 );
 214 }
 215
 216 #endif /* SFD_H */