"## ##;\n"
"## ##;\n"
"###+#####+###;aa,aaa\n"
- "#############;\n"
+ "#############;\n",
+
+ // Level 5
+ "###############;\n"
+ "####-##########;abcb\n"
+ "## ##;\n"
+ "## ##;\n"
+ "## ##;\n"
+ "## ##;\n"
+ "## ##;\n"
+ "## ##;\n"
+ "## ##;\n"
+ "## ##;\n"
+ "## ##;\n"
+ "##########+####;bcba\n"
+ "###############;\n"
};
m3x3f m_projection;
};
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;
world.io = NULL;
}
-static void map_reclassify( v2i start, v2i end );
+static void map_reclassify( v2i start, v2i end, int update_texbuffer );
static int map_load( const char *str )
{
map_free();
c ++;
}
- map_reclassify( NULL, NULL );
+ // 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 loaded! (%u:%u)\n", world.w, world.h );
return 1;
}
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();
map_load( level_pack[ 0 ] );
{
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}};
vg_info( "Stopping simulation!\n" );
}
- float ratio = (float)vg_window_y / (float)vg_window_x;
- float const size = 9.5f;
+ // 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] = -0.5f * world.w;
- origin[1] = -0.5f * world.h;
+ origin[0] = floorf( -0.5f * world.w );
+ origin[1] = floorf( -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 );
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
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;
{
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 )
glViewport( 0,0, vg_window_x, vg_window_y );
glDisable( GL_DEPTH_TEST );
- glClearColor( 0.8f, 0.8f, 0.8f, 1.0f );
+ glClearColor( 0.369768f, 0.3654f, 0.42f, 1.0f );
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
v4f const colour_default = {1.0f, 1.0f, 1.0f, 1.0f};
use_mesh( &world.tile );
+ // Draw background
+
+ if(1){
+
+ SHADER_USE( shader_background );
+ glUniformMatrix3fv( SHADER_UNIFORM( shader_background, "uPv" ), 1, GL_FALSE, (float *)vg_pv );
+
+ glActiveTexture( GL_TEXTURE0 );
+ glBindTexture( GL_TEXTURE_2D, world.background_data );
+ glUniform1i( SHADER_UNIFORM( shader_background, "uTexMain" ), 0 );
+
+ 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 );
+
+ }
+
+
SHADER_USE( shader_tile_main );
m2x2f subtransform;
glUniformMatrix2fv( SHADER_UNIFORM( shader_tile_main, "uSubTransform" ), 1, GL_FALSE, (float *)subtransform );
glUniformMatrix3fv( SHADER_UNIFORM( shader_tile_main, "uPv" ), 1, GL_FALSE, (float *)vg_pv );
glUniform1f( SHADER_UNIFORM( shader_tile_main, "uGhost" ), 0.0f );
+ glUniform1f( SHADER_UNIFORM( shader_tile_main, "uForeground" ), 0.0f );
+
+ glEnable(GL_BLEND);
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ glBlendEquation(GL_FUNC_ADD);
// Bind textures
vg_tex2d_bind( &tex_tile_data, 0 );
render_tiles( NULL, NULL, colour_default, colour_default );
- glEnable(GL_BLEND);
- glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
- glBlendEquation(GL_FUNC_ADD);
+
SHADER_USE( shader_ball );
glUniformMatrix3fv( SHADER_UNIFORM( shader_ball, "uPv" ), 1, GL_FALSE, (float *)vg_pv );
vg_tex2d_bind( &tex_wood, 1 );
glUniform1i( SHADER_UNIFORM( shader_tile_main, "uTexWood" ), 1 );
+ glUniform1f( SHADER_UNIFORM( shader_tile_main, "uForeground" ), 1.0f );
render_tiles( NULL, NULL, colour_default, colour_selected );
// Draw splitters
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);
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 )
void vg_ui(void)
{
//ui_test();
- sfx_internal_debug_overlay();
}
projects / fishladder.git / blobdiff