cyclotone 0.1.0

data/lib/cyclotone/transforms/time.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Cyclotone
+  module Transforms
+    module Time
+      def fast(amount)
+        factor = Pattern.to_rational(amount)
+
+        Pattern.new do |span|
+          source_span = TimeSpan.new(span.start * factor, span.stop * factor)
+
+          query_span(source_span).map do |event|
+            Pattern.map_event(event) { |time| time / factor }
+          end
+        end
+      end
+
+      def slow(amount)
+        fast(Rational(1, 1) / Pattern.to_rational(amount))
+      end
+
+      def early(amount)
+        offset = Pattern.to_rational(amount)
+
+        Pattern.new do |span|
+          query_span(span.shift(offset)).map do |event|
+            Pattern.shift_event(event, -offset)
+          end
+        end
+      end
+
+      def late(amount)
+        early(-Pattern.to_rational(amount))
+      end
+
+      def rev
+        Pattern.new do |span|
+          cycle_start = Rational(span.cycle_number)
+          reversed_span = span.reverse_within(cycle_start)
+
+          query_span(reversed_span).map do |event|
+            event.with_span(
+              new_whole: event.whole&.reverse_within(cycle_start),
+              new_part: event.part.reverse_within(cycle_start)
+            )
+          end
+        end
+      end
+
+      def palindrome
+        Pattern.new do |span|
+          span.cycle_number.even? ? rev.query_span(span) : query_span(span)
+        end
+      end
+
+      def hurry(amount)
+        fast(amount).fmap do |value|
+          next value unless value.is_a?(Hash)
+
+          current_speed = value[:speed] || 1.0
+          value.merge(speed: current_speed * amount.to_f)
+        end
+      end
+
+      def off(amount, &block)
+        transformed = block.call(self).early(amount)
+        Pattern.stack([self, transformed])
+      end
+
+      def swing(amount, div = 4)
+        step_shift = Pattern.to_rational(amount) / Pattern.to_rational(div)
+
+        map_events do |event|
+          next event unless event.onset
+
+          cycle_start = Rational(event.onset.floor)
+          step_index = (((event.onset - cycle_start) * div).floor).to_i
+          next event if step_index.even?
+
+          Pattern.shift_event(event, step_shift)
+        end
+      end
+
+      def inside(amount, &block)
+        slow(amount).then(&block).fast(amount)
+      end
+
+      def outside(amount, &block)
+        fast(amount).then(&block).slow(amount)
+      end
+    end
+  end
+end

data/lib/cyclotone/transition.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+module Cyclotone
+  module Transition
+    DEFAULT_DURATION = 2
+
+    def xfade(id, pattern)
+      xfade_in(id, DEFAULT_DURATION, pattern)
+    end
+
+    def xfade_in(id, cycles, pattern)
+      slot_id = normalize_slot_reference(id)
+      current = @slots[slot_id] || Pattern.silence
+      replacement = Pattern.ensure_pattern(pattern)
+      duration = Pattern.to_rational(cycles)
+      return assign(slot_id, replacement) if duration <= 0
+
+      start_cycle = transition_start_cycle
+
+      mixed = Pattern.stack([
+        apply_gain_envelope(current, start_cycle: start_cycle, duration: duration, direction: :out),
+        apply_gain_envelope(replacement, start_cycle: start_cycle, duration: duration, direction: :in)
+      ])
+
+      assign(slot_id, mixed)
+    end
+
+    def clutch(id, pattern)
+      clutch_in(id, DEFAULT_DURATION, pattern)
+    end
+
+    def clutch_in(id, cycles, pattern)
+      slot_id = normalize_slot_reference(id)
+      current = @slots[slot_id] || Pattern.silence
+      replacement = Pattern.ensure_pattern(pattern)
+      duration = Pattern.to_rational(cycles)
+      return assign(slot_id, replacement) if duration <= 0
+
+      start_cycle = transition_start_cycle
+      swapped = Pattern.new do |span|
+        source_events = current.query_span(span).map { |event| [event, :current] }
+        target_events = replacement.query_span(span).map { |event| [event, :replacement] }
+
+        (source_events + target_events).filter_map do |event, source|
+          time = event.onset || event.part.start
+          desired_source = clutch_source(slot_id, time, event.value, start_cycle, duration)
+          event if source == desired_source
+        end.then { |events| Pattern.sort_events(events) }
+      end
+
+      assign(slot_id, swapped)
+    end
+
+    def interpolate(id, pattern)
+      interpolate_in(id, 4, pattern)
+    end
+
+    def interpolate_in(id, cycles, pattern)
+      slot_id = normalize_slot_reference(id)
+      current = @slots[slot_id] || Pattern.silence
+      replacement = Pattern.ensure_pattern(pattern)
+      duration = Pattern.to_rational(cycles)
+      return assign(slot_id, replacement) if duration <= 0
+
+      start_cycle = transition_start_cycle
+      morphed = Pattern.new do |span|
+        anchor_times = Pattern.stack([current, replacement]).query_span(span).map do |event|
+          event.onset || event.part.start
+        end.uniq.sort
+
+        anchor_times.filter_map do |time|
+          source_event = current.query_event_at(time)
+          target_event = replacement.query_event_at(time)
+          base_event = target_event || source_event
+          next unless base_event
+
+          progress = transition_progress(time, start_cycle, duration)
+          base_event.with_value(interpolate_value(source_event&.value, target_event&.value, progress))
+        end.then { |events| Pattern.sort_events(events) }
+      end
+
+      assign(slot_id, morphed)
+    end
+
+    def jump(id, pattern)
+      assign(normalize_slot_reference(id), pattern)
+    end
+
+    def jump_in(id, cycles, pattern)
+      slot_id = normalize_slot_reference(id)
+      current = @slots[slot_id] || Pattern.silence
+      replacement = Pattern.ensure_pattern(pattern)
+      switch_cycle = transition_start_cycle + Pattern.to_rational(cycles)
+      return assign(slot_id, replacement) if switch_cycle <= transition_start_cycle
+
+      delayed = Pattern.new { |span| split_query(span, switch_cycle, current, replacement) }
+
+      assign(slot_id, delayed)
+    end
+
+    def anticipate(id, pattern)
+      jump_in(id, 8, pattern)
+    end
+
+    def fade_in(cycles)
+      start_cycle = transition_start_cycle
+      duration = Pattern.to_rational(cycles)
+      return self if duration <= 0
+
+      @slots.keys.each do |slot_id|
+        assign(slot_id, apply_gain_envelope(@slots.fetch(slot_id), start_cycle: start_cycle, duration: duration, direction: :in))
+      end
+
+      self
+    end
+
+    def fade_out(cycles)
+      start_cycle = transition_start_cycle
+      duration = Pattern.to_rational(cycles)
+      return self if duration <= 0
+
+      @slots.keys.each do |slot_id|
+        assign(slot_id, apply_gain_envelope(@slots.fetch(slot_id), start_cycle: start_cycle, duration: duration, direction: :out))
+      end
+
+      self
+    end
+
+    private
+
+    def apply_gain_envelope(pattern, start_cycle:, duration:, direction:)
+      Pattern.ensure_pattern(pattern).fmap do |value|
+        next value unless value.is_a?(Hash)
+
+        factor = lambda do |time|
+          progress = ((time - start_cycle.to_f) / duration.to_f).clamp(0.0, 1.0)
+          direction == :in ? progress : 1.0 - progress
+        end
+
+        value.merge(gain_envelope: factor)
+      end.map_events do |event|
+        next event unless event.value.is_a?(Hash)
+
+        time = event.onset || event.part.start
+        value = event.value.dup
+        envelope = value.delete(:gain_envelope)
+        current_gain = value[:gain] || 1.0
+        value[:gain] = current_gain * envelope.call(time)
+        event.with_value(value)
+      end
+    end
+
+    def split_query(span, switch_cycle, current, replacement)
+      if span.stop <= switch_cycle
+        current.query_span(span)
+      elsif span.start >= switch_cycle
+        replacement.query_span(span)
+      else
+        before = current.query_span(TimeSpan.new(span.start, switch_cycle))
+        after = replacement.query_span(TimeSpan.new(switch_cycle, span.stop))
+        Pattern.sort_events(before + after)
+      end
+    end
+
+    def transition_start_cycle
+      Pattern.to_rational(@scheduler.current_cycle.floor)
+    end
+
+    def transition_progress(time, start_cycle, duration)
+      ((time.to_f - start_cycle.to_f) / duration.to_f).clamp(0.0, 1.0)
+    end
+
+    def clutch_source(slot_id, time, value, start_cycle, duration)
+      progress = transition_progress(time, start_cycle, duration)
+      chosen = Support::Deterministic.float(:clutch, slot_id, time, value) < progress
+
+      chosen ? :replacement : :current
+    end
+
+    def interpolate_value(source, target, progress)
+      return source if target.nil?
+      return target if source.nil?
+
+      if source.is_a?(Numeric) && target.is_a?(Numeric)
+        source.to_f + ((target.to_f - source.to_f) * progress)
+      elsif source.is_a?(Hash) && target.is_a?(Hash)
+        interpolate_hash(source, target, progress)
+      else
+        progress < 0.5 ? source : target
+      end
+    end
+
+    def interpolate_hash(source, target, progress)
+      (source.keys | target.keys).each_with_object({}) do |key, result|
+        result[key] =
+          if source.key?(key) && target.key?(key)
+            interpolate_value(source[key], target[key], progress)
+          else
+            progress < 0.5 ? source.fetch(key, target[key]) : target.fetch(key, source[key])
+          end
+      end
+    end
+  end
+end

data/lib/cyclotone/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Cyclotone
+  VERSION = "0.1.0"
+end

data/lib/cyclotone.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "cyclotone/errors"
+require_relative "cyclotone/support/deterministic"
+require_relative "cyclotone/version"
+require_relative "cyclotone/euclidean"
+require_relative "cyclotone/mini_notation/ast"
+require_relative "cyclotone/mini_notation/parser"
+require_relative "cyclotone/time_span"
+require_relative "cyclotone/event"
+require_relative "cyclotone/transforms/time"
+require_relative "cyclotone/transforms/concatenation"
+require_relative "cyclotone/transforms/accumulation"
+require_relative "cyclotone/transforms/alteration"
+require_relative "cyclotone/transforms/condition"
+require_relative "cyclotone/transforms/sample"
+require_relative "cyclotone/pattern"
+require_relative "cyclotone/mini_notation/compiler"
+require_relative "cyclotone/controls"
+require_relative "cyclotone/oscillators"
+require_relative "cyclotone/harmony"
+require_relative "cyclotone/state"
+require_relative "cyclotone/backends/osc_backend"
+require_relative "cyclotone/backends/midi_backend"
+require_relative "cyclotone/backends/midi_file_backend"
+require_relative "cyclotone/scheduler"
+require_relative "cyclotone/transition"
+require_relative "cyclotone/stream"
+require_relative "cyclotone/dsl"
+
+module Cyclotone
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: cyclotone
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yudai Takada
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Cyclotone provides rational-time spans, immutable pattern events, and
+  composable pattern primitives for building live coding music tools in Ruby.
+email:
+- t.yudai92@gmail.com
+executables:
+- cyclotone
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- Rakefile
+- cyclotone.gemspec
+- exe/cyclotone
+- lib/cyclotone.rb
+- lib/cyclotone/backends/midi_backend.rb
+- lib/cyclotone/backends/midi_file_backend.rb
+- lib/cyclotone/backends/midi_message_support.rb
+- lib/cyclotone/backends/osc_backend.rb
+- lib/cyclotone/controls.rb
+- lib/cyclotone/dsl.rb
+- lib/cyclotone/errors.rb
+- lib/cyclotone/euclidean.rb
+- lib/cyclotone/event.rb
+- lib/cyclotone/harmony.rb
+- lib/cyclotone/mini_notation/ast.rb
+- lib/cyclotone/mini_notation/compiler.rb
+- lib/cyclotone/mini_notation/parser.rb
+- lib/cyclotone/oscillators.rb
+- lib/cyclotone/pattern.rb
+- lib/cyclotone/scheduler.rb
+- lib/cyclotone/state.rb
+- lib/cyclotone/stream.rb
+- lib/cyclotone/support/deterministic.rb
+- lib/cyclotone/time_span.rb
+- lib/cyclotone/transforms/accumulation.rb
+- lib/cyclotone/transforms/alteration.rb
+- lib/cyclotone/transforms/concatenation.rb
+- lib/cyclotone/transforms/condition.rb
+- lib/cyclotone/transforms/sample.rb
+- lib/cyclotone/transforms/time.rb
+- lib/cyclotone/transition.rb
+- lib/cyclotone/version.rb
+homepage: https://github.com/ydah/cyclotone
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/ydah/cyclotone
+  changelog_uri: https://github.com/ydah/cyclotone/releases
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: Pattern-based live coding primitives for Ruby.
+test_files: []