電脳の海

float hash21(vec2 p) {
    p = fract(p * vec2(123.45, 678.90));
    p += dot(p, p + 45.67);
    return fract(p.x * p.y);
}

float value_noise(vec2 p) {
    vec2 i = floor(p);
    vec2 f = fract(p);
    f = f * f * (3.0 - 2.0 * f);

    float a = hash21(i);
    float b = hash21(i + vec2(1.0, 0.0));
    float c = hash21(i + vec2(0.0, 1.0));
    float d = hash21(i + vec2(1.0, 1.0));

    return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);
}

float fbm(vec2 p) {
    float sum = 0.0;
    float amp = 0.5;
    float freq = 1.0;
    for (int i = 0; i < 5; i++) {
        sum += value_noise(p * freq) * amp;
        freq *= 2.0;
        amp *= 0.5;
    }
    return sum;
}

void mainImage(out vec4 fragColor, in vec2 fragCoord) {
    vec2 uv = (fragCoord * 2.0 - iResolution.xy) / iResolution.y;
    vec2 R = iResolution.xy / iResolution.y;

    float time = iTime * 0.15; // Global slow time

    // --- Digital Ocean Flow Field ---
    vec2 flow_uv = uv * 0.7 + time * 0.5;
    vec2 displacement = vec2(
        fbm(flow_uv * 3.0 + vec2(0.0, time * 0.5)),
        fbm(flow_uv * 3.0 + vec2(time * 0.5, 0.0))
    ) * 0.2; // Scale the distortion
    
    vec2 distorted_uv = uv + displacement;

    // --- Flowing Text/Data Pattern ---
    vec2 grid_uv = distorted_uv * 15.0; // Scale for grid cells
    grid_uv.y -= iTime * 0.3; // Overall vertical scroll

    vec2 cell_id = floor(grid_uv);
    vec2 cell_pos = fract(grid_uv) - 0.5; // Centered in cell (-0.5 to 0.5)

    float pattern_val = 0.0;

    // Base grid lines (subtle background structure)
    float grid_line_thickness = 0.03;
    pattern_val += smoothstep(grid_line_thickness, grid_line_thickness * 0.5, abs(cell_pos.x)) * 0.05;
    pattern_val += smoothstep(grid_line_thickness, grid_line_thickness * 0.5, abs(cell_pos.y)) * 0.05;

    // Procedural "characters" or "data segments"
    float char_seed = hash21(cell_id);
    float char_time_offset = iTime * (0.5 + char_seed * 0.5); // Varied blinking time per cell
    float blink = (sin(char_time_offset * 5.0 + char_seed * 10.0) * 0.5 + 0.5); // Blinking effect

    float segment_thickness = 0.1;
    
    // Vertical line segments
    if (char_seed < 0.6) {
        float segment_length = 0.3 + 0.2 * sin(char_seed * 20.0 + iTime * 2.0);
        float segment_offset_y = sin(char_seed * 30.0 + iTime * 1.5) * 0.2; // Wavy motion

        float dist_x = abs(cell_pos.x);
        float dist_y = abs(cell_pos.y - segment_offset_y);
        
        if (dist_y < segment_length * 0.5) {
             pattern_val = max(pattern_val, smoothstep(segment_thickness, segment_thickness * 0.5, dist_x) * blink);
        }
    }

    // Horizontal line segments (less frequent)
    if (char_seed > 0.6 && char_seed < 0.8) {
        float h_segment_length = 0.2 + 0.1 * sin(char_seed * 15.0 + iTime * 1.8);
        float h_segment_offset_x = sin(char_seed * 25.0 + iTime * 1.2) * 0.2;

        float dist_x = abs(cell_pos.x - h_segment_offset_x);
        float dist_y = abs(cell_pos.y);
        
        if (dist_x < h_segment_length * 0.5) {
            pattern_val = max(pattern_val, smoothstep(segment_thickness, segment_thickness * 0.5, dist_y) * blink * 0.5);
        }
    }

    // Random "dots" or "pixels"
    if (char_seed > 0.85) {
        float dot_size = 0.08 + 0.05 * sin(char_seed * 40.0 + iTime * 4.0);
        pattern_val = max(pattern_val, smoothstep(dot_size, dot_size * 0.5, length(cell_pos)) * blink * 1.5);
    }

    // Add some overall noise for organic texture
    pattern_val += fbm(distorted_uv * 8.0 + time * 0.5) * 0.1;

    // Amplify and sharpen the pattern for glowing effect
    pattern_val = pow(pattern_val, 2.0) * 5.0; 

    // --- Coloring ---
    vec3 color_bg = vec3(0.02, 0.02, 0.1);    // Deep dark blue background
    vec3 color_mid = vec3(0.05, 0.2, 0.4);   // Mid-tone ocean blue
    vec3 color_fg = vec3(0.1, 0.6, 0.8);     // Cyan/Blue glow
    vec3 color_bright = vec3(0.7, 1.0, 1.0); // Brightest core (white-cyan)

    vec3 final_color = color_bg;
    final_color = mix(final_color, color_mid, pattern_val * 0.5);
    final_color = mix(final_color, color_fg, pattern_val * 1.5);
    final_color = mix(final_color, color_bright, pattern_val * 3.0);
    
    // Clamp color values to prevent over-saturation
    final_color = min(final_color, vec3(1.0));

    // --- Subtle Vignette ---
    float vignette = smoothstep(1.0, 0.7, length(uv));
    final_color *= vignette;

    fragColor = vec4(final_color, 1.0);
}