hotcocoa 0.5

data/lib/hotcocoa/graphics/elements/particle.rb

@@ -0,0 +1,75 @@
+# Ruby Cocoa Graphics is a graphics library providing a simple object-oriented 
+# interface into the power of Mac OS X's Core Graphics and Core Image drawing libraries.  
+# With a few lines of easy-to-read code, you can write scripts to draw simple or complex 
+# shapes, lines, and patterns, process and filter images, create abstract art or visualize 
+# scientific data, and much more.
+# 
+# Inspiration for this project was derived from Processing and NodeBox.  These excellent 
+# graphics programming environments are more full-featured than RCG, but they are implemented 
+# in Java and Python, respectively.  RCG was created to offer similar functionality using 
+# the Ruby programming language.
+#
+# Author::    James Reynolds  (mailto:drtoast@drtoast.com)
+# Copyright:: Copyright (c) 2008 James Reynolds
+# License::   Distributes under the same terms as Ruby
+
+module HotCocoa::Graphics
+  
+  # wandering particle with brownian motion
+  class Particle 
+
+    attr_accessor :acceleration, :points, :stroke, :velocity_x, :velocity_y, :x, :y
+
+    # initialize particle origin x,y coordinates (relative to the center)
+    def initialize (x, y, velocity_x=0.0, velocity_y=2.0)
+      @age = 0
+      @acceleration = 0.5
+    
+      @x = x
+      @y = y
+    
+      @previous_x = 0
+      @previous_y = 0
+
+      # initialize velocity
+      @velocity_x=velocity_x
+      @velocity_y=velocity_y
+    
+      # append the point to the array
+      @points = [NSPoint.new(@x, @y)]
+      @stroke = Color.white
+    end
+  
+    # move to a new position using brownian motion
+    def move
+      # save old x,y position
+      @previous_x=@x
+      @previous_y=@y
+
+      # move particle by velocity_x,velocity_y
+      @x += @velocity_x
+      @y += @velocity_y
+
+      # randomly increase/decrease direction
+      @velocity_x += random(-1.0, 1.0) * @acceleration
+      @velocity_y += random(-1.0, 1.0) * @acceleration
+
+      # draw a line from the old position to the new
+      #CANVAS.line(@previous_x,@previous_y,@x,@y);
+      @points.push(NSPoint.new(@x, @y))
+    
+      # grow old
+      @age += 1
+      if @age>200
+        # die and be reborn
+      end
+    
+    end
+  
+    def draw(canvas)
+      canvas.nofill
+      canvas.lines(@points)
+    end
+  
+  end
+end

data/lib/hotcocoa/graphics/elements/rope.rb

@@ -0,0 +1,99 @@
+# Ruby Cocoa Graphics is a graphics library providing a simple object-oriented 
+# interface into the power of Mac OS X's Core Graphics and Core Image drawing libraries.  
+# With a few lines of easy-to-read code, you can write scripts to draw simple or complex 
+# shapes, lines, and patterns, process and filter images, create abstract art or visualize 
+# scientific data, and much more.
+# 
+# Inspiration for this project was derived from Processing and NodeBox.  These excellent 
+# graphics programming environments are more full-featured than RCG, but they are implemented 
+# in Java and Python, respectively.  RCG was created to offer similar functionality using 
+# the Ruby programming language.
+#
+# Author::    James Reynolds  (mailto:drtoast@drtoast.com)
+# Copyright:: Copyright (c) 2008 James Reynolds
+# License::   Distributes under the same terms as Ruby
+
+module HotCocoa::Graphics
+  
+  class Rope
+  
+    attr_accessor :x0, :y0, :x1, :y1, :width, :fibers, :roundness, :strokewidth
+  
+    def initialize(canvas, options={})
+      @canvas       = canvas
+      @width        = options[:width] || 200
+      @fibers       = options[:fibers] || 200
+      @roundness    = options[:roundness] || 1.0
+      @strokewidth  = options[:strokewidth] || 0.4
+    end
+  
+    def hair(hair_x0=@x0, hair_y0=@y0, hair_x1=@x1, hair_y1=@y1, hair_width=@width, hair_fibers=@fibers)
+      @canvas.push
+      @canvas.strokewidth(@strokewidth)
+      @canvas.autoclosepath(false)
+      @canvas.nofill
+      hair_x0 = choose(hair_x0)
+      hair_y0 = choose(hair_y0)
+      hair_x1 = choose(hair_x1)
+      hair_y1 = choose(hair_y1)
+      vx0 = random(-@canvas.width   / 2,  @canvas.width   / 2) * @roundness
+      vy0 = random(-@canvas.height  / 2,  @canvas.height  / 2) * @roundness
+      vx1 = random(-@canvas.width   / 2,  @canvas.width   / 2) * @roundness
+      vy1 = random(-@canvas.height  / 2,  @canvas.height  / 2) * @roundness
+      hair_fibers.times do |j|
+        #x0,y0,x1,y1 = [@x0.choose,@y0.choose,@x1.choose,@y1.choose]
+        @canvas.beginpath(hair_x0, hair_y0)
+        @canvas.curveto(
+            hair_x0 + vx0 + rand(hair_width), hair_y0 + vy0 + rand(hair_width), # control point 1
+            hair_x1 + vx1, hair_y1 + vy1,                                       # control point 2
+            hair_x1, hair_y1                                                    # end point
+        )
+        @canvas.endpath
+      end
+      @canvas.pop
+    end
+  
+    def ribbon(ribbon_x0=@x0, ribbon_y0=@y0, ribbon_x1=@x1, ribbon_y1=@y1, ribbon_width=@width, ribbon_fibers=@fibers)
+      @canvas.push
+      @canvas.strokewidth(@strokewidth)
+      @canvas.autoclosepath(false)
+      @canvas.nofill
+      black = Color.black
+      white = Color.white
+      ribbon_x0 = choose(ribbon_x0)
+      ribbon_y0 = choose(ribbon_y0)
+      ribbon_x1 = choose(ribbon_x1)
+      ribbon_y1 = choose(ribbon_y1)
+      vx0 = random(-@canvas.width   / 2, @canvas.width  / 2) * @roundness
+      vy0 = random(-@canvas.height  / 2, @canvas.height / 2) * @roundness
+      vx1 = random(-@canvas.width   / 2, @canvas.width  / 2) * @roundness
+      vy1 = random(-@canvas.height  / 2, @canvas.height / 2) * @roundness
+      xwidth = rand(ribbon_width)
+      ywidth = rand(ribbon_width)
+      ribbon_fibers.times do |j|
+        #x0,y0,x1,y1 = [@x0.choose,@y0.choose,@x1.choose,@y1.choose]
+        xoffset = (j-1).to_f * xwidth / ribbon_fibers
+        yoffset = (j-1).to_f * ywidth / ribbon_fibers
+        cpx0 = ribbon_x0 + vx0 + xoffset
+        cpy0 = ribbon_y0 + vy0 + yoffset
+        cpx1 = ribbon_x1 + vx1
+        cpy1 = ribbon_y1 + vy1
+        # debug - show control points
+        # @canvas.fill(black)
+        # @canvas.oval(cpx0,cpy0,5,5,:center)
+        # @canvas.fill(white)
+        # @canvas.oval(cpx1,cpy1,5,5,:center)
+        # @canvas.nofill
+      
+        @canvas.beginpath(x0, y0)
+        @canvas.curveto(
+          cpx0, cpy0,           # control point 1
+          cpx1, cpy1,           # control point 2
+          ribbon_x1, ribbon_y1  # end point
+        )
+        @canvas.endpath
+      end
+      @canvas.pop
+    end
+  end
+end

data/lib/hotcocoa/graphics/elements/sandpainter.rb

@@ -0,0 +1,71 @@
+# Ruby Cocoa Graphics is a graphics library providing a simple object-oriented 
+# interface into the power of Mac OS X's Core Graphics and Core Image drawing libraries.  
+# With a few lines of easy-to-read code, you can write scripts to draw simple or complex 
+# shapes, lines, and patterns, process and filter images, create abstract art or visualize 
+# scientific data, and much more.
+# 
+# Inspiration for this project was derived from Processing and NodeBox.  These excellent 
+# graphics programming environments are more full-featured than RCG, but they are implemented 
+# in Java and Python, respectively.  RCG was created to offer similar functionality using 
+# the Ruby programming language.
+#
+# Author::    James Reynolds  (mailto:drtoast@drtoast.com)
+# Copyright:: Copyright (c) 2008 James Reynolds
+# License::   Distributes under the same terms as Ruby
+
+module HotCocoa::Graphics
+
+  # draw watercolor-like painted strokes (adapted from code by Jared Tarbell - complexification.net)
+  class SandPainter
+
+    attr_accessor :color, :grains, :grainsize, :maxalpha, :jitter, :huedrift, :saturationdrift, :brightnessdrift
+
+    def initialize(canvas, color=Color.red)
+      @canvas           = canvas
+      @color            = color
+      # set a random initial gain value
+      @gain             = random(0.01, 0.1)
+      @grainsize        = 6.0
+      @grains           = 64
+      @maxalpha         = 0.1
+      @jitter           = 0
+      @huedrift         = 0.2
+      @saturationdrift  = 0.3
+      @brightnessdrift  = 0.3
+    end
+  
+    # render a line that fades out from ox,oy to x,y
+    def render(ox, oy, x, y) 
+      @canvas.push
+      # modulate gain
+      @gain += random(-0.050, 0.050)
+      @gain = inrange(@gain, 0.0, 1.0)
+      # calculate grains by distance
+      #@grains = (sqrt((ox-x)*(ox-x)+(oy-y)*(oy-y))).to_i
+
+      # ramp from 0 to .015 for g = 0 to 1
+      w = @gain / (@grains-1)
+    
+      #raycolor = @color.analog
+      #@color.drift(0.2,0.1,0.1)
+      @color.drift(huedrift, saturationdrift, brightnessdrift)
+      #for i in 0..@grains do ##RACK change to fixnum.times
+      (@grains + 1).times do |i|
+        # set alpha for this grain (ramp from maxalpha to 0.0 for i = 0 to 64)
+        a = @maxalpha - (i / @grains.to_f) * @maxalpha
+        fillcolor = @color.copy.a(a)
+        @canvas.fill(fillcolor)
+        #C.rect(ox+(x-ox)*sin(sin(i*w)),oy+(y-oy)*sin(sin(i*w)),1,1)
+        scaler = sin(sin(i * w)) # ramp sinusoidally from 0 to 1
+        x1 = ox + (x - ox) * scaler + random(-@jitter, @jitter)
+        y1 = oy + (y - oy) * scaler + random(-@jitter, @jitter)
+        #puts "#{scaler} #{w} #{i} #{a} => #{x1},#{y1} #{scaler}"
+        @canvas.oval(x1, y1, @grainsize, @grainsize, :center)
+        #C.oval(x,y,@grainsize,@grainsize,:center)
+        #C.oval(ox,oy,@grainsize,@grainsize,:center)
+      end
+      @canvas.pop
+    
+    end
+  end
+end

data/lib/hotcocoa/graphics/gradient.rb

@@ -0,0 +1,63 @@
+# Ruby Cocoa Graphics is a graphics library providing a simple object-oriented 
+# interface into the power of Mac OS X's Core Graphics and Core Image drawing libraries.  
+# With a few lines of easy-to-read code, you can write scripts to draw simple or complex 
+# shapes, lines, and patterns, process and filter images, create abstract art or visualize 
+# scientific data, and much more.
+# 
+# Inspiration for this project was derived from Processing and NodeBox.  These excellent 
+# graphics programming environments are more full-featured than RCG, but they are implemented 
+# in Java and Python, respectively.  RCG was created to offer similar functionality using 
+# the Ruby programming language.
+#
+# Author::    James Reynolds  (mailto:drtoast@drtoast.com)
+# Copyright:: Copyright (c) 2008 James Reynolds
+# License::   Distributes under the same terms as Ruby
+
+module HotCocoa::Graphics
+  
+  # draw a smooth gradient between any number of key colors
+  class Gradient
+  
+    attr_reader :gradient, :drawpre, :drawpost
+  
+    # create a new gradient from black to white
+    def initialize(*colors)
+      @colorspace = CGColorSpaceCreateWithName(KCGColorSpaceGenericRGB)
+      colors = colors[0] if colors[0].class == Array
+      set(colors)
+      pre(true)
+      post(true)
+      self
+    end
+  
+    # create a gradient that evenly distributes the given colors
+    def set(colors)
+      colors ||= [Color.black, Color.white]
+      cgcolors = []
+      locations = []
+      increment = 1.0 / (colors.size - 1).to_f
+      i = 0
+      colors.each do |c|
+        cgcolor = CGColorCreate(@colorspace, [c.r, c.g, c.b, c.a])
+        cgcolors.push(cgcolor)
+        location = i * increment
+        locations.push(location)
+        i = i + 1
+      end
+      @gradient = CGGradientCreateWithColors(@colorspace, cgcolors, locations)
+    end
+  
+    # extend gradient before start location? (true/false)
+    def pre(tf=nil)
+      @drawpre = (tf ? KCGGradientDrawsBeforeStartLocation : 0) unless tf.nil?
+      @drawpre
+    end
+
+    # extend gradient after end location? (true/false)
+    def post(tf=nil)
+      @drawpost = (tf ? KCGGradientDrawsAfterEndLocation : 0) unless tf.nil?
+      @drawpost
+    end
+
+  end
+end