#include "vg/vg.h"
#include "fishladder_resources.h"
-const char *level_pack[] =
-{
- // Level 0
- "#########;\n"
- "###-#####;acac\n"
- "## ##;\n"
- "## ##;\n"
- "## ##;\n"
- "## ##;\n"
- "#####+###;acac\n"
- "#########;\n",
-
- // Level 1
- "#########;\n"
- "##-###-##;b,b\n"
- "## ##;\n"
- "## ##;\n"
- "## ##;\n"
- "## ##;\n"
- "## ##;\n"
- "####+####;bb\n"
- "#########;\n",
-
- // Level 2
- "###########;\n"
- "#####-#####;bbbbb\n"
- "## ##;\n"
- "## ###;\n"
- "## # ##;\n"
- "## ##;\n"
- "###+##+####;bbb,bb\n"
- "###########;\n",
-
- // Level 3
- "#############;\n"
- "###-#####-###;a,aaa\n"
- "## ##;\n"
- "## ##;\n"
- "## ##;\n"
- "## ##;\n"
- "## ##;\n"
- "## ##;\n"
- "######+######;aaaa\n"
- "#############;\n",
-
- // Level 4
- "#############;\n"
- "###-#####-###;aaa,aa\n"
- "## ##;\n"
- "## ##;\n"
- "## ##;\n"
- "## ##;\n"
- "## ##;\n"
- "## ##;\n"
- "###+#####+###;aa,aaa\n"
- "#############;\n"
+const char *level_pack_1[] = {
+ "level0",
+ "level1",
+ "level2",
+ "level3",
+ "level4",
+ "level5"
};
+#pragma pack(push,1)
+struct career_state
+{
+ u32 version;
+
+ struct career_level
+ {
+ u32 score;
+ u32 time;
+ u32 completed;
+ }
+ levels[ vg_list_size( level_pack_1 ) ];
+}
+career = { .version = 1 };
+#pragma pack(pop)
+
+static void career_serialize(void)
+{
+ vg_asset_write( "sav/game.sav", &career, sizeof( struct career_state ) );
+}
+
+static void career_load(void)
+{
+ i64 sz;
+ struct career_state *cr = vg_asset_read_s( "sav/game.sav", &sz );
+
+ memset( (void*)career.levels, 0, vg_list_size(level_pack_1) * sizeof(struct career_level) );
+
+ if( cr )
+ {
+ if( sz > sizeof( struct career_state ) )
+ vg_warn( "This save file is too big! Some levels will be lost\n" );
+
+ if( sz <= offsetof( struct career_state, levels ) )
+ {
+ vg_error( "This save file is too small to have a header\n" );
+ free( cr );
+ return;
+ }
+
+ u32 const size_header = offsetof(struct career_state, levels);
+ u32 const size_levels = sizeof(struct career_state)-size_header;
+ u32 const size_levels_input = sz - size_header;
+
+ memcpy( (void*)career.levels, (void*)cr->levels, size_levels );
+
+ if( sz < sizeof( struct career_state ) )
+ {
+ memset( ((void*)career.levels) + size_levels_input, 0, size_levels-size_levels_input );
+ }
+
+ free( cr );
+ vg_success( "Loaded save file... Info:\n" );
+
+ for( int i = 0; i < vg_list_size( career.levels ); i ++ )
+ {
+ struct career_level *lvl = &career.levels[i];
+ vg_info( "Score: %u, Time: %u, Completed: %u\n", lvl->score, lvl->time, lvl->completed );
+ }
+ }
+ else
+ {
+ vg_info( "No save file... Using blank one\n" );
+ }
+}
+
m3x3f m_projection;
m3x3f m_view;
m3x3f m_mdl;
};
v3f colour_sets[] =
-{ { 0.9f, 0.2f, 0.01f },
+{ { 0.9f, 0.6f, 0.20f },
{ 0.2f, 0.9f, 0.14f },
- { 0.1f, 0.3f, 0.85f } };
+ { 0.4f, 0.8f, 1.00f } };
static void colour_code_v3( char cc, v3f target )
{
struct mesh tile, circle;
GLuint background_data;
+ GLuint random_samples;
int selected, tile_x, tile_y;
v2f tile_pos;
fishes[16];
int num_fishes;
+
+ char map_name[128];
+ struct career_level *ptr_career_level;
+
} world = {};
static void map_free(void)
world.io = NULL;
}
-static void map_reclassify( v2i start, v2i end );
-static int map_load( const char *str )
+static void map_reclassify( v2i start, v2i end, int update_texbuffer );
+static int map_load( const char *str, const char *name )
{
map_free();
// Tile initialization
// row[ cx ] .. etc
+ struct cell *cell = &row[ cx ];
if( *c == '+' || *c == '-' )
{
struct cell_terminal term = { .id = cx + world.h*world.w };
arrpush( world.io, term );
- row[ cx ++ ].state = *c == '+'? FLAG_INPUT: FLAG_OUTPUT;
+ cell->state = *c == '+'? FLAG_INPUT: FLAG_OUTPUT;
reg_end ++;
}
- else if( *c == '#' )
- {
- row[ cx ++ ].state = FLAG_WALL;
- }
- else
- {
- row[ cx ++ ].state = 0x00;
- }
+ else if( *c == '#' ) cell->state = FLAG_WALL;
+ else if( *c == '*' ) cell->state = FLAG_CANAL;
+ else cell->state = 0x00;
+
+ cx ++;
}
c ++;
}
- map_reclassify( NULL, NULL );
- vg_success( "Map loaded! (%u:%u)\n", world.w, world.h );
+ // Update data texture to fill out the background
+ {
+ u8 info_buffer[64*64*4];
+ for( int i = 0; i < 64*64; i ++ )
+ {
+ u8 *px = &info_buffer[i*4];
+ px[0] = 255;
+ px[1] = 0;
+ px[2] = 0;
+ px[3] = 0;
+ }
+
+ glBindTexture( GL_TEXTURE_2D, world.background_data );
+ glTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, 64, 64, GL_RGBA, GL_UNSIGNED_BYTE, info_buffer );
+ }
+
+ map_reclassify( NULL, NULL, 1 );
+ vg_success( "Map '%s' loaded! (%u:%u)\n", name, world.w, world.h );
+
+ strncpy( world.map_name, name, vg_list_size( world.map_name )-1 );
return 1;
}
return &world.data[ pos[1]*world.w + pos[0] ];
}
+static void map_serialize( FILE *stream )
+{
+ for( int y = 0; y < world.h; y ++ )
+ {
+ for( int x = 0; x < world.w; x ++ )
+ {
+ struct cell *cell = pcell( (v2i){ x, y } );
+
+ if( cell->state & FLAG_WALL ) fputc( '#', stream );
+ else if( cell->state & FLAG_INPUT ) fputc( '+', stream );
+ else if( cell->state & FLAG_OUTPUT ) fputc( '-', stream );
+ else if( cell->state & FLAG_CANAL ) fputc( '*', stream );
+ else fputc( ' ', stream );
+ }
+
+ fputc( ';', stream );
+
+ int terminal_write_count = 0;
+
+ for( int x = 0; x < world.w; x ++ )
+ {
+ for( int i = 0; i < arrlen( world.io ); i ++ )
+ {
+ struct cell_terminal *term = &world.io[i];
+ if( term->id == y*world.w+x )
+ {
+ if( terminal_write_count )
+ fputc( ',', stream );
+ terminal_write_count ++;
+
+ for( int j = 0; j < arrlen( term->conditions ); j ++ )
+ fputc( term->conditions[j], stream );
+ }
+ }
+ }
+
+ fputc( '\n', stream );
+ }
+}
+
int main( int argc, char *argv[] )
{
vg_init( argc, argv, "Fish (Marbles Computer) Ladder Simulator 2022 | N,M: change level | SPACE: Test | LeftClick: Toggle tile" );
}
+static int console_save_map( int argc, char const *argv[] )
+{
+ char map_path[ 256 ];
+
+ strcpy( map_path, "sav/" );
+ strcat( map_path, world.map_name );
+ strcat( map_path, ".map" );
+
+ FILE *test_writer = fopen( map_path, "wb" );
+ if( test_writer )
+ {
+ map_serialize( test_writer );
+
+ fclose( test_writer );
+ return 1;
+ }
+ else
+ {
+ vg_error( "Unable to open stream for writing\n" );
+ return 0;
+ }
+}
+
+static int console_load_map( int argc, char const *argv[] )
+{
+ char map_path[ 256 ];
+
+ if( argc >= 1 )
+ {
+ // try from saves
+ strcpy( map_path, "sav/" );
+ strcat( map_path, argv[0] );
+ strcat( map_path, ".map" );
+
+ char *text_source = vg_textasset_read( map_path );
+
+ if( !text_source )
+ {
+ strcpy( map_path, "maps/" );
+ strcat( map_path, argv[0] );
+ strcat( map_path, ".map" );
+
+ text_source = vg_textasset_read( map_path );
+ }
+
+ if( text_source )
+ {
+ map_load( text_source, argv[0] );
+ free( text_source );
+
+ // Update career link
+ world.ptr_career_level = NULL;
+
+ for( int i = 0; i < vg_list_size( level_pack_1 ); i ++ )
+ {
+ if( !strcmp( level_pack_1[i], argv[0] ) )
+ {
+ world.ptr_career_level = career.levels + i;
+ break;
+ }
+ }
+
+ return 1;
+ }
+ else
+ {
+ vg_error( "Missing maps '%s'\n", argv[0] );
+ return 0;
+ }
+ }
+ else
+ {
+ vg_error( "Missing argument <map_path>\n" );
+ return 0;
+ }
+}
+
+static void simulation_stop(void)
+{
+ world.simulating = 0;
+ world.num_fishes = 0;
+ world.sim_frame = 0;
+
+ for( int i = 0; i < arrlen( world.io ); i ++ )
+ world.io[i].recv_count = 0;
+
+ sfx_system_fadeout( &audio_system_balls_rolling, 44100 );
+
+ vg_info( "Stopping simulation!\n" );
+}
+
+static int console_changelevel( int argc, char const *argv[] )
+{
+ if( argc >= 1 )
+ {
+ // Save current level
+ if( console_save_map( 0, NULL ) )
+ if( console_load_map( argc, argv ) )
+ {
+ simulation_stop();
+ return 1;
+ }
+ }
+ else
+ {
+ vg_error( "Missing argument <map_path>\n" );
+ }
+
+ return 0;
+}
+
void vg_start(void)
{
+ vg_function_push( (struct vg_cmd){
+ .name = "map_write",
+ .function = console_save_map
+ });
+
+ vg_function_push( (struct vg_cmd){
+ .name = "map_load",
+ .function = console_load_map
+ });
+
+ vg_function_push( (struct vg_cmd){
+ .name = "changelevel",
+ .function = console_changelevel
+ });
+
// Quad mesh
{
float quad_mesh[] =
0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f,
0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f,
- 0.48f, 0.48f, 0.5f, 0.52f, 0.52f, 0.52f, // Static dot
- 0.375f, 0.25f, 0.5f, 0.75f, 0.625f, 0.25f, // Downwards pointing arrow
- 0.25f, 0.625f, 0.75f, 0.5f, 0.25f, 0.375f, // Left
- 0.625f, 0.75f, 0.5f, 0.25f, 0.375f, 0.75f, // up
- 0.75f, 0.375f, 0.25f, 0.5f, 0.75f, 0.625f
+ 0.0f, 0.0f, 0.0f, 1.0f, 4.0f, 1.0f,
+ 0.0f, 0.0f, 4.0f, 1.0f, 4.0f, 0.0f
};
init_mesh( &world.tile, quad_mesh, vg_list_size(quad_mesh) );
}
// Create info data texture
- glGenTextures( &world.background_data );
- glBindTexture( GL_TEXTURE_2D, texture_name );
- glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, 64, 64, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL );
- vg_tex2d_nearest();
+ {
+ glGenTextures( 1, &world.background_data );
+ glBindTexture( GL_TEXTURE_2D, world.background_data );
+ glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, 64, 64, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL );
+ vg_tex2d_nearest();
+ }
+
+ // Create random smaples texture
+ {
+ u8 *data = malloc(512*512*2);
+ for( int i = 0; i < 512*512*2; i ++ )
+ data[ i ] = rand()/(RAND_MAX/255);
+
+ glGenTextures( 1, &world.random_samples );
+ glBindTexture( GL_TEXTURE_2D, world.random_samples );
+ glTexImage2D( GL_TEXTURE_2D, 0, GL_RG, 512, 512, 0, GL_RG, GL_UNSIGNED_BYTE, data );
+ vg_tex2d_linear();
+ vg_tex2d_repeat();
+
+ free( data );
+ }
resource_load_main();
- map_load( level_pack[ 0 ] );
+ // Restore gamestate
+ career_load();
+ console_load_map( 1, level_pack_1 );
}
void vg_free(void)
{
+ console_save_map( 0, NULL );
+ career_serialize();
+
resource_free_main();
+ glDeleteTextures( 1, &world.background_data );
+ glDeleteTextures( 1, &world.random_samples );
+
free_mesh( &world.tile );
free_mesh( &world.circle );
return 1;
}
-static void map_reclassify( v2i start, v2i end )
+static void map_reclassify( v2i start, v2i end, int update_texbuffer )
{
v2i full_start = { 1,1 };
v2i full_end = { world.w-1, world.h-1 };
start = full_start;
end = full_end;
}
+
+ // Texture data
+ u8 info_buffer[64*64*4];
+ u32 pixel_id = 0;
+
+ int px0 = vg_max( start[0], full_start[0] ),
+ px1 = vg_min( end[0], full_end[0] ),
+ py0 = vg_max( start[1], full_start[1] ),
+ py1 = vg_min( end[1], full_end[1] );
- for( int y = vg_max( start[1], full_start[1] ); y < vg_min( end[1], full_end[1] ); y ++ )
+ for( int y = py0; y < py1; y ++ )
{
- for( int x = vg_max( start[0], full_start[0] ); x < vg_min( end[0], full_end[0] ); x ++ )
+ for( int x = px0; x < px1; x ++ )
{
+ struct cell *cell = pcell((v2i){x,y});
+
v2i dirs[] = {{1,0},{0,1},{-1,0},{0,-1}};
+ u8 height = 0;
u8 config = 0x00;
- if( pcell((v2i){x,y})->state & (FLAG_CANAL|FLAG_INPUT|FLAG_OUTPUT) )
+ if( cell->state & (FLAG_CANAL|FLAG_INPUT|FLAG_OUTPUT) )
{
for( int i = 0; i < vg_list_size( dirs ); i ++ )
{
if( neighbour->state & (FLAG_CANAL|FLAG_INPUT|FLAG_OUTPUT) )
config |= 0x1 << i;
}
+
+ height = 128;
}
- else config = 0xF;
+ else
+ {
+ if( cell->state & FLAG_WALL )
+ height = 255;
+
+ config = 0xF;
+ }
pcell((v2i){x,y})->config = config;
+
+ u8 *info_px = &info_buffer[ (pixel_id ++)*4 ];
+ info_px[0] = height;
+ info_px[1] = cell->state & FLAG_WALL? 0: 255;
+ info_px[2] = 0;
+ info_px[3] = 0;
}
}
+
+ if( update_texbuffer )
+ {
+ glBindTexture( GL_TEXTURE_2D, world.background_data );
+ glTexSubImage2D( GL_TEXTURE_2D, 0, px0 + 16, py0 + 16, px1-px0, py1-py0, GL_RGBA, GL_UNSIGNED_BYTE, info_buffer );
+ }
}
v2f const curve_3[] = {{0.5f,1.0f},{0.5f,0.625f},{0.625f,0.5f},{1.0f,0.5f}};
v2f const curve_9[] = {{1.0f,0.5f},{0.625f,0.5f},{0.5f,0.375f},{0.5f,0.0f}};
v2f const curve_12[]= {{0.0f,0.5f},{0.375f,0.5f},{0.5f,0.375f},{0.5f,0.0f}};
+v2f const curve_2[] = {{0.5f,1.0f},{0.5f,0.8f},{0.5f,0.3f},{0.5f,0.2f}};
+v2f const curve_8[] = {{0.5f,0.8f},{0.5f,0.5f},{0.5f,0.3f},{0.5f,0.0f}};
+
v2f const curve_7[] = {{0.5f,0.8438f},{0.875f,0.8438f},{0.625f,0.5f},{1.0f,0.5f}};
v2f const curve_7_1[] = {{0.5f,0.8438f},{1.0f-0.875f,0.8438f},{1.0-0.625f,0.5f},{0.0f,0.5f}};
void vg_update(void)
{
- static int curlevel = 0;
- int changelvl = curlevel;
- if( vg_get_button_down( "prev" ) ) { if( curlevel > 0 ) changelvl --; }
- else if( vg_get_button_down( "next" ) ) { if( curlevel < vg_list_size( level_pack )-1 ) changelvl ++; }
-
- if( changelvl != curlevel )
- {
- map_load( level_pack[ changelvl ] );
- curlevel = changelvl;
-
- // TEMP!!! code dupe
- world.simulating = 0;
- world.num_fishes = 0;
- world.sim_frame = 0;
-
- for( int i = 0; i < arrlen( world.io ); i ++ )
- world.io[i].recv_count = 0;
-
- vg_info( "Stopping simulation!\n" );
- }
-
// Fit within screen
float r1 = (float)vg_window_y / (float)vg_window_x,
sfx_set_playrnd( &audio_tile_mod, &audio_system_sfx, 0, 3 );
map_reclassify( (v2i){ world.tile_x -2, world.tile_y -2 },
- (v2i){ world.tile_x +2, world.tile_y +2 } );
+ (v2i){ world.tile_x +2, world.tile_y +2 }, 1 );
}
}
else
{
if( world.simulating )
{
- world.simulating = 0;
- world.num_fishes = 0;
- world.sim_frame = 0;
-
- for( int i = 0; i < arrlen( world.io ); i ++ )
- world.io[i].recv_count = 0;
-
- vg_info( "Stopping simulation!\n" );
-
- sfx_system_fadeout( &audio_system_balls_rolling, 44100 );
+ simulation_stop();
}
else
{
}
}
+ int alive_count = 0;
+
// Update fish positions
for( int i = 0; i < world.num_fishes; i ++ )
{
cell_entry->state |= FLAG_FLIP_ROTATING;
}
}
+
+ if( fish->alive )
+ alive_count ++;
}
// Check for collisions
if( !can_spawn )
world.num_fishes--;
+ else
+ alive_count ++;
}
}
}
+ if( alive_count == 0 )
+ {
+ if( world.ptr_career_level )
+ {
+ world.ptr_career_level->completed = 1;
+
+ for( int i = 0; i < arrlen( world.io ); i ++ )
+ {
+ struct cell_terminal *term = &world.io[ i ];
+ int is_input = world.data[ term->id ].state & FLAG_INPUT;
+
+ if( !is_input )
+ {
+ if( term->recv_count == arrlen( term->conditions ) )
+ {
+ for( int j = 0; j < arrlen( term->conditions ); j ++ )
+ {
+ if( term->recv[j] != term->conditions[j] )
+ {
+ world.ptr_career_level->completed = 0;
+ break;
+ }
+ }
+ }
+ else
+ {
+ world.ptr_career_level->completed = 0;
+ break;
+ }
+ }
+ }
+
+ if( world.ptr_career_level->completed )
+ {
+ vg_success( "Level passed!\n" );
+
+ world.ptr_career_level->score = 9;
+ world.ptr_career_level->time = world.sim_frame;
+ }
+ else
+ {
+ vg_error( "Level failed :(\n" );
+ }
+ }
+
+ simulation_stop(); // TODO: Async?
+ break;
+ }
+
world.sim_frame ++;
}
else
curve = curve_9;
break;
+ case 2: curve = curve_2; break;
+ case 8: curve = curve_8; break;
case 3: curve = curve_3; break;
case 6: curve = curve_6; break;
case 9: curve = curve_9; break;
// Draw background
- if(0){
+ if(1){
SHADER_USE( shader_background );
glUniformMatrix3fv( SHADER_UNIFORM( shader_background, "uPv" ), 1, GL_FALSE, (float *)vg_pv );
- vg_tex2d_bind( &tex_background, 0 );
+ glActiveTexture( GL_TEXTURE0 );
+ glBindTexture( GL_TEXTURE_2D, world.background_data );
glUniform1i( SHADER_UNIFORM( shader_background, "uTexMain" ), 0 );
- glUniform3f( SHADER_UNIFORM( shader_background, "uOffset" ), -50, -50, 100 );
+ glUniform3f( SHADER_UNIFORM( shader_background, "uOffset" ), -16, -16, 64 );
+ glUniform1f( SHADER_UNIFORM( shader_background, "uVariance" ), 0.02f );
+
+ glActiveTexture( GL_TEXTURE1 );
+ glBindTexture( GL_TEXTURE_2D, world.random_samples );
+ glUniform1i( SHADER_UNIFORM( shader_background, "uSamplerNoise" ), 1 );
draw_mesh( 0, 2 );
// Draw splitters
- for( int y = 0; y < world.h; y ++ )
+ for( int y = 2; y < world.h-2; y ++ )
{
- for( int x = 0; x < world.w; x ++ )
+ for( int x = 2; x < world.w-2; x ++ )
{
struct cell *cell = pcell((v2i){x,y});
v2i new_end = { world.tile_x + 2, world.tile_y + 2 };
world.data[ world.selected ].state ^= FLAG_CANAL;
- map_reclassify( new_begin, new_end );
+ map_reclassify( new_begin, new_end, 0 );
m2x2_identity( subtransform );
glUniform1f( SHADER_UNIFORM( shader_tile_main, "uGhost" ), 1.0f );
render_tiles( new_begin, new_end, colour_default, colour_default );
world.data[ world.selected ].state ^= FLAG_CANAL;
- map_reclassify( new_begin, new_end );
+ map_reclassify( new_begin, new_end, 0 );
}
//glDisable(GL_BLEND);
SHADER_USE( shader_tile_colour );
glUniformMatrix3fv( SHADER_UNIFORM( shader_tile_colour, "uPv" ), 1, GL_FALSE, (float *)vg_pv );
use_mesh( &world.circle );
+
+ int const filled_start = 0;
+ int const filled_count = 32;
+ int const empty_start = 32;
+ int const empty_count = 32*2;
// Draw i/o arrays
for( int i = 0; i < arrlen( world.io ); i ++ )
int posx = term->id % world.w;
int posy = (term->id - posx)/world.w;
int is_input = world.data[ term->id ].state & FLAG_INPUT;
-
- int const filled_start = 0;
- int const filled_count = 32;
- int const empty_start = 32;
- int const empty_count = 32*2;
-
+
v4f dot_colour = { 0.0f, 0.0f, 0.0f, 1.0f };
for( int j = 0; j < arrlen( term->conditions ); j ++ )
{
- float y_offset = is_input? 0.8f: 0.2f;
+ float y_offset = is_input? 1.2f: -0.2f;
glUniform3f( SHADER_UNIFORM( shader_tile_colour, "uOffset" ), (float)posx + 0.2f + 0.2f * (float)j, (float)posy + y_offset, 0.1f );
if( is_input )
{
glUniform4f( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 0.0f, 0.0f, 0.0f, 1.0f );
glUniform3f( SHADER_UNIFORM( shader_tile_colour, "uOffset" ), -0.5f + cosf( vg_time * 4.0f ) * 0.2f, sinf( vg_time * 4.0f ) * 0.2f + (float)world.h * 0.5f, 0.05f );
- draw_mesh( 0, 32 );
+ draw_mesh( filled_start, filled_count );
}
+
+ // Level selection UI
+ float ratio = ((float)vg_window_x/(float)vg_window_y);
+
+ m3x3f ui_view = M3X3_IDENTITY;
+ m3x3_scale( ui_view, (v3f){ 1.0f, -ratio, 1.0f } );
+ glUniformMatrix3fv( SHADER_UNIFORM( shader_tile_colour, "uPv" ), 1, GL_FALSE, (float *)ui_view );
+
+ // Calculate mouse in UIsp
+ v3f mouse_ui_space = { ((float)vg_mouse[0] / (float)(vg_window_x)) * 2.0f - 1.0f,
+ (((float)vg_mouse[1] / (float)(vg_window_y)) * 2.0f - 1.0f)*(1.0f/ratio), 0.0125f };
+
+ // Get selected level
+ const float selection_scale = 0.05f;
+ int const level_count = vg_list_size( level_pack_1 );
+ int level_select = -1;
+
+ if( mouse_ui_space[0] <= -0.8f )
+ {
+ float levels_range = (float)level_count*selection_scale*0.6f;
+ float level_offset = ((mouse_ui_space[1] + levels_range) / levels_range) * 0.5f * (float)level_count;
+ level_select = floorf( level_offset );
+
+ // Draw selector
+ if( level_select >= 0 && level_select < vg_list_size( level_pack_1 ) )
+ {
+ glUniform4f( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 0.369768f, 0.3654f, 0.42f, 1.0f );
+
+ use_mesh( &world.tile );
+ glUniform3f( SHADER_UNIFORM( shader_tile_colour, "uOffset" ),
+ -1.0f,
+ (-(float)level_count + (float)level_select * 2.0f ) * selection_scale * 0.6f,
+ selection_scale
+ );
+ draw_mesh( 2, 2 );
+
+ use_mesh( &world.circle );
+
+ if( vg_get_button_down( "primary" ) )
+ {
+ console_changelevel( 1, level_pack_1 + level_select );
+ }
+ }
+ }
+ else mouse_ui_space[1] = INFINITY;
+
+ glUniform4f( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 0.4f, 0.39f, 0.45f, 1.0f );
+
+ // Draw levels
+ for( int i = 0; i < level_count; i ++ )
+ {
+ v3f level_ui_space = {
+ -0.97f,
+ (-(float)level_count + (float)i * 2.0f ) * selection_scale * 0.6f + selection_scale * 0.5f,
+ selection_scale * 0.5f
+ };
+
+ float scale = vg_clampf( 1.0f - fabsf(level_ui_space[1] - mouse_ui_space[1]) * 2.0f, 0.9f, 1.0f );
+ level_ui_space[2] *= scale;
+
+ glUniform3fv( SHADER_UNIFORM( shader_tile_colour, "uOffset" ), 1, level_ui_space );
+ draw_mesh( empty_start, empty_count );
+ }
+
+ glUniform3fv( SHADER_UNIFORM( shader_tile_colour, "uOffset" ), 1, mouse_ui_space );
+ draw_mesh( empty_start, empty_count );
}
void vg_ui(void)
projects / fishladder.git / blobdiff