+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.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) );
+ }
+
+ // Circle mesh
+ {
+ float circle_mesh[32*6*3];
+ int res = vg_list_size( circle_mesh ) / (6*3);
+
+ for( int i = 0; i < res; i ++ )
+ {
+ v2f v0 = { sinf( ((float)i/(float)res)*VG_TAUf ), cosf( ((float)i/(float)res)*VG_TAUf ) };
+ v2f v1 = { sinf( ((float)(i+1)/(float)res)*VG_TAUf ), cosf( ((float)(i+1)/(float)res)*VG_TAUf ) };
+
+ circle_mesh[ i*6+0 ] = 0.0f;
+ circle_mesh[ i*6+1 ] = 0.0f;
+
+ v2_copy( v0, circle_mesh + 32*6 + i*12 );
+ v2_muls( v0, 0.8f, circle_mesh + 32*6 + i*12+2 );
+ v2_copy( v1, circle_mesh + 32*6 + i*12+4 );
+
+ v2_copy( v1, circle_mesh + 32*6 + i*12+6 );
+ v2_muls( v1, 0.8f, circle_mesh + 32*6 + i*12+8 );
+ v2_muls( v0, 0.8f, circle_mesh + 32*6 + i*12+10 );
+
+ v2_copy( v0, circle_mesh + i*6+4 );
+ v2_copy( v1, circle_mesh + i*6+2 );
+ v2_copy( v0, circle_mesh+i*6+4 );
+ v2_copy( v1, circle_mesh+i*6+2 );
+ }
+
+ init_mesh( &world.circle, circle_mesh, vg_list_size( circle_mesh ) );
+ }
+
+ // Create info data texture
+ {
+ 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();
+
+ // 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 );
+
+ map_free();
+}
+
+static int cell_interactive( v2i co )
+{
+ // Bounds check
+ if( co[0] < 2 || co[0] >= world.w-2 || co[1] < 2 || co[1] >= world.h-2 )
+ return 0;
+
+ // Flags check
+ if( world.data[ world.w*co[1] + co[0] ].state & (FLAG_WALL|FLAG_INPUT|FLAG_OUTPUT) )
+ return 0;
+
+ // List of 3x3 configurations that we do not allow
+ static u32 invalid_src[][9] =
+ {
+ { 0,1,0,
+ 1,1,1,
+ 0,1,0
+ },
+ { 0,0,0,
+ 0,1,1,
+ 0,1,1
+ },
+ { 0,0,0,
+ 1,1,0,
+ 1,1,0
+ },
+ { 0,1,1,
+ 0,1,1,
+ 0,0,0
+ },
+ { 1,1,0,
+ 1,1,0,
+ 0,0,0
+ },
+ { 0,1,0,
+ 0,1,1,
+ 0,1,0
+ },
+ { 0,1,0,
+ 1,1,0,
+ 0,1,0
+ }
+ };
+
+ // Statically compile invalid configurations into bitmasks
+ static u32 invalid[ vg_list_size(invalid_src) ];
+
+ for( int i = 0; i < vg_list_size(invalid_src); i ++ )
+ {
+ u32 comped = 0x00;
+
+ for( int j = 0; j < 3; j ++ )
+ for( int k = 0; k < 3; k ++ )
+ comped |= invalid_src[i][ j*3+k ] << ((j*5)+k);
+
+ invalid[i] = comped;
+ }
+
+ // Extract 5x5 grid surrounding tile
+ u32 blob = 0x1000;
+ for( int y = co[1]-2; y < co[1]+3; y ++ )
+ for( int x = co[0]-2; x < co[0]+3; x ++ )
+ {
+ struct cell *cell = pcell((v2i){x,y});
+
+ if( cell && (cell->state & (FLAG_CANAL|FLAG_INPUT|FLAG_OUTPUT)) )
+ blob |= 0x1 << ((y-(co[1]-2))*5 + x-(co[0]-2));
+ }
+
+ // Run filter over center 3x3 grid to check for invalid configurations
+ int kernel[] = { 0, 1, 2, 5, 6, 7, 10, 11, 12 };
+ for( int i = 0; i < vg_list_size(kernel); i ++ )
+ {
+ if( blob & (0x1 << (6+kernel[i])) )
+ {
+ u32 window = blob >> kernel[i];
+
+ for( int j = 0; j < vg_list_size(invalid); j ++ )
+ if((window & invalid[j]) == invalid[j])
+ return 0;
+ }
+ }
+
+ return 1;
+}
+
+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 };
+
+ if( !start || !end )
+ {
+ 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 = py0; y < py1; y ++ )
+ {
+ 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( cell->state & (FLAG_CANAL|FLAG_INPUT|FLAG_OUTPUT) )
+ {
+ for( int i = 0; i < vg_list_size( dirs ); i ++ )
+ {
+ struct cell *neighbour = pcell((v2i){x+dirs[i][0], y+dirs[i][1]});
+ if( neighbour->state & (FLAG_CANAL|FLAG_INPUT|FLAG_OUTPUT) )
+ config |= 0x1 << i;
+ }
+
+ height = 128;
+ }
+ 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_6[] = {{0.5f,1.0f},{0.5f,0.625f},{0.375f,0.5f},{0.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}};
+
+float const curve_7_linear_section = 0.1562f;
+
+void vg_update(void)
+{
+ // Fit within screen
+
+ float r1 = (float)vg_window_y / (float)vg_window_x,
+ r2 = (float)world.h / (float)world.w,
+ size;
+
+ size = ( r2 < r1? (float)world.w * 0.5f: ((float)world.h * 0.5f) / r1 ) + 2.5f;
+ m3x3_projection( m_projection, -size, size, -size*r1, size*r1 );
+
+ v3f origin;
+ origin[0] = floorf( -0.5f * world.w );
+ origin[1] = floorf( -0.5f * world.h );
+ origin[2] = 0.0f;
+
+ m3x3_identity( m_view );
+ m3x3_translate( m_view, origin );
+ m3x3_mul( m_projection, m_view, vg_pv );
+ vg_projection_update();
+
+ // Input stuff
+ v2_copy( vg_mouse_ws, world.tile_pos );
+
+ world.tile_x = floorf( world.tile_pos[0] );
+ world.tile_y = floorf( world.tile_pos[1] );
+
+ // Tilemap editing
+ if( !world.simulating )
+ {
+ if( cell_interactive( (v2i){ world.tile_x, world.tile_y } ))
+ {
+ world.selected = world.tile_y * world.w + world.tile_x;
+
+ if( vg_get_button_down("primary") )
+ {
+ world.data[ world.selected ].state ^= FLAG_CANAL;
+
+ if( world.data[ world.selected ].state & FLAG_CANAL )
+ sfx_set_playrnd( &audio_tile_mod, &audio_system_sfx, 3, 6 );
+ else
+ 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 }, 1 );
+ }
+ }
+ else
+ world.selected = -1;
+ }
+ else world.selected = -1;
+
+ // Simulation stop/start
+ if( vg_get_button_down("go") )
+ {
+ if( world.simulating )
+ {
+ simulation_stop();
+ }
+ else
+ {
+ vg_success( "Starting simulation!\n" );
+
+ sfx_set_playrnd( &audio_rolls, &audio_system_balls_rolling, 0, 1 );
+
+ world.simulating = 1;
+ world.num_fishes = 0;
+ world.sim_frame = 0;
+ world.sim_start = vg_time;
+
+ for( int i = 0; i < world.w*world.h; i ++ )
+ {
+ world.data[ i ].state &= ~FLAG_FLIP_FLOP;
+ }
+
+ for( int i = 0; i < arrlen( world.io ); i ++ )
+ world.io[i].recv_count = 0;
+ }
+ }
+
+ // Fish ticks
+ if( world.simulating )
+ {
+ while( world.sim_frame < (int)((vg_time-world.sim_start)*2.0f) )
+ {
+ //vg_info( "frame: %u\n", world.sim_frame );
+ sfx_set_playrnd( &audio_random, &audio_system_balls_switching, 0, 9 );
+
+ // Update splitter deltas
+ for( int i = 0; i < world.h*world.w; i ++ )
+ {
+ struct cell *cell = &world.data[i];
+ if( cell->config == k_cell_type_split )
+ {
+ cell->state &= ~FLAG_FLIP_ROTATING;
+ }
+ }
+
+ int alive_count = 0;
+
+ // Update fish positions
+ for( int i = 0; i < world.num_fishes; i ++ )
+ {
+ struct fish *fish = &world.fishes[i];
+ struct cell *cell_current = pcell( fish->pos );
+
+ if( fish->alive == -1 )
+ fish->alive = 0;
+
+ if( fish->alive != 1 )
+ continue;
+
+ // Apply to output
+ if( cell_current->state & FLAG_OUTPUT )
+ {
+ for( int j = 0; j < arrlen( world.io ); j ++ )
+ {
+ struct cell_terminal *term = &world.io[j];
+
+ if( term->id == fish->pos[1]*world.w + fish->pos[0] )
+ {
+ term->recv[ term->recv_count ++ ] = fish->payload;
+ break;
+ }
+ }
+
+ fish->alive = 0;
+ continue;
+ }
+
+ if( cell_current->config == k_cell_type_split )
+ {
+ // Flip flop L/R
+ fish->dir[0] = cell_current->state&FLAG_FLIP_FLOP?1:-1;
+ fish->dir[1] = 0;
+
+ cell_current->state ^= FLAG_FLIP_FLOP;
+ }
+ else if( cell_current->config == k_cell_type_merge )
+ {
+ // Can only move up
+ fish->dir[0] = 0;
+ fish->dir[1] = -1;
+ }
+ else
+ {
+ struct cell *cell_next = pcell( (v2i){ fish->pos[0]+fish->dir[0], fish->pos[1]+fish->dir[1] } );
+ if( !(cell_next->state & (FLAG_CANAL|FLAG_OUTPUT)) )
+ {
+ // Try other directions for valid, so down, left, right..
+ v2i dirs[] = {{1,0},{-1,0},{0,-1}};
+ vg_info( "Trying some other directions...\n" );
+
+ for( int j = 0; j < vg_list_size(dirs); j ++ )
+ {
+ if( (dirs[j][0] == -fish->dir[0]) && (dirs[j][1] == -fish->dir[1]) )
+ continue;
+
+ if( pcell( (v2i){ fish->pos[0]+dirs[j][0], fish->pos[1]+dirs[j][1] } )->state & (FLAG_CANAL|FLAG_OUTPUT) )
+ {
+ fish->dir[0] = dirs[j][0];
+ fish->dir[1] = dirs[j][1];
+ }
+ }
+ }
+ }
+
+ fish->pos[0] += fish->dir[0];
+ fish->pos[1] += fish->dir[1];
+
+ struct cell *cell_entry = pcell( fish->pos );
+
+ if( !(cell_entry->state & (FLAG_INPUT|FLAG_CANAL|FLAG_OUTPUT) ))
+ fish->alive = 0;
+ else
+ {
+ if( fish->dir[0] )
+ {
+ if( cell_entry->config == k_cell_type_split ||
+ cell_entry->config == k_cell_type_ramp_right ||
+ cell_entry->config == k_cell_type_ramp_left )
+ {
+ // Special death (FALL)
+ v2_sub( fish->physics_co, fish->physics_v, fish->physics_v );
+ v2_divs( fish->physics_v, vg_time_delta, fish->physics_v );
+
+ fish->alive = -2;
+ vg_warn( "Special death (fall)\n" );
+ continue;
+ }
+ }
+
+ if( cell_entry->config == k_cell_type_split )
+ {
+ sfx_set_playrnd( &audio_splitter, &audio_system_balls_important, 0, 1 );
+ cell_entry->state |= FLAG_FLIP_ROTATING;
+ }
+ }
+
+ if( fish->alive )
+ alive_count ++;
+ }
+
+ // Check for collisions
+ for( int i = 0; i < world.num_fishes; i ++ )
+ {
+ if( world.fishes[i].alive == 1 )
+ {
+ for( int j = i+1; j < world.num_fishes; j ++ )
+ {
+ if( (world.fishes[j].alive == 1) && (world.fishes[i].pos[0] == world.fishes[j].pos[0]) &&
+ (world.fishes[i].pos[1] == world.fishes[j].pos[1]) )
+ {
+ // Shatter death (+0.5s)
+ world.fishes[i].alive = -1;
+ world.fishes[j].alive = -1;
+ world.fishes[i].death_time = 0.5f;
+ world.fishes[j].death_time = 0.5f;
+ }
+ }
+ }
+ }
+
+ // Spawn fishes
+ for( int i = 0; i < arrlen( world.io ); i ++ )
+ {
+ struct cell_terminal *term = &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;
+
+ if( is_input )
+ {
+ if( world.sim_frame < arrlen( term->conditions ) )
+ {
+ struct fish *fish = &world.fishes[world.num_fishes++];
+ fish->pos[0] = posx;
+ fish->pos[1] = posy;
+ fish->alive = 1;
+ fish->payload = term->conditions[world.sim_frame];
+
+ int can_spawn = 0;
+
+ v2i dirs[] = {{1,0},{-1,0},{0,-1}};
+ for( int j = 0; j < vg_list_size(dirs); j ++ )
+ if( pcell( (v2i){ posx+dirs[j][0], posy+dirs[j][1] } )->state & FLAG_CANAL )
+ {
+ fish->dir[0] = dirs[j][0];
+ fish->dir[1] = dirs[j][1];
+ can_spawn = 1;
+ break;
+ }
+
+ 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 ++;
+ }
+
+ float scaled_time = 0.0f;
+ scaled_time = (vg_time-world.sim_start)*2.0f;
+ world.frame_lerp = scaled_time - (float)world.sim_frame;
+
+ // Update positions
+ for( int i = 0; i < world.num_fishes; i ++ )
+ {
+ struct fish *fish = &world.fishes[i];
+
+ if( fish->alive == 0 )
+ continue;
+
+ if( fish->alive == -1 && (world.frame_lerp > fish->death_time) )
+ continue; // Todo: particle thing?
+
+ if( fish->alive == -2 )
+ {
+ v2_muladds( fish->physics_v, (v2f){ 0.0, -9.8f }, vg_time_delta, fish->physics_v );
+ v2_muladds( fish->physics_co, fish->physics_v, vg_time_delta, fish->physics_co );
+ }
+ else
+ {
+ struct cell *cell = pcell(fish->pos);
+ v2f const *curve;
+
+ float t = world.frame_lerp;
+
+ v2_copy( fish->physics_co, fish->physics_v );
+
+ switch( cell->config )
+ {
+ case 13:
+ if( fish->dir[0] == 1 )
+ curve = curve_12;
+ 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;
+ case 12: curve = curve_12; break;
+ case 7:
+ if( t > curve_7_linear_section )
+ {
+ t -= curve_7_linear_section;
+ t *= (1.0f/(1.0f-curve_7_linear_section));
+
+ curve = cell->state & FLAG_FLIP_FLOP? curve_7: curve_7_1;
+ }
+ else curve = NULL;
+ break;
+ default: curve = NULL; break;
+ }
+
+ if( curve )
+ {
+ float t2 = t * t;
+ float t3 = t * t * t;
+
+ float cA = 3.0f*t2 - 3.0f*t3;
+ float cB = 3.0f*t3 - 6.0f*t2 + 3.0f*t;
+ float cC = 3.0f*t2 - t3 - 3.0f*t + 1.0f;
+
+ fish->physics_co[0] = t3*curve[3][0] + cA*curve[2][0] + cB*curve[1][0] + cC*curve[0][0];
+ fish->physics_co[1] = t3*curve[3][1] + cA*curve[2][1] + cB*curve[1][1] + cC*curve[0][1];
+ fish->physics_co[0] += (float)fish->pos[0];
+ fish->physics_co[1] += (float)fish->pos[1];
+ }
+ else
+ {
+ v2f origin;
+ origin[0] = (float)fish->pos[0] + (float)fish->dir[0]*-0.5f + 0.5f;
+ origin[1] = (float)fish->pos[1] + (float)fish->dir[1]*-0.5f + 0.5f;
+
+ fish->physics_co[0] = origin[0] + (float)fish->dir[0]*t;
+ fish->physics_co[1] = origin[1] + (float)fish->dir[1]*t;
+ }
+ }
+ }
+ }
+}
+
+static void render_tiles( v2i start, v2i end, v4f const regular_colour, v4f const selected_colour )
+{
+ v2i full_start = { 0,0 };
+ v2i full_end = { world.w, world.h };
+
+ if( !start || !end )
+ {
+ start = full_start;
+ end = full_end;
+ }
+
+ glUniform4fv( SHADER_UNIFORM( shader_tile_main, "uColour" ), 1, regular_colour );
+
+ for( int y = start[1]; y < end[1]; y ++ )
+ {
+ for( int x = start[0]; x < end[0]; x ++ )
+ {
+ struct cell *cell = pcell((v2i){x,y});
+ int selected = world.selected == y*world.w + x;
+
+ int tile_offsets[][2] =
+ {
+ {2, 0}, {0, 3}, {0, 2}, {2, 2},
+ {1, 0}, {2, 3}, {3, 2}, {1, 3},
+ {3, 1}, {0, 1}, {1, 2}, {2, 1},
+ {1, 1}, {3, 3}, {2, 1}, {2, 1}
+ };
+
+ int uv[2] = { 3, 0 };
+
+ if( cell->state & (FLAG_CANAL|FLAG_INPUT|FLAG_OUTPUT) )
+ {
+ uv[0] = tile_offsets[ cell->config ][0];
+ uv[1] = tile_offsets[ cell->config ][1];
+ } else continue;
+
+ glUniform4f( SHADER_UNIFORM( shader_tile_main, "uOffset" ), (float)x, (float)y, uv[0], uv[1] );
+ if( selected )
+ {
+ glUniform4fv( SHADER_UNIFORM( shader_tile_main, "uColour" ), 1, selected_colour );
+ draw_mesh( 0, 2 );
+ glUniform4fv( SHADER_UNIFORM( shader_tile_main, "uColour" ), 1, regular_colour );
+ }
+ else
+ draw_mesh( 0, 2 );
+ }
+ }
+}
+
+void vg_render(void)