ruby-processing 2.4.3 → 2.4.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (76) hide show
  1. checksums.yaml +4 -4
  2. data/.gitignore +3 -1
  3. data/CHANGELOG +5 -0
  4. data/README.md +4 -2
  5. data/lib/ruby-processing/exporters/application_exporter.rb +1 -0
  6. data/lib/ruby-processing/version.rb +1 -1
  7. data/library/boids/boids.rb +14 -13
  8. data/library/vecmath/lib/vec.rb +20 -4
  9. data/samples/contributed/circle_collision.rb +92 -149
  10. data/samples/contributed/drawolver.rb +13 -27
  11. data/samples/contributed/elegant_ball.rb +158 -0
  12. data/samples/contributed/fern.rb +16 -3
  13. data/samples/contributed/flight_patterns.rb +16 -4
  14. data/samples/external_library/java_processing/{pbox2d → box2d_processing}/bumpy_surface_noise.rb +4 -9
  15. data/samples/external_library/java_processing/{pbox2d → box2d_processing}/data/java_args.txt +0 -0
  16. data/samples/external_library/java_processing/{pbox2d → box2d_processing}/library/custom_shape/custom_shape.rb +1 -1
  17. data/samples/external_library/java_processing/{pbox2d → box2d_processing}/library/particle_system/particle_system.rb +7 -10
  18. data/samples/external_library/java_processing/{pbox2d → box2d_processing}/library/surface/surface.rb +2 -2
  19. data/samples/external_library/java_processing/{pbox2d → box2d_processing}/liquidy.rb +7 -7
  20. data/samples/external_library/java_processing/{pbox2d → box2d_processing}/polygons.rb +4 -9
  21. data/samples/external_library/java_processing/custom/README.md +15 -0
  22. data/samples/external_library/java_processing/custom/Rakefile +28 -0
  23. data/samples/external_library/java_processing/custom/landscape.rb +58 -0
  24. data/samples/external_library/java_processing/custom/src/nn/Connection.java +47 -0
  25. data/samples/external_library/java_processing/custom/src/nn/HiddenNeuron.java +20 -0
  26. data/samples/external_library/java_processing/custom/src/nn/InputNeuron.java +23 -0
  27. data/samples/external_library/java_processing/custom/src/nn/Network.java +136 -0
  28. data/samples/external_library/java_processing/custom/src/nn/Neuron.java +79 -0
  29. data/samples/external_library/java_processing/custom/src/nn/OutputNeuron.java +7 -0
  30. data/samples/external_library/java_processing/custom/xor.rb +88 -0
  31. data/samples/external_library/ruby_gem/README +1 -1
  32. data/samples/external_library/ruby_gem/data/data.json +8 -0
  33. data/samples/external_library/ruby_gem/draw_test.rb +171 -0
  34. data/samples/processing_app/basics/form/icosahedra.rb +39 -0
  35. data/samples/processing_app/basics/form/library/icosahedron/icosahedron.rb +60 -0
  36. data/samples/processing_app/basics/form/toroid.rb +78 -92
  37. data/samples/processing_app/basics/transform/birds.rb +6 -12
  38. data/samples/processing_app/basics/transform/cubes_in_cube.rb +25 -22
  39. data/samples/processing_app/basics/transform/library/cube/cube.rb +16 -16
  40. data/samples/processing_app/basics/transform/rotate_push_pop.rb +1 -1
  41. data/samples/processing_app/demos/graphics/bezier_patch.rb +18 -31
  42. data/samples/processing_app/demos/graphics/trefoil.rb +15 -15
  43. data/samples/processing_app/library/vecmath/acceleration_with_vectors.rb +3 -3
  44. data/samples/processing_app/library/vecmath/hilbert_fractal.rb +2 -2
  45. data/samples/processing_app/library/vecmath/library/flock/flock.rb +18 -21
  46. data/samples/processing_app/library/vecmath/library/hilbert/hilbert.rb +11 -8
  47. data/samples/processing_app/library/vecmath/library/wiggler/wiggler.rb +7 -15
  48. data/samples/processing_app/library/vecmath/seeking_neural.rb +172 -0
  49. data/samples/processing_app/topics/animation/animated_sprite.rb +5 -8
  50. data/samples/processing_app/topics/animation/sequential.rb +2 -3
  51. data/samples/processing_app/topics/create_shapes/library/particle/particle_system.rb +7 -7
  52. data/samples/processing_app/topics/create_shapes/particle_system_pshape.rb +2 -2
  53. data/samples/processing_app/topics/create_shapes/wiggle_pshape.rb +2 -1
  54. data/samples/processing_app/topics/lsystems/koch.rb +1 -1
  55. data/samples/processing_app/topics/lsystems/library/koch/koch_fractal.rb +24 -23
  56. data/samples/processing_app/topics/motion/circle_collision.rb +117 -160
  57. data/samples/processing_app/topics/motion/library/cube/cube.rb +1 -1
  58. data/samples/processing_app/topics/motion/morph.rb +1 -1
  59. data/samples/processing_app/topics/motion/reflection1.rb +17 -16
  60. data/samples/processing_app/topics/shaders/conway.rb +2 -2
  61. data/samples/processing_app/topics/shaders/data/conway.glsl +10 -10
  62. data/samples/processing_app/topics/shaders/glsl_heightmap_noise.rb +9 -8
  63. data/samples/processing_app/topics/shaders/landscape.rb +1 -1
  64. data/samples/processing_app/topics/simulate/flocking.rb +1 -1
  65. data/samples/processing_app/topics/simulate/library/flock/flock.rb +62 -57
  66. data/samples/processing_app/topics/simulate/multiple_particle_systems.rb +8 -28
  67. data/samples/processing_app/topics/simulate/simple_particle_system.rb +9 -7
  68. data/samples/processing_app/topics/simulate/smoke_particle_system.rb +12 -11
  69. data/vendors/Rakefile +2 -2
  70. metadata +26 -21
  71. data/samples/contributed/pong.rb +0 -177
  72. data/samples/contributed/simple_buffer.rb +0 -44
  73. data/samples/external_library/java_processing/pbox2d/contact_test.rb +0 -23
  74. data/samples/processing_app/basics/form/icosahedra/icosahedra.rb +0 -72
  75. data/samples/processing_app/basics/form/icosahedra/icosahedron.rb +0 -116
  76. data/samples/processing_app/basics/form/icosahedra/shape_3D.rb +0 -25
@@ -1,184 +1,141 @@
1
1
  # Based on http://processing.org/learning/topics/circlecollision.html
2
- # by Joe Holt
3
2
 
3
+ load_library :vecmath
4
4
 
5
5
 
6
- # This inner class demonstrates the use of Ruby-Processing's emulation of
7
- # Java inner classes. The Balls are able to call Processing::App methods.
8
6
  class Ball
9
- attr_accessor :x, :y, :r, :m, :vec
10
- def initialize(r = 0.0, vec = nil, x = 0.0, y = 0.0)
11
- @x, @y, @r = x, y, r
7
+ attr_accessor :position, :r, :m, :velocity
8
+
9
+ def initialize(x = 0.0, y = 0.0, r = 0.0)
10
+ @position = Vec2D.new(x, y)
11
+ @r = r
12
12
  @m = r * 0.1
13
- @vec = vec
14
- end
13
+ @velocity = Vec2D.new(rand(-3.0 .. 3), rand(-3.0 .. 3))
14
+ end
15
15
 
16
- def move
17
- @x += @vec.x
18
- @y += @vec.y
16
+ def update
17
+ @position += velocity
19
18
  end
20
19
 
21
- def draw
22
- r = @r * 2
23
- ellipse @x, @y, r, r
24
- @px, @py = @x, @y
20
+ def check_boundary width, height
21
+ if (position.x > width - r)
22
+ position.x = width - r
23
+ velocity.x *= -1
24
+ elsif (position.x < r)
25
+ position.x = r
26
+ velocity.x *= -1
27
+ elsif (position.y > height - r)
28
+ position.y = height - r
29
+ velocity.y *= -1
30
+ elsif (position.y < r)
31
+ position.y = r
32
+ velocity.y *= -1
33
+ end
25
34
  end
26
35
 
27
- def erase
28
- r = @r * 2
29
- rect @px, @py, r, r
36
+ def check_collision balls
37
+ balls.each do |other_ball|
38
+ if !(other_ball.equal?(self))
39
+ # get distances between the balls components
40
+ difference = other_ball.position - position
41
+
42
+ # calculate magnitude of the vector separating the balls
43
+
44
+ dist_mag_squared = difference.mag_squared
45
+
46
+ if dist_mag_squared < (r + other_ball.r) * (r + other_ball.r)
47
+ # get angle of difference
48
+ theta = difference.heading
49
+ # precalculate trig values
50
+ sine = sin(theta)
51
+ cosine = cos(theta)
52
+
53
+ # ball_array will hold rotated ball positions. You just
54
+ # need to worry about ball_array[1] position
55
+ ball_array = [Ball.new, Ball.new]
56
+ # other_ball's position is relative to ball's
57
+ # so you can use the vector between them (difference) as the
58
+ # reference point in the rotation expressions.
59
+ # ball_array[0].x and ball_array[0].y will initialize
60
+ # automatically to 0.0, which is what you want
61
+ # since other_ball will rotate around ball
62
+ ball_array[1].position.x = cosine * difference.x + sine * difference.y
63
+ ball_array[1].position.y = cosine * difference.y - sine * difference.x
64
+
65
+ # rotate Temporary velocities
66
+ velocity_array = [Vec2D.new, Vec2D.new]
67
+ velocity_array[0].x = cosine * velocity.x + sine * velocity.y
68
+ velocity_array[0].y = cosine * velocity.y - sine * velocity.x
69
+ velocity_array[1].x = cosine * other_ball.velocity.x + sine * other_ball.velocity.y
70
+ velocity_array[1].y = cosine * other_ball.velocity.y - sine * other_ball.velocity.x
71
+
72
+ # Now that velocities are rotated, you can use 1D
73
+ # conservation of momentum equations to calculate
74
+ # the final velocity along the x-axis.
75
+ final_velocities = [Vec2D.new, Vec2D.new]
76
+ # final rotated velocity for ball
77
+ final_velocities[0].x = ((m - other_ball.m) * velocity_array[0].x + 2 * other_ball.m * velocity_array[1].x) / (m + other_ball.m)
78
+ final_velocities[0].y = velocity_array[0].y
79
+ # final rotated velocity for ball
80
+ final_velocities[1].x = ((other_ball.m - m) * velocity_array[1].x + 2 * m * velocity_array[0].x) / (m + other_ball.m)
81
+ final_velocities[1].y = velocity_array[1].y
82
+
83
+ # hack to avoid clumping
84
+ ball_array[0].position.x += final_velocities[0].x
85
+ ball_array[1].position.x += final_velocities[1].x
86
+
87
+ # Rotate ball positions and velocities back
88
+ # Reverse signs in trig expressions to rotate
89
+ # in the opposite direction
90
+ # rotate balls
91
+ final_positions = [Vec2D.new, Vec2D.new]
92
+ final_positions[0].x = cosine * ball_array[0].position.x - sine * ball_array[0].position.y
93
+ final_positions[0].y = cosine * ball_array[0].position.y + sine * ball_array[0].position.x
94
+ final_positions[1].x = cosine * ball_array[1].position.x - sine * ball_array[1].position.y
95
+ final_positions[1].y = cosine * ball_array[1].position.y + sine * ball_array[1].position.x
96
+
97
+ # update balls to screen position
98
+ other_ball.position = position + final_positions[1]
99
+ @position += final_positions[0]
100
+
101
+ # update velocities
102
+ velocity.x = cosine * final_velocities[0].x - sine * final_velocities[0].y
103
+ velocity.y = cosine * final_velocities[0].y + sine * final_velocities[0].x
104
+ other_ball.velocity.x = cosine * final_velocities[1].x - sine * final_velocities[1].y
105
+ other_ball.velocity.y = cosine * final_velocities[1].y + sine * final_velocities[1].x
106
+ end
107
+ end
108
+ end
30
109
  end
31
- end
32
-
33
-
34
- def setup
35
- size 400, 400
36
- no_stroke
37
- frame_rate 30
38
- rect_mode RADIUS
39
- @balls = []
40
- 5.times { @balls << Ball.new(10, PVector.new(2.15, -1.35), *empty_space(15)) }
41
- 2.times { @balls << Ball.new(40, PVector.new(-1.65, 0.42), *empty_space(45)) }
42
- @frame_time = nil
43
- @frame_count = 0
44
- end
45
-
46
-
47
- def draw
48
- t = Time.now
49
- fps = 1.0 / (t - @frame_time) if @frame_time
50
- @frame_time = t
51
- @frame_count += 1
52
110
 
53
- # erase previous screen
54
- if @frame_count == 1
55
- background 51
56
- else
57
- fill 51
58
- @balls.each { |ball| ball.erase }
111
+ def display
112
+ no_stroke
113
+ fill(204)
114
+ ellipse(position.x, position.y, r * 2, r * 2)
59
115
  end
60
116
 
61
- # move the balls
62
- fill 240
63
- @balls.each do |ball|
64
- ball.move
65
- ball.draw
66
- check_boundary_collision ball
67
- end
68
- check_object_collisions
69
117
  end
70
118
 
119
+ attr_reader :balls
71
120
 
72
- def empty_space(r)
73
- x = y = nil
74
- while !x || !empty_space?(x, y, r) do
75
- x = rand(width)
76
- y = rand(height)
77
- end
78
- return x, y
79
- end
80
-
81
-
82
- def empty_space?(x, y, r)
83
- @balls.each do |ball|
84
- vx = x - ball.x
85
- vy = y - ball.y
86
- mag = sqrt(vx * vx + vy * vy)
87
- return false if mag < r + ball.r
88
- end
89
- return true
90
- end
91
-
92
-
93
- def check_object_collisions
94
-
95
- (0...(@balls.length)).each do |ia|
96
- ((ia+1)...(@balls.length)).each do |ib|
97
-
98
- ba = @balls[ia]
99
- bb = @balls[ib]
100
-
101
- # get distances between the balls components
102
- bVect = PVector.new
103
- bVect.x = bb.x - ba.x
104
- bVect.y = bb.y - ba.y
105
-
106
- # calculate magnitude of the vector separating the balls
107
- bVectMag = bVect.mag
108
- next if bVectMag >= ba.r + bb.r
109
- # get angle of bVect
110
- theta = atan2(bVect.y, bVect.x)
111
- # precalculate trig values
112
- sine = sin(theta)
113
- cosine = cos(theta)
114
-
115
- # bTemp will hold rotated ball positions. You just
116
- # need to worry about bTemp[1] position
117
- bTemp = [Ball.new, Ball.new]
118
- # bb's position is relative to ba's
119
- # so you can use the vector between them (bVect) as the
120
- # reference point in the rotation expressions.
121
- # bTemp[0].x and bTemp[0].y will initialize
122
- # automatically to 0.0, which is what you want
123
- # since bb will rotate around ba
124
- bTemp[1].x = cosine * bVect.x + sine * bVect.y
125
- bTemp[1].y = cosine * bVect.y - sine * bVect.x
126
-
127
- # rotate Temporary velocities
128
- vTemp = [PVector.new, PVector.new]
129
- vTemp[0].x = cosine * ba.vec.x + sine * ba.vec.y
130
- vTemp[0].y = cosine * ba.vec.y - sine * ba.vec.x
131
- vTemp[1].x = cosine * bb.vec.x + sine * bb.vec.y
132
- vTemp[1].y = cosine * bb.vec.y - sine * bb.vec.x
133
-
134
- # Now that velocities are rotated, you can use 1D
135
- # conservation of momentum equations to calculate
136
- # the final velocity along the x-axis.
137
- vFinal = [PVector.new, PVector.new]
138
- # final rotated velocity for ba
139
- vFinal[0].x = ((ba.m - bb.m) * vTemp[0].x + 2 * bb.m * vTemp[1].x) / (ba.m + bb.m)
140
- vFinal[0].y = vTemp[0].y
141
- # final rotated velocity for ba
142
- vFinal[1].x = ((bb.m - ba.m) * vTemp[1].x + 2 * ba.m * vTemp[0].x) / (ba.m + bb.m)
143
- vFinal[1].y = vTemp[1].y
144
-
145
- # hack to avoid clumping
146
- bTemp[0].x += vFinal[0].x
147
- bTemp[1].x += vFinal[1].x
148
-
149
- # Rotate ball positions and velocities back
150
- # Reverse signs in trig expressions to rotate
151
- # in the opposite direction
152
- # rotate balls
153
- bFinal = [Ball.new, Ball.new]
154
- bFinal[0].x = cosine * bTemp[0].x - sine * bTemp[0].y
155
- bFinal[0].y = cosine * bTemp[0].y + sine * bTemp[0].x
156
- bFinal[1].x = cosine * bTemp[1].x - sine * bTemp[1].y
157
- bFinal[1].y = cosine * bTemp[1].y + sine * bTemp[1].x
158
-
159
- # update balls to screen position
160
- bb.x = ba.x + bFinal[1].x
161
- bb.y = ba.y + bFinal[1].y
162
- ba.x = ba.x + bFinal[0].x
163
- ba.y = ba.y + bFinal[0].y
164
-
165
- # update velocities
166
- ba.vec.x = cosine * vFinal[0].x - sine * vFinal[0].y
167
- ba.vec.y = cosine * vFinal[0].y + sine * vFinal[0].x
168
- bb.vec.x = cosine * vFinal[1].x - sine * vFinal[1].y
169
- bb.vec.y = cosine * vFinal[1].y + sine * vFinal[1].x
170
- end
171
- end
172
-
121
+ def setup
122
+ size 640, 360
123
+ @balls = [
124
+ Ball.new(100, 400, 20),
125
+ Ball.new(100, 100, 20),
126
+ Ball.new(200, 100, 20),
127
+ Ball.new(700, 400, 60)
128
+ ]
173
129
  end
174
130
 
175
131
 
176
- def check_boundary_collision(ball)
177
- unless (ball.r ... width - ball.r).cover? ball.x
178
- ball.vec.x *= -1
179
- end
180
- unless (ball.r ... height - ball.r).cover? ball.y
181
- ball.vec.y *= -1
132
+ def draw
133
+ background(51)
134
+ balls.each do |b|
135
+ b.update
136
+ b.display
137
+ b.check_boundary width, height
138
+ b.check_collision(balls)
182
139
  end
183
140
  end
184
141
 
@@ -111,7 +111,7 @@ Boundary = Struct.new(:lower, :upper) do
111
111
  end
112
112
 
113
113
  # Leaner meaner substitute for vanilla processings
114
- # PVector class, provides only functionality we need
114
+ # PVector class, provides only the functionality we need
115
115
  #
116
116
  Vect = Struct.new(:x, :y, :z) do
117
117
 
@@ -1,6 +1,6 @@
1
1
  #
2
2
  # Morph.
3
- #
3
+ # see vecmath library for a variant using Vec2D instead of PVector
4
4
  # Changing one shape into another by interpolating
5
5
  # vertices from one to another
6
6
  #
@@ -6,6 +6,7 @@
6
6
  # reflection vector, N is the normal, and L is the incident
7
7
  # vector.
8
8
  #
9
+ load_library :vecmath
9
10
 
10
11
  attr_reader :base1, :base2, :base_length, :coords, :position, :radius
11
12
  attr_reader :direction, :speed, :velocity, :incidence
@@ -15,14 +16,14 @@ def setup
15
16
  @radius = 6
16
17
  @speed = 3.5
17
18
  fill(128)
18
- @base1 = PVector.new(0, height - 150)
19
- @base2 = PVector.new(width, height)
19
+ @base1 = Vec2D.new(0, height - 150)
20
+ @base2 = Vec2D.new(width, height)
20
21
  @coords = create_ground
21
22
  # start ellipse at middle top of screen
22
- @position = PVector.new(width/2, 0)
23
+ @position = Vec2D.new(width/2, 0)
23
24
  # set initial random direction
24
- @direction = PVector.random2D
25
- @velocity = PVector.new
25
+ @direction = Vec2D.new(rand(-1.0 .. 1), rand(-1.0 .. 1))
26
+ @velocity = Vec2D.new
26
27
  end
27
28
 
28
29
  def draw
@@ -36,34 +37,34 @@ def draw
36
37
  quad(base1.x, base1.y, base2.x, base2.y, base2.x, height, 0, height)
37
38
 
38
39
  # calculate base top normal
39
- base_delta = PVector.sub(base2, base1)
40
- base_delta.normalize
41
- normal = PVector.new(-base_delta.y, base_delta.x)
40
+ base_delta = base2 - base1
41
+ base_delta.normalize!
42
+ normal = Vec2D.new(-base_delta.y, base_delta.x)
42
43
  # draw ellipse
43
44
  no_stroke
44
45
  fill(255)
45
46
  ellipse(position.x, position.y, radius * 2, radius * 2)
46
47
 
47
48
  # set ellipse velocity
48
- @velocity.set(direction)
49
- @velocity.mult(speed)
49
+ @velocity.x, @velocity.y = direction.x, direction.y
50
+ @velocity *= speed
50
51
 
51
52
  # move ellipse
52
- @position.add(velocity)
53
+ @position += velocity
53
54
 
54
55
  # normalized incidence vector
55
- @incidence = PVector.mult(direction, -1)
56
+ @incidence = direction * -1
56
57
 
57
58
  # detect and handle collision
58
59
  coords.each do |coord|
59
60
  # check distance between ellipse and base top coordinates
60
- if (PVector.dist(position, coord) < radius)
61
+ if (Vec2D.dist_squared(position, coord) < radius * radius)
61
62
 
62
63
  # calculate dot product of incident vector and base top normal
63
64
  dot = incidence.dot(normal)
64
65
 
65
66
  # assign reflection vector to direction vector
66
- direction.set(2*normal.x*dot - incidence.x, 2*normal.y*dot - incidence.y, 0)
67
+ direction.x, direction.y = 2*normal.x*dot - incidence.x, 2*normal.y*dot - incidence.y
67
68
  # draw base top normal at collision point
68
69
  stroke(255, 128, 0)
69
70
  line(position.x, position.y, position.x - normal.x*100, position.y - normal.y*100)
@@ -94,11 +95,11 @@ end
94
95
 
95
96
  def create_ground
96
97
  # calculate length of base top
97
- @base_length = PVector.dist(base1, base2)
98
+ @base_length = Vec2D.dist(base1, base2)
98
99
  # fill base top coordinate array
99
100
  coords = []
100
101
  (0 ... base_length.ceil).each do |i|
101
- coords << PVector.new(
102
+ coords << Vec2D.new(
102
103
  base1.x + ((base2.x - base1.x) / base_length) * i,
103
104
  base1.y + ((base2.y - base1.y) / base_length) * i)
104
105
  end
@@ -1,7 +1,7 @@
1
1
  # GLSL version of Conway's game of life, ported from GLSL sandbox:
2
2
  # http://glsl.heroku.com/e/207.3
3
- # Exemplifies the use of the buffer uniform in the shader, that gives
4
- # access to the previous frame.
3
+ # Exemplifies the use of the ppixels uniform in the shader, that gives
4
+ # access to the pixels of the previous frame.
5
5
  attr_accessor :pg, :conway
6
6
 
7
7
  def setup
@@ -9,7 +9,7 @@ precision highp float;
9
9
  uniform float time;
10
10
  uniform vec2 mouse;
11
11
  uniform vec2 resolution;
12
- uniform sampler2D buffer;
12
+ uniform sampler2D ppixels;
13
13
 
14
14
  vec4 live = vec4(0.5,1.0,0.7,1.);
15
15
  vec4 dead = vec4(0.,0.,0.,1.);
@@ -28,15 +28,15 @@ void main( void ) {
28
28
  }
29
29
  } else {
30
30
  float sum = 0.;
31
- sum += texture2D(buffer, position + pixel * vec2(-1., -1.)).g;
32
- sum += texture2D(buffer, position + pixel * vec2(-1., 0.)).g;
33
- sum += texture2D(buffer, position + pixel * vec2(-1., 1.)).g;
34
- sum += texture2D(buffer, position + pixel * vec2(1., -1.)).g;
35
- sum += texture2D(buffer, position + pixel * vec2(1., 0.)).g;
36
- sum += texture2D(buffer, position + pixel * vec2(1., 1.)).g;
37
- sum += texture2D(buffer, position + pixel * vec2(0., -1.)).g;
38
- sum += texture2D(buffer, position + pixel * vec2(0., 1.)).g;
39
- vec4 me = texture2D(buffer, position);
31
+ sum += texture2D(ppixels, position + pixel * vec2(-1., -1.)).g;
32
+ sum += texture2D(ppixels, position + pixel * vec2(-1., 0.)).g;
33
+ sum += texture2D(ppixels, position + pixel * vec2(-1., 1.)).g;
34
+ sum += texture2D(ppixels, position + pixel * vec2(1., -1.)).g;
35
+ sum += texture2D(ppixels, position + pixel * vec2(1., 0.)).g;
36
+ sum += texture2D(ppixels, position + pixel * vec2(1., 1.)).g;
37
+ sum += texture2D(ppixels, position + pixel * vec2(0., -1.)).g;
38
+ sum += texture2D(ppixels, position + pixel * vec2(0., 1.)).g;
39
+ vec4 me = texture2D(ppixels, position);
40
40
 
41
41
  if (me.g <= 0.1) {
42
42
  if ((sum >= 2.9) && (sum <= 3.1)) {
@@ -11,6 +11,7 @@
11
11
  #
12
12
  # Photographs by Folkert Gorter (@folkertgorter / http://superfamous.com/) made available under a CC Attribution 3.0 license.
13
13
  #
14
+ load_library :vecmath
14
15
 
15
16
  DIM = 300 # the grid dimensions of the heightmap
16
17
  attr_reader :blur_factor # the blur for the displacement map (to make it smoother)
@@ -78,16 +79,16 @@ def create_plane(xsegs, ysegs)
78
79
  v = y / ysegs.to_f
79
80
 
80
81
  # generate positions for the vertices of each cell (-0.5 to center the shape around the origin)
81
- positions << PVector.new(u - 0.5, v - 0.5, 0)
82
- positions << PVector.new(u + usegsize - 0.5, v - 0.5, 0)
83
- positions << PVector.new(u + usegsize - 0.5, v + vsegsize - 0.5, 0)
84
- positions << PVector.new(u - 0.5, v + vsegsize - 0.5, 0)
82
+ positions << Vec3D.new(u - 0.5, v - 0.5, 0)
83
+ positions << Vec3D.new(u + usegsize - 0.5, v - 0.5, 0)
84
+ positions << Vec3D.new(u + usegsize - 0.5, v + vsegsize - 0.5, 0)
85
+ positions << Vec3D.new(u - 0.5, v + vsegsize - 0.5, 0)
85
86
 
86
87
  # generate texture coordinates for the vertices of each cell
87
- tex_coords << PVector.new(u, v)
88
- tex_coords << PVector.new(u + usegsize, v)
89
- tex_coords << PVector.new(u + usegsize, v + vsegsize)
90
- tex_coords << PVector.new(u, v + vsegsize)
88
+ tex_coords << Vec2D.new(u, v)
89
+ tex_coords << Vec2D.new(u + usegsize, v)
90
+ tex_coords << Vec2D.new(u + usegsize, v + vsegsize)
91
+ tex_coords << Vec2D.new(u, v + vsegsize)
91
92
  end
92
93
  end
93
94