rbgl 0.1.0

data/examples/hexagonal_flow.rb

@@ -0,0 +1,333 @@
+# frozen_string_literal: true
+
+# Hexagon X5 - Hexagonal Flow Pattern
+# Original: https://www.shadertoy.com/view/4cVfWG
+# Created by @byt3_m3chanic - 12/17/2024
+# License: Creative Commons Attribution-NonCommercial-ShareAlike 3.0
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+
+require "rbgl"
+require "rlsl"
+
+WIDTH = 640
+HEIGHT = 480
+
+# Hexagonal grid constants
+module HexConstants
+  N = 3.0
+  S4 = 0.577350  # 1/sqrt(3)
+  S3 = 0.288683  # 1/(2*sqrt(3))
+  S2 = 0.866025  # sqrt(3)/2
+end
+
+shader = RLSL.define(:hexflow) do
+  uniforms do
+    float :time
+    vec2 :mouse
+  end
+
+  helpers(:c) do
+    n = HexConstants::N
+    s4 = HexConstants::S4
+    s3 = HexConstants::S3
+    s2 = HexConstants::S2
+
+    <<~C
+      // Constants (PI and TAU already defined in code_generator.rb)
+      #define PI2 6.283185307f
+
+      static const float N = #{n}f;
+      static const float s4 = #{s4}f;
+      static const float s3 = #{s3}f;
+      static const float s2 = #{s2}f;
+
+      // Global state
+      static vec3 clr, trm;
+      static float tk, ln;
+      static float r2_cos, r2_sin, r3_cos, r3_sin;
+
+      // 2x2 matrix multiply
+      static inline vec2 mat2_mul(float c, float s, vec2 v) {
+        return vec2_new(c * v.x + s * v.y, -s * v.x + c * v.y);
+      }
+
+      // Hash function (custom version for hex grid)
+      static float hex_hash21(vec2 p) {
+        p.x = fmodf(p.x, 3.0f * N);
+        if (p.x < 0.0f) p.x += 3.0f * N;
+        float d = p.x * 26.37f + p.y * 45.93f;
+        return fract(sinf(d) * 4374.23f);
+      }
+
+      // Hexagon grid system
+      static vec4 hexgrid(vec2 uv) {
+        vec2 p1 = vec2_new(floorf(uv.x / 1.732f) + 0.5f, floorf(uv.y) + 0.5f);
+        vec2 p2 = vec2_new(floorf((uv.x - 1.0f) / 1.732f) + 0.5f, floorf(uv.y - 0.5f) + 0.5f);
+
+        vec2 h1 = vec2_new(uv.x - p1.x * 1.732f, uv.y - p1.y);
+        vec2 h2 = vec2_new(uv.x - (p2.x + 0.5f) * 1.732f, uv.y - (p2.y + 0.5f));
+
+        if (vec2_dot(h1, h1) < vec2_dot(h2, h2)) {
+          return vec4_new(h1.x, h1.y, p1.x, p1.y);
+        } else {
+          return vec4_new(h2.x, h2.y, p2.x + 0.5f, p2.y + 0.5f);
+        }
+      }
+
+      // Draw function with anti-aliasing
+      static void draw(float d, float px, vec3 *C) {
+        float b = fabsf(d) - tk;
+
+        // Shadow
+        float t1 = smoothstep(0.1f + px, -px, b - 0.01f);
+        C->x = mix_f(C->x, C->x * 0.25f, t1);
+        C->y = mix_f(C->y, C->y * 0.25f, t1);
+        C->z = mix_f(C->z, C->z * 0.25f, t1);
+
+        // Fill
+        float t2 = smoothstep(px, -px, b);
+        C->x = mix_f(C->x, clr.x, t2);
+        C->y = mix_f(C->y, clr.y, t2);
+        C->z = mix_f(C->z, clr.z, t2);
+
+        // Highlight
+        float t3 = smoothstep(0.01f + px, -px, b + 0.1f);
+        C->x = mix_f(C->x, clamp_f(C->x + 0.2f, C->x, 0.95f), t3);
+        C->y = mix_f(C->y, clamp_f(C->y + 0.2f, C->y, 0.95f), t3);
+        C->z = mix_f(C->z, clamp_f(C->z + 0.2f, C->z, 0.95f), t3);
+
+        // Trim
+        float t4 = smoothstep(px, -px, fabsf(b) - ln);
+        C->x = mix_f(C->x, trm.x, t4);
+        C->y = mix_f(C->y, trm.y, t4);
+        C->z = mix_f(C->z, trm.z, t4);
+      }
+
+      // Procedural texture replacement (since we don't have iChannel0)
+      static vec3 proc_texture(vec2 p) {
+        float n = sinf(p.x * 10.0f) * sinf(p.y * 10.0f);
+        n = n * 0.5f + 0.5f;
+        return vec3_new(0.906f * n, 0.282f * n, 0.075f * n);
+      }
+    C
+  end
+
+  fragment do
+    <<~C
+      // Initialize rotation matrices (1.047 radians = 60 degrees)
+      r2_cos = cosf(1.047f);
+      r2_sin = sinf(1.047f);
+      r3_cos = cosf(-1.047f);
+      r3_sin = sinf(-1.047f);
+
+      // Normalized coordinates
+      vec2 uv_screen = vec2_new(
+        (2.0f * frag_coord.x - resolution.x) / fmaxf(resolution.x, resolution.y),
+        (2.0f * frag_coord.y - resolution.y) / fmaxf(resolution.x, resolution.y)
+      );
+
+      // Mouse offset
+      vec2 mouse_norm = vec2_new(
+        (2.0f * u.mouse.x - resolution.x) / resolution.x,
+        (2.0f * u.mouse.y - resolution.y) / resolution.y
+      );
+
+      // Log-polar transformation
+      float len = sqrtf(uv_screen.x * uv_screen.x + uv_screen.y * uv_screen.y);
+      if (len < 0.001f) len = 0.001f;
+
+      vec2 uv_polar = vec2_new(
+        -logf(len) - mouse_norm.x,
+        -atan2f(uv_screen.y, uv_screen.x) - mouse_norm.y
+      );
+
+      uv_polar = vec2_div(uv_polar, 3.628f);
+      uv_polar = vec2_mul(uv_polar, N);
+
+      // Animation
+      uv_polar.y += u.time * 0.05f;
+      uv_polar.x += u.time * 0.15f;
+
+      float sc = 3.0f;
+      float px = 0.01f;  // Approximate fwidth
+
+      // Hexgrid with swapped coordinates
+      vec4 H = hexgrid(vec2_new(uv_polar.y * sc, uv_polar.x * sc));
+      vec2 p = vec2_new(H.x, H.y);
+      vec2 id = vec2_new(H.z, H.w);
+
+      float hs = hex_hash21(id);
+
+      // Random rotation
+      if (hs < 0.5f) {
+        if (hs < 0.25f) {
+          p = mat2_mul(r3_cos, r3_sin, p);
+        } else {
+          p = mat2_mul(r2_cos, r2_sin, p);
+        }
+      }
+
+      // Triangle vertices
+      vec2 p0 = vec2_new(p.x - (-s3), p.y - 0.5f);
+      vec2 p1 = vec2_new(p.x - s4, p.y);
+      vec2 p2 = vec2_new(p.x - (-s3), p.y - (-0.5f));
+
+      vec3 d3 = vec3_new(vec2_length(p0), vec2_length(p1), vec2_length(p2));
+      vec2 pp = vec2_new(0.0f, 0.0f);
+
+      if (d3.x > d3.y) pp = p1;
+      if (d3.y > d3.z) pp = p2;
+      if (d3.z > d3.x && d3.y > d3.x) pp = p0;
+
+      ln = 0.015f;
+      tk = 0.14f + 0.1f * sinf(uv_polar.x * 5.0f + u.time);
+
+      vec3 C = vec3_new(0.0f, 0.0f, 0.0f);
+
+      // Tile background (hexagon SDF)
+      float d = fmaxf(fabsf(p.x) * s2 + fabsf(p.y) * 0.5f, fabsf(p.y)) - (0.5f - ln);
+      vec3 tex_col = proc_texture(vec2_mul(p, 2.0f));
+
+      float t_bg = smoothstep(px, -px, d);
+      C.x = mix_f(0.0125f, tex_col.x, t_bg);
+      C.y = mix_f(0.0125f, tex_col.y, t_bg);
+      C.z = mix_f(0.0125f, tex_col.z, t_bg);
+
+      // Shading
+      float shade1 = clamp_f(1.0f - (H.y + 0.15f), 0.0f, 1.0f);
+      float t_s1 = mix_f(smoothstep(px, -px, d + 0.035f), 0.0f, shade1);
+      C.x = mix_f(C.x, C.x + 0.1f, t_s1);
+      C.y = mix_f(C.y, C.y + 0.1f, t_s1);
+      C.z = mix_f(C.z, C.z + 0.1f, t_s1);
+
+      float shade2 = clamp_f(1.0f - (H.x + 0.5f), 0.0f, 1.0f);
+      float t_s2 = mix_f(smoothstep(px, -px, d + 0.025f), 0.0f, shade2);
+      C.x = mix_f(C.x, C.x * 0.1f, t_s2);
+      C.y = mix_f(C.y, C.y * 0.1f, t_s2);
+      C.z = mix_f(C.z, C.z * 0.1f, t_s2);
+
+      // Base tile distance
+      float b = vec2_length(pp) - s3;
+      float t_val = 1e5f, g = 1e5f;
+      float tg = 1.0f;
+
+      hs = fract(hs * 53.71f);
+
+      // Alternate tile patterns
+      if (hs > 0.95f) {
+        vec2 p4 = mat2_mul(r3_cos, r3_sin, p);
+        vec2 p5 = mat2_mul(r2_cos, r2_sin, p);
+
+        b = vec2_length(vec2_new(p.x, fabsf(p.y) - 0.5f));
+        g = fabsf(p5.x);
+        t_val = fabsf(p4.x);
+        tg = 0.0f;
+      } else if (hs > 0.65f) {
+        b = fabsf(p.x);
+        g = fminf(vec2_length(p1) - s3, vec2_length(vec2_new(p1.x + 1.155f, p1.y)) - s3);
+        tg = 0.0f;
+      } else if (hs < 0.15f) {
+        vec2 p4 = mat2_mul(r3_cos, r3_sin, p);
+        vec2 p5 = mat2_mul(r2_cos, r2_sin, p);
+
+        t_val = fabsf(p.x);
+        b = fabsf(p5.x);
+        g = fabsf(p4.x);
+        tg = 0.0f;
+      } else if (hs < 0.22f) {
+        b = vec2_length(vec2_new(p.x, fabsf(p.y) - 0.5f));
+        g = fminf(vec2_length(p1) - s3, vec2_length(vec2_new(p1.x + 1.155f, p1.y)) - s3);
+      }
+
+      clr = vec3_new(0.420f, 0.278f, 0.043f);
+      trm = vec3_new(0.0f, 0.0f, 0.0f);
+
+      // Draw segments
+      draw(t_val, px, &C);
+      draw(g, px, &C);
+      draw(b, px, &C);
+
+      // Solid balls
+      if (tg > 0.0f) {
+        float v = vec2_length(p) - 0.25f;
+
+        float t1 = smoothstep(0.1f + px, -px, v - 0.01f);
+        C.x = mix_f(C.x, C.x * 0.25f, t1);
+        C.y = mix_f(C.y, C.y * 0.25f, t1);
+        C.z = mix_f(C.z, C.z * 0.25f, t1);
+
+        float t2 = smoothstep(px, -px, v);
+        C.x = mix_f(C.x, clr.x, t2);
+        C.y = mix_f(C.y, clr.y, t2);
+        C.z = mix_f(C.z, clr.z, t2);
+
+        float t3 = smoothstep(0.01f + px, -px, v + 0.1f);
+        C.x = mix_f(C.x, clamp_f(C.x + 0.2f, C.x, 0.95f), t3);
+        C.y = mix_f(C.y, clamp_f(C.y + 0.2f, C.y, 0.95f), t3);
+        C.z = mix_f(C.z, clamp_f(C.z + 0.2f, C.z, 0.95f), t3);
+
+        float t4 = smoothstep(px, -px, fabsf(v) - ln);
+        C.x = mix_f(C.x, trm.x, t4);
+        C.y = mix_f(C.y, trm.y, t4);
+        C.z = mix_f(C.z, trm.z, t4);
+      }
+
+      // Gamma correction
+      C.x = powf(C.x, 0.4545f);
+      C.y = powf(C.y, 0.4545f);
+      C.z = powf(C.z, 0.4545f);
+
+      return C;
+    C
+  end
+end
+
+# Initialize display
+window = RBGL::GUI::Window.new(width: WIDTH, height: HEIGHT, title: "Hexagon X5")
+
+puts "Hexagon X5 - Hexagonal Flow Pattern"
+puts "Original: https://www.shadertoy.com/view/4cVfWG"
+puts "License: Creative Commons Attribution-NonCommercial-ShareAlike 3.0"
+puts "https://creativecommons.org/licenses/by-nc-sa/3.0/deed.en"
+puts "Move mouse to pan"
+puts "Press 'q' or Escape to quit"
+
+start_time = Time.now
+frame_count = 0
+last_fps_time = start_time
+running = true
+mouse_x = WIDTH / 2.0
+mouse_y = HEIGHT / 2.0
+
+buffer = "\x00" * (WIDTH * HEIGHT * 4)
+
+while running && !window.should_close?
+  time = Time.now - start_time
+
+  shader.render(buffer, WIDTH, HEIGHT, { time: time, mouse: [mouse_x, mouse_y] })
+
+  window.set_pixels(buffer)
+
+  events = window.poll_events_raw
+  events.each do |e|
+    case e[:type]
+    when :key_press
+      running = false if e[:key] == 12 || e[:key] == "q"
+    when :mouse_move
+      mouse_x = e[:x].to_f
+      mouse_y = e[:y].to_f
+    end
+  end
+
+  frame_count += 1
+  now = Time.now
+  if now - last_fps_time >= 1.0
+    fps = frame_count / (now - last_fps_time)
+    puts "FPS: #{fps.round(1)}"
+    frame_count = 0
+    last_fps_time = now
+  end
+end
+
+window.close

data/examples/multi_return_test.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+# Multiple Return Value Test Shader
+# Tests Ruby-mode multiple return value support in RLSL
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+
+require "rbgl"
+require "rlsl"
+
+WIDTH = 640
+HEIGHT = 480
+
+shader = RLSL.define(:multi_return_test) do
+  uniforms do
+    float :time
+  end
+
+  functions do
+    # Function that returns multiple values (tuple)
+    define :compute_basis, returns: [:vec3, :vec3], params: { n: :vec3 }
+  end
+
+  helpers do
+    # Function returning multiple values as an array
+    def compute_basis(n)
+      # Orthonormal basis calculation
+      a = 1.0 / (1.0 + n.z + 0.0001)
+      b = n.y * a
+      c = 0.0 - n.x * a
+      xp = vec3(n.z + b, c, 0.0 - n.x)
+      yp = vec3(c, 1.0 - b, 0.0 - n.y)
+      [xp, yp]
+    end
+  end
+
+  fragment do |frag_coord, resolution, u|
+    uv = vec2(
+      (frag_coord.x - resolution.x * 0.5) / resolution.y,
+      (frag_coord.y - resolution.y * 0.5) / resolution.y
+    )
+
+    # Create a normal from UV coordinates
+    t = u.time * 0.5
+    n = normalize(vec3(uv.x + sin(t), uv.y + cos(t), 1.0))
+
+    # Get basis vectors using multiple return values
+    tang, binorm = compute_basis(n)
+
+    # Visualize the basis vectors
+    r = abs(tang.x) * 0.5 + 0.5
+    g = abs(binorm.y) * 0.5 + 0.5
+    b = abs(n.z) * 0.5 + 0.5
+
+    vec3(r, g, b)
+  end
+end
+
+# Initialize display
+window = RBGL::GUI::Window.new(width: WIDTH, height: HEIGHT, title: "Multi Return Test")
+
+puts "Multiple Return Value Test Shader"
+puts "Tests Ruby-mode multiple return value support"
+puts "Press 'q' or Escape to quit"
+
+start_time = Time.now
+frame_count = 0
+last_fps_time = start_time
+running = true
+
+buffer = "\x00" * (WIDTH * HEIGHT * 4)
+
+while running && !window.should_close?
+  time = Time.now - start_time
+
+  shader.render(buffer, WIDTH, HEIGHT, { time: time })
+
+  window.set_pixels(buffer)
+
+  events = window.poll_events_raw
+  events.each do |e|
+    case e[:type]
+    when :key_press
+      running = false if e[:key] == 12 || e[:key] == "q"
+    end
+  end
+
+  frame_count += 1
+  now = Time.now
+  if now - last_fps_time >= 1.0
+    fps = frame_count / (now - last_fps_time)
+    puts "FPS: #{fps.round(1)}"
+    frame_count = 0
+    last_fps_time = now
+  end
+end
+
+window.close

data/examples/plasma.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+# Classic Plasma Effect using Native Shader DSL
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+
+require "rbgl"
+require "rlsl"
+
+WIDTH = 640
+HEIGHT = 480
+
+# Define plasma shader using pure Ruby DSL
+shader = RLSL.define(:plasma) do
+  uniforms do
+    float :time
+  end
+
+  fragment do |frag_coord, resolution, u|
+    uv = frag_coord / resolution.y
+    cx = uv.x - 0.5
+    cy = uv.y - 0.5
+
+    v1 = sin(cx * 10.0 + u.time)
+    v2 = sin(10.0 * (cx * sin(u.time / 2.0) + cy * cos(u.time / 3.0)) + u.time)
+
+    cx2 = cx + 0.5 * sin(u.time / 5.0)
+    cy2 = cy + 0.5 * cos(u.time / 3.0)
+    v3 = sin(sqrt(100.0 * (cx2 * cx2 + cy2 * cy2) + 1.0) + u.time)
+
+    v = v1 + v2 + v3
+
+    r = sin(v * PI)
+    g = sin(v * PI + 2.0 * PI / 3.0)
+    b = sin(v * PI + 4.0 * PI / 3.0)
+
+    vec3((r + 1.0) * 0.5, (g + 1.0) * 0.5, (b + 1.0) * 0.5)
+  end
+end
+
+# Initialize display
+window = RBGL::GUI::Window.new(width: WIDTH, height: HEIGHT, title: "Plasma Effect")
+
+puts "Plasma Effect - Native Shader DSL"
+puts "Press 'q' or Escape to quit"
+
+start_time = Time.now
+frame_count = 0
+last_fps_time = start_time
+running = true
+
+buffer = "\x00" * (WIDTH * HEIGHT * 4)
+
+while running && !window.should_close?
+  time = Time.now - start_time
+
+  shader.render(buffer, WIDTH, HEIGHT, { time: time })
+
+  window.set_pixels(buffer)
+
+  events = window.poll_events_raw
+  events.each do |e|
+    if e[:type] == :key_press && (e[:key] == 12 || e[:key] == "q")
+      running = false
+    end
+  end
+
+  frame_count += 1
+  now = Time.now
+  if now - last_fps_time >= 1.0
+    fps = frame_count / (now - last_fps_time)
+    puts "FPS: #{fps.round(1)}"
+    frame_count = 0
+    last_fps_time = now
+  end
+end
+
+window.close

data/examples/sphere_raymarch.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+# Raymarching Sphere - Native Shader DSL
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+
+require "rbgl"
+require "rlsl"
+
+WIDTH = 640
+HEIGHT = 480
+
+shader = RLSL.define(:raymarch) do
+  uniforms do
+    float :time
+  end
+
+  fragment do |frag_coord, resolution, u|
+    uv = frag_coord / resolution.y
+
+    # Ray origin (camera position)
+    ro = vec3(0.0, 0.0, -3.0)
+
+    # Ray direction
+    centered = uv - vec2(0.5, 0.5)
+    rd = normalize(vec3(centered.x, centered.y, 1.0))
+
+    # Sphere center (animated)
+    sphere_center = vec3(
+      sin(u.time) * 0.5,
+      cos(u.time * 0.7) * 0.3,
+      0.0
+    )
+    sphere_radius = 0.8
+
+    # Ray-sphere intersection
+    oc = ro - sphere_center
+    a = dot(rd, rd)
+    b = 2.0 * dot(oc, rd)
+    c = dot(oc, oc) - sphere_radius * sphere_radius
+    discriminant = b * b - 4.0 * a * c
+
+    if discriminant > 0.0
+      t = (0.0 - b - sqrt(discriminant)) / (2.0 * a)
+      if t > 0.0
+        # Hit point
+        hit = ro + rd * t
+
+        # Normal at hit point
+        normal = normalize(hit - sphere_center)
+
+        # Light direction (animated)
+        light_dir = normalize(vec3(
+          sin(u.time * 0.5),
+          1.0,
+          cos(u.time * 0.3)
+        ))
+
+        # Diffuse lighting
+        diff = clamp(dot(normal, light_dir), 0.0, 1.0)
+
+        # Specular
+        view_dir = rd * -1.0
+        reflect_dir = normal * 2.0 * dot(normal, light_dir) - light_dir
+        spec = pow(clamp(dot(view_dir, reflect_dir), 0.0, 1.0), 32.0)
+
+        # Base color (hue shifts with time)
+        base_color = vec3(
+          0.5 + 0.5 * sin(u.time),
+          0.5 + 0.5 * sin(u.time + 2.0),
+          0.5 + 0.5 * sin(u.time + 4.0)
+        )
+
+        # Combine
+        ambient = 0.1
+        base_color * (ambient + diff * 0.7) + vec3(spec * 0.5, spec * 0.5, spec * 0.5)
+      else
+        # Behind camera
+        vec3(0.05, 0.05, 0.1)
+      end
+    else
+      # Background gradient
+      t = uv.y
+      mix(vec3(0.1, 0.1, 0.2), vec3(0.02, 0.02, 0.05), t)
+    end
+  end
+end
+
+# Initialize display
+window = RBGL::GUI::Window.new(width: WIDTH, height: HEIGHT, title: "Raymarched Sphere")
+
+puts "Raymarching Sphere - Native Shader DSL"
+puts "Press 'q' or Escape to quit"
+
+start_time = Time.now
+frame_count = 0
+last_fps_time = start_time
+running = true
+
+buffer = "\x00" * (WIDTH * HEIGHT * 4)
+
+while running && !window.should_close?
+  time = Time.now - start_time
+
+  shader.render(buffer, WIDTH, HEIGHT, { time: time })
+
+  window.set_pixels(buffer)
+
+  events = window.poll_events_raw
+  events.each do |e|
+    if e[:type] == :key_press && (e[:key] == 12 || e[:key] == "q")
+      running = false
+    end
+  end
+
+  frame_count += 1
+  now = Time.now
+  if now - last_fps_time >= 1.0
+    fps = frame_count / (now - last_fps_time)
+    puts "FPS: #{fps.round(1)}"
+    frame_count = 0
+    last_fps_time = now
+  end
+end
+
+window.close