dynamic background hsader

diff --git a/fishladder.c b/fishladder.c
index 1bc0d5cf02591af208d25bb2cb997cadba0fc6ff..c4d575d4642e73f3caf0a35d3c5937936b9c36c5 100644 (file)
--- a/fishladder.c
+++ b/fishladder.c
@@ -59,7 +59,22 @@ const char *level_pack[] =
        "##         ##;\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;
@@ -101,9 +116,9 @@ enum cell_type
 };
 
 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 )
 {
@@ -191,6 +206,7 @@ struct world
        struct mesh tile, circle;
        
        GLuint background_data;
+       GLuint random_samples;
        
        int selected, tile_x, tile_y;
        v2f tile_pos;
@@ -224,7 +240,7 @@ static void map_free(void)
        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();
@@ -341,7 +357,23 @@ static int map_load( const char *str )
                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;
 }
@@ -406,10 +438,27 @@ void vg_start(void)
        }
        
        // 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();
        
@@ -420,6 +469,9 @@ void vg_free(void)
 {
        resource_free_main();
 
+       glDeleteTextures( 1, &world.background_data );
+       glDeleteTextures( 1, &world.random_samples );
+
        free_mesh( &world.tile );
        free_mesh( &world.circle );
        
@@ -511,7 +563,7 @@ static int cell_interactive( v2i co )
        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 };
@@ -521,16 +573,28 @@ static void map_reclassify( v2i start, v2i 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 = 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 ++ )
                                {
@@ -538,12 +602,32 @@ static void map_reclassify( v2i start, v2i end )
                                        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}};
@@ -621,7 +705,7 @@ void vg_update(void)
                                        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
@@ -997,15 +1081,21 @@ void vg_render(void)
        
        // 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 );
 
@@ -1122,7 +1212,7 @@ void vg_render(void)
                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 );
@@ -1132,7 +1222,7 @@ void vg_render(void)
                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);
@@ -1160,7 +1250,7 @@ void vg_render(void)
                
                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 )

diff --git a/fishladder_resources.h b/fishladder_resources.h
index 00cb199a780b3334f02ed0eb9201c46fc7939d0a..4408dcf8784b4ecfe293a7fcb76443099af5c04d 100644 (file)
--- a/fishladder_resources.h
+++ b/fishladder_resources.h
@@ -250,31 +250,46 @@ SHADER_DEFINE( shader_background,
        "{"
                "vec2 world_pos = a_co * uOffset.z + uOffset.xy;"
                "gl_Position = vec4( uPv * vec3( world_pos, 1.0 ), 1.0 );"
-               "aTexCoords = world_pos * 0.25;"
+               "aTexCoords = a_co;"
        "}",
        
        // FRAGMENT
        "out vec4 FragColor;"
        ""
        "uniform sampler2D uTexMain;"
+       "uniform sampler2D uSamplerNoise;"
+       "uniform float uVariance;"
        ""
        "in vec2 aTexCoords;"
        ""
-       "vec2 hash22(vec2 p)"
-       "{"
-               "vec3 p3 = fract(vec3(p.xyx) * vec3(.1031, .1030, .0973));"
-               "p3 += dot(p3, p3.yzx+33.33);"
-               "return fract((p3.xx+p3.yz)*p3.zy);"
-       "}"
-       ""
        "void main()"
        "{"
-               "vec2 random_offset = floor( hash22( floor( aTexCoords * 4.0 ) ) * 4.0 ) * 0.25;"
-               "vec4 background = texture( uTexMain, aTexCoords );"
-               "FragColor = vec4( background.rgb * (1.0+random_offset.r*0.015), 1.0 );"
+               "float ao_accum = 0.0;"
+               "for( int i=0; i<10; ++i )"
+               "{"
+                       "vec2 random_noise = (texture( uSamplerNoise, aTexCoords * 20.0 + float(i) * 0.2 ).xy - vec2( 0.5, 0.5 )) * uVariance;"
+                       "vec4 background = texture( uTexMain, aTexCoords + random_noise );"
+                       "ao_accum += background.r * clamp((1.0 - length( random_noise )), 0.0, 1.0);"
+               "}"
+               "ao_accum *= 0.15;"
+               
+               "vec4 data_this_tile = texture( uTexMain, aTexCoords );"
+               
+               "ao_accum -= data_this_tile.r;"
+               
+               "vec3 colour_main = vec3( 0.369768, 0.3654, 0.42 );"
+               
+               "vec2 square_coords = fract( aTexCoords * 64.0 );"
+               "vec2 grid_coords = abs( square_coords - 0.5 );"
+               "float edge_contrast = (1.0-ao_accum*0.2);"
+               
+               "float gridline = step( 0.49, max(grid_coords.x,grid_coords.y) );"
+               "float gridline_fadeout = min(max(edge_contrast-1.0, 0.0)*40.0 + data_this_tile.g,10.0);"
+               
+               "FragColor = vec4( colour_main * edge_contrast + gridline * 0.02 * gridline_fadeout, 1.0 );"
        "}"
        ,
-       UNIFORMS({ "uPv", "uOffset", "uTexMain" })
+       UNIFORMS({ "uPv", "uOffset", "uTexMain", "uVariance", "uSamplerNoise" })
 )
 
 void vg_register(void)