3rb 0.1.0

data/examples/18_platonic_solids.rb

@@ -0,0 +1,268 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Platonic Solids - SDF Raymarching
+# Based on https://www.shadertoy.com/view/tclXzr
+
+require_relative "../lib/3rb"
+
+VERTEX_SHADER = <<~GLSL
+  #version 330 core
+
+  layout(location = 0) in vec3 position;
+  layout(location = 2) in vec2 uv;
+
+  out vec2 vUv;
+
+  void main() {
+    vUv = uv;
+    gl_Position = vec4(position.xy * 2.0, 0.0, 1.0);
+  }
+GLSL
+
+FRAGMENT_SHADER = <<~GLSL
+  #version 330 core
+
+  in vec2 vUv;
+
+  uniform float iTime;
+  uniform vec2 iResolution;
+
+  out vec4 fragColor;
+
+  #define TETRAHEDRON 0
+  #define CUBE 1
+  #define OCTAHEDRON 2
+  #define DODECAHEDRON 3
+  #define ICOSAHEDRON 4
+
+  #define PI 3.14159265359
+  #define PHI 1.618033988749895
+
+  #define MAX_STEPS 100
+  #define MAX_DIST 100.0
+  #define SURF_DIST 0.001
+  #define ROTATION_SPEED 0.5
+
+  vec3 rotateX(vec3 p, float a) {
+    float c = cos(a), s = sin(a);
+    return vec3(p.x, p.y * c - p.z * s, p.y * s + p.z * c);
+  }
+
+  vec3 rotateY(vec3 p, float a) {
+    float c = cos(a), s = sin(a);
+    return vec3(p.x * c - p.z * s, p.y, p.x * s + p.z * c);
+  }
+
+  vec3 rotateZ(vec3 p, float a) {
+    float c = cos(a), s = sin(a);
+    return vec3(p.x * c - p.y * s, p.x * s + p.y * c, p.z);
+  }
+
+  float sdTetrahedron(vec3 p, float r) {
+    float k = sqrt(2.0);
+    p.xy = abs(p.xy);
+    p.xy = (p.y > p.x) ? p.yx : p.xy;
+    p.xz = (p.z > p.x) ? p.zx : p.xz;
+    p.xy = (p.y > p.x) ? p.yx : p.xy;
+    float d = p.z - r;
+    return d * 0.57735027;
+  }
+
+  float sdBox(vec3 p, vec3 b) {
+    vec3 d = abs(p) - b;
+    return length(max(d, 0.0)) + min(max(d.x, max(d.y, d.z)), 0.0);
+  }
+
+  float sdOctahedron(vec3 p, float r) {
+    return (abs(p.x) + abs(p.y) + abs(p.z) - r) * 0.57735027;
+  }
+
+  float sdDodecahedron(vec3 p, float r) {
+    const vec3 n = normalize(vec3(PHI, 1.0, 0.0));
+
+    float d = 0.0;
+    d = max(d, abs(dot(p, vec3(n.x, n.y, n.z))));
+    d = max(d, abs(dot(p, vec3(n.x, n.y, -n.z))));
+    d = max(d, abs(dot(p, vec3(n.x, -n.y, n.z))));
+    d = max(d, abs(dot(p, vec3(n.x, -n.y, -n.z))));
+    d = max(d, abs(dot(p, vec3(n.z, n.x, n.y))));
+    d = max(d, abs(dot(p, vec3(n.z, n.x, -n.y))));
+    d = max(d, abs(dot(p, vec3(n.z, -n.x, n.y))));
+    d = max(d, abs(dot(p, vec3(n.z, -n.x, -n.y))));
+    d = max(d, abs(dot(p, vec3(n.y, n.z, n.x))));
+    d = max(d, abs(dot(p, vec3(n.y, n.z, -n.x))));
+    d = max(d, abs(dot(p, vec3(n.y, -n.z, n.x))));
+    d = max(d, abs(dot(p, vec3(n.y, -n.z, -n.x))));
+
+    return (d - r) * 0.5;
+  }
+
+  float sdIcosahedron(vec3 p, float r) {
+    const float q = sqrt(5.0);
+    const vec3 n1 = normalize(vec3(q, 2.0, 0));
+    const vec3 n2 = normalize(vec3(q, 0, 2.0));
+    const vec3 n3 = normalize(vec3(0, 2.0, q));
+    const vec3 n4 = normalize(vec3(0, q, 2.0));
+    const vec3 n5 = normalize(vec3(2.0, 0, q));
+    const vec3 n6 = normalize(vec3(2.0, q, 0));
+
+    float d;
+    d = max(abs(dot(p, n1.xyz)), max(abs(dot(p, n1.zxy)), abs(dot(p, n1.yzx))));
+    d = max(d, max(abs(dot(p, n2.xyz)), max(abs(dot(p, n2.zxy)), abs(dot(p, n2.yzx)))));
+    d = max(d, max(abs(dot(p, n3.xyz)), max(abs(dot(p, n3.zxy)), abs(dot(p, n3.yzx)))));
+    d = max(d, max(abs(dot(p, n4.xyz)), max(abs(dot(p, n4.zxy)), abs(dot(p, n4.yzx)))));
+    d = max(d, max(abs(dot(p, n5.xyz)), max(abs(dot(p, n5.zxy)), abs(dot(p, n5.yzx)))));
+    d = max(d, max(abs(dot(p, n6.xyz)), max(abs(dot(p, n6.zxy)), abs(dot(p, n6.yzx)))));
+
+    return (d - r) * 0.4;
+  }
+
+  float getPlatonicSolid(vec3 p, int type, float size) {
+    if (type == TETRAHEDRON) return sdTetrahedron(p, size);
+    if (type == CUBE) return sdBox(p, vec3(size));
+    if (type == OCTAHEDRON) return sdOctahedron(p, size);
+    if (type == DODECAHEDRON) return sdDodecahedron(p, size);
+    if (type == ICOSAHEDRON) return sdIcosahedron(p, size);
+    return MAX_DIST;
+  }
+
+  float getSDF(vec3 p) {
+    float t = iTime * ROTATION_SPEED;
+
+    p = rotateY(p, t * 0.3);
+    p = rotateX(p, t * 0.2);
+
+    int solidType = int(mod(floor(t * 0.2), 5.0));
+
+    float solidDist = getPlatonicSolid(p, solidType, 1.0);
+
+    float ripple = sin(20.0 * p.x + t) * sin(20.0 * p.y + t) * sin(20.0 * p.z + t) * 0.05;
+    solidDist += ripple;
+
+    return solidDist;
+  }
+
+  float rayMarch(vec3 ro, vec3 rd) {
+    float dO = 0.0;
+
+    for (int i = 0; i < MAX_STEPS; i++) {
+      vec3 p = ro + rd * dO;
+      float dS = getSDF(p);
+      dO += dS;
+      if (dS < SURF_DIST || dO > MAX_DIST) break;
+    }
+
+    return dO;
+  }
+
+  vec3 getNormal(vec3 p) {
+    float d = getSDF(p);
+    vec2 e = vec2(0.001, 0);
+
+    vec3 n = d - vec3(
+      getSDF(p - e.xyy),
+      getSDF(p - e.yxy),
+      getSDF(p - e.yyx)
+    );
+
+    return normalize(n);
+  }
+
+  vec3 getColor(vec3 p, vec3 n, float t) {
+    vec3 baseColor = 0.5 + 0.5 * sin(vec3(0.0, 0.33, 0.67) * PI * 2.0 + t * 0.5);
+
+    vec3 color = baseColor + 0.5 * sin(t + p.zxy) * 0.5;
+
+    color += 0.5 * n;
+
+    float pattern = sin(p.x * 20.0) * sin(p.y * 20.0) * sin(p.z * 20.0);
+    color += pattern * 0.1;
+
+    return clamp(color, 0.0, 1.0);
+  }
+
+  void main() {
+    vec2 fragCoord = vUv * iResolution;
+    vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
+
+    vec3 ro = vec3(0, 0, -4);
+    vec3 rd = normalize(vec3(uv, 1.0));
+
+    float camTime = iTime * 0.3;
+    ro = rotateY(ro, camTime * 0.5);
+    rd = rotateY(rd, camTime * 0.5);
+
+    float d = rayMarch(ro, rd);
+
+    vec3 col = vec3(0.1, 0.1, 0.2) - max(rd.y, 0.0) * 0.2;
+
+    if (d < MAX_DIST) {
+      vec3 p = ro + rd * d;
+      vec3 n = getNormal(p);
+
+      col = getColor(p, n, iTime);
+
+      vec3 lightDir = normalize(vec3(1, 2, -3));
+      float diff = max(dot(n, lightDir), 0.1);
+      col *= diff;
+
+      vec3 h = normalize(lightDir - rd);
+      float spec = pow(max(dot(n, h), 0.0), 32.0);
+      col += spec * 0.5;
+
+      float glow = 1.0 - clamp(d / 10.0, 0.0, 1.0);
+      col += vec3(0.1, 0.3, 0.6) * glow * glow;
+
+      col = mix(col, vec3(0.1, 0.1, 0.2), 1.0 - exp(-d * 0.05));
+    }
+
+    vec2 vigUV = fragCoord / iResolution.xy;
+    vigUV = (vigUV - 0.5) * 2.0;
+    float vignette = 1.0 - dot(vigUV, vigUV) * 0.3;
+    col *= vignette;
+
+    float grain = fract(sin(dot(fragCoord, vec2(12.9898, 78.233)) + iTime) * 43758.5453);
+    col += (grain - 0.5) * 0.05;
+
+    col = pow(col, vec3(0.4545));
+
+    fragColor = vec4(col, 1.0);
+  }
+GLSL
+
+scene = Sunrb::Scene.new
+scene.background = Sunrb::Color.new(0x000000)
+
+camera = Sunrb::OrthographicCamera.new(
+  left: -1, right: 1, top: 1, bottom: -1, near: 0.1, far: 10
+)
+camera.position.z = 1
+
+geometry = Sunrb::PlaneGeometry.new(width: 2, height: 2)
+
+shader_material = Sunrb::ShaderMaterial.new(
+  vertex_shader: VERTEX_SHADER,
+  fragment_shader: FRAGMENT_SHADER,
+  uniforms: {
+    iTime: 0.0,
+    iResolution: Sunrb::Vector2.new(800, 600)
+  }
+)
+
+quad = Sunrb::Mesh.new(geometry, shader_material)
+scene.add(quad)
+
+puts "=== Platonic Solids - SDF Raymarching ==="
+puts "Tetrahedron -> Cube -> Octahedron -> Dodecahedron -> Icosahedron"
+puts "Press ESC to exit"
+
+renderer = Sunrb::OpenGLRenderer.new(width: 800, height: 600, title: "Platonic Solids - SDF Raymarching")
+
+time = 0.0
+
+renderer.run do |delta|
+  time += delta
+  shader_material.uniforms[:iTime] = time
+  renderer.render(scene, camera)
+end

data/lib/3rb/animation/animation_clip.rb

@@ -0,0 +1,287 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class AnimationClip
+    attr_accessor :uuid, :name, :tracks, :duration, :blend_mode
+
+    BLEND_MODE = {
+      normal: 2500,
+      additive: 2501
+    }.freeze
+
+    def initialize(name: "", duration: -1, tracks: [], blend_mode: :normal)
+      @uuid = SecureRandom.uuid
+      @name = name
+      @tracks = tracks
+      @duration = duration
+      @blend_mode = blend_mode
+
+      reset_duration if @duration < 0
+    end
+
+    def reset_duration
+      @duration = 0
+
+      @tracks.each do |track|
+        @duration = [@duration, track.times.last || 0].max
+      end
+
+      self
+    end
+
+    def trim
+      @tracks.each(&:trim)
+      self
+    end
+
+    def validate
+      valid = true
+
+      @tracks.each do |track|
+        valid = false unless track.validate
+      end
+
+      valid
+    end
+
+    def optimize
+      @tracks.each(&:optimize)
+      self
+    end
+
+    def clone
+      tracks = @tracks.map(&:clone)
+      AnimationClip.new(
+        name: @name,
+        duration: @duration,
+        tracks: tracks,
+        blend_mode: @blend_mode
+      )
+    end
+
+    def to_h
+      {
+        uuid: @uuid,
+        name: @name,
+        duration: @duration,
+        blend_mode: @blend_mode,
+        tracks: @tracks.map(&:to_h)
+      }
+    end
+
+    def self.from_h(data)
+      tracks = (data[:tracks] || []).map { |t| KeyframeTrack.from_h(t) }
+      new(
+        name: data[:name],
+        duration: data[:duration],
+        tracks: tracks,
+        blend_mode: data[:blend_mode] || :normal
+      )
+    end
+  end
+
+  class KeyframeTrack
+    attr_accessor :name, :times, :values, :interpolation
+
+    INTERPOLATION = {
+      discrete: 2300,
+      linear: 2301,
+      smooth: 2302
+    }.freeze
+
+    def initialize(name:, times:, values:, interpolation: :linear)
+      @name = name
+      @times = times.map(&:to_f)
+      @values = values.map(&:to_f)
+      @interpolation = interpolation
+    end
+
+    def value_size
+      @values.length / @times.length
+    end
+
+    def get_value_at_time(time)
+      times = @times
+
+      return get_value_at_index(0) if time <= times.first
+      return get_value_at_index(times.length - 1) if time >= times.last
+
+      idx = binary_search(times, time)
+
+      if idx >= 0
+        get_value_at_index(idx)
+      else
+        insert_idx = -idx - 1
+        interpolate(insert_idx - 1, insert_idx, time)
+      end
+    end
+
+    def get_value_at_index(index)
+      size = value_size
+      offset = index * size
+      @values[offset, size]
+    end
+
+    def interpolate(idx1, idx2, time)
+      t1 = @times[idx1]
+      t2 = @times[idx2]
+      alpha = (time - t1) / (t2 - t1)
+
+      size = value_size
+      v1 = get_value_at_index(idx1)
+      v2 = get_value_at_index(idx2)
+
+      case @interpolation
+      when :discrete
+        v1
+      when :linear
+        v1.zip(v2).map { |a, b| a + (b - a) * alpha }
+      when :smooth
+        t = alpha * alpha * (3 - 2 * alpha)
+        v1.zip(v2).map { |a, b| a + (b - a) * t }
+      else
+        v1.zip(v2).map { |a, b| a + (b - a) * alpha }
+      end
+    end
+
+    def trim
+      return self if @times.empty?
+
+      min_time = @times.first
+      return self if min_time == 0
+
+      @times = @times.map { |t| t - min_time }
+      self
+    end
+
+    def validate
+      return false if @times.empty? || @values.empty?
+      return false if @values.length % @times.length != 0
+
+      @times.each_cons(2).all? { |a, b| a <= b }
+    end
+
+    def optimize
+      # Remove keyframes with duplicate values
+      return self if @times.length < 2
+
+      size = value_size
+      new_times = [@times.first]
+      new_values = @values[0, size]
+
+      (1...@times.length).each do |i|
+        current = @values[i * size, size]
+        previous = @values[(i - 1) * size, size]
+
+        unless values_equal?(current, previous)
+          new_times << @times[i]
+          new_values.concat(current)
+        end
+      end
+
+      @times = new_times
+      @values = new_values
+      self
+    end
+
+    def clone
+      KeyframeTrack.new(
+        name: @name,
+        times: @times.dup,
+        values: @values.dup,
+        interpolation: @interpolation
+      )
+    end
+
+    def to_h
+      {
+        name: @name,
+        times: @times,
+        values: @values,
+        interpolation: @interpolation
+      }
+    end
+
+    def self.from_h(data)
+      new(
+        name: data[:name],
+        times: data[:times],
+        values: data[:values],
+        interpolation: data[:interpolation] || :linear
+      )
+    end
+
+    private
+
+    def binary_search(array, value)
+      low = 0
+      high = array.length - 1
+
+      while low <= high
+        mid = (low + high) / 2
+
+        if array[mid] == value
+          return mid
+        elsif array[mid] < value
+          low = mid + 1
+        else
+          high = mid - 1
+        end
+      end
+
+      -(low + 1)
+    end
+
+    def values_equal?(a, b)
+      return false unless a.length == b.length
+
+      a.zip(b).all? { |x, y| (x - y).abs < 0.000001 }
+    end
+  end
+
+  class VectorKeyframeTrack < KeyframeTrack
+  end
+
+  class QuaternionKeyframeTrack < KeyframeTrack
+    def interpolate(idx1, idx2, time)
+      t1 = @times[idx1]
+      t2 = @times[idx2]
+      alpha = (time - t1) / (t2 - t1)
+
+      q1 = Quaternion.new(*get_value_at_index(idx1))
+      q2 = Quaternion.new(*get_value_at_index(idx2))
+
+      q1.slerp(q2, alpha).to_a
+    end
+  end
+
+  class NumberKeyframeTrack < KeyframeTrack
+  end
+
+  class ColorKeyframeTrack < KeyframeTrack
+  end
+
+  class BooleanKeyframeTrack < KeyframeTrack
+    def initialize(name:, times:, values:, interpolation: :discrete)
+      super(name: name, times: times, values: values.map { |v| v ? 1.0 : 0.0 }, interpolation: interpolation)
+    end
+  end
+
+  class StringKeyframeTrack < KeyframeTrack
+    def initialize(name:, times:, values:, interpolation: :discrete)
+      @name = name
+      @times = times.map(&:to_f)
+      @string_values = values
+      @values = (0...values.length).to_a.map(&:to_f)
+      @interpolation = :discrete
+    end
+
+    def get_value_at_index(index)
+      @string_values[index]
+    end
+
+    def interpolate(idx1, _idx2, _time)
+      @string_values[idx1]
+    end
+  end
+end