Make triangles able to raster images

Author: DSchaedler

app/lib/dinraal.rb

@@ -44,12 +44,15 @@ def circle_outline(options = {})
 
     angle = 0
     while angle < 360
-      new_pixel = point_at_distance_angle(point: { x: x, y: y }, distance: radius, angle: angle)
+      new_pixel = point_at_distance_angle(point: { x: x, y: y },
+                                          distance: radius,
+                                          angle: angle)
 
       new_pixel[:x] = new_pixel[:x].floor
       new_pixel[:y] = new_pixel[:y].floor
 
-      possible_pixel = { x: new_pixel[:x], y: new_pixel[:y], w: 1, h: 1, r: r, g: g, b: b, a: a }.solid!
+      possible_pixel = { x: new_pixel[:x], y: new_pixel[:y], w: 1, h: 1,
+                         r: r, g: g, b: b, a: a }.solid!
 
       pixels << possible_pixel unless pixels.include?(possible_pixel)
       angle += 1
@@ -82,7 +85,8 @@ def circle_raster(options = {})
       pixels[x_min] ||= []
       y_min = y - radius
       while y_min <= y_max
-        possible_pixel = { x: x_min, y: y_min, w: 1, h: 1, r: r, g: g, b: b, a: a }.solid!
+        possible_pixel = { x: x_min, y: y_min, w: 1, h: 1,
+                           r: r, g: g, b: b, a: a }.solid!
         pixels[x_min][y_min] = possible_pixel if args.geometry.point_inside_circle?({ x: x_min, y: y_min }, { x: x, y: y }, radius)
         y_min += 1
       end
@@ -108,19 +112,19 @@ def point_inside_triangle?(point:, triangle:)
     triangle = triangle.reverse
 
     leg0 = [triangle[0], triangle[1]]
-    leg0_slope = args.geometry.line_slope(leg0.flatten)
+    leg0_slope = args.geometry.line_slope(leg0.flatten, replace_infinity: 1080)
     leg0_intercept = triangle[0][1] - (leg0_slope * triangle[0][0])
 
     return false unless point_y <= leg0_slope * point_x + leg0_intercept
 
     leg1 = [triangle[0], triangle[2]]
-    leg1_slope = args.geometry.line_slope(leg1.flatten)
+    leg1_slope = args.geometry.line_slope(leg1.flatten, replace_infinity: 1080)
     leg1_intercept = triangle[0][1] - (leg1_slope * triangle[0][0])
 
     return false unless point_y <= leg1_slope * point_x + leg1_intercept
 
     leg2 = [triangle[1], triangle[2]]
-    leg2_slope = args.geometry.line_slope(leg2.flatten)
+    leg2_slope = args.geometry.line_slope(leg2.flatten, replace_infinity: 1080)
     leg2_intercept = triangle[2][1] - (leg2_slope * triangle[2][0])
 
     return false unless point_y >= leg2_slope * point_x + leg2_intercept
@@ -166,61 +170,101 @@ def triangle_raster(options = {})
     y2 = options[:y2]
     x3 = options[:x3]
     y3 = options[:y3]
-    r = options[:r]
-    g = options[:g]
-    b = options[:b]
-    a = options[:a]
+
+    r = options[:r].nil? ? 0 : options[:r]
+    g = options[:g].nil? ? 0 : options[:g]
+    b = options[:b].nil? ? 0 : options[:b]
+    a = options[:a].nil? ? 255 : options[:a]
+
+    path = options[:path].nil? ? 'pixel' : options[:path]
+
+    image_width = options[:image_width].nil? ? [x, x2, x3].max - [x, x2, x3].min : options[:image_width]
 
     args = $gtk.args
     triangle = [[x, y], [x2, y2], [x3, y3]]
     triangle = triangle.sort_by { |point| point[1] }
     triangle = triangle.reverse
 
-    line_slope = args.geometry.line_slope [triangle[0][0], triangle[0][1], triangle[2][0], triangle[2][1]]
+    line_slope = args.geometry.line_slope([triangle[0][0], triangle[0][1], triangle[2][0], triangle[2][1]], replace_infinity: 1080)
     x_intercept = triangle[0][1] - (line_slope * triangle[0][0])
 
     vertex4 = [(triangle[1][1] - x_intercept) / line_slope, triangle[1][1]]
 
     leg0 = [triangle[0], triangle[1]]
-    leg0_slope = args.geometry.line_slope(leg0.flatten)
+    leg0_slope = args.geometry.line_slope(leg0.flatten, replace_infinity: 1080)
     leg0_intercept = triangle[0][1] - (leg0_slope * triangle[0][0])
 
     leg1 = [triangle[0], vertex4]
-    leg1_slope = args.geometry.line_slope(leg1.flatten)
+    leg1_slope = args.geometry.line_slope(leg1.flatten, replace_infinity: 1080)
     leg1_intercept = triangle[0][1] - (leg1_slope * triangle[0][0])
 
-    leg2 = [triangle[2], triangle[1]]
-    leg2_slope = args.geometry.line_slope(leg2.flatten)
+    leg2 = [triangle[1], triangle[2]]
+    leg2_slope = args.geometry.line_slope(leg2.flatten, replace_infinity: 1080)
     leg2_intercept = triangle[2][1] - (leg2_slope * triangle[2][0])
 
-    leg3 = [triangle[2], vertex4]
-    leg3_slope = args.geometry.line_slope(leg3.flatten)
+    leg3 = [vertex4, triangle[2]]
+    leg3_slope = args.geometry.line_slope(leg3.flatten, replace_infinity: 1080)
     leg3_intercept = triangle[2][1] - (leg3_slope * triangle[2][0])
 
     raster_lines = []
 
+    x_offset = [x, x2, x3].min
+    y_offset = [y, y2, y3].min
+
     y_iter = triangle[0][1]
     while y_iter >= vertex4[1]
+      start_x = (y_iter - leg0_intercept) / leg0_slope
+      end_x = (y_iter - leg1_intercept) / leg1_slope
+
+      sort_list = [start_x, end_x].sort
+      small_x = sort_list[0]
+      big_x = sort_list[1]
+
+      start_x = small_x
+      end_x = big_x
+
+      draw_width = end_x - x_offset > image_width ? image_width - start_x + x_offset : end_x - start_x
+
+      grab = draw_width.abs
       raster_lines << {
-        x: (y_iter - leg0_intercept) / leg0_slope,
+        x: start_x,
         y: y_iter,
-        x2: (y_iter - leg1_intercept) / leg1_slope,
-        y2: y_iter,
-        r: r, g: g, b: b, a: a
-      }.line!
+        w: draw_width,
+        h: 1,
+        r: r, g: g, b: b, a: a,
+        path: path,
+        source_x: start_x - x_offset, source_y: y_iter - y_offset,
+        source_w: grab, source_h: 1
+      }.sprite!
       y_iter -= 1
     end
 
-    y_iter = triangle[2][1]
-    while y_iter <= vertex4[1]
+    y_iter = vertex4[1]
+    while y_iter >= triangle[2][1]
+      start_x = (y_iter - leg2_intercept) / leg2_slope
+      end_x = (y_iter - leg3_intercept) / leg3_slope
+
+      sort_list = [start_x, end_x].sort
+      small_x = sort_list[0]
+      big_x = sort_list[1]
+
+      start_x = small_x
+      end_x = big_x
+
+      draw_width = end_x - x_offset > image_width ? image_width - start_x + x_offset : end_x - start_x
+
+      grab = draw_width.abs
       raster_lines << {
-        x: (y_iter - leg2_intercept) / leg2_slope,
+        x: start_x,
         y: y_iter,
-        x2: (y_iter - leg3_intercept) / leg3_slope,
-        y2: y_iter,
-        r: r, g: g, b: b, a: a
-      }.line!
-      y_iter += 1
+        w: draw_width,
+        h: 1,
+        r: r, g: g, b: b, a: a,
+        path: path,
+        source_x: start_x - x_offset, source_y: y_iter - y_offset,
+        source_w: grab, source_h: 1
+      }.sprite
+      y_iter -= 1
     end
     raster_lines
   end

app/main.rb

@@ -1,39 +1,52 @@
+$gtk.reset
+
 require 'app/lib/dinraal.rb'
 
-$gtk.reset
+def make_rt(args)
+  args.render_target(:static_rt).clear_before_render = true
+  args.render_target(:static_rt).primitives << Dinraal.triangle_raster(args.state.tri1)
 
-def tick(args)
-  tri1 = { x: 100, y: 100, x2: 250, y2: 600, x3: 900, y3: 500, r: 255 }
-  tri2 = { x: 130, y: 130, x2: 200, y2: 300, x3: 400, y3: 400, b: 255 }
+  args.render_target(:static_rt).primitives << Dinraal.circle_outline(x: 20, y: 580, radius: 20, g: 255)
+  args.render_target(:static_rt).primitives << Dinraal.circle_raster(x: 70, y: 580, radius: 20, b: 255)
 
-  if args.state.tick_count.zero?
-    args.render_target(:static_rt).clear_before_render = true
+  args.render_target(:static_rt).primitives << Dinraal.triangle_outline(args.state.tri1)
+  args.render_target(:static_rt).primitives << Dinraal.triangle_outline(args.state.tri2)
+
+  args.render_target(:static_rt).primitives << Dinraal.triangle_center(args.state.tri1).merge(w: 5, h: 5, g: 255).solid!
+  args.render_target(:static_rt).primitives << Dinraal.triangle_center(args.state.tri2).merge(w: 5, h: 5, g: 255).solid!
 
-    args.render_target(:static_rt).primitives << Dinraal.triangle_raster(tri1)
+  args.render_target(:static_rt).primitives << Dinraal.triangle_bounding_box(args.state.tri1)
+  args.render_target(:static_rt).primitives << Dinraal.triangle_bounding_box(args.state.tri2)
+end
+
+def tick(args)
+  # args.state.tri1 ||= { x: 800, y: 500, x2: 450, y2: 650, x3: 400, y3: 300, path: 'sprites/rick.png', image_width: 300 }
+  args.state.tri1 ||= { x: 800, y: 500, x2: 450, y2: 650, x3: 400, y3: 300, g: 255 }
+  args.state.tri2 ||= { x: 200, y: 600, x2: 400, y2: 600, x3: 275, y3: 500, r: 255 }
 
-    args.render_target(:static_rt).primitives << Dinraal.circle_outline(x: 500, y: 500, radius: 20, g: 255)
+  new_tri = args.state.tri1.merge(x: args.inputs.mouse.x, y: args.inputs.mouse.y)
 
-    args.render_target(:static_rt).primitives << Dinraal.circle_raster(x: 700, y: 500, radius: 20, b: 255)
+  if args.state.tick_count.zero?
+    make_rt(args)
+  elsif args.inputs.mouse.up && new_tri != args.state.tri1
+    args.state.tri1 = new_tri
+    make_rt(args)
+  else
+    args.render_target(:static_rt).clear_before_render = false
   end
 
   outputs = []
   outputs << { x: 0, y: 0, w: 1280, h: 720, path: :static_rt }.sprite!
 
-  outputs << Dinraal.triangle_outline(tri2)
-  outputs << Dinraal.triangle_center(tri1).merge(w: 5, h: 5, g: 255).solid!
-  outputs << Dinraal.triangle_center(tri2).merge(w: 5, h: 5, g: 255).solid!
-
   mouse_x = args.inputs.mouse.x
   mouse_y = args.inputs.mouse.y
 
-  mouse_inside = Dinraal.point_inside_triangle?(point: { x: mouse_x, y: mouse_y }, triangle: tri1)
-
-  outputs << { x: args.grid.center_x, y: 720, text: "Mouse inside red: #{mouse_inside}", alignment_enum: 1 }.label!
+  mouse_inside = Dinraal.point_inside_triangle?(point: { x: mouse_x, y: mouse_y }, triangle: args.state.tri1)
 
-  outputs << Dinraal.triangle_bounding_box(tri2)
+  outputs << { x: args.grid.center_x, y: 720, text: "Mouse inside image: #{mouse_inside}", alignment_enum: 1 }.label!
 
-  two_contains_one = Dinraal.triangle_inside_triangle?(inner: tri2, outer: tri1)
-  outputs << { x: args.grid.center_x, y: 700, text: "Red triangle contains blue triangle: #{two_contains_one}", alignment_enum: 1 }.label!
+  two_contains_one = Dinraal.triangle_inside_triangle?(inner: args.state.tri2, outer: args.state.tri1)
+  outputs << { x: args.grid.center_x, y: 700, text: "Image contains red triangle: #{two_contains_one}", alignment_enum: 1 }.label!
 
   args.outputs.primitives << outputs