X-Git-Url: https://harrygodden.com/git/?a=blobdiff_plain;f=fishladder.c;h=d66cd2e18780b27eb48890130eeade53a7b0b04c;hb=27f1751d523e9dee4ab00ec10666bbb3d8db74bc;hp=2cd35291dafe2532d49037732b0353927e743be3;hpb=8c0c078d020902e7a30a9cc01ab62e6bef80294a;p=fishladder.git diff --git a/fishladder.c b/fishladder.c index 2cd3529..d66cd2e 100644 --- a/fishladder.c +++ b/fishladder.c @@ -8,11 +8,11 @@ SHADER_DEFINE( shader_tile_colour, // VERTEX "layout (location=0) in vec2 a_co;" "uniform mat3 uPv;" - "uniform vec2 uOffset;" + "uniform vec3 uOffset;" "" "void main()" "{" - "gl_Position = vec4( uPv * vec3( a_co + uOffset, 1.0 ), 1.0 );" + "gl_Position = vec4( uPv * vec3( a_co * uOffset.z + uOffset.xy, 1.0 ), 1.0 );" "}", // FRAGMENT @@ -27,27 +27,322 @@ SHADER_DEFINE( shader_tile_colour, UNIFORMS({ "uPv", "uOffset", "uColour" }) ) +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" +}; + m3x3f m_projection; m3x3f m_view; m3x3f m_mdl; +#define FLAG_INPUT 0x1 +#define FLAG_OUTPUT 0x2 +#define FLAG_CANAL 0x4 +#define FLAG_WALL 0x8 +#define FLAG_DROP_L 0x10 +#define FLAG_SPLIT 0x20 +#define FLAG_MERGER 0x40 +#define FLAG_DROP_R 0x80 +#define FLAG_FLIP_FLOP 0x100 + +v3f colour_sets[] = +{ { 0.9f, 0.2f, 0.01f }, + { 0.2f, 0.9f, 0.14f }, + { 0.1f, 0.3f, 0.85f } }; + +static void colour_code_v3( char cc, v3f target ) +{ + if( cc >= 'a' && cc <= 'z' ) + { + int id = cc - 'a'; + + if( id < vg_list_size( colour_sets ) ) + { + v3_copy( colour_sets[ id ], target ); + return; + } + } + + v3_copy( (v3f){0.0f,0.0f,0.0f}, target ); +} + +struct mesh +{ + GLuint vao, vbo; + u32 elements; +}; + +static void init_mesh( struct mesh *m, float *tris, u32 length ) +{ + m->elements = length/3; + glGenVertexArrays( 1, &m->vao ); + glGenBuffers( 1, &m->vbo ); + + glBindVertexArray( m->vao ); + glBindBuffer( GL_ARRAY_BUFFER, m->vbo ); + glBufferData( GL_ARRAY_BUFFER, length*sizeof(float), tris, GL_STATIC_DRAW ); + + glVertexAttribPointer( 0, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(float), (void*)0 ); + glEnableVertexAttribArray( 0 ); + + VG_CHECK_GL(); +} + +static void free_mesh( struct mesh *m ) +{ + glDeleteVertexArrays( 1, &m->vao ); + glDeleteBuffers( 1, &m->vbo ); +} + +static void draw_mesh( int const start, int const count ) +{ + glDrawArrays( GL_TRIANGLES, start*3, count*3 ); +} + +static void use_mesh( struct mesh *m ) +{ + glBindVertexArray( m->vao ); +} + struct world { struct cell { u32 state; - } + u8 config; + } *data; + u32 frame; + + u32 sim_frame; + float sim_start; + int simulating; + + struct cell_terminal + { + // TODO: Split into input/output structures + char *conditions; + char recv[12]; + int recv_count; + int id; + } + *io; + u32 w, h; - GLuint tile_vao; - GLuint tile_vbo; -} world = { .w = 1, .h = 1 }; + struct mesh tile, circle, splitter_l, splitter_r; + + int selected; + + struct fish + { + v2i pos; + v2i dir; + int alive; + char payload; + } + fishes[16]; + + int num_fishes; +} world = {}; + +static void map_free(void) +{ + for( int i = 0; i < arrlen( world.io ); i ++ ) + arrfree( world.io[ i ].conditions ); + + arrfree( world.data ); + arrfree( world.io ); + + world.w = 0; + world.h = 0; + world.data = NULL; + world.io = NULL; +} + +static int map_load( const char *str ) +{ + map_free(); + + char const *c = str; + + // Scan for width + for(;; world.w ++) + { + if( str[world.w] == ';' ) + break; + else if( !str[world.w] ) + { + vg_error( "Unexpected EOF when parsing level\n" ); + return 0; + } + } + + struct cell *row = arraddnptr( world.data, world.w ); + int cx = 0; + int reg_start = 0, reg_end = 0; + + for(;;) + { + if( !*c ) + break; + + if( *c == ';' ) + { + c ++; + + // Parse attribs + if( *c != '\n' ) + { + while( *c ) + { + if( reg_start < reg_end ) + { + if( *c >= 'a' && *c <= 'z' ) + { + arrpush( world.io[ reg_start ].conditions, *c ); + } + else + { + if( *c == ',' || *c == '\n' ) + { + reg_start ++; + + if( *c == '\n' ) + break; + } + else + { + vg_error( "Unkown attribute '%c' (row: %u)\n", *c, world.h ); + return 0; + } + } + } + else + { + vg_error( "Too many values to assign (row: %u)\n", world.h ); + return 0; + } + + c ++; + } + } + + if( reg_start != reg_end ) + { + vg_error( "Not enough values assigned (row: %u, %u of %u)\n", world.h, reg_start, reg_end ); + return 0; + } + + if( cx != world.w ) + { + vg_error( "Not enough cells to match previous row definition (row: %u, %u<%u)\n", world.h, cx, world.w ); + return 0; + } + + row = arraddnptr( world.data, world.w ); + cx = 0; + world.h ++; + reg_end = reg_start = arrlen( world.io ); + } + else + { + if( cx == world.w ) + { + vg_error( "Too many cells to match previous row definition (row: %u, %u>%u)\n", world.h, cx, world.w ); + return 0; + } + + // Tile initialization + // row[ cx ] .. etc + + 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; + reg_end ++; + } + else if( *c == '#' ) + { + row[ cx ++ ].state = FLAG_WALL; + } + else + { + row[ cx ++ ].state = 0x00; + } + } + + c ++; + } + + vg_success( "Map loaded! (%u:%u)\n", world.w, world.h ); + return 1; +} + +static struct cell *pcell( v2i pos ) +{ + return &world.data[ pos[1]*world.w + pos[0] ]; +} int main( int argc, char *argv[] ) { - vg_init( argc, argv, "FishLadder" ); + vg_init( argc, argv, "Fish (Marbles Computer) Ladder Simulator 2022 | N,M: change level | SPACE: Test | LeftClick: Toggle tile" ); } void vg_register(void) @@ -57,46 +352,427 @@ void vg_register(void) void vg_start(void) { - glGenVertexArrays( 1, &world.tile_vao ); - glGenBuffers( 1, &world.tile_vbo ); - - float quad_mesh[] = + // 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 - }; + 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) ); + } - glBindVertexArray( world.tile_vao ); - glBindBuffer( GL_ARRAY_BUFFER, world.tile_vbo ); - glBufferData - ( - GL_ARRAY_BUFFER, - sizeof( quad_mesh ), - quad_mesh, - GL_STATIC_DRAW - ); + // 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 ) ); + } - glVertexAttribPointer( 0, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(float), (void*)0 ); - glEnableVertexAttribArray( 0 ); + // 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 ) ); + } - VG_CHECK_GL(); + map_load( level_pack[ 0 ] ); } void vg_free(void) { - glDeleteVertexArrays( 1, &world.tile_vao ); - glDeleteBuffers( 1, &world.tile_vbo ); + 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) { + 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" ); + } + float ratio = (float)vg_window_y / (float)vg_window_x; - float const size = 7.5f; + 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_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 ++ ) + 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--; + } + } + } + + 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 ) + 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->state & (FLAG_INPUT|FLAG_CANAL)) ) + { + fish->alive = 0; + } + else + { + if( cell_current->state & FLAG_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->state & FLAG_MERGER ) + { + // 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]; + } + } + + world.sim_frame ++; + } + } } void vg_render(void) @@ -104,22 +780,161 @@ void vg_render(void) glViewport( 0,0, vg_window_x, vg_window_y ); glDisable( GL_DEPTH_TEST ); - glClearColor( 0.01f, 0.01f, 0.01f, 1.0f ); + glClearColor( 0.8f, 0.8f, 0.8f, 1.0f ); glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); - glBindVertexArray( world.tile_vao ); + use_mesh( &world.tile ); SHADER_USE( shader_tile_colour ); glUniformMatrix3fv( SHADER_UNIFORM( shader_tile_colour, "uPv" ), 1, GL_FALSE, (float *)vg_pv ); + // Shadow layer + glUniform4f( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 0.5f, 0.5f, 0.5f, 1.0f ); + 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_CANAL ) + { + continue; + } + + glUniform3f( SHADER_UNIFORM( shader_tile_colour, "uOffset" ), (float)x - 0.2f, (float)y - 0.15f, 1.0f ); + draw_mesh( 0, 2 ); + } + for( int y = 0; y < world.h; y ++ ) { for( int x = 0; x < world.w; x ++ ) { - glUniform2f( SHADER_UNIFORM( shader_tile_colour, "uOffset" ), (float)x, (float)y ); - glUniform4f( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1.0f, 1.0f, 1.0f, 1.0f ); - glDrawArrays( GL_TRIANGLES, 0, 6 ); + struct cell *cell = pcell((v2i){x,y}); + int selected = world.selected == y*world.w + x; + + if( cell->state & FLAG_SPLIT ) + { + glUniform4f( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 0.9f, 0.9f, 0.9f, 1.0f ); + glUniform3f( SHADER_UNIFORM( shader_tile_colour, "uOffset" ), (float)x, (float)y, 1.0f ); + + struct mesh *splitter = cell->state & FLAG_FLIP_FLOP? &world.splitter_r: &world.splitter_l; + + use_mesh( splitter ); + draw_mesh( 0, splitter->elements ); + use_mesh( &world.tile ); + } + + if( (cell->state & FLAG_CANAL) && !selected ) + continue; + + glUniform3f( SHADER_UNIFORM( shader_tile_colour, "uOffset" ), (float)x, (float)y, 1.0f ); + + v4f colour; + + if( cell->state & FLAG_WALL ) { v4_copy( (v4f){ 0.2f, 0.2f, 0.2f, 1.0f }, colour ); } + else if( cell->state & FLAG_CANAL ) { v4_copy( (v4f){ 0.6f, 0.6f, 0.6f, 1.0f }, colour ); } + else if( cell->state & FLAG_INPUT ) { v4_copy( (v4f){ 0.5f, 0.5f, 0.5f, 1.0f }, colour ); } + else if( cell->state & FLAG_OUTPUT ) { v4_copy( (v4f){ 0.4f, 0.4f, 0.4f, 1.0f }, colour ); } + else v4_copy( (v4f){ 0.9f, 0.9f, 0.9f, 1.0f }, colour ); + + //if( cell->water[world.frame&0x1] ) + // v4_copy( (v4f){ 0.2f, 0.3f, 0.7f * (float)(cell->water[world.frame&0x1]) * (1.0f/16.0f), 1.0f }, colour ); + + if( selected ) + v3_muls( colour, sinf( vg_time )*0.25f + 0.5f, colour ); + + //if( cell->state & (FLAG_SPLIT) ) + // v4_copy( (v4f){ 0.75f, 0.75f, 0.02f, 1.0f }, colour ); + //if( cell->state & (FLAG_MERGER) ) + // v4_copy( (v4f){ 0.75f, 0.02f, 0.75f, 1.0f }, colour ); + + glUniform4fv( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1, colour ); + + draw_mesh( 0, 2 ); + } + } + + use_mesh( &world.circle ); + + // Draw i/o arrays + 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; + + 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 ++ ) + { + glUniform3f( SHADER_UNIFORM( shader_tile_colour, "uOffset" ), (float)posx + 0.2f + 0.2f * (float)j, (float)posy + 0.2f, 0.1f ); + + if( is_input ) + { + colour_code_v3( term->conditions[j], dot_colour ); + glUniform4fv( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1, dot_colour ); + + // Draw filled if tick not passed, draw empty if empty + if( world.sim_frame > j ) + draw_mesh( empty_start, empty_count ); + else + draw_mesh( filled_start, filled_count ); + } + else + { + if( term->recv_count > j ) + { + colour_code_v3( term->recv[j], dot_colour ); + v3_muls( dot_colour, 0.8f, dot_colour ); + glUniform4fv( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1, dot_colour ); + + draw_mesh( filled_start, filled_count ); + } + + colour_code_v3( term->conditions[j], dot_colour ); + glUniform4fv( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1, dot_colour ); + + draw_mesh( empty_start, empty_count ); + } } } + + // Draw 'fish' + if( world.simulating ) + { + float scaled_time = (vg_time-world.sim_start)*2.0f; + float lerp = 1.0f-(scaled_time - (float)world.sim_frame); + + v4f dot_colour = { 0.0f, 0.0f, 0.0f, 1.0f }; + + for( int i = 0; i < world.num_fishes; i ++ ) + { + struct fish *fish = &world.fishes[i]; + + if( !fish->alive ) + continue; + + colour_code_v3( fish->payload, dot_colour ); + glUniform4fv( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1, dot_colour ); + + glUniform3f( SHADER_UNIFORM( shader_tile_colour, "uOffset" ), (float)fish->pos[0] + 0.5f - (float)fish->dir[0]*lerp, (float)fish->pos[1] + 0.25f - (float)fish->dir[1]*lerp, 0.25f ); + draw_mesh( 0, 32 ); + } + } + + if( world.simulating ) + { + 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 ); + } } -void vg_ui(void){} \ No newline at end of file +void vg_ui(void) +{ + ui_test(); +}