percolator 0.0.1.prealpha

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MzJlYTY2MGQ5OWIwNzljYmIzZmNhYTBmZTdiZWQ2MDY4ZTdkN2NkNg==
+  data.tar.gz: !binary |-
+    ZDI1ODg2ODJiOTk0MjM0MmNjYTZlMTQzNjhlOGQ4NGFkZjhjODg0Nw==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    NjRmMzFiOGRiODZmYmYyOTVlOGVkNzk1ZjBkNGM1NmViNjFlMmJiNDFkZDFm
+    YzVhY2I0ZmEzYTg2YTg3ODYyM2FjZTU3NzE5MDRmNTBjMjAzYTlmYzAzY2Vk
+    MWVlYzdjNzQ0NmNjNDVkYWJjZTE4YmJlNzZjNDQzMWU2ZDYzNzU=
+  data.tar.gz: !binary |-
+    OTJiOTY0YTkzYTUzYWQzMjEyNThkOTFiNjQ2Zjc3YzRiOGNmMjJjMWY3MmQ5
+    NzU2MTk5ZDFlNjFmOTA4MjA0OGY4NThkNTEzZjA0YzcyNTRhMWJkMGE4MmM1
+    Y2FiNTgzNWU2MzBjNDgzNjFkNjNjOTAwYzA4MWIyMGUzNjk1MWM=

data/README.md

@@ -0,0 +1,74 @@
+# Percolator
+
+Simple particle-based physics engine
+
+__Still in pre-alpha state, not production ready__
+
+## Usage
+
+This example will build a 50 lightweight and 50 heavyweight colliding particles in a bounded box (see more examples in `spec/percolator_spec.rb`):
+
+```ruby
+percolator = Percolator.new
+collision  = Percolator::Behaviors::Collision.new
+edge_bound = Percolator::Behaviors::EdgeBound.new(
+  Percolator::Vector.new(0, 0), # min
+  Percolator::Vector.new(WIDTH, HEIGHT) # max
+)
+50.times do
+  Percolator::Particle.new(
+    radius: 7,
+    mass: 1.0,
+    pos: Percolator::Vector.new(rand(WIDTH), rand(HEIGHT)),
+    vel: Percolator::Vector.new(rand(SPEED_RANGE), rand(SPEED_RANGE))
+  ).tap do |p|
+    percolator.add_particle(p)
+    collision.add_particle(p)
+  end
+end
+50.times do
+  Percolator::Particle.new(
+    radius: 9,
+    mass: 2.0,
+    pos: Percolator::Vector.new(rand(WIDTH), rand(HEIGHT)),
+    vel: Percolator::Vector.new(rand(SPEED_RANGE), rand(SPEED_RANGE))
+  ).tap do |p|
+    percolator.add_particle(p)
+    collision.add_particle(p)
+  end
+end
+
+percolator.add_behavior(collision)
+percolator.add_behavior(edge_bound)
+```
+
+To simulate and save the state of each step:
+
+```ruby
+frames = []
+120.times do
+  frames.push(percolator.to_h);
+  percolator.step
+end
+json = JSON.generate(content)
+```
+
+## Testing
+
+Run `bundle exec guard` to automatically run the tests. If you want to see the actual simulation, start a local server (by running something like `python -m SimpleHTTPServer 8000`) You can then open `http://localhost:8000/spec/preview.html` to see animated demos.
+
+## Todo
+
+- More behaviors
+- Benchmarking
+  - Algorithms
+  - MRI vs Jruby vs Rubinius
+  - GC optimization
+
+## Credits
+
+- Heavily influenced by [Soulwire's Coffee-Physics](http://github.com/soulwire/Coffee-Physics)
+
+## License
+
+Percolator is released under the [MIT License](http://opensource.org/licenses/MIT).

data/lib/percolator.rb

@@ -0,0 +1,61 @@
+require 'json'
+
+class Percolator
+  attr_reader :particles
+
+  def initialize(integrator = Integrators::Euler)
+    @integrator = integrator
+    @viscosity = 0.005
+    @drag = 1.0 - @viscosity
+    @precision = 4 # Iterations per step
+    @dt = 1.0 / @precision
+
+    @behaviors = [] # Global behaviors
+    @particles = []
+    @springs   = []
+  end
+
+  def step(steps = 1)
+    steps.times do
+      integrate
+    end
+  end
+
+  def add_particle(p)
+    @particles.push(p)
+  end
+
+  def add_behavior(behavior)
+    @behaviors.push(behavior)
+  end
+
+  def to_h
+    { particles: @particles.map(&:to_h) }
+  end
+
+  private
+
+  def integrate
+    @particles.each_with_index do |p, index|
+      @behaviors.each { |b| b.apply(p, @dt, index) }
+      p.update(@dt)
+    end
+
+    @integrator.integrate(@particles, @dt, @drag)
+
+    # @springs.each do |s|
+    #   s.apply()
+    # end
+  end
+end
+
+# core
+require 'percolator/vector'
+require 'percolator/particle'
+
+# behaviors
+require 'percolator/behaviors/collision'
+require 'percolator/behaviors/edge_bound'
+
+# integrators
+require 'percolator/integrators/euler'

data/lib/percolator/behaviors/behavior.rb

@@ -0,0 +1,14 @@
+#class Percolator
+#  class Behaviours
+#    class Behaviour
+#      # Each behaviour has a unique id
+#
+#      def initialize
+#        @interval = 1
+#      end
+#
+#      def apply(p, dt, index)
+#      ed
+#    end
+#  end
+#end

data/lib/percolator/behaviors/collision.rb

@@ -0,0 +1,78 @@
+class Percolator
+  class Behaviors
+    class Collision
+      def initialize(useMass = true)
+        @pool = []
+        # Delta between particle positions.
+        @delta = Vector.new
+
+        @temp_vel1    = Vector.new
+        @temp_vel2    = Vector.new
+        @rotated_vel1 = Vector.new
+        @rotated_vel2 = Vector.new
+      end
+
+      def add_particle(p)
+        @pool.push(p)
+      end
+
+      def apply(p1, dt, index)
+        @pool[index...@pool.length].each do |p2|
+          unless p1 == p2
+            dist = p1.pos.dist(p2.pos)
+            radii = p1.radius + p2.radius
+
+            if dist <= radii
+              # Heavily lifted from http://processing.org/learning/topics/circlecollision.html
+              delta  = p1.pos.dup.sub(p2.pos)
+              theta  = Math.atan2(delta.y, delta.x)
+              sine   = Math.sin(theta)
+              cosine = Math.cos(theta)
+
+              # rotate temporary velocities
+              @temp_vel1.set(
+                (cosine * p1.vel.x) + sine * p1.vel.y,
+                (cosine * p1.vel.y) - sine * p1.vel.x
+              )
+              @temp_vel2.set(
+                (cosine * p2.vel.x) + sine * p2.vel.y,
+                (cosine * p2.vel.y) - sine * p2.vel.x
+              )
+
+              # Now that velocities are rotated, you can use 1D
+              # conservation of momentum equations to calculate
+              # the final velocity along the x-axis.
+
+              @rotated_vel1.set(
+                ((p1.mass - p2.mass) * @temp_vel1.x + 2 * p2.mass * @temp_vel2.x) / (p1.mass + p2.mass),
+                @temp_vel1.y
+              )
+              @rotated_vel2.set(
+                ((p2.mass - p1.mass) * @temp_vel2.x + 2 * p1.mass * @temp_vel1.x) / (p1.mass + p2.mass),
+                @temp_vel2.y
+              )
+
+              # update velocities
+              p1.vel.set(
+                cosine * @rotated_vel1.x - sine * @rotated_vel1.y,
+                cosine * @rotated_vel1.y + sine * @rotated_vel1.x
+              )
+              p2.vel.set(
+                cosine * @rotated_vel2.x - sine * @rotated_vel2.y,
+                cosine * @rotated_vel2.y + sine * @rotated_vel2.x
+              )
+
+              # make sure they aren't overlapping anymore
+              overlap = radii - dist
+              mass_ratio = p1.mass / (p1.mass + p2.mass)
+              p1.pos.x += cosine * overlap * mass_ratio
+              p1.pos.y += sine   * overlap * mass_ratio
+              p2.pos.x -= cosine * overlap * (1 - mass_ratio)
+              p2.pos.y -= sine   * overlap * (1 - mass_ratio)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/percolator/behaviors/edge_bound.rb

@@ -0,0 +1,29 @@
+class Percolator
+  class Behaviors
+    class EdgeBound
+      def initialize(min, max)
+        @min = min
+        @max = max
+      end
+
+      def apply(p, dt, index)
+        if p.pos.x - p.radius < @min.x
+          p.pos.x = @min.x + p.radius
+          p.vel.x = p.vel.x.abs
+        elsif p.pos.x + p.radius > @max.x
+          p.pos.x = @max.x - p.radius
+          p.vel.x = -1 * p.vel.x.abs
+        end
+
+        if p.pos.y - p.radius < @min.y
+          p.pos.y = @min.y + p.radius
+          p.vel.y = p.vel.y.abs
+        elsif p.pos.y + p.radius > @max.y
+          p.pos.y = @max.y - p.radius
+          p.vel.y = -1 * p.vel.y.abs
+        end
+      end
+    end
+  end
+end
+

data/lib/percolator/integrators/euler.rb

@@ -0,0 +1,28 @@
+class Percolator
+  module Integrators
+    class Euler
+      # x += (v * dt) + (a * 0.5 * dt * dt)
+      # v += a * dt
+      def self.integrate(particles, delta, drag)
+        delta_squared = delta * delta
+        momentum = Vector.new
+        acc = Vector.new
+
+        particles.reject { |p| p.fixed? }.each do |p|
+          p.acc.scale(p.mass_inv) # F = ma
+          momentum.become(p.vel)
+          acc.become(p.acc)
+
+          p.pos.
+            add(momentum.scale(delta)).
+            add(acc.scale(0.5 * delta_squared))
+
+          p.vel.add(p.acc.scale(delta))
+          p.vel.scale(drag) # Apply friction
+
+          p.acc.clear
+        end
+      end
+    end
+  end
+end

data/lib/percolator/particle.rb

@@ -0,0 +1,64 @@
+class Percolator
+  class Particle
+    # @GUID = 0
+
+    DEFAULTS = {
+      mass: 1.0,
+      radius: 1.0,
+      fixed: false,
+    }
+
+    attr_reader :pos, :vel, :acc, :mass_inv, :radius, :mass
+
+    def initialize(params)
+      # Set a unique id.
+      # @id = 'p' + Particle.GUID++
+      full_params = DEFAULTS.merge(params)
+
+      setMass   full_params[:mass]
+      setRadius full_params[:radius]
+      @fixed  = full_params[:fixed]
+      @pos    = full_params[:pos] || Vector.new
+      @vel    = full_params[:vel] || Vector.new
+
+      @behaviors = []
+      @acc = Vector.new
+    end
+
+    def moveTo(pos)
+      @pos.become(pos)
+    end
+
+    def setMass(mass = 1.0)
+      @mass = mass
+      @mass_inv = 1.0 / @mass
+    end
+
+    def setRadius(radius = 1.0)
+      @radius = radius
+      @radiusSq = @radius * @radius
+    end
+
+    def fixed?
+      !!@fixed
+    end
+
+    # Applies all behaviors to derive new force
+    def update(dt)
+      unless @fixed
+        @behaviors.each do |behavior|
+          behavior.affect(self, dt, index)
+        end
+      end
+    end
+
+    def to_h
+      {
+        pos: @pos.to_h,
+        vel: @vel.to_h,
+        radius: @radius,
+        mass: @mass,
+      }
+    end
+  end
+end

data/lib/percolator/vector.rb

@@ -0,0 +1,113 @@
+class Percolator
+  class Vector
+    attr_accessor :x, :y
+
+    def initialize(x = 0.0, y = 0.0)
+      @x = x
+      @y = y
+    end
+
+    # Sets the components of this vector
+    def set(x, y)
+      @x = x
+      @y = y
+      self
+    end
+
+    # Add a vector to this one
+    def add(v)
+      @x += v.x
+      @y += v.y
+      self
+    end
+
+    # Subtracts a vector from this one
+    def sub(v)
+      @x -= v.x
+      @y -= v.y
+      self
+    end
+
+    # Scales this vector by a value
+    def scale(f)
+      @x *= f
+      @y *= f
+      self
+    end
+
+    # Normalises the vector, making it a unit vector (of length 1)
+    def norm
+      m = mag
+      @x /= m
+      @y /= m
+      self
+    end
+
+    # Limits the vector length to a given amount
+    def limit(l)
+      mSq = @x*@x + @y*@y
+      if mSq > l*l
+        m = Math.sqrt(mSq)
+        @x /= m
+        @y /= m
+        @x *= l
+        @y *= l
+      end
+      self
+    end
+
+    # more memory efficient way of `v1 = v2.dup`
+    def become(v)
+      @x = v.x
+      @y = v.y
+      self
+    end
+
+    # Computes the dot product between vectors
+    def dot(v)
+      @x * v.x + @y * v.y
+    end
+
+    # Computes the cross product between vectors
+    def cross(v)
+      (@x * v.y) - (@y * v.x)
+    end
+
+    # Computes the magnitude (length)
+    def mag
+      Math.sqrt(@x*@x + @y*@y)
+    end
+
+    # Computes the squared magnitude (length)
+    def magSq
+      @x*@x + @y*@y
+    end
+
+    # Computes the distance to another vector
+    def dist(v)
+      dx = v.x - @x
+      dy = v.y - @y
+      Math.sqrt(dx*dx + dy*dy)
+    end
+
+    # Computes the squared distance to another vector
+    def distSq(v)
+      dx = v.x - @x
+      dy = v.y - @y
+      dx*dx + dy*dy
+    end
+
+    # Resets the vector to zero
+    def clear
+      @x = 0.0
+      @y = 0.0
+    end
+
+    def to_h
+      {
+        x: @x,
+        y: @y,
+      }
+    end
+  end
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: percolator
+version: !ruby/object:Gem::Version
+  version: 0.0.1.prealpha
+platform: ruby
+authors:
+- James Gary
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rb-fsevent
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: mrjamesgary@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/percolator/behaviors/behavior.rb
+- lib/percolator/behaviors/collision.rb
+- lib/percolator/behaviors/edge_bound.rb
+- lib/percolator/integrators/euler.rb
+- lib/percolator/particle.rb
+- lib/percolator/vector.rb
+- lib/percolator.rb
+- README.md
+homepage: http://github.com/jamesgary/percolator
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.0
+signing_key: 
+specification_version: 4
+summary: Simple particle-based physics engine
+test_files: []