查看: 3097|回复: 24

[原创发布] RM 2D绘图的插件(加了传送位图功能啦,效率测试)

[复制链接]

遠航の猫咪

梦石
3
星屑
27057
在线时间
2428 小时
注册时间
2005-10-15
回帖
989

开拓者

发表于 2022-3-1 07:07:53 | 显示全部楼层 |阅读模式

加入我们,或者,欢迎回来。

您需要 登录 才可以下载或查看,没有账号?注册会员

×
本帖最后由 SailCat 于 2022-3-1 22:07 编辑

不依赖SEP Core运行,所以独立发一下
但是……谢谢大家的测试我只能说[泪目]……看来这个功能做出来终究还是有它的可取之处的,那就后续再更新一下吧~
就是写着顺手就写出来了……

  1. #==============================================================================
  2. # ■ [Bitmap Canvas] 位图画布处理核心 v1.0 by SailCat
  3. #------------------------------------------------------------------------------
  4. #   方法:本脚本插入Main之前使用
  5. #   依赖:无
  6. #   版本:v1.0 (Build 220228)
  7. #   效果:
  8. #     1. 可以用简单指令在位图对象上画图
  9. #   配置:画笔线形的配置
  10. #   冲突:无
  11. #   说明:
  12. #     1. 绘制直线:
  13. #        draw_line(起始x, 起始y, 结束x, 结束y, 颜色, 线形)
  14. #     2. 绘制渐变色直线:
  15. #        gradient_draw_line(起始x, 起始y, 结束x, 结束y, 颜色1, 颜色2)
  16. #     3. 绘制路径(连续直线):
  17. #        draw_path(点1x, 点1y, 点2x, 点2y, 点3x, 点3y[, ...], 颜色)
  18. #     4. 绘制多边形(连续封闭直线):
  19. #        draw_polygon(点1x, 点1y, 点2x, 点2y, 点3x, 点3y[, ...], 颜色)
  20. #     5. 绘制正多边形:
  21. #        draw_isogon(外接圆心x, 外接圆心y, 半径, 边数, 旋转角, 颜色)
  22. #     6. 绘制椭圆:
  23. #        draw_ellipse(圆心x, 圆心y, 半横径,半纵径, 颜色)
  24. #     7. 绘制圆:
  25. #        draw_circle(圆心x, 圆心y, 半径,颜色)
  26. #     8. 填涂多边形:
  27. #        fill_polygon(点1x, 点1y, 点2x, 点2y, 点3x, 点3y[, ...], 边框颜色[,
  28. #          填充颜色1[, 填充颜色2]])
  29. #     9. 填涂正多边形:
  30. #        fill_isogon(外接圆心x, 外接圆心y, 半径, 边数, 旋转角, 边框颜色[,
  31. #          填充颜色1[, 填充颜色2]])
  32. #     10.填涂椭圆:
  33. #        fill_ellipse(圆心x, 圆心y, 半横径,半纵径, 边框颜色[, 填充颜色1[,
  34. #          填充颜色2]])
  35. #     11.填涂圆:
  36. #        fill_circle(圆心x, 圆心y, 半径,边框颜色[, 填充颜色1[, 填充颜色2]])
  37. #     12.传送多边形:
  38. #        blt_polygon(点1x, 点1y, 点2x, 点2y, 点3x, 点3y[, ...], 源位图,
  39. #          参考点1, 参考点1y[, 不透明度])
  40. #     13.传送正多边形:
  41. #        blt_isogon(外接圆心x, 外接圆心y, 半径, 边数, 旋转角, 源位图, 参考心x,
  42. #          参考心y[, 不透明度])
  43. #     14.传送椭圆:
  44. #        blt_ellipse(圆心x, 圆心y, 半横径,半纵径, 源位图, 参考心x, 参考心y[,
  45. #          不透明度])
  46. #     15.传送圆:
  47. #        blt_circle(圆心x, 圆心y, 半径,源位图, 参考心x, 参考心y[, 不透明度])
  48. #==============================================================================
  49. #==============================================================================
  50. # ■ SailCat's 插件公用
  51. #==============================================================================
  52. module SailCat
  53.   #--------------------------------------------------------------------------
  54.   # ● 脚本配置区
  55.   #--------------------------------------------------------------------------
  56.   module Canvas_Config
  57.     CANVAS_LINE_DOTTED = [1, 0]               # 点线画笔
  58.     CANVAS_LINE_DASHED = [1, 1, 0, 1]         # 短虚线画笔
  59.     CANVAS_LINE_LONGDASH = [1, 1, 0, 0, 1, 1] # 长虚线画笔
  60.     CANVAS_LINE_DASHDOT = [1, 0, 1, 1, 1, 0]  # 点划线画笔
  61.     CANVAS_LINE_BROKEN = [1, 0, 0]            # 散点画笔
  62.   end
  63. end

  64. #==============================================================================
  65. # ■ Bitmap
  66. #==============================================================================
  67. class Bitmap
  68.   include SailCat::Canvas_Config
  69.   #--------------------------------------------------------------------------
  70.   # ● 常量
  71.   #--------------------------------------------------------------------------
  72.   CANVAS_LINE_SOLID = [1]                     # 实心画笔,该常量禁止修改配置
  73.   #--------------------------------------------------------------------------
  74.   # ● 绘制直线
  75.   #     x1 : 起始的 X 坐标
  76.   #     y1 : 起始的 Y 坐标
  77.   #     x2 : 结束的 X 坐标
  78.   #     y2 : 结束的 Y 坐标
  79.   #     color : 直线的颜色 (Color)
  80.   #     style : 直线的线型
  81.   #--------------------------------------------------------------------------
  82.   def draw_line(x1, y1, x2, y2, color, style = CANVAS_LINE_SOLID)
  83.     return set_pixel(x1, y1, color) if x1 == x2 and y1 == y2
  84.     dx = (x2 - x1).abs
  85.     dy = (y2 - y1).abs
  86.     x = x1
  87.     y = y1
  88.     rx = x2 - x1 <=> 0
  89.     ry = y2 - y1 <=> 0
  90.     b_index = 0
  91.     b_size = style.size
  92.     if dx == 0 and style == CANVAS_LINE_SOLID
  93.       fill_rect(x1, [y1, y2].min, 1, dy + 1, color)
  94.     elsif dy == 0 and style == CANVAS_LINE_SOLID
  95.       fill_rect([x1, x2].min, y1, dx + 1, 1, color)
  96.     elsif dx <= dy
  97.       f = dx.to_f * rx / dy
  98.       dy.times do
  99.         set_pixel(x.round, y, color) if style[b_index] == 1
  100.         x += f
  101.         y += ry
  102.         b_index += 1
  103.         b_index %= b_size
  104.       end
  105.       set_pixel(x.round, y, color)
  106.     else
  107.       f = dy.to_f * ry / dx
  108.       dx.times do
  109.         set_pixel(x, y.round, color) if style[b_index] == 1
  110.         x += rx
  111.         y += f
  112.         b_index += 1
  113.         b_index %= b_size
  114.       end
  115.       set_pixel(x, y.round, color)
  116.     end
  117.   end
  118.   #--------------------------------------------------------------------------
  119.   # ● 绘制渐变直线
  120.   #     x1 : 起始的 X 坐标
  121.   #     y1 : 起始的 Y 坐标
  122.   #     x2 : 结束的 X 坐标
  123.   #     y2 : 结束的 Y 坐标
  124.   #     color1 : 直线的起始颜色 (Color)
  125.   #     color2 : 直线的终止颜色 (Color)
  126.   #--------------------------------------------------------------------------
  127.   def gradient_draw_line(x1, y1, x2, y2, color1, color2)
  128.     return set_pixel(x1, y1, color) if x1 == x2 and y1 == y2
  129.     return draw_line(x1, y1, x2, y2, color1) if color1 == color2
  130.     dx = (x2 - x1).abs
  131.     dy = (y2 - y1).abs
  132.     rx = x2 - x1 <=> 0
  133.     ry = y2 - y1 <=> 0
  134.     c = color1.clone
  135.     if dx <= dy
  136.       f = dx.to_f / dy * rx
  137.       x = x1.to_f
  138.       y = y1
  139.       dr = (color2.red - color1.red) / dy
  140.       dg = (color2.green - color1.green) / dy
  141.       db = (color2.blue - color1.blue) / dy
  142.       da = (color2.alpha - color1.alpha) / dy
  143.       dy.times do
  144.         set_pixel(x.round, y, c)
  145.         x += f
  146.         y += ry
  147.         c.set(c.red + dr, c.green + dg, c.blue + db, c.alpha + da)
  148.       end
  149.     else
  150.       f = dy.to_f / dx * ry
  151.       x = x1
  152.       y = y1.to_f
  153.       dr = (color2.red - color1.red) / dx
  154.       dg = (color2.green - color1.green) / dx
  155.       db = (color2.blue - color1.blue) / dx
  156.       da = (color2.alpha - color1.alpha) / dx
  157.       dx.times do
  158.         set_pixel(x, y.round, c)
  159.         x += rx
  160.         y += f
  161.         c.set(c.red + dr, c.green + dg, c.blue + db, c.alpha + da)
  162.       end
  163.     end
  164.   end
  165.   #--------------------------------------------------------------------------
  166.   # ● 绘制路径
  167.   #     x1 : 第一点的 X 坐标
  168.   #     y1 : 第一点的 Y 坐标
  169.   #     x2 : 第二点的 X 坐标
  170.   #     y2 : 第二点的 Y 坐标
  171.   #     x3 : 第三点的 X 坐标
  172.   #     y3 : 第三点的 Y 坐标
  173.   #     args : 后续的参数(可以加多个点,至少要包括颜色)
  174.   #--------------------------------------------------------------------------
  175.   def draw_path(x1, y1, x2, y2, x3, y3, *args)
  176.     raise ArgumentError if args.size % 2 == 0 or not args[-1].is_a?(Color)
  177.     color = args[-1]
  178.     nodes = [x1, y1, x2, y2, x3, y3].concat(args[0...-1])
  179.     0.step(nodes.size - 4, 2) {|i| draw_line(*(nodes[i, 4].concat([color])))}
  180.   end
  181.   #--------------------------------------------------------------------------
  182.   # ● 绘制多边形
  183.   #     x1 : 第一点的 X 坐标
  184.   #     y1 : 第一点的 Y 坐标
  185.   #     x2 : 第二点的 X 坐标
  186.   #     y2 : 第二点的 Y 坐标
  187.   #     x3 : 第三点的 X 坐标
  188.   #     y3 : 第三点的 Y 坐标
  189.   #     args : 后续的参数(可以加多个点,至少要包括颜色)
  190.   #--------------------------------------------------------------------------
  191.   def draw_polygon(x1, y1, x2, y2, x3, y3, *args)
  192.     raise ArgumentError if args.size % 2 == 0 or not args[-1].is_a?(Color)
  193.     args.insert(-2, x1, y1)
  194.     draw_path(x1, y1, x2, y2, x3, y3, *args)
  195.   end
  196.   #--------------------------------------------------------------------------
  197.   # ● 绘制实心多边形
  198.   #     x1 : 第一点的 X 坐标
  199.   #     y1 : 第一点的 Y 坐标
  200.   #     x2 : 第二点的 X 坐标
  201.   #     y2 : 第二点的 Y 坐标
  202.   #     x3 : 第三点的 X 坐标
  203.   #     y3 : 第三点的 Y 坐标
  204.   #     args : 后续的参数(可以加多个点,至少要包括一个颜色,至多可有三个颜色)
  205.   #--------------------------------------------------------------------------
  206.   def fill_polygon(x1, y1, x2, y2, x3, y3, *args)
  207.     raise ArgumentError unless args[-1].is_a?(Color)
  208.     fill2 = args[-3].is_a?(Color) ? args.pop : args[-1]
  209.     fill1 = args[-2].is_a?(Color) ? args.pop : args[-1]
  210.     draw_polygon(x1, y1, x2, y2, x3, y3, *args)
  211.     color = args[-1]
  212.     nodes = [x1, y1, x2, y2, x3, y3].concat(args[0...-1])
  213.     edges = {}
  214.     min_y = height
  215.     max_y = 0
  216.     0.step(nodes.size - 2, 2) do |i|
  217.       xi, yi = nodes[i, 2]
  218.       min_y = [min_y, yi].min
  219.       max_y = [max_y, yi].max
  220.       xj, yj = nodes[(i + 2) % nodes.size, 2]
  221.       dx = 1.0 * (xi - xj) / (yi - yj)
  222.       if yi < yj
  223.         yh = nodes[i - 1]
  224.         if yh < yi
  225.           yi += 1
  226.           xi += dx
  227.         end
  228.         edges[yi] ||= []
  229.         edges[yi].push([xi, dx, yj])
  230.       elsif yi > yj
  231.         yk = nodes[(i + 5) % nodes.size]
  232.         if yj > yk
  233.           yj += 1
  234.           xj += dx
  235.         end
  236.         edges[yj] ||= []
  237.         edges[yj].push([xj, dx, yi])
  238.       end
  239.     end
  240.     return unless max_y - min_y > 1
  241.     aet = edges[min_y]
  242.     aet.each {|edge| edge[0] += edge[1]}
  243.     aet.sort!
  244.     if fill1 != fill2
  245.       dh = max_y - min_y - 1
  246.       dr = (fill2.red - fill1.red) / dh
  247.       dg = (fill2.green - fill1.green) / dh
  248.       db = (fill2.blue - fill1.blue) / dh
  249.       da = (fill2.alpha - fill1.alpha) / dh
  250.       gradient = true
  251.     end
  252.     f = fill1.clone
  253.     for y in min_y + 1..max_y - 1
  254.       if edges[y]
  255.         aet.concat(edges[y])
  256.         aet.sort!
  257.       end
  258.       0.step(aet.size - 1, 2) do |i|
  259.         xi = aet[i][0].round
  260.         xj = aet[i + 1][0].round
  261.         xi += 1 until xi == width - 1 or get_pixel(xi, y) != color
  262.         xj -= 1 until xj == 0 or get_pixel(xj, y) != color
  263.         if xj >= xi
  264.           fill_rect(xi, y, xj - xi + 1, 1, f)
  265.         end
  266.         aet.reject! {|edge| edge[2] == y}
  267.         aet.each {|edge| edge[0] += edge[1]}
  268.         aet.sort!
  269.         f.set(f.red + dr, f.green + dg, f.blue + db, f.alpha + da) if gradient
  270.       end
  271.     end
  272.   end
  273.   #--------------------------------------------------------------------------
  274.   # ● 传送位图多边形
  275.   #     x1 : 第一点的 X 坐标
  276.   #     y1 : 第一点的 Y 坐标
  277.   #     x2 : 第二点的 X 坐标
  278.   #     y2 : 第二点的 Y 坐标
  279.   #     x3 : 第三点的 X 坐标
  280.   #     y3 : 第三点的 Y 坐标
  281.   #     args : 后续的参数(加多个点,最后是位图, 偏移x,偏移y,(可选)不透明度)
  282.   #            偏移x和偏移y的位置参考第一个点
  283.   #--------------------------------------------------------------------------
  284.   def blt_polygon(x1, y1, x2, y2, x3, y3, *args)
  285.     if args[-3].is_a?(Bitmap)
  286.       src, x0, y0 = args[-3, 3]
  287.       opacity = 255
  288.       nodes = [x1, y1, x2, y2, x3, y3].concat(args[0...-3])
  289.     elsif args[-4].is_a?(Bitmap)
  290.       src, x0, y0, opacity = args[-4, 4]
  291.       nodes = [x1, y1, x2, y2, x3, y3].concat(args[0...-4])
  292.     else
  293.       raise ArgumentError
  294.     end
  295.     raise ArgumentError unless nodes.size[0] == 0
  296.     edges = {}
  297.     min_y = height
  298.     max_y = 0
  299.     ox = x0 - x1
  300.     oy = y0 - y1
  301.     0.step(nodes.size - 2, 2) do |i|
  302.       xi, yi = nodes[i, 2]
  303.       min_y = [min_y, yi].min
  304.       max_y = [max_y, yi].max
  305.       xj, yj = nodes[(i + 2) % nodes.size, 2]
  306.       dx = 1.0 * (xi - xj) / (yi - yj)
  307.       if yi < yj
  308.         yh = nodes[i - 1]
  309.         if yh < yi
  310.           yi += 1
  311.           xi += dx
  312.         end
  313.         edges[yi] ||= []
  314.         edges[yi].push([xi, dx, yj])
  315.       elsif yi > yj
  316.         yk = nodes[(i + 5) % nodes.size]
  317.         if yj > yk
  318.           yj += 1
  319.           xj += dx
  320.         end
  321.         edges[yj] ||= []
  322.         edges[yj].push([xj, dx, yi])
  323.       end
  324.     end
  325.     aet = []
  326.     for y in min_y..max_y
  327.       if edges[y]
  328.         aet.concat(edges[y])
  329.         aet.sort!
  330.       end
  331.       0.step(aet.size - 1, 2) do |i|
  332.         xi = aet[i][0].round
  333.         xj = aet[i + 1][0].round
  334.         blt(xi, y, src, Rect.new(xi + ox, y + oy, xj - xi + 1, 1), opacity)
  335.         aet.reject! {|edge| edge[2] == y}
  336.         aet.each {|edge| edge[0] += edge[1]}
  337.         aet.sort!
  338.       end
  339.     end
  340.   end
  341.   #--------------------------------------------------------------------------
  342.   # ● 绘制正多边形
  343.   #     x : 正多边形外接圆心 X 坐标
  344.   #     y : 正多边形外接圆心 Y 坐标
  345.   #     rad : 正多边形外接圆 半径
  346.   #     edges : 正多边形的边数
  347.   #     angle : 正多边形旋转角度
  348.   #     color : 正多边形的颜色 (Color)
  349.   #--------------------------------------------------------------------------
  350.   def draw_isogon(x, y, rad, edges, angle, color)
  351.     raise ArgumentError if edges < 3
  352.     step = Math::PI * 2 / edges
  353.     args = []
  354.     angle_i = Math::PI * (270 + angle) / 180
  355.     edges.times do
  356.       args.push((x + rad * Math.cos(angle_i)).round,
  357.         (y + rad * Math.sin(angle_i)).round)
  358.       angle_i += step
  359.     end
  360.     args.push(color)
  361.     draw_polygon(*args)
  362.   end
  363.   #--------------------------------------------------------------------------
  364.   # ● 绘制实心正多边形
  365.   #     x : 正多边形外接圆心 X 坐标
  366.   #     y : 正多边形外接圆心 Y 坐标
  367.   #     rad : 正多边形外接圆 半径
  368.   #     edges : 正多边形的边数
  369.   #     angle : 正多边形旋转角度
  370.   #     border_color : 正多边形的边框颜色 (Color)
  371.   #     fill_color1 : 填充渐变的上颜色 (Color)
  372.   #     fill_color2 : 填充渐变的下颜色 (Color)
  373.   #--------------------------------------------------------------------------
  374.   def fill_isogon(x, y, rad, edges, angle, border_color, fill_color1 =
  375.     border_color, fill_color2 = fill_color1)
  376.     raise ArgumentError if edges < 3
  377.     step = Math::PI * 2 / edges
  378.     args = []
  379.     angle_i = Math::PI * (270 + angle) / 180
  380.     edges.times do
  381.       args.push((x + rad * Math.cos(angle_i)).round,
  382.         (y + rad * Math.sin(angle_i)).round)
  383.       angle_i += step
  384.     end
  385.     args.push(border_color, fill_color1, fill_color2)
  386.     fill_polygon(*args)
  387.   end
  388.   #--------------------------------------------------------------------------
  389.   # ● 传送位图正多边形
  390.   #     x : 正多边形外接圆心 X 坐标
  391.   #     y : 正多边形外接圆心 Y 坐标
  392.   #     rad : 正多边形外接圆 半径
  393.   #     edges : 正多边形的边数
  394.   #     angle : 正多边形旋转角度
  395.   #     src_bitmap : 传送元位图
  396.   #     x0 : 传送圆心 X 坐标
  397.   #     y0 : 传送圆心 Y 坐标
  398.   #     opacity : 不透明度
  399.   #--------------------------------------------------------------------------
  400.   def blt_isogon(x, y, rad, edges, angle, src_bitmap, x0, y0, opacity = 255)
  401.     raise ArgumentError if edges < 3
  402.     step = Math::PI * 2 / edges
  403.     args = []
  404.     angle_i = Math::PI * (270 + angle) / 180
  405.     edges.times do
  406.       args.push((x + rad * Math.cos(angle_i)).round,
  407.         (y + rad * Math.sin(angle_i)).round)
  408.       angle_i += step
  409.     end
  410.     args.push(src_bitmap, x0 - x + args[0], y0 - y + args[1], opacity)
  411.     blt_polygon(*args)
  412.   end
  413.   #--------------------------------------------------------------------------
  414.   # ● 绘制圆
  415.   #     x : 圆心 X 坐标
  416.   #     y : 圆心 Y 坐标
  417.   #     rad : 半径
  418.   #     color : 圆的颜色 (Color)
  419.   #--------------------------------------------------------------------------
  420.   def draw_circle(x, y, rad, color)
  421.     raise ArgumentError if rad < 0
  422.     return set_pixel(x, y, color) if rad == 0
  423.     draw_ellipse(x, y, rad, rad, color)
  424.   end
  425.   #--------------------------------------------------------------------------
  426.   # ● 绘制椭圆
  427.   #     x : 圆心 X 坐标
  428.   #     y : 圆心 Y 坐标
  429.   #     rad_x : 水平半径
  430.   #     rad_y : 垂直半径
  431.   #     color : 椭圆的颜色 (Color)
  432.   #     fill1 : 填充的颜色1 (Color)
  433.   #     fill2 : 填充的颜色2 (Color)
  434.   #--------------------------------------------------------------------------
  435.   def draw_ellipse(x, y, rad_x, rad_y, color, fill1 = nil, fill2 = nil)
  436.     raise ArgumentError if rad_x < 0 or rad_y < 0
  437.     return set_pixel(x, y, color) if rad_x == 0 and rad_y == 0
  438.     return fill_rect(x - rad_x, y, rad_x << 1, 1, color) if rad_y == 0
  439.     return fill_rect(x, y - rad_y, 1, rad_y << 1, color) if rad_x == 0
  440.     ry2 = rad_y * rad_y
  441.     rx2 = rad_x * rad_x
  442.     d = ry2 + rx2 * (0.25 - rad_y)
  443.     dx = 0
  444.     last_dy = dy = rad_y
  445.     f = fill1 && fill1.clone
  446.     if fill2
  447.       f2 = fill2.clone
  448.       dr = (fill2.red - fill1.red) / ((rad_y << 1) - 1)
  449.       dg = (fill2.green - fill1.green) / ((rad_y << 1) - 1)
  450.       db = (fill2.blue - fill1.blue) / ((rad_y << 1) - 1)
  451.       da = (fill2.alpha - fill1.alpha) / ((rad_y << 1) - 1)
  452.     end
  453.     begin
  454.       set_pixel(x + dx, y + dy, color)
  455.       set_pixel(x + dx, y - dy, color)
  456.       set_pixel(x - dx, y - dy, color)
  457.       set_pixel(x - dx, y + dy, color)
  458.       if f and dx > 1 and dy < rad_y and last_dy != dy
  459.         last_dy = dy
  460.         fill_rect(x - dx + 1, y - dy, (dx << 1) - 1, 1, f)
  461.         fill_rect(x - dx + 1, y + dy, (dx << 1) - 1, 1, f2)
  462.         if fill2
  463.           f.set(f.red + dr, f.green + dg, f.blue + db, f.alpha + da)
  464.           f2.set(f2.red - dr, f2.green - dg, f2.blue - db, f2.alpha - da)
  465.         end
  466.       end
  467.       if d <= -1e-6
  468.         d += ry2 * ((dx << 1) + 3)
  469.       else
  470.         d += ry2 * ((dx << 1) + 3) + rx2 * (1 - dy << 1)
  471.         dy -= 1
  472.       end
  473.       dx += 1
  474.     end while ry2 * (dx + 1) < rx2 * (dy - 0.5)
  475.     d = ry2 * (dx + 0.5) * (dx + 0.5) + rx2 * (dy - 1) * (dy - 1) - rx2 * ry2
  476.     begin
  477.       set_pixel(x + dx, y + dy, color)
  478.       set_pixel(x + dx, y - dy, color)
  479.       set_pixel(x - dx, y - dy, color)
  480.       set_pixel(x - dx, y + dy, color)
  481.       if f and dx > 1 and dy < rad_y and last_dy != dy
  482.         last_dy = dy
  483.         fill_rect(x - dx + 1, y - dy, (dx << 1) - 1, 1, f)
  484.         fill_rect(x - dx + 1, y + dy, (dx << 1) - 1, 1, f2)
  485.         if fill2
  486.           f.set(f.red + dr, f.green + dg, f.blue + db, f.alpha + da)
  487.           f2.set(f2.red - dr, f2.green - dg, f2.blue - db, f2.alpha - da)
  488.         end
  489.       end
  490.       if d <= -1e-6
  491.         d += ry2 * (dx + 1 << 1) + rx2 * (3 - (dy << 1))
  492.         dx += 1
  493.       else
  494.         d += rx2 * (3 - (dy << 1))
  495.       end
  496.       dy -= 1
  497.     end while dy >= 0
  498.   end
  499.   #--------------------------------------------------------------------------
  500.   # ● 绘制实心圆
  501.   #     x : 圆心 X 坐标
  502.   #     y : 圆心 Y 坐标
  503.   #     rad : 半径
  504.   #     border_color : 圆的边框颜色 (Color)
  505.   #     fill_color1 : 填充渐变的上颜色 (Color)
  506.   #     fill_color2 : 填充渐变的下颜色 (Color)
  507.   #--------------------------------------------------------------------------
  508.   def fill_circle(x, y, rad, border_color, fill_color1 = border_color,
  509.     fill_color2 = fill_color1)
  510.     draw_ellipse(x, y, rad, rad, border_color, fill_color1, fill_color2)
  511.   end
  512.   #--------------------------------------------------------------------------
  513.   # ● 绘制实心椭圆
  514.   #     x : 圆心 X 坐标
  515.   #     y : 圆心 Y 坐标
  516.   #     rad_x : 水平半径
  517.   #     rad_y : 垂直半径
  518.   #     border_color : 椭圆的边框颜色 (Color)
  519.   #     fill_color1 : 填充渐变的上颜色 (Color)
  520.   #     fill_color2 : 填充渐变的下颜色 (Color)
  521.   #--------------------------------------------------------------------------
  522.   def fill_ellipse(x, y, rad_x, rad_y, border_color, fill_color1 =
  523.     border_color, fill_color2 = fill_color1)
  524.     draw_ellipse(x, y, rad_x, rad_y, border_color, fill_color1, fill_color2)
  525.   end
  526.   #--------------------------------------------------------------------------
  527.   # ● 传送位图圆
  528.   #     x : 圆心 X 坐标
  529.   #     y : 圆心 Y 坐标
  530.   #     rad : 半径
  531.   #     src_bitmap : 传送元位图
  532.   #     x0 : 传送圆心 X 坐标
  533.   #     y0 : 传送圆心 Y 坐标
  534.   #     opacity : 不透明度
  535.   #--------------------------------------------------------------------------
  536.   def blt_circle(x, y, rad, src_bitmap, x0, y0, opacity = 255)
  537.     blt_ellipse(x, y, rad, rad, src_bitmap, x0, y0, opacity)
  538.   end
  539.   #--------------------------------------------------------------------------
  540.   # ● 传送位图椭圆
  541.   #     x : 圆心 X 坐标
  542.   #     y : 圆心 Y 坐标
  543.   #     rad_x : 水平半径
  544.   #     rad_y : 垂直半径
  545.   #     src_bitmap : 传送元位图
  546.   #     x0 : 传送圆心 X 坐标
  547.   #     y0 : 传送圆心 Y 坐标
  548.   #     opacity : 不透明度
  549.   #--------------------------------------------------------------------------
  550.   def blt_ellipse(x, y, rad_x, rad_y, src_bitmap, x0, y0, opacity = 255)
  551.     raise ArgumentError if rad_x < 0 or rad_y < 0
  552.     return blt(x - rad_x, y, src_bitmap, Rect.new(x0 - rad_x, y0,
  553.       rad_x << 1, 1), opacity) if rad_y == 0
  554.     return blt(x, y - rad_y, src_bitmap, Rect.new(x0, y0 - rad_y,
  555.       1, rad_y << 1), opacity) if rad_x == 0
  556.     ry2 = rad_y * rad_y
  557.     rx2 = rad_x * rad_x
  558.     d = ry2 + rx2 * (0.25 - rad_y)
  559.     dx = 0
  560.     dy = rad_y
  561.     last_dy = nil
  562.     begin
  563.       if last_dy != dy
  564.         last_dy = dy
  565.         blt(x - dx + 1, y - dy, src_bitmap, Rect.new(x0 - dx + 1, y0 - dy,
  566.           (dx << 1) - 1, 1), opacity)
  567.         blt(x - dx + 1, y + dy, src_bitmap, Rect.new(x0 - dx + 1, y0 + dy,
  568.           (dx << 1) - 1, 1), opacity)
  569.       end
  570.       if d <= -1e-6
  571.         d += ry2 * ((dx << 1) + 3)
  572.       else
  573.         d += ry2 * ((dx << 1) + 3) + rx2 * (1 - dy << 1)
  574.         dy -= 1
  575.       end
  576.       dx += 1
  577.     end while ry2 * (dx + 1) < rx2 * (dy - 0.5)
  578.     d = ry2 * (dx + 0.5) * (dx + 0.5) + rx2 * (dy - 1) * (dy - 1) - rx2 * ry2
  579.     begin
  580.       if last_dy != dy
  581.         last_dy = dy
  582.         blt(x - dx + 1, y - dy, src_bitmap, Rect.new(x0 - dx + 1, y0 - dy,
  583.           (dx << 1) - 1, 1), opacity)
  584.         blt(x - dx + 1, y + dy, src_bitmap, Rect.new(x0 - dx + 1, y0 + dy,
  585.           (dx << 1) - 1, 1), opacity)
  586.       end
  587.       if d <= -1e-6
  588.         d += ry2 * (dx + 1 << 1) + rx2 * (3 - (dy << 1))
  589.         dx += 1
  590.       else
  591.         d += rx2 * (3 - (dy << 1))
  592.       end
  593.       dy -= 1
  594.     end while dy >= 0
  595.   end
  596. end
复制代码


测试用的代码:
  1. r = Sprite.new
  2. b = Bitmap.new(640, 480)
  3. r.bitmap = b
  4. b.gradient_draw_line(14, 41, 99, 78, Color.new(254, 243, 239), Color.new(37, 48, 65))
  5. b.gradient_draw_line(99, 41, 14, 78, Color.new(254, 243, 239), Color.new(37, 48, 65))
  6. b.gradient_draw_line(114, 78, 199, 41, Color.new(254, 243, 239), Color.new(37, 48, 65))
  7. b.gradient_draw_line(199, 78, 114, 41, Color.new(254, 243, 239), Color.new(37, 48, 65))
  8. b.fill_polygon(27,68,155,261,167,116,605,18,Color.new(255, 255, 255), Color.new(255,0,0), Color.new(232, 141, 232))
  9. b.fill_ellipse(220,320,100,100,Color.new(255,255,255), Color.new(255, 0, 0), Color.new(0, 255, 0))
  10. b.fill_isogon(320,240,85,7,45, Color.new(234,110,86), Color.new(0,78,89), Color.new(153, 57, 217))
  11. b.draw_line(0, 420, 420, 420, Color.new(120,240,120), SailCat::Canvas_Config::CANVAS_LINE_BROKEN)
  12. r.x = 0
  13. r.y = 0
  14. loop do
  15.   Graphics.update
  16.   Input.update
  17.   exit if Input.trigger?(Input::B)
  18. end
复制代码

20220301070605.png
20220301134058.png

效率方面没有问题,毕竟全屏也就640x480而已,而填充矩形操作其实很快,横向渐变本质是填充1高矩形,所以很快……纵向我知道慢8倍左右所以就不做了……
实际效率测试(i7-1065G7)
Bitmap#draw_ellipse 画和屏幕一样大的椭圆,约40次/帧(1600次/秒)
Bitmap#fill_ellipse,填涂和屏幕一样大的椭圆(无渐变),约20次/帧(808次/秒)
Bitmap#fill_ellipse,填涂和屏幕一样大的椭圆(有渐变),约16次/帧(638次/秒)
Bitmap#draw_isogon,画和屏幕一样大的正十六边形,约31次/帧(1240次/秒)
Bitmap#fill_isogon,填涂和屏幕一样大的正十六边形,约8次/帧(292次/秒)
Bitmap#blt_isogon,裁切和屏幕一样大的正十六边形,约12次/帧(474次/秒)
评价一下
ruby的效率,实话说确实不能算高,尤其是1.x版本,这也是为什么RMXP把分辨率限在640x480,VX和VA为了做能到60帧/秒,把分辨率降到了544x416的原因,太大的屏幕确实很难渲染过来(VX和XP是一样的1.81,VA是1.92)
但ruby的效率虽然不高,内建的Bitmap提供的接口方法效率却并不差,因为很早之前我就测试过,单是set_pixel这一个操作,每一帧(注意是帧,不是秒,是1/40秒)可以做大几千次,get_pixel能做上万次
有童鞋说这没法和WINAPI32调RtlMovememory来比,那个不在我们的讨论范围里,想想我就是为了在屏幕上画点儿东西,犯得着上WinAPI32吗?
而且RGSS从1到3,Bitmap类的方法和存储方式连变都没有变过,不得不说这是十几年前的制作工具至少还算得上“能用”的一个好处了。
这次写的插件,其实真的就是随便写的(我最开始只是需要一个Bitmap#draw_line方法,写着写着就跑偏了……),不算后面blt(那个也就花了半小时)的修改,大概总体上用了三四个小时修改+调试
细节的优化之处肯定还存在,比如draw_ellipse里面那8个很扎眼的set_pixel,可以封装的,但是意义不大了。这种代码封装得好看点未必说效率就能多高。减少不必要的执行量才是最重要的。
我倒是没有想过大家这么热情,反复测试,菜刀还提出了实际的应用场景,看起来这确实还是有一些用的吧。
效率的话上面已经测试过了,实话说,两个字:够用。要知道连draw_text做“屏幕一样大的”文字渲染都能给你卡的要死要活的,我这里所有的测试都是直接上和屏幕一样大的绘图。
这里面draw系列的方法,其复杂度是o(w+h),说人话就是,和你绘制的图形的周长正相关,因为屏幕640+480=1120,所以你就是画满了一圈2240个点,事实上和屏幕一样大的不论是圆,椭圆,矩形还是别的什么,还真的就是2240个点
fill系列的方法(包括blt),其复杂度从算法上讲都是o(w*h),也就是说和你绘制的图形的面积正相关(废话,要填充啊),这个时候,set_pixel是绝对不能用了,一帧能做8000次,一秒就是480000次,一秒只能渲染一个半屏幕的像素,那样会卡到没法用。而这个前提是除了set_pixel什么也别做,什么也别计算。
但是这些fill的方法,涉及到查找边缘,正交等复杂数学算法,全都是慢的不行不行的浮点计算,所以一秒能渲染一个屏幕就是顶天了,卡一秒刷一个图片,绝对没法忍受。
幸好,所有的fill方法,我全部调用的是逐行填充的fill_rect,由于Bitmap内部的存储方式,做横行填充要比纵列填充快近8倍。所以默认的实现,全部都使用了横行填充的方式,不论你渐变还是不渐变。
事实上所有的计算机图形学教程也都是教你怎么横行填充,内存的速度是一方面,还有另一个纵列填充很要命的问题:数学计算没法表示tan90度的值,绕不开的,需要你自己写东西来特别处理
fill_rect已经被证明一帧可以在全屏尺度(640*1像素)上执行两千多次,所以这里在加了形状限制的情况下,连上计算,大约每帧能做十几次,已经足够用了。
因为你实际使用是不需要填涂这么大的矩形的
像draw_ellipse(320,240,320,240)一帧能做40次,那draw_ellipse(320,240,32,24)一帧也不过就是做400次
而fill_ellipse(320,240,320,240)一帧能16次,fill_ellipse(320,240,32,24)一帧能做的次数就有200次之多。菜刀那个50大小的头像,真的是随便渲染,还有以前我记得有人提出的半环式血条什么的,也是随便搞,完全都不会卡,大概就是在你渲染的时候帧率会从40变成38或者39这个样子。
要知道自写界面最卡的是什么?是Sprite的旋转和缩放,是永远回避不了的draw_text方法
而不是这些简单的2D绘图指令

感谢大家给了我动力,我可能会研究一波曲线的画法然后这几天更新出来
能不能用,相信你们的测试和兴趣已经说明,这个插件并没那么莫名其妙了
所以标题改啦~
另(理论上VA可以用,我没试,因为Bitmap结构是一样的,VA区的童鞋有兴趣可以拿走拿走别客气)

点评

《就是写着顺手就写出来了》  发表于 2022-3-2 13:15
就说如果你们觉得这个插件有用我可以继续开发其他形状,不然就放着吧……  发表于 2022-3-1 07:28

评分

参与人数 4赞 +4 收起 理由
sdgn + 1 精品文章
张咚咚 + 1 精品文章
taeckle + 1 我们都要像大神学习!
灯笼菜刀王 + 1 &amp;quot;顺手写出来的&amp;quot;

查看全部评分

SailCat (小猫子·要开心一点) 共上站 24 次,发表过 11 篇文章 上 次 在: [2006年01月28日11:41:18 星期六] 从 [162.105.120.91] 到本站一游。

老鹰

梦石
40
星屑
38044
在线时间
7127 小时
注册时间
2012-5-26
回帖
3306

极短24评委极短23参与极短22参与极短21评委老司机慢点开短篇十吟唱者组别冠军开拓者剧作品鉴家

发表于 2022-3-1 07:49:47 | 显示全部楼层
这也是可以顺手随便写出来的吗
回复

使用道具 举报

梦石
0
星屑
8026
在线时间
1051 小时
注册时间
2012-4-3
回帖
1270

开拓者

发表于 2022-3-1 08:19:09 来自手机 | 显示全部楼层
有点意思,联想起一个左右对比填涂的小游戏。
不知道像素点的描绘是否可以变为手动,不限预设形状,随着玩家操作,比如简单的跟随鼠标[单点一粒/按定涂鸦]?

点评

像素点描绘已有,剩下的核心的部分,解决这两条就基本成了:输入描绘、判定不规则图形的填涂饱腹度。  发表于 2022-3-2 08:26
是啊,像Photoshop工具的钢笔头,出墨量可以选的那种就更人性化了。如果猫大有这个扩展意愿的话,我可以搜集一些关于这个小游戏详细的材料补充。  发表于 2022-3-2 08:17
有点意思,但是一个像素点也实在太小了,要做,就得做成画笔式的,也就是描绘的线条本身是有宽度的  发表于 2022-3-1 23:19
回复

使用道具 举报

梦石
0
星屑
42345
在线时间
6022 小时
注册时间
2006-11-10
回帖
6975
发表于 2022-3-1 10:26:15 | 显示全部楼层
未标题-1.jpg

搭配半生烛光DLL里的蒙版可以搞非矩形头像框

不过, 它这个蒙版不太好用, 结果变黑白的~~

猫大是否考虑把它做成蒙版
未标题-2.jpg

点评

效果很好  发表于 2022-3-1 15:21
a.bitmap.blt_circle(50, 50, 50, RPG::Cache.is(9, "baixue_G"), 50, 50, 255)  发表于 2022-3-1 13:43
做成刀把版  发表于 2022-3-1 10:45
回复

使用道具 举报

梦石
1
星屑
24088
在线时间
3339 小时
注册时间
2011-7-8
回帖
3862

开拓者

发表于 2022-3-1 10:56:07 | 显示全部楼层
本帖最后由 guoxiaomi 于 2022-3-1 13:13 编辑

三角形ABC,然后三个点各有自己的颜色,最终三角形内点P的颜色是这三个点颜色的线性插值,插值比例就是PBC:PAC:PAB。

顺便看到set_pixel我其实是很慌的,是不是可以靠之前某位朋友写的汇编来高速操作?

点评

这是顶点着色??挺好奇怎么算(插值几乎都是浮点运算……) 简单的周边渐变填充GDI+可以直接画在RMXP的bitmap上,就是效率很低……  发表于 2022-3-1 16:43
我再看看!  发表于 2022-3-1 15:01
一帧能做7000次 而凡是用到set_pixel的算法其复杂度都是o(w+h) 所以……复杂度是o(wh)的我全部是用的fill_rect  发表于 2022-3-1 13:29
熟悉rgss和ruby,xp区版主~
正在填坑:《膜拜组传奇》讲述膜拜组和学霸们的故事。
已上steam:与TXBD合作的Reformers《变革者》
* 战斗调用公共事件 *
* RGSOS 网络脚本 *
回复

使用道具 举报

梦石
0
星屑
6483
在线时间
119 小时
注册时间
2020-1-8
回帖
205
发表于 2022-3-1 16:59:30 | 显示全部楼层
本帖最后由 RPGzh500223 于 2022-3-2 13:05 编辑

楼主考虑一下支持水平渐变,效率为垂直的一半(用Bitmap#stretch_blt,尽管看起来有点怪……)
用Bitmap#blt模拟水平渐变,效率大概垂直的58%,看起来正常多了
  1. class Bitmap
  2.   # cx    椭圆中心点X           基本整型
  3.   # cy    椭圆中心点Y           基本整型
  4.   # ax    椭圆X半轴长度         无符号整型
  5.   # by    椭圆Y半轴长度         无符号整型
  6.   # mode  椭圆颜色填充方向(0:左->右;1:上->下)   无符号整型
  7.   # color 椭圆边框颜色          RMXP的Color实例对象
  8.   # fillB 椭圆填充的起始颜色    RMXP的Color实例对象
  9.   # fillE 椭圆填充的终止颜色    RMXP的Color实例对象 或 nil(单色填充)
  10.   def fill_ellipse2(cx, cy, ax, by, mode, color, fillB, fillE=nil)
  11.    
  12.     if fillE
  13.       if mode == 0 then step = ax + ax - 1
  14.       elsif mode == 1 then step, fE = by + by - 1, fillE.clone
  15.       end
  16.       gR = (fillE.red   - fillB.red  ) / step
  17.       gG = (fillE.green - fillB.green) / step
  18.       gB = (fillE.blue  - fillB.blue ) / step
  19.       gA = (fillE.alpha - fillB.alpha) / step
  20.     end  
  21.     if mode == 0
  22.       if fillE
  23.         src, src_rect = Bitmap.new(ax + ax, 1), Rect.new(0, 0, 0, 0)
  24.         fB = fillB.clone
  25.         src.width.times do |x|
  26.           src.set_pixel(x, 0, fB)
  27.           fB.set(fB.red + gR, fB.green + gG, fB.blue + gB, fB.alpha + gA)
  28.         end
  29.       else
  30.         mode = 1
  31.       end
  32.     end   
  33.    
  34.     ratio, fB, w2 = ax.to_f / by, fillB.clone, 0
  35.     (by - 1).downto(0) do |y|
  36.       w = (Math.sqrt((by + y) * (by - y)) * ratio).to_i
  37.       
  38.       if mode == 1
  39.         self.fill_rect(cx - w, cy - y, w + w, 1, fB)
  40.             
  41.         if fillE
  42.           self.fill_rect(cx - w, cy + y, w + w, 1, fE)
  43.           fB.set(fB.red + gR, fB.green + gG, fB.blue + gB, fB.alpha + gA)
  44.           fE.set(fE.red - gR, fE.green - gG, fE.blue - gB, fE.alpha - gA)
  45.         else
  46.           self.fill_rect(cx - w, cy + y, w + w, 1, fB)
  47.         end
  48.       elsif mode == 0
  49.         src_rect.set(ax - w, 0, w + w, 1)
  50.         self.blt(cx - w, cy - y, src, src_rect)
  51.         self.blt(cx + w, cy + y, src, src_rect)
  52.       end
  53.       
  54.       self.set_pixel(cx - w, cy - y, color)
  55.       self.set_pixel(cx + w, cy - y, color)
  56.       self.set_pixel(cx - w, cy + y, color)
  57.       self.set_pixel(cx + w, cy + y, color)
  58.       
  59.       while w2 < w
  60.         self.set_pixel(cx - w2, cy - y - 1, color)
  61.         self.set_pixel(cx + w2, cy - y - 1, color)
  62.         self.set_pixel(cx - w2, cy + y + 1, color)
  63.         self.set_pixel(cx + w2, cy + y + 1, color)
  64.         w2 += 1
  65.       end
  66.     end
  67.   end
  68. end
复制代码


这RGB颜色渐变……

回复楼上的示意图GDI+50次/秒

回复楼上的示意图GDI+50次/秒
h.png
v.png

点评

昨天我把blt实现了以后就知道结合原始blt做水平渐变根本不是问题了,只不过就是填充一个w*1那么长的然后一行行做进去  发表于 2022-3-2 17:00
50次秒得gdi+的速度吧,纯RGSS应该到不了,因为所有不走fill_rect或者没法走fill_rect的像素点描绘,极限就是几千个点/帧,1/50秒这还不到一帧  发表于 2022-3-1 19:47
回复

使用道具 举报

梦石
0
星屑
42345
在线时间
6022 小时
注册时间
2006-11-10
回帖
6975
发表于 2022-3-2 10:02:27 | 显示全部楼层
本帖最后由 灯笼菜刀王 于 2022-3-2 10:05 编辑

另外想到个用途, 只要不刷新, 可以无限往 bitmap 上画图形, 那也可用于"战争迷雾" ,  即时描绘可能影响效率, 但是战棋是不需要即时描绘的

以前我就想过这种用法, 然而只能画矩形, 太不像迷雾了, 就放弃了

为了比较有气氛,  猫大能否让描绘的图形带羽化边缘呢?(就是边缘半透明递减, 能自定义模糊半径更好 )

点评

sepcore里有bitmap#blur  发表于 2022-3-2 11:49
回复

使用道具 举报

遠航の猫咪

梦石
3
星屑
27057
在线时间
2428 小时
注册时间
2005-10-15
回帖
989

开拓者

 楼主| 发表于 2022-3-6 02:19:39 | 显示全部楼层
已初步搞定了:绘制曲线、封闭曲线填充、使用图案(包括水平渐变样式)快速填充

SEP Debug 2022_3_6 2_15_48.png

就还得写几个接口用方法,明天来继续更新

点评

画笔粗度用set_pixel重载效果不理想,大概有一半的常数复杂度被浪费掉了(因为画笔是一格一格前进的,重载set_pixel导致全方向重涂,实际没必要)  发表于 2022-3-6 02:21

评分

参与人数 1赞 +1 收起 理由
guoxiaomi + 1 塞糖

查看全部评分

SailCat (小猫子·要开心一点) 共上站 24 次,发表过 11 篇文章 上 次 在: [2006年01月28日11:41:18 星期六] 从 [162.105.120.91] 到本站一游。
回复

使用道具 举报

梦石
0
星屑
4657
在线时间
1069 小时
注册时间
2013-3-28
回帖
309

开拓者

发表于 2022-3-26 17:28:53 | 显示全部楼层
有没有办法绘制边缘渐变到透明的图形
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 注册会员

本版积分规则

Powered by Discuz! X5.0 © 2001-2026 Discuz! Team.

在本版发帖返回顶部