+void vg_register(void)
+{
+ SHADER_INIT( shader_tile_colour );
+}
+
+void vg_start(void)
+{
+ // 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
+ };
+
+ 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 ) );
+ }
+
+ // splitters (temp)
+ {
+ float splitter_l[] =
+ {
+ #include "models/splitter_l.obj.h"
+ };
+ float splitter_r[] =
+ {
+ #include "models/splitter_r.obj.h"
+ };
+
+ init_mesh( &world.splitter_l, splitter_l, vg_list_size( splitter_l ) );
+ init_mesh( &world.splitter_r, splitter_r, vg_list_size( splitter_r ) );
+ }
+
+ map_load
+ (
+ "#############;\n"
+ "###-#####-###;aaa,aa\n"
+ "## ##;\n"
+ "## ##;\n"
+ "## ##;\n"
+ "## ##;\n"
+ "## ##;\n"
+ "## ##;\n"
+ "###+#####+###;aa,aaa\n"
+ "#############;\n"
+ );
+}
+
+void vg_free(void)
+{
+ free_mesh( &world.tile );
+ free_mesh( &world.circle );
+ free_mesh( &world.splitter_l );
+ free_mesh( &world.splitter_r );
+
+ 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;
+}
+
+void vg_update(void)
+{
+ float ratio = (float)vg_window_y / (float)vg_window_x;
+ float const size = 9.5f;
+
+ v3f origin;
+ origin[0] = -0.5f * world.w;
+ origin[1] = -0.5f * world.h;
+ origin[2] = 0.0f;
+
+ m3x3_projection( m_projection, -size, size, -size*ratio, size*ratio );
+ m3x3_identity( m_view );
+ m3x3_translate( m_view, origin );
+ m3x3_mul( m_projection, m_view, vg_pv );
+ vg_projection_update();
+
+ // Input stuff
+
+ v2f tile_pos;
+ v2_copy( vg_mouse_ws, tile_pos );
+
+ int tile_x = floorf( tile_pos[0] );
+ int tile_y = floorf( tile_pos[1] );
+
+ // Tilemap editing
+ if( !world.simulating )
+ {
+ if( cell_interactive( (v2i){ tile_x, tile_y } ))
+ {
+ world.selected = tile_y * world.w + tile_x;
+
+ if( vg_get_button_down("primary") )
+ {
+ world.data[ world.selected ].state ^= FLAG_CANAL;
+ }
+ }
+ else
+ world.selected = -1;
+ }
+
+ // Simulation stop/start
+ if( vg_get_button_down("go") )
+ {
+ 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" );
+ }
+ else
+ {
+ vg_success( "Starting simulation!\n" );
+
+ 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;
+ }
+ }
+
+ // Simulation stuff
+ // ========================================================
+
+ // Reclassify world. TODO: Move into own function
+ for( int y = 2; y < world.h-2; y ++ )
+ {
+ for( int x = 2; x < world.w-2; x ++ )
+ {
+ v2i dirs[] = {{1,0},{0,1},{-1,0},{0,-1}};
+
+ u8 config = 0x00;
+
+ if( pcell((v2i){x,y})->state & FLAG_CANAL )
+ {
+ 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;
+ }
+ } else config = 0xF;
+
+ pcell((v2i){x,y})->config = config;
+ pcell((v2i){x,y})->state &= ~(FLAG_DROP_L|FLAG_DROP_R|FLAG_SPLIT|FLAG_MERGER);
+ }
+ }
+
+ for( int y = 2; y < world.h-2; y ++ )
+ for( int x = 2; x < world.w-2; x ++ )
+ {
+ // R,D,L,- 1110 (splitter, 1 drop created)
+
+ // R,-,L,U - 1011 (merger, 2 drop created)
+
+ u8 config = pcell((v2i){x,y})->config;
+
+ if( config == 0x7 ) // splitter
+ {
+ world.data[y*world.w+x ].state |= (FLAG_SPLIT | FLAG_DROP_L | FLAG_DROP_R);
+ }
+ else if( config == 0xD )
+ {
+ world.data[y*world.w+x-1].state |= FLAG_DROP_R;
+ world.data[y*world.w+x+1].state |= FLAG_DROP_L;
+ world.data[y*world.w+x].state |= FLAG_MERGER;
+ }
+ }
+
+ // 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 );
+
+ 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 ++ )
+ {
+ v2i target;
+ 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--;
+ }
+ }
+ }