improve visuals

diff --git a/fishladder.c b/fishladder.c
index d4640be4b2f08e27c15113af77bd07bfe819f5e8..b95248c0d76443f19c2015fe3626f829bd89b2a8 100644 (file)
--- a/fishladder.c
+++ b/fishladder.c
@@ -923,8 +923,13 @@ struct dcareer_state
 };
 #pragma pack(pop)
 
+static int career_load_success = 0;
+
 static void career_serialize(void)
 {
+       if( !career_load_success )
+               return;
+
        struct dcareer_state encoded;
        encoded.version = 2;
        encoded.in_map = world.pCmpLevel? world.pCmpLevel->serial_id: -1;
@@ -1003,7 +1008,6 @@ static void career_load(void)
                {
                        vg_warn( "This save file is too small to have a header. Creating a blank one\n" );
                        free( cr );
-                       return;
                }
                
                memcpy( (void*)&encoded, cr, VG_MIN( sizeof( struct dcareer_state ), sz ) );
@@ -1045,6 +1049,8 @@ static void career_load(void)
                        }
                }
        }
+       
+       career_load_success = 1;
 }
 
 // MAIN GAMEPLAY
@@ -1527,11 +1533,6 @@ void vg_update(void)
                                        if( cell_current->state & FLAG_IS_TRIGGER )
                                        {
                                                int trigger_id = cell_current->links[0]?0:1;
-                                               int connection_id = cell_current->links[trigger_id];
-                                               int target_px = connection_id % world.w;
-                                               int target_py = (connection_id - target_px)/world.w;
-                                               
-                                               vg_line2( (v2f){ fish->pos[0], fish->pos[1] }, (v2f){ target_px, target_py }, 0xffffffff, 0xffffffff );
                                                
                                                struct cell *target_peice = &world.data[ cell_current->links[trigger_id] ];
                                                
@@ -2028,7 +2029,7 @@ void vg_render(void)
        v4f const colour_default = {1.0f, 1.0f, 1.0f, 1.0f};
        v4f const colour_selected = {0.90f, 0.92f, 1.0f, 1.0f};
 
-       int const circle_base = 4;
+       int const circle_base = 6;
        int const filled_start = circle_base+0;
        int const filled_count = circle_base+32;
        int const empty_start = circle_base+32;
@@ -2220,25 +2221,33 @@ void vg_render(void)
        
        // WIRES
        // ========================================================================================================
-       glDisable(GL_BLEND);
+       //glDisable(GL_BLEND);
 
        SHADER_USE( shader_wire );
        glBindVertexArray( world.wire.vao );
 
        glUniformMatrix3fv( SHADER_UNIFORM( shader_wire, "uPv" ), 1, GL_FALSE, (float *)vg_pv );
-       glUniform4f( SHADER_UNIFORM( shader_wire, "uColour" ), 0.2f, 0.2f, 0.2f, 1.0f );
+       
+       v4f const wire_left_colour = { 0.5f, 0.5f, 0.5f, 1.0f };
+       v4f const wire_right_colour = { 0.2f, 0.2f, 0.2f, 1.0f };
+       v4f const wire_drag_colour = { 0.2f, 0.2f, 0.2f, 0.6f };
+       
+       glUniform1f( SHADER_UNIFORM( shader_wire, "uTime" ), world.frame_lerp );
+       glUniform1f( SHADER_UNIFORM( shader_wire, "uGlow" ), 0.0f );
        
        if( world.id_drag_from )
-       {               
+       {
+               glUniform4fv( SHADER_UNIFORM( shader_wire, "uColour" ), 1, wire_drag_colour );
                glUniform1f( SHADER_UNIFORM( shader_wire, "uCurve" ), 0.4f );
-               glUniform3f( SHADER_UNIFORM( shader_wire, "uStart" ), world.drag_from_co[0], world.drag_from_co[1], 0.06f );
-               glUniform3f( SHADER_UNIFORM( shader_wire, "uEnd" ), world.drag_to_co[0], world.drag_to_co[1], 0.06f );
+               glUniform3f( SHADER_UNIFORM( shader_wire, "uStart" ), world.drag_from_co[0], world.drag_from_co[1], 0.20f );
+               glUniform3f( SHADER_UNIFORM( shader_wire, "uEnd" ), world.drag_to_co[0], world.drag_to_co[1], 0.20f );
                glDrawElements( GL_TRIANGLES, world.wire.em, GL_UNSIGNED_SHORT, (void*)(0) );
        }
        
        // Pulling animation
        float rp_x1 = world.frame_lerp*9.0f;
-       float rp_x2 = 1.0f-rp_x1*expf(1.0f-rp_x1)* 0.36f;
+       float rp_xa = rp_x1*expf(1.0f-rp_x1)* 0.36f;
+       float rp_x2 = 1.0f-rp_xa;
        
        for( int y = 2; y < world.h-2; y ++ )
        {
@@ -2268,23 +2277,91 @@ void vg_render(void)
                                        
                                        v2_add( desc->trigger_pos, endpoint, endpoint );
                                        
+                                       glUniform4fv( SHADER_UNIFORM( shader_wire, "uColour" ), 1, trigger_id? wire_right_colour: wire_left_colour );
                                        glUniform1f( SHADER_UNIFORM( shader_wire, "uCurve" ), cell->state & FLAG_TRIGGERED? rp_x2 * 0.4f: 0.4f );
-                                       glUniform3f( SHADER_UNIFORM( shader_wire, "uStart" ), startpoint[0], startpoint[1], 0.04f );
-                                       glUniform3f( SHADER_UNIFORM( shader_wire, "uEnd" ), endpoint[0], endpoint[1], 0.04f );
+                                       glUniform1f( SHADER_UNIFORM( shader_wire, "uGlow" ), cell->state & FLAG_TRIGGERED? rp_xa: 0.0f );
+                                       glUniform3f( SHADER_UNIFORM( shader_wire, "uStart" ), startpoint[0], startpoint[1], 0.18f );
+                                       glUniform3f( SHADER_UNIFORM( shader_wire, "uEnd" ), endpoint[0], endpoint[1], 0.18f );
                                        glDrawElements( GL_TRIANGLES, world.wire.em, GL_UNSIGNED_SHORT, (void*)(0) );
                                }
                        }
                }
        }
        
-       // I/O ARRAYS
+       // WIRE ENDPOINTS
        // ========================================================================================================
        
        SHADER_USE( shader_tile_colour );
        glUniformMatrix3fv( SHADER_UNIFORM( shader_tile_colour, "uPv" ), 1, GL_FALSE, (float *)vg_pv );
        use_mesh( &world.shapes );
        
-       glEnable(GL_BLEND);
+       for( int y = 2; y < world.h-2; y ++ )
+       {
+               for( int x = 2; x < world.w-2; x ++ )
+               {
+                       struct cell *cell = pcell((v2i){x,y});
+
+                       if( cell->state & FLAG_CANAL )
+                       {
+                               if( cell->state & FLAG_IS_TRIGGER )
+                               {
+                                       struct cell_description *desc = &cell_descriptions[ cell->config ];
+                               
+                                       int trigger_id = cell->links[0]?0:1;
+                                       
+                                       int x2 = cell->links[trigger_id] % world.w;
+                                       int y2 = (cell->links[trigger_id] - x2) / world.w;
+                                       
+                                       v2f pts[2];
+                                       
+                                       pts[0][0] = (float)x2 + (trigger_id? 0.75f: 0.25f);
+                                       pts[0][1] = (float)y2 + 0.25f;
+                                       
+                                       pts[1][0] = x;
+                                       pts[1][1] = y;
+                                       
+                                       v2_add( desc->trigger_pos, pts[1], pts[1] );
+                                       
+                                       glUniform4fv( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 
+                                                       1, trigger_id? wire_right_colour: wire_left_colour );
+                                       
+                                       for( int i = 0; i < 2; i ++ )
+                                       {
+                                               glUniform3f( SHADER_UNIFORM( shader_tile_colour, "uOffset" ), 
+                                                       pts[i][0],
+                                                       pts[i][1], 
+                                                       0.08f 
+                                               );
+                                               draw_mesh( filled_start, filled_count );        
+                                       }
+                               }
+                       }
+               }
+       }
+       
+       // SUB SPLITTER DIRECTION
+       // ========================================================================================================
+       
+       glUniform4f( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 0.9f, 0.35f, 0.1f, 0.75f );
+       
+       for( int y = 2; y < world.h-2; y ++ )
+       {
+               for( int x = 2; x < world.w-2; x ++ )
+               {
+                       struct cell *cell = pcell((v2i){x,y});
+
+                       if( cell->state & FLAG_CANAL && cell->state & FLAG_TARGETED && cell->config == k_cell_type_split )
+                       {
+                               glUniform3f( SHADER_UNIFORM( shader_tile_colour, "uOffset" ), x, y, 1.0f );
+                               draw_mesh( cell->state & FLAG_FLIP_FLOP? 5: 4, 1 );
+                       }
+               }
+       }
+       
+       // I/O ARRAYS
+       // ========================================================================================================
+       
+       //glEnable(GL_BLEND);
        
        for( int i = 0; i < arrlen( world.io ); i ++ )
        {
@@ -2982,6 +3059,9 @@ static int console_changelevel( int argc, char const *argv[] )
 // START UP / SHUTDOWN
 // ===========================================================================================================
 
+#define TRANSFORM_TRI_2D( S, OX, OY, X1, Y1, X2, Y2, X3, Y3 ) \
+       X1*S+OX, Y1*S+OY, X2*S+OX, Y2*S+OY, X3*S+OX, Y3*S+OY 
+
 void vg_start(void)
 {
        // Steamworks callbacks
@@ -3010,15 +3090,18 @@ void vg_start(void)
 
        // Combined quad, long quad / empty circle / filled circle mesh
        {
-               float combined_mesh[6*8 + 32*6*3] = {
+               float combined_mesh[6*6 + 32*6*3] = {
                        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, 0.2f, 1.0f, 0.2f,
-                       0.0f, 0.0f, 1.0f, 0.2f, 1.0f, 0.0f
+                       0.0f, 0.0f, 1.0f, 0.2f, 1.0f, 0.0f,
+                       
+                       TRANSFORM_TRI_2D( 0.15f,0.05f,0.4f, 0.0f, 1.0f, 1.0f, 2.0f, 1.0f, 0.0f ),
+                       TRANSFORM_TRI_2D( 0.15f,0.80f,0.4f, 0.0f, 0.0f, 0.0f, 2.0f, 1.0f, 1.0f )
                };
                
-               float *circle_mesh = combined_mesh + 6*4;
+               float *circle_mesh = combined_mesh + 6*6;
                int const res = 32;
 
                for( int i = 0; i < res; i ++ )

diff --git a/fishladder_resources.h b/fishladder_resources.h
index 7e78aa48ccad779c292d38dba09202f53d8f33dc..30b4dc9609e3af70754233636234e8556ee19afa 100644 (file)
--- a/fishladder_resources.h
+++ b/fishladder_resources.h
@@ -385,15 +385,26 @@ SHADER_DEFINE( shader_wire,
        ""
        "uniform sampler2D uTexMain;"
        "uniform vec4 uColour;"
+       "uniform float uTime;"
+       "uniform float uGlow;"
        ""
        "in vec2 aTexCoords;"
        ""
        "void main()"
        "{"
-               "FragColor = uColour;"
+               // Compute shadowing
+               "float shadow = 1.0 - abs(aTexCoords.y - 0.5) * 2.0;"
+               "float masking = smoothstep( 0.5, 0.8, shadow );"
+               
+               "vec3 colour_comp = mix( vec3(0.0,0.0,0.0), uColour.rgb, masking );"
+               
+               "float flow_thing = fract( aTexCoords.x + uTime );"
+               "vec3 final_comp = colour_comp + flow_thing * uGlow;"
+               
+               "FragColor = vec4( final_comp, max( shadow* 0.2, masking ) * uColour.a );"
        "}"
        ,
-       UNIFORMS({ "uPv", "uColour", "uTexMain", "uStart", "uEnd", "uCurve" })
+       UNIFORMS({ "uPv", "uColour", "uTexMain", "uStart", "uEnd", "uCurve", "uTime", "uGlow" })
 )
 
 SHADER_DEFINE( shader_buttons,

diff --git a/maps/cmp_xor.map b/maps/cmp_xor.map
new file mode 100644 (file)
index 0000000..1cf622c
--- /dev/null
+++ b/maps/cmp_xor.map
@@ -0,0 +1,12 @@
+#############;
+######-######;:c:c:
+##         ##;
+##         ##;
+##         ##;
+##         ##;
+##         ##;
+##         ##;
+##         ##;
+##         ##;
+###+##+###+##;::a:a,:a::a,c:c:c:c
+#############;

diff --git a/vg/vg.h b/vg/vg.h
index 5d67f714807264699dbda5a33984ffe6e7f2cbba..13f3d63f00a8b8364db9f03441eb719ce3710151 100644 (file)
--- a/vg/vg.h
+++ b/vg/vg.h
@@ -154,7 +154,7 @@ static void vg_init( int argc, char *argv[], const char *window_name )
        glfwWindowHint( GLFW_CONTEXT_VERSION_MINOR, 3 );
        glfwWindowHint( GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE );
        glfwWindowHint( GLFW_OPENGL_DEBUG_CONTEXT, GL_TRUE );
-       glfwWindowHint( GLFW_RESIZABLE, GLFW_FALSE );
+       glfwWindowHint( GLFW_RESIZABLE, GLFW_TRUE );
        
        glfwWindowHint( GLFW_SAMPLES, 4 );