Replace 2D cross product with wedge product

monkstone · monkstone · commit d25359a155a6 · 2021-12-14T10:44:06.000Z
diff --git a/contributed/circles.rb b/contributed/circles.rb
@@ -22,8 +22,8 @@ def draw
   end
 
   # set the style of the circle
-  @dc = map1d(millis, 0..150_000, 0..360) # slowly changes hue
-  stroke((@c + @dc) % 360, 50, 100, 5)
+  @delta_hue = map1d(millis, 0..150_000, 0..360) # slowly changes hue
+  stroke((@hue + @delta_hue) % 360, 50, 100, 5)
   no_fill
 
   ## verifies if there is a circle and draw it
@@ -39,7 +39,7 @@ def draw_circle(pts)
 end
 
 def reset
-  @c = rand(360)
+  @hue = rand(360)
   @points = TrianglePoints.new
   3.times { @points << TPoint.new(Vec2D.new(rand(5..width - 5), rand(5..height - 5))) }
   background 0
diff --git a/contributed/elegant_ball.rb b/contributed/elegant_ball.rb
@@ -134,12 +134,9 @@ def draw_triangle(depth, r, p1, p2, p3)
     v3 = (p3 + p1) * 0.5
     unless r == 0.0
       # Project the vertices out onto the sphere with radius r.
-      v1.normalize!
-      v1 *= r
-      v2.normalize!
-      v2 *= r
-      v3.normalize!
-      v3 *= r
+      v1.set_mag(r)
+      v2.set_mag(r)
+      v3.set_mag(r)
     end
     ## Generate the next level of detail
     depth -= 1
diff --git a/contributed/library/circle/lib/t_points.rb b/contributed/library/circle/lib/t_points.rb
@@ -20,7 +20,7 @@ def <<(pt)
   end
 
   def collinear?
-    full? ? (positions[0] - positions[1]).cross(positions[1] - positions[2]).zero? : false
+    full? ? ((positions[0] - positions[1]) ^ (positions[1] - positions[2])).zero? : false
   end
 
   # returns positions as an array of Vec2D
diff --git a/external_library/gem/mdarray/geometry/geometry.rb b/external_library/gem/mdarray/geometry/geometry.rb
diff --git a/external_library/gem/mdarray/geometry/lib/cylinder.rb b/external_library/gem/mdarray/geometry/lib/cylinder.rb
diff --git a/external_library/gem/mdarray/geometry/lib/matrix4.rb b/external_library/gem/mdarray/geometry/lib/matrix4.rb
diff --git a/external_library/gem/mdarray/geometry/lib/plane.rb b/external_library/gem/mdarray/geometry/lib/plane.rb
diff --git a/processing_app/library/vecmath/vec2d/basic_circumcircle_sketch.rb b/processing_app/library/vecmath/vec2d/basic_circumcircle_sketch.rb
@@ -3,7 +3,7 @@
 # Here is a sketch that clearly demonstrates some of the most egregious parts of
 # vanilla processing:-
 # PVector is over complicated and overloads 2D and 3D functionality, cf Vec2D
-# JRubyArt and propane which behaves as a 2D vector (cross product is a float)
+# JRubyArt and propane which behaves as a 2D vector (wedge product is a float)
 # and can easily be used in chain calculations.
 
 ##################################################
diff --git a/processing_app/library/vecmath/vec2d/circles.rb b/processing_app/library/vecmath/vec2d/circles.rb
@@ -31,7 +31,7 @@ def draw
   no_fill
   # verifies if there is a circle and draw it
   return if collinear(@points[0].pos, @points[1].pos, @points[2].pos)
-  draw_circle *@points
+  draw_circle(*@points)
 end
 
 def draw_circle(a, b, c)
@@ -53,7 +53,7 @@ def bisector(a, b)
 end
 
 def collinear(a, b, c)
-  (a - b).cross(b - c).zero?
+  ((a - b) ^ (b - c)).zero?
 end
 
 def center(bisector)
diff --git a/processing_app/library/vecmath/vec2d/library/circle/lib/points.rb b/processing_app/library/vecmath/vec2d/library/circle/lib/points.rb
@@ -21,7 +21,7 @@ def <<(pt)
 
   def collinear?
     return false unless full?
-    (array[0] - array[1]).cross(array[1] - array[2]).zero?
+    ((array[0] - array[1]) ^ (array[1] - array[2])).zero?
   end
 
   def array
diff --git a/processing_app/library/vecmath/vec2d/library/circle2/lib/circumcircle.rb b/processing_app/library/vecmath/vec2d/library/circle2/lib/circumcircle.rb
@@ -33,6 +33,6 @@ def radius
   end
 
   def collinear?
-    (a - b).cross(b - c).zero?
+    ((a - b) ^ (b - c)).zero?
   end
 end
diff --git a/processing_app/library/vecmath/vec2d/library/circle2/lib/points.rb b/processing_app/library/vecmath/vec2d/library/circle2/lib/points.rb
@@ -21,7 +21,7 @@ def <<(pt)
 
   def collinear?
     return false unless full?
-    (array[0] - array[1]).cross(array[1] - array[2]).zero?
+    ((array[0] - array[1]) ^ (array[1] - array[2])).zero?
   end
 
   def array
diff --git a/processing_app/library/vecmath/vec2d/library/simple_circle/lib/simple_points.rb b/processing_app/library/vecmath/vec2d/library/simple_circle/lib/simple_points.rb
@@ -20,7 +20,7 @@ def <<(pt)
   end
 
   def collinear?
-    full? ? (points[0] - points[1]).cross(points[1] - points[2]).zero? : false
+    full? ? ((points[0] - points[1]) ^ (points[1] - points[2])).zero? : false
   end
 
   def full?
diff --git a/processing_app/library/vecmath/vec2d/library/simple_circle/lib/t_points.rb b/processing_app/library/vecmath/vec2d/library/simple_circle/lib/t_points.rb
@@ -20,7 +20,7 @@ def <<(pt)
   end
 
   def collinear?
-    full? ? (vec[0] - vec[1]).cross(vec[1] - vec[2]).zero? : false
+    full? ? ((vec[0] - vec[1]) ^ (vec[1] - vec[2])).zero? : false
   end
 
   def vec
diff --git a/processing_app/topics/shaders/data/sigmoids.glsl b/processing_app/topics/shaders/data/sigmoids.glsl
@@ -0,0 +1,126 @@
+#ifdef GL_ES
+precision mediump float;
+precision mediump int;
+#endif
+
+// From a shadertoy sketch by Victor Shepardson
+// https://www.shadertoy.com/view/ltfXzj
+
+uniform vec3      iResolution;           // viewport resolution (in pixels)
+uniform float     iTime;                 // shader playback time (in seconds)
+
+const float pi = 3.14159;
+
+float sigmoid(float x){
+ 	return x/(1.+abs(x));
+}
+
+float iter(vec2 p, vec4 a, vec4 wt, vec4 ws, float t, float m, float stereo){
+    float wp = .2;
+    vec4 phase = vec4(mod(t, wp), mod(t+wp*.25, wp), mod(t+wp*.5, wp), mod(t+wp*.75, wp))/wp;
+    float zoom = 1./(1.+.5*(p.x*p.x+p.y*p.y));
+    vec4 scale = zoom*pow(vec4(2.), -4.*phase);
+    vec4 ms = .5-.5*cos(2.*pi*phase);
+    vec4 pan = stereo/scale*(1.-phase)*(1.-phase);
+    vec4 v = ms*sin( wt*(t+m) + (m+ws*scale)*((p.x+pan) * cos((t+m)*a) + p.y * sin((t+m)*a)));
+    return sigmoid(v.x+v.y+v.z+v.w+m);
+}
+
+vec3 scene(float gt, vec2 uv, vec4 a0, vec4 wt0, vec4 ws0, float blur){
+    //time modulation
+    float tm = mod(.0411*gt, 1.);
+    tm = sin(2.*pi*tm*tm);
+    float t = (.04*gt + .05*tm);
+
+    float stereo = 1.*(sigmoid(2.*(sin(1.325*t*cos(.5*t))+sin(-.7*t*sin(.77*t)))));//+sin(-17.*t)+sin(10.*t))));
+    //t = 0.;
+    //also apply spatial offset
+    uv+= .5*sin(.33*t)*vec2(cos(t), sin(t));
+
+    //wildly iterate and divide
+    float p0 = iter(uv, a0, wt0, ws0, t, 0., stereo);
+
+   	float p1 = iter(uv, a0, wt0, ws0, t, p0, stereo);
+
+    float p2 = sigmoid(p0/(p1+blur));
+
+    float p3 = iter(uv, a0, wt0, ws0, t, p2, stereo);
+
+    float p4 = sigmoid(p3/(p2+blur));
+
+    float p5 = iter(uv, a0, wt0, ws0, t, p4, stereo);
+
+    float p6 = sigmoid(p4/(p5+blur));
+
+    float p7 = iter(uv, a0, wt0, ws0, t, p6, stereo);
+
+    float p8 = sigmoid(p4/(p2+blur));
+
+    float p9 = sigmoid(p8/(p7+blur));
+
+    float p10 = iter(uv, a0, wt0, ws0, t, p8, stereo);
+
+    float p11 = iter(uv, a0, wt0, ws0, t, p9, stereo);
+
+    float p12 = sigmoid(p11/(p10+blur));
+
+    float p13 = iter(uv, a0, wt0, ws0, t, p12, stereo);
+
+    //colors
+    vec3 accent_color = vec3(1.,0.2,0.);//vec3(0.99,0.5,0.2);
+    /*float r = sigmoid(-1.+2.*p0+p1-max(1.*p3,0.)+p5+p7+p10+p11+p13);
+    float g = sigmoid(-1.+2.*p0-max(1.*p1,0.)-max(2.*p3,0.)-max(2.*p5,0.)+p7+p10+p11+p13);
+    float b = sigmoid(0.+1.5*p0+p1+p3+-max(2.*p5,0.)+p7+p10+p11+p13);
+    */
+    float r = sigmoid(p0+p1+p5+p7+p10+p11+p13);
+    float g = sigmoid(p0-p1+p3+p7+p10+p11);
+    float b = sigmoid(p0+p1+p3+p5+p11+p13);
+
+
+    vec3 c = max(vec3(0.), .4+.6*vec3(r,g,b));
+
+    float eps = .4;
+    float canary = min(abs(p1), abs(p2));
+    canary = min(canary, abs(p5));
+    //canary = min(canary, abs(p6));
+    canary = min(canary, abs(p7));
+    canary = min(canary, abs(p10));
+    float m = max(0.,eps-canary)/eps;
+    m = sigmoid((m-.5)*700./(1.+10.*blur))*.5+.5;
+    //m = m*m*m*m*m*m*m*m*m*m;
+    vec3 m3 = m*(1.-accent_color);
+    c *= .8*(1.-m3)+.3;//mix(c, vec3(0.), m);
+
+    return c;
+}
+
+void main( void )
+{
+    float s = min(iResolution.x, iResolution.y);
+   	vec2 uv = (2.*gl_FragCoord.xy - vec2(iResolution.xy)) / s;
+
+    float blur = .5*(uv.x*uv.x+uv.y*uv.y);
+
+    //angular, spatial and temporal frequencies
+    vec4 a0 = pi*vec4(.1, -.11, .111, -.1111);
+    vec4 wt0 = 2.*pi*vec4(.3);//.3333, .333, .33, .3);
+    vec4 ws0 = 2.5*vec4(11., 13., 11., 5.);
+
+    //aa and motion blur
+    float mb = 1.;
+    float t = 1100.+iTime;
+    vec3 c = scene(t, uv, a0, wt0, ws0, blur)
+        + scene(t-mb*.00185, uv+(1.+blur)*vec2(.66/s, 0.), a0, wt0, ws0, blur)
+        + scene(t-mb*.00370, uv+(1.+blur)*vec2(-.66/s, 0.), a0, wt0, ws0, blur)
+        + scene(t-mb*.00555, uv+(1.+blur)*vec2(0., .66/s), a0, wt0, ws0, blur)
+        + scene(t-mb*.00741, uv+(1.+blur)*vec2(0., -.66/s), a0, wt0, ws0, blur)
+        + scene(t-mb*.00926, uv+(1.+blur)*vec2(.5/s, .5/s), a0, wt0, ws0, blur)
+        + scene(t-mb*.01111, uv+(1.+blur)*vec2(-.5/s, .5/s), a0, wt0, ws0, blur)
+        + scene(t-mb*.01296, uv+(1.+blur)*vec2(-.5/s, -.5/s), a0, wt0, ws0, blur)
+        + scene(t-mb*.01481, uv+(1.+blur)*vec2(.5/s, -.5/s), a0, wt0, ws0, blur)
+
+        ;
+    c/=9.;
+
+    gl_FragColor = vec4(c,1.0);
+}
diff --git a/processing_app/topics/shaders/sigmoids.rb b/processing_app/topics/shaders/sigmoids.rb
@@ -0,0 +1,34 @@
+attr_reader :previous_time, :wrapper, :start
+# Shader by Victor Shepardson
+
+def settings
+  size(800, 450, P2D)
+end
+
+def setup
+  sketch_title 'Sigmoids n sine (by Victor Shepardson)'
+  @previous_time = 0.0
+  @mouse_dragged = false
+  @mouse_click_state = 0.0
+  @wrapper = load_shader(data_path('sigmoids.glsl'))
+  # Assume the dimension of the window will not change over time
+  wrapper.set('iResolution', width.to_f, height.to_f, 0.0)
+  @last_mouse_position = Vec2D.new(mouse_x, mouse_y)
+  @start = java.lang.System.current_time_millis
+end
+
+def playback_time_seconds
+  (java.lang.System.current_time_millis - start) / 1000.0
+end
+
+def render_time
+  playback_time_seconds - previous_time
+end
+
+def draw
+  wrapper.set('iTime', playback_time_seconds)
+  @previous_time = playback_time_seconds
+  shader(wrapper)
+  # Draw the output of the shader onto a rectangle that covers the whole viewport.
+  rect(0, 0, width, height)
+end
