查看: 3672|回复: 11

[原创发布] 【正式发布】RM BitmapCanvas 2D绘图插件

[复制链接]

遠航の猫咪

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

开拓者

发表于 2022-11-21 06:13:38 | 显示全部楼层 |阅读模式

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

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

×
不依赖SEP,插入默认工程应该就可以使用
提供20个绘图指令,无论如何应该够用了

Q&A:
Q:这个脚本能用来干什么?
A:绘制异型血槽(如环状)、绘制能力雷达(六边形战士)、绘制渐变转场中的渐变分隔线、异型透视窗格、等等……
Q:绘图指令具体如何调用?
A:参见脚本前面的说明。
Q:能用虚线绘制矩形和直线以外的形状吗?
A:不能。
Q:为什么可填充的形状中不包括矩形?
A:参见Bitmap#fill_rect,如果你使用RGD或者SEP Core那么还有Bitmap#gradient_fill_rect
Q:我想用平行四边形切一个位图传送怎么办?默认只有Bitmap#blt,而你这个插件也只能用正多边形切正方形或者菱形?
A:请找到四边形的四个顶点,然后调用blt_polygon,所有平行四边形都是多边形的一种。
Q:我的位图传送后被切边了,不完整?
A:只有用位图填充,即fill系指令时,你给的位图会被插件自动重复成图案以保证填满。仅单纯的传送不会复制位图,如果你的位图比传送的区域小,尝试使用填充指令而不是传送指令,或者你看看是不是参照点没有写对导致传歪了。
Q:渐变的效率怎么样?
A:肯定是不如GDI+,但是比draw_text快,反正你用足够了。

  1. #==============================================================================
  2. # ■ [Bitmap Canvas] 位图画布处理核心 v1.1 by SailCat
  3. #------------------------------------------------------------------------------
  4. #   方法:本脚本插入Main之前使用
  5. #   依赖:无
  6. #   版本:v1.1 (Build 221121)
  7. #   效果:
  8. #     1. 可以用简单指令在位图对象上绘制图形,可以绘制从直线到封闭曲线的15种图形
  9. #     2. 可以用简单指令在位图对象上叠加以不同形状(共5种)剪裁的其他位图
  10. #   配置:画笔线形的配置
  11. #   冲突:无
  12. #   说明:
  13. #     1. 绘制直线:
  14. #        draw_line(起始x, 起始y, 结束x, 结束y, 颜色, 线形)
  15. #     2. 绘制矩形(空心):
  16. #       a) draw_rect(左上x, 左上y, 长, 宽, 颜色, 线形)
  17. #       b) draw_rect(矩形, 颜色, 线形)
  18. #     3. 绘制渐变色直线:
  19. #        gradient_draw_line(起始x, 起始y, 结束x, 结束y, 颜色1, 颜色2)
  20. #     4. 绘制路径(连续直线):
  21. #        draw_path(点1x, 点1y, 点2x, 点2y, 点3x, 点3y[, ...], 颜色)
  22. #     5. 绘制多边形(连续封闭直线):
  23. #        draw_polygon(点1x, 点1y, 点2x, 点2y, 点3x, 点3y[, ...], 颜色)
  24. #     6. 绘制正多边形:
  25. #        draw_isogon(外接圆心x, 外接圆心y, 半径, 边数, 旋转角, 颜色)
  26. #     7. 绘制椭圆:
  27. #        draw_ellipse(圆心x, 圆心y, 半横径,半纵径, 颜色)
  28. #     8. 绘制圆:
  29. #        draw_circle(圆心x, 圆心y, 半径,颜色)
  30. #     9. 绘制曲线:
  31. #        draw_curve(起始x, 起始y, 中继点Ax, 中继点Ay, 中继点Bx, 中继点By[,
  32. #          中继点Cx, 中继点Cy[, ...]], 结束x, 结束y, 颜色)
  33. #     10. 绘制封闭曲线:
  34. #        draw_closed_curve(点1x, 点1y, 中继1Ax, 中继1Ay, 中继1Bx, 中继1By,
  35. #          点2x, 点2y[, 中继2Ax, 中继2Ay, 中继2Bx, 中继2By, 点3x, 点3y[, ...]],
  36. #          颜色)
  37. #     11.填涂多边形:
  38. #       a) fill_polygon(点1x, 点1y, 点2x, 点2y, 点3x, 点3y[, ...], 边框颜色[,
  39. #          填充颜色1[, 填充颜色2[, 渐变方向]]])
  40. #       b) fill_polygon(点1x, 点1y, 点2x, 点2y, 点3x, 点3y[, ...], 边框颜色,
  41. #          填充位图[, 不透明度])
  42. #     12.填涂正多边形:
  43. #       a) fill_isogon(外接圆心x, 外接圆心y, 半径, 边数, 旋转角, 边框颜色[,
  44. #          填充颜色1[, 填充颜色2[, 渐变方向]]])
  45. #       b) fill_isogon(外接圆心x, 外接圆心y, 半径, 边数, 旋转角, 边框颜色,
  46. #          填充位图[, 不透明度])
  47. #     13.填涂椭圆:
  48. #       a) fill_ellipse(圆心x, 圆心y, 半横径,半纵径, 边框颜色[, 填充颜色1[,
  49. #          填充颜色2[, 渐变方向]]])
  50. #       b) fill_ellipse(圆心x, 圆心y, 半横径,半纵径, 边框颜色, 填充位图[,
  51. #          不透明度])
  52. #     14.填涂圆:
  53. #       a) fill_circle(圆心x, 圆心y, 半径,边框颜色[, 填充颜色1[, 填充颜色2[,
  54. #          渐变方向]]])
  55. #       b) fill_circle(圆心x, 圆心y, 半径,边框颜色, 填充位图[, 不透明度])
  56. #     15.填涂封闭曲线:
  57. #       a) fill_closed_curve(点1x, 点1y, 中继1Ax, 中继1Ay, 中继1Bx, 中继1By,
  58. #          点2x, 点2y[, 中继2Ax, 中继2Ay, 中继2Bx, 中继2By, 点3x, 点3y[, ...]],
  59. #          边框颜色[, 填充颜色1[, 填充颜色2[, 渐变方向]]])
  60. #       b) fill_closed_curve(点1x, 点1y, 中继1Ax, 中继1Ay, 中继1Bx, 中继1By,
  61. #          点2x, 点2y[, 中继2Ax, 中继2Ay, 中继2Bx, 中继2By, 点3x, 点3y[, ...]],
  62. #          边框颜色, 填充位图[, 不透明度])
  63. #     16.传送多边形:
  64. #        blt_polygon(点1x, 点1y, 点2x, 点2y, 点3x, 点3y[, ...], 源位图,
  65. #          参考点1x, 参考点1y[, 不透明度])
  66. #     17.传送正多边形:
  67. #        blt_isogon(外接圆心x, 外接圆心y, 半径, 边数, 旋转角, 源位图, 参考心x,
  68. #          参考心y[, 不透明度])
  69. #     18.传送椭圆:
  70. #        blt_ellipse(圆心x, 圆心y, 半横径,半纵径, 源位图, 参考心x, 参考心y[,
  71. #          不透明度])
  72. #     19.传送圆:
  73. #        blt_circle(圆心x, 圆心y, 半径,源位图, 参考心x, 参考心y[, 不透明度])
  74. #     20.传送封闭曲线:
  75. #        blt_closed_curve(点1x, 点1y, 中继1Ax, 中继1Ay, 中继1Bx, 中继1By,
  76. #          点2x, 点2y[, 中继2Ax, 中继2Ay, 中继2Bx, 中继2By, 点3x, 点3y[, ...]],
  77. #          源位图, 参考点1x, 参考点1y[, 不透明度])
  78. #==============================================================================
  79. #==============================================================================
  80. # ■ SailCat's 插件公用
  81. #==============================================================================
  82. module SailCat
  83.   #--------------------------------------------------------------------------
  84.   # ● 脚本配置区
  85.   #--------------------------------------------------------------------------
  86.   module Canvas_Config
  87.     CANVAS_LINE_DOTTED = [1, 0]               # 点线画笔
  88.     CANVAS_LINE_DASHED = [1, 1, 0, 1]         # 短虚线画笔
  89.     CANVAS_LINE_LONGDASH = [1, 1, 0, 0, 1, 1] # 长虚线画笔
  90.     CANVAS_LINE_DASHDOT = [1, 0, 1, 1, 1, 0]  # 点划线画笔
  91.     CANVAS_LINE_BROKEN = [1, 0, 0]            # 散点画笔
  92.   end
  93. end

  94. #==============================================================================
  95. # ■ Bitmap
  96. #==============================================================================
  97. class Bitmap
  98.   include SailCat::Canvas_Config
  99.   #--------------------------------------------------------------------------
  100.   # ● 常量
  101.   #--------------------------------------------------------------------------
  102.   CANVAS_LINE_SOLID = [1]                     # 实心画笔,该常量禁止修改配置
  103.   #--------------------------------------------------------------------------
  104.   # ● 绘制直线
  105.   #     x1 : 起始的 X 坐标
  106.   #     y1 : 起始的 Y 坐标
  107.   #     x2 : 结束的 X 坐标
  108.   #     y2 : 结束的 Y 坐标
  109.   #     color : 直线的颜色 (Color)
  110.   #     style : 直线的线型
  111.   #--------------------------------------------------------------------------
  112.   def draw_line(x1, y1, x2, y2, color, style = CANVAS_LINE_SOLID)
  113.     return set_pixel(x1, y1, color) if x1 == x2 and y1 == y2
  114.     dx = (x2 - x1).abs
  115.     dy = (y2 - y1).abs
  116.     x = x1
  117.     y = y1
  118.     rx = x2 - x1 <=> 0
  119.     ry = y2 - y1 <=> 0
  120.     b_index = 0
  121.     b_size = style.size
  122.     if dx == 0 and style == CANVAS_LINE_SOLID
  123.       fill_rect(x1, [y1, y2].min, 1, dy + 1, color)
  124.     elsif dy == 0 and style == CANVAS_LINE_SOLID
  125.       fill_rect([x1, x2].min, y1, dx + 1, 1, color)
  126.     elsif dx <= dy
  127.       f = dx.to_f * rx / dy
  128.       dy.times do
  129.         set_pixel(x.round, y, color) if style[b_index] == 1
  130.         x += f
  131.         y += ry
  132.         b_index = (b_index + 1) % b_size
  133.       end
  134.       set_pixel(x.round, y, color)
  135.     else
  136.       f = dy.to_f * ry / dx
  137.       dx.times do
  138.         set_pixel(x, y.round, color) if style[b_index] == 1
  139.         x += rx
  140.         y += f
  141.         b_index = (b_index + 1) % b_size
  142.       end
  143.       set_pixel(x, y.round, color)
  144.     end
  145.   end
  146.   #--------------------------------------------------------------------------
  147.   # ● 绘制空心矩形
  148.   #     参数形式1 : 左上 X 坐标, 左上 Y 坐标, 宽度, 高度, 颜色, 线型
  149.   #     参数形式2 : 目标矩形 (Rect), 颜色, 线型
  150.   #--------------------------------------------------------------------------
  151.   def draw_rect(*args)
  152.     case args[0]
  153.     when Numeric
  154.       raise ArgumentError if args.size < 4
  155.       x, y, w, h, color = args[0..4]
  156.       style = args[5] || CANVAS_LINE_SOLID
  157.     when Rect
  158.       raise ArgumentError if args.size < 2
  159.       rect = args[0]
  160.       x, y, w, h = rect.x, rect.y, rect.width, rect.height
  161.       color = args[1]
  162.       style = args[2] || CANVAS_LINE_SOLID
  163.     else
  164.       raise ArgumentError
  165.     end
  166.     draw_line(x, y, x + w, y, color, style)
  167.     draw_line(x, y, x, y + h, color, style)
  168.     draw_line(x + w, y, x + w, y + h, color, style)
  169.     draw_line(x, y + h, x + w, y + h, color, style)
  170.   end
  171.   #--------------------------------------------------------------------------
  172.   # ● 绘制渐变直线
  173.   #     x1 : 起始的 X 坐标
  174.   #     y1 : 起始的 Y 坐标
  175.   #     x2 : 结束的 X 坐标
  176.   #     y2 : 结束的 Y 坐标
  177.   #     color1 : 直线的起始颜色 (Color)
  178.   #     color2 : 直线的终止颜色 (Color)
  179.   #--------------------------------------------------------------------------
  180.   def gradient_draw_line(x1, y1, x2, y2, color1, color2)
  181.     return set_pixel(x1, y1, color) if x1 == x2 and y1 == y2
  182.     return draw_line(x1, y1, x2, y2, color1) if color1 == color2
  183.     dx = (x2 - x1).abs
  184.     dy = (y2 - y1).abs
  185.     rx = x2 - x1 <=> 0
  186.     ry = y2 - y1 <=> 0
  187.     c = color1.clone
  188.     if dx <= dy
  189.       f = dx.to_f / dy * rx
  190.       x = x1.to_f
  191.       y = y1
  192.       dr = (color2.red - color1.red) / dy
  193.       dg = (color2.green - color1.green) / dy
  194.       db = (color2.blue - color1.blue) / dy
  195.       da = (color2.alpha - color1.alpha) / dy
  196.       (dy + 1).times do
  197.         set_pixel(x.round, y, c)
  198.         x += f
  199.         y += ry
  200.         c.set(c.red + dr, c.green + dg, c.blue + db, c.alpha + da)
  201.       end
  202.     else
  203.       f = dy.to_f / dx * ry
  204.       x = x1
  205.       y = y1.to_f
  206.       dr = (color2.red - color1.red) / dx
  207.       dg = (color2.green - color1.green) / dx
  208.       db = (color2.blue - color1.blue) / dx
  209.       da = (color2.alpha - color1.alpha) / dx
  210.       (dx + 1).times do
  211.         set_pixel(x, y.round, c)
  212.         x += rx
  213.         y += f
  214.         c.set(c.red + dr, c.green + dg, c.blue + db, c.alpha + da)
  215.       end
  216.     end
  217.   end
  218.   #--------------------------------------------------------------------------
  219.   # ● 绘制路径
  220.   #     x1 : 第一点的 X 坐标
  221.   #     y1 : 第一点的 Y 坐标
  222.   #     x2 : 第二点的 X 坐标
  223.   #     y2 : 第二点的 Y 坐标
  224.   #     x3 : 第三点的 X 坐标
  225.   #     y3 : 第三点的 Y 坐标
  226.   #     args : 后续的参数(可以加多个点,至少要包括颜色)
  227.   #--------------------------------------------------------------------------
  228.   def draw_path(x1, y1, x2, y2, x3, y3, *args)
  229.     raise ArgumentError if args.size[0] == 0 or not args[-1].is_a?(Color)
  230.     color = args[-1]
  231.     nodes = [x1, y1, x2, y2, x3, y3].concat(args[0...-1])
  232.     0.step(nodes.size - 4, 2) {|i| draw_line(*(nodes[i, 4].concat([color])))}
  233.   end
  234.   #--------------------------------------------------------------------------
  235.   # ● 绘制多边形
  236.   #     x1 : 第一点的 X 坐标
  237.   #     y1 : 第一点的 Y 坐标
  238.   #     x2 : 第二点的 X 坐标
  239.   #     y2 : 第二点的 Y 坐标
  240.   #     x3 : 第三点的 X 坐标
  241.   #     y3 : 第三点的 Y 坐标
  242.   #     args : 后续的参数(可以加多个点,至少要包括颜色)
  243.   #--------------------------------------------------------------------------
  244.   def draw_polygon(x1, y1, x2, y2, x3, y3, *args)
  245.     raise ArgumentError if args.size[0] == 0 or not args[-1].is_a?(Color)
  246.     args.insert(-2, x1, y1)
  247.     draw_path(x1, y1, x2, y2, x3, y3, *args)
  248.   end
  249.   #--------------------------------------------------------------------------
  250.   # ● 绘制实心多边形
  251.   #     x1 : 第一点的 X 坐标
  252.   #     y1 : 第一点的 Y 坐标
  253.   #     x2 : 第二点的 X 坐标
  254.   #     y2 : 第二点的 Y 坐标
  255.   #     x3 : 第三点的 X 坐标
  256.   #     y3 : 第三点的 Y 坐标
  257.   #     args : 后续的参数,包括后续点,并在所有点之后指定填充选项,填充选项有:
  258.   #            3个颜色 + true/false : 颜色1为边框色,颜色2和颜色3用于填充,最后
  259.   #              true = 垂直方向渐变 false = 水平方向渐变
  260.   #            3个颜色 : 颜色1用于描边,颜色2和颜色3用于填充,固定水平方向渐变
  261.   #            2个颜色 : 颜色1用于描边,颜色2用于填充
  262.   #            1个颜色 : 以该颜色描边,并实心填充
  263.   #            颜色 + 位图 + 数值 : 颜色用于描边,位图用于填充,数值为不透明度
  264.   #            颜色 + 位图 : 颜色用于描边,位图用于填充,不透明度固定为255
  265.   #--------------------------------------------------------------------------
  266.   def fill_polygon(x1, y1, x2, y2, x3, y3, *args)
  267.     case args[-1]
  268.     when FalseClass, TrueClass
  269.       raise ArgumentError unless args[-4..-2].all?{|c| c.is_a?(Color)}
  270.       fill_mode = args.pop ? 1 : 0
  271.       fill2 = args.pop
  272.       fill1 = args.pop
  273.       fill_mode = 0 if fill1 == fill2
  274.     when Color
  275.       fill_mode = 0
  276.       fill2 = args[-3].is_a?(Color) ? args.pop : args[-1]
  277.       fill1 = args[-2].is_a?(Color) ? args.pop : args[-1]
  278.     when Bitmap
  279.       raise ArgumentError unless args[-2].is_a?(Color)
  280.       fill_mode = 2
  281.       fill_opacity = 255
  282.       fill_pattern = args.pop
  283.     when Numeric
  284.       raise ArgumentError unless args[-3].is_a?(Color) and
  285.         args[-2].is_a?(Bitmap)
  286.       fill_mode = 2
  287.       fill_opacity = args.pop
  288.       fill_pattern = args.pop
  289.     else
  290.       raise ArgumentError
  291.     end
  292.     draw_polygon(x1, y1, x2, y2, x3, y3, *args)
  293.     color = args[-1]
  294.     nodes = [x1, y1, x2, y2, x3, y3].concat(args[0...-1])
  295.     edges = {}
  296.     min_y = height
  297.     max_x = max_y = 0
  298.     min_x = width
  299.     0.step(nodes.size - 2, 2) do |i|
  300.       xi, yi = nodes[i, 2]
  301.       min_y = [min_y, yi].min
  302.       max_y = [max_y, yi].max
  303.       min_x = [min_x, xi].min
  304.       max_x = [max_x, xi].max
  305.       xj, yj = nodes[(i + 2) % nodes.size, 2]
  306.       dx = 1.0 * (xi - xj) / (yi - yj)
  307.       if yi < yj
  308.         delta = -1
  309.         delta -= 2 until (yh = nodes[(i + delta) % nodes.size]) != yi
  310.         if yh < yi
  311.           yi += 1
  312.           xi += dx
  313.         end
  314.         edges[yi] ||= []
  315.         edges[yi].push([xi, dx, yj])
  316.       elsif yi > yj
  317.         delta = 5
  318.         delta += 2 until (yk = nodes[(i + delta) % nodes.size]) != yj
  319.         if yj > yk
  320.           yj += 1
  321.           xj += dx
  322.         end
  323.         edges[yj] ||= []
  324.         edges[yj].push([xj, dx, yi])
  325.       end
  326.     end
  327.     return unless max_y - min_y > 1 and max_x - min_x > 1
  328.     dw = max_x - min_x - 1
  329.     dh = max_y - min_y - 1
  330.     if fill_mode == 0
  331.       if fill1 != fill2
  332.         dr = (fill2.red - fill1.red) / dh
  333.         dg = (fill2.green - fill1.green) / dh
  334.         db = (fill2.blue - fill1.blue) / dh
  335.         da = (fill2.alpha - fill1.alpha) / dh
  336.         gradient = true
  337.       end
  338.       f = fill1.clone
  339.       aet = edges[min_y].each {|edge| edge[0] += edge[1]}.sort!
  340.       for y in min_y + 1..max_y - 1
  341.         aet.concat(edges[y]).sort! if edges[y]
  342.         0.step(aet.size - 2, 2) do |i|
  343.           xi = aet[i][0].round
  344.           xj = aet[i + 1][0].round
  345.           xi += 1 until xi == width - 1 or get_pixel(xi, y) != color
  346.           xj -= 1 until xj == 0 or get_pixel(xj, y) != color
  347.           fill_rect(xi, y, xj - xi + 1, 1, f) if xj >= xi
  348.         end
  349.         aet.reject! {|edge| edge[2] == y}
  350.         aet.each {|edge| edge[0] += edge[1]}.sort!
  351.         f.set(f.red + dr, f.green + dg, f.blue + db, f.alpha + da) if gradient
  352.       end
  353.     else
  354.       if fill_mode == 2
  355.         src = Bitmap.new(dw, fill_pattern.height)
  356.         0.step(dw - 1, fill_pattern.width) do |x|
  357.           src.blt(x, 0, fill_pattern, fill_pattern.rect, fill_opacity)
  358.         end
  359.       else
  360.         src = Bitmap.new(dw, 1)
  361.         src.gradient_draw_line(0, 0, dw - 1, 0, fill1, fill2)
  362.       end
  363.       ox = -1 - min_x
  364.       y_index = 0
  365.       aet = edges[min_y].each {|edge| edge[0] += edge[1]}.sort!
  366.       for y in min_y + 1..max_y - 1
  367.         aet.concat(edges[y]).sort! if edges[y]
  368.         0.step(aet.size - 2, 2) do |i|
  369.           xi = aet[i][0].round
  370.           xj = aet[i + 1][0].round
  371.           xi += 1 until xi == width - 1 or get_pixel(xi, y) != color
  372.           xj -= 1 until xj == 0 or get_pixel(xj, y) != color
  373.           blt(xi, y, src, Rect.new(xi + ox, y_index, xj - xi + 1, 1))
  374.         end
  375.         aet.reject! {|edge| edge[2] == y}
  376.         aet.each {|edge| edge[0] += edge[1]}.sort!
  377.         y_index = (y_index + 1) % src.height
  378.       end
  379.       src.dispose
  380.     end
  381.   end
  382.   #--------------------------------------------------------------------------
  383.   # ● 传送位图多边形
  384.   #     x1 : 第一点的 X 坐标
  385.   #     y1 : 第一点的 Y 坐标
  386.   #     x2 : 第二点的 X 坐标
  387.   #     y2 : 第二点的 Y 坐标
  388.   #     x3 : 第三点的 X 坐标
  389.   #     y3 : 第三点的 Y 坐标
  390.   #     args : 后续的参数(加多个点,最后是位图, 偏移x,偏移y,(可选)不透明度)
  391.   #            偏移x和偏移y的位置参考第一个点
  392.   #--------------------------------------------------------------------------
  393.   def blt_polygon(x1, y1, x2, y2, x3, y3, *args)
  394.     if args[-3].is_a?(Bitmap)
  395.       src, x0, y0 = args[-3, 3]
  396.       opacity = 255
  397.       nodes = [x1, y1, x2, y2, x3, y3].concat(args[0...-3])
  398.     elsif args[-4].is_a?(Bitmap)
  399.       src, x0, y0, opacity = args[-4, 4]
  400.       nodes = [x1, y1, x2, y2, x3, y3].concat(args[0...-4])
  401.     else
  402.       raise ArgumentError
  403.     end
  404.     raise ArgumentError unless nodes.size[0] == 0
  405.     edges = {}
  406.     min_y = height
  407.     max_y = 0
  408.     ox = x0 - x1
  409.     oy = y0 - y1
  410.     0.step(nodes.size - 2, 2) do |i|
  411.       xi, yi = nodes[i, 2]
  412.       min_y = [min_y, yi].min
  413.       max_y = [max_y, yi].max
  414.       xj, yj = nodes[(i + 2) % nodes.size, 2]
  415.       dx = 1.0 * (xi - xj) / (yi - yj)
  416.       if yi < yj
  417.         delta = -1
  418.         delta -= 2 until (yh = nodes[(i + delta) % nodes.size]) != yi
  419.         if yh < yi
  420.           yi += 1
  421.           xi += dx
  422.         end
  423.         edges[yi] ||= []
  424.         edges[yi].push([xi, dx, yj])
  425.       elsif yi > yj
  426.         delta = 5
  427.         delta += 2 until (yk = nodes[(i + delta) % nodes.size]) != yj
  428.         if yj > yk
  429.           yj += 1
  430.           xj += dx
  431.         end
  432.         edges[yj] ||= []
  433.         edges[yj].push([xj, dx, yi])
  434.       end
  435.     end
  436.     aet = []
  437.     for y in min_y..max_y
  438.       aet.concat(edges[y]).sort! if edges[y]
  439.       0.step(aet.size - 1, 2) do |i|
  440.         xi = aet[i][0].round
  441.         xj = aet[i + 1][0].round
  442.         blt(xi, y, src, Rect.new(xi + ox, y + oy, xj - xi + 1, 1), opacity)
  443.       end
  444.       aet.reject! {|edge| edge[2] == y}
  445.       aet.each {|edge| edge[0] += edge[1]}.sort!
  446.     end
  447.   end
  448.   #--------------------------------------------------------------------------
  449.   # ● 绘制正多边形
  450.   #     x : 正多边形外接圆心 X 坐标
  451.   #     y : 正多边形外接圆心 Y 坐标
  452.   #     rad : 正多边形外接圆 半径
  453.   #     edges : 正多边形的边数
  454.   #     angle : 正多边形旋转角度
  455.   #     color : 正多边形的颜色 (Color)
  456.   #--------------------------------------------------------------------------
  457.   def draw_isogon(x, y, rad, edges, angle, color)
  458.     raise ArgumentError if edges < 3
  459.     step = Math::PI * 2 / edges
  460.     args = []
  461.     angle_i = Math::PI * (270 + angle) / 180
  462.     edges.times do
  463.       args.push((x + rad * Math.cos(angle_i)).round,
  464.         (y + rad * Math.sin(angle_i)).round)
  465.       angle_i += step
  466.     end
  467.     draw_polygon(*args.push(color))
  468.   end
  469.   #--------------------------------------------------------------------------
  470.   # ● 绘制实心正多边形
  471.   #     x : 正多边形外接圆心 X 坐标
  472.   #     y : 正多边形外接圆心 Y 坐标
  473.   #     rad : 正多边形外接圆 半径
  474.   #     edges : 正多边形的边数
  475.   #     angle : 正多边形旋转角度
  476.   #     color : 边框的颜色 (Color)
  477.   #     fill : 填充选项,具体的填充选项有:
  478.   #            2个颜色 + true/false : 两个颜色以垂直/水平方式渐变填充
  479.   #            2个颜色 : 两个颜色以水平方向渐变填充
  480.   #            1个颜色 : 实心填充
  481.   #            位图 + 数值 : 以位图图案填充,数值为不透明度
  482.   #            位图 : 以位图图案填充,不透明度固定为255
  483.   #            省略 : 用边框色实心填充
  484.   #--------------------------------------------------------------------------
  485.   def fill_isogon(x, y, rad, edges, angle, color, *fill)
  486.     raise ArgumentError if edges < 3
  487.     step = Math::PI * 2 / edges
  488.     args = []
  489.     angle_i = Math::PI * (270 + angle) / 180
  490.     edges.times do
  491.       args.push((x + rad * Math.cos(angle_i)).round,
  492.         (y + rad * Math.sin(angle_i)).round)
  493.       angle_i += step
  494.     end
  495.     fill_polygon(*args.push(color).concat(fill))
  496.   end
  497.   #--------------------------------------------------------------------------
  498.   # ● 传送位图正多边形
  499.   #     x : 正多边形外接圆心 X 坐标
  500.   #     y : 正多边形外接圆心 Y 坐标
  501.   #     rad : 正多边形外接圆 半径
  502.   #     edges : 正多边形的边数
  503.   #     angle : 正多边形旋转角度
  504.   #     src_bitmap : 传送元位图
  505.   #     x0 : 传送圆心 X 坐标
  506.   #     y0 : 传送圆心 Y 坐标
  507.   #     opacity : 不透明度
  508.   #--------------------------------------------------------------------------
  509.   def blt_isogon(x, y, rad, edges, angle, src_bitmap, x0, y0, opacity = 255)
  510.     raise ArgumentError if edges < 3
  511.     step = Math::PI * 2 / edges
  512.     args = []
  513.     angle_i = Math::PI * (270 + angle) / 180
  514.     edges.times do
  515.       args.push((x + rad * Math.cos(angle_i)).round,
  516.         (y + rad * Math.sin(angle_i)).round)
  517.       angle_i += step
  518.     end
  519.     args.push(src_bitmap, x0 - x + args[0], y0 - y + args[1], opacity)
  520.     blt_polygon(*args)
  521.   end
  522.   #--------------------------------------------------------------------------
  523.   # ● 绘制圆
  524.   #     x : 圆心 X 坐标
  525.   #     y : 圆心 Y 坐标
  526.   #     rad : 半径
  527.   #     color : 圆的颜色 (Color)
  528.   #--------------------------------------------------------------------------
  529.   def draw_circle(x, y, rad, color)
  530.     draw_ellipse(x, y, rad, rad, color)
  531.   end
  532.   #--------------------------------------------------------------------------
  533.   # ● 绘制椭圆
  534.   #     x : 圆心 X 坐标
  535.   #     y : 圆心 Y 坐标
  536.   #     rad_x : 水平半径
  537.   #     rad_y : 垂直半径
  538.   #     color : 椭圆的颜色 (Color)
  539.   #--------------------------------------------------------------------------
  540.   def draw_ellipse(x, y, rad_x, rad_y, color)
  541.     fill_ellipse(x, y, rad_x, rad_y, color, nil)
  542.   end
  543.   #--------------------------------------------------------------------------
  544.   # ● 绘制实心圆
  545.   #     x : 圆心 X 坐标
  546.   #     y : 圆心 Y 坐标
  547.   #     rad : 半径
  548.   #     border_color : 圆的边框颜色 (Color)
  549.   #     fill : 填充选项,具体的填充选项有:
  550.   #            nil : 不填充
  551.   #            2个颜色 + true/false : 两个颜色以垂直/水平方式渐变填充
  552.   #            2个颜色 : 两个颜色以水平方向渐变填充
  553.   #            1个颜色 : 实心填充
  554.   #            位图 + 数值 : 以位图图案填充,数值为不透明度
  555.   #            位图 : 以位图图案填充,不透明度固定为255
  556.   #            省略 : 用边框色实心填充
  557.   #--------------------------------------------------------------------------
  558.   def fill_circle(x, y, rad, border_color, *fill)
  559.     fill_ellipse(x, y, rad, rad, border_color, *fill)
  560.   end
  561.   #--------------------------------------------------------------------------
  562.   # ● 绘制实心椭圆
  563.   #     x : 圆心 X 坐标
  564.   #     y : 圆心 Y 坐标
  565.   #     rad_x : 水平半径
  566.   #     rad_y : 垂直半径
  567.   #     border_color : 椭圆的边框颜色 (Color)
  568.   #     fill : 填充选项,具体的填充选项有:
  569.   #            nil : 不填充
  570.   #            2个颜色 + true/false : 两个颜色以垂直/水平方式渐变填充
  571.   #            2个颜色 : 两个颜色以水平方向渐变填充
  572.   #            1个颜色 : 实心填充
  573.   #            位图 + 数值 : 以位图图案填充,数值为不透明度
  574.   #            位图 : 以位图图案填充,不透明度固定为255
  575.   #            省略 : 用边框色实心填充
  576.   #--------------------------------------------------------------------------
  577.   def fill_ellipse(x, y, rad_x, rad_y, border_color, *fill)
  578.     raise ArgumentError if rad_x < 0 or rad_y < 0
  579.     return set_pixel(x, y, border_color) if rad_x == 0 and rad_y == 0
  580.     return fill_rect(x - rad_x, y, rad_x << 1, 1, border_color) if rad_y == 0
  581.     return fill_rect(x, y - rad_y, 1, rad_y << 1, border_color) if rad_x == 0
  582.     ry2 = rad_y * rad_y
  583.     rx2 = rad_x * rad_x
  584.     d = ry2 + rx2 * (0.25 - rad_y)
  585.     dx = 0
  586.     dy = rad_y
  587.     if fill.size == 0
  588.       fill_mode = 0
  589.       f1 = f2 = border_color.clone
  590.     else
  591.       case fill[0]
  592.       when Color
  593.         f1 = fill[0].clone
  594.         if fill[1]
  595.           f2 = fill[1].clone
  596.           fill_mode = f1 == f2 ? 0 : (fill[2] ? 3 : 1)
  597.         else
  598.           f2 = f1
  599.           fill_mode = 0
  600.         end
  601.       when Bitmap
  602.         fill_mode = 2
  603.       else
  604.         fill_mode = -1
  605.       end
  606.     end
  607.     case fill_mode
  608.     when 1
  609.       dist = rad_y - 1 << 1
  610.       if dist > 0
  611.         dr = (f2.red - f1.red) / dist
  612.         dg = (f2.green - f1.green) / dist
  613.         db = (f2.blue - f1.blue) / dist
  614.         da = (f2.alpha - f1.alpha) / dist
  615.       end
  616.     when 2
  617.       src = Bitmap.new((rad_x << 1) - 1, fill[0].height)
  618.       0.step((rad_x << 1) - 1, fill[0].width) do |x0|
  619.         src.blt(x0, 0, fill[0], fill[0].rect, fill[1] || 255)
  620.       end
  621.     when 3
  622.       src = Bitmap.new((rad_x << 1) - 1, 1)
  623.       src.gradient_draw_line(0, 0, rad_x - 1 << 1 , 0, f1, f2)
  624.     end
  625.     begin
  626.       set_pixel(x + dx, y + dy, border_color)
  627.       set_pixel(x + dx, y - dy, border_color)
  628.       set_pixel(x - dx, y - dy, border_color)
  629.       set_pixel(x - dx, y + dy, border_color)
  630.       if d <= -1e-6
  631.         d += ry2 * ((dx << 1) + 3)
  632.       else
  633.         d += ry2 * ((dx << 1) + 3) + rx2 * (1 - dy << 1)
  634.         dy -= 1
  635.         case fill_mode
  636.         when 0, 1
  637.           fill_rect(x - dx, y - dy, (dx << 1) + 1, 1, f1)
  638.           fill_rect(x - dx, y + dy, (dx << 1) + 1, 1, f2)
  639.           if fill_mode == 1
  640.             f1.set(f1.red + dr, f1.green + dg, f1.blue + db, f1.alpha + da)
  641.             f2.set(f2.red - dr, f2.green - dg, f2.blue - db, f2.alpha - da)
  642.           end
  643.         when 2, 3
  644.           blt(x - dx, y - dy, src, Rect.new(rad_x - dx - 1,
  645.             (rad_y - dy - 1) % src.height,(dx << 1) + 1, 1))
  646.           blt(x - dx, y + dy, src, Rect.new(rad_x - dx - 1,
  647.             (rad_y + dy - 1) % src.height,(dx << 1) + 1, 1))
  648.         end
  649.       end
  650.       dx += 1
  651.     end while ry2 * (dx + 1) < rx2 * (dy - 0.5)
  652.     d = ry2 * (dx + 0.5) * (dx + 0.5) + rx2 * (dy - 1) * (dy - 1) - rx2 * ry2
  653.     sy = dy
  654.     begin
  655.       set_pixel(x + dx, y + dy, border_color)
  656.       set_pixel(x + dx, y - dy, border_color)
  657.       set_pixel(x - dx, y - dy, border_color)
  658.       set_pixel(x - dx, y + dy, border_color)
  659.       if fill_mode >= 0 and dy < sy
  660.         case fill_mode
  661.         when 0, 1
  662.           fill_rect(x - dx + 1, y - dy, (dx << 1) - 1, 1, f1)
  663.           fill_rect(x - dx + 1, y + dy, (dx << 1) - 1, 1, f2) unless dy == 0
  664.           if fill_mode == 1
  665.             f1.set(f1.red + dr, f1.green + dg, f1.blue + db, f1.alpha + da)
  666.             f2.set(f2.red - dr, f2.green - dg, f2.blue - db, f2.alpha - da)
  667.           end
  668.         when 2, 3
  669.           blt(x - dx + 1, y - dy, src, Rect.new(rad_x - dx,
  670.             (rad_y - dy - 1) % src.height,(dx << 1) - 1, 1))
  671.           blt(x - dx + 1, y + dy, src, Rect.new(rad_x - dx,
  672.             (rad_y + dy - 1) % src.height,(dx << 1) - 1, 1)) unless dy == 0
  673.         end
  674.       end
  675.       if d <= -1e-6
  676.         d += ry2 * (dx + 1 << 1) + rx2 * (3 - (dy << 1))
  677.         dx += 1
  678.       else
  679.         d += rx2 * (3 - (dy << 1))
  680.       end
  681.       dy -= 1
  682.     end while dy >= 0
  683.     src.dispose if fill_mode > 1
  684.   end
  685.   #--------------------------------------------------------------------------
  686.   # ● 传送位图圆
  687.   #     x : 圆心 X 坐标
  688.   #     y : 圆心 Y 坐标
  689.   #     rad : 半径
  690.   #     src_bitmap : 传送元位图
  691.   #     x0 : 传送圆心 X 坐标
  692.   #     y0 : 传送圆心 Y 坐标
  693.   #     opacity : 不透明度
  694.   #--------------------------------------------------------------------------
  695.   def blt_circle(x, y, rad, src_bitmap, x0, y0, opacity = 255)
  696.     blt_ellipse(x, y, rad, rad, src_bitmap, x0, y0, opacity)
  697.   end
  698.   #--------------------------------------------------------------------------
  699.   # ● 传送位图椭圆
  700.   #     x : 圆心 X 坐标
  701.   #     y : 圆心 Y 坐标
  702.   #     rad_x : 水平半径
  703.   #     rad_y : 垂直半径
  704.   #     src_bitmap : 传送元位图
  705.   #     x0 : 传送圆心 X 坐标
  706.   #     y0 : 传送圆心 Y 坐标
  707.   #     opacity : 不透明度
  708.   #--------------------------------------------------------------------------
  709.   def blt_ellipse(x, y, rad_x, rad_y, src_bitmap, x0, y0, opacity = 255)
  710.     raise ArgumentError if rad_x < 0 or rad_y < 0
  711.     return blt(x - rad_x, y, src_bitmap, Rect.new(x0 - rad_x, y0,
  712.       rad_x << 1, 1), opacity) if rad_y == 0
  713.     return blt(x, y - rad_y, src_bitmap, Rect.new(x0, y0 - rad_y,
  714.       1, rad_y << 1), opacity) if rad_x == 0
  715.     ry2 = rad_y * rad_y
  716.     rx2 = rad_x * rad_x
  717.     d = ry2 + rx2 * (0.25 - rad_y)
  718.     dx = 0
  719.     dy = rad_y
  720.     begin
  721.       if d <= -1e-6
  722.         d += ry2 * ((dx << 1) + 3)
  723.       else
  724.         blt(x - dx, y - dy, src_bitmap, Rect.new(x0 - dx, y0 - dy, dx << 1, 1),
  725.           opacity)
  726.         blt(x - dx, y + dy, src_bitmap, Rect.new(x0 - dx, y0 + dy, dx << 1, 1),
  727.           opacity)
  728.         d += ry2 * ((dx << 1) + 3) + rx2 * (1 - dy << 1)
  729.         dy -= 1
  730.       end
  731.       dx += 1
  732.     end while ry2 * (dx + 1) < rx2 * (dy - 0.5)
  733.     d = ry2 * (dx + 0.5) * (dx + 0.5) + rx2 * (dy - 1) * (dy - 1) - rx2 * ry2
  734.     begin
  735.       blt(x - dx, y - dy, src_bitmap, Rect.new(x0 - dx, y0 - dy, dx << 1, 1),
  736.         opacity)
  737.       blt(x - dx, y + dy, src_bitmap, Rect.new(x0 - dx, y0 + dy, dx << 1, 1),
  738.         opacity) unless dy == 0
  739.       if d <= -1e-6
  740.         d += ry2 * (dx + 1 << 1) + rx2 * (3 - (dy << 1))
  741.         dx += 1
  742.       else
  743.         d += rx2 * (3 - (dy << 1))
  744.       end
  745.       dy -= 1
  746.     end while dy >= 0
  747.   end
  748.   #--------------------------------------------------------------------------
  749.   # ● 绘制曲线
  750.   #     x1 : 起始点 X 坐标
  751.   #     x2 : 起始点 Y 坐标
  752.   #     cx1 : 控制点1 X 坐标
  753.   #     cy1 : 控制点1 Y 坐标
  754.   #     cx2 : 控制点2 X 坐标
  755.   #     cx2 : 控制点2 Y 坐标
  756.   #     x2 : 终止点(或控制点3) X 坐标
  757.   #     y2 : 终止点(或控制点3) Y 坐标
  758.   #     args : 后续的参数,可以追加额外的控制点,以最后一个点的坐标为终止点,
  759.   #            最后还需再指定一个颜色 (Color)
  760.   #--------------------------------------------------------------------------
  761.   def draw_curve(x1, y1, cx1, cy1, cx2, cy2, x2, y2, *args)
  762.     raise ArgumentError if args.size[0] == 0 or not args[-1].is_a?(Color)
  763.     color = args[-1]
  764.     points = [x1, y1, cx1, cy1, cx2, cy2, x2, y2].concat(args[0...-1])
  765.     draw_path(*get_curve_path(points).push(color))
  766.   end
  767.   #--------------------------------------------------------------------------
  768.   # ● 绘制封闭曲线
  769.   #     x1 : 起始点 X 坐标
  770.   #     x2 : 起始点 Y 坐标
  771.   #     cx1 : 控制点1 X 坐标
  772.   #     cy1 : 控制点1 Y 坐标
  773.   #     cx2 : 控制点2 X 坐标
  774.   #     cx2 : 控制点2 Y 坐标
  775.   #     x2 : 终止点 X 坐标
  776.   #     y2 : 终止点 Y 坐标
  777.   #     args : 后续的参数,每多指定一个曲线节点,增加6个参数,分别表示从前一终
  778.   #            止点作为起始点曲线的控制点1 X/Y、控制点2 X/Y、及本曲线终点的X/Y
  779.   #            最后还需再指定一个颜色 (Color)
  780.   #--------------------------------------------------------------------------
  781.   def draw_closed_curve(x1, y1, cx1, cy1, cx2, cy2, x2, y2, *args)
  782.     raise ArgumentError if args.size % 6 != 1 or not args[-1].is_a?(Color)
  783.     color = args[-1]
  784.     points = [x1, y1, cx1, cy1, cx2, cy2, x2, y2].concat(args[0...-1])
  785.     edges = []
  786.     0.step(points.size - 8, 6) do |i|
  787.       edges.concat(get_curve_path(points[i, 8]))
  788.     end
  789.     draw_polygon(*edges.push(color))
  790.   end
  791.   #--------------------------------------------------------------------------
  792.   # ● 绘制填充的封闭曲线
  793.   #     x1 : 起始点 X 坐标
  794.   #     x2 : 起始点 Y 坐标
  795.   #     cx1 : 控制点1 X 坐标
  796.   #     cy1 : 控制点1 Y 坐标
  797.   #     cx2 : 控制点2 X 坐标
  798.   #     cx2 : 控制点2 Y 坐标
  799.   #     x2 : 终止点 X 坐标
  800.   #     y2 : 终止点 Y 坐标
  801.   #     args : 后续的参数,每多指定一个曲线节点,增加6个参数,分别表示从前终止
  802.   #            点起始的下一曲线段控制点1 X/Y、控制点2 X/Y、及该曲线终止点的X/Y
  803.   #            最后要指定填充选项,填充选项有:
  804.   #            3个颜色 + true/false : 颜色1为边框色,颜色2和颜色3用于填充,最后
  805.   #              true = 垂直方向渐变 false = 水平方向渐变
  806.   #            3个颜色 : 颜色1用于描边,颜色2和颜色3用于填充,水平方向渐变
  807.   #            2个颜色 : 颜色1用于描边,颜色2用于填充
  808.   #            1个颜色 : 以该颜色描边,并实心填充
  809.   #            颜色 + 位图 + 数值 : 颜色用于描边,位图用于填充,数值为不透明度
  810.   #            颜色 + 位图 : 颜色用于描边,位图用于填充,不透明度固定为255
  811.   #--------------------------------------------------------------------------
  812.   def fill_closed_curve(x1, y1, cx1, cy1, cx2, cy2, x2, y2, *args)
  813.     case args[-1]
  814.     when FalseClass, TrueClass
  815.       arg_chop = -4
  816.     when Color
  817.       arg_chop = args[-3].is_a?(Color) ? -3 :
  818.         args[-2].is_a?(Color) ? -2 : -1
  819.     when Bitmap
  820.       arg_chop = -2
  821.     when Numeric
  822.       arg_chop = -3
  823.     else
  824.       raise ArgumentError
  825.     end
  826.     raise ArgumentError if (args.size + arg_chop) % 6 != 0
  827.     points = [x1, y1, cx1, cy1, cx2, cy2, x2, y2].concat(args[0...arg_chop])
  828.     edges = []
  829.     0.step(points.size - 8, 6) do |i|
  830.       edges.concat(get_curve_path(points[i, 8])[0...-2])
  831.     end
  832.     fill_polygon(*edges.concat(args[arg_chop..-1]))
  833.   end
  834.   #--------------------------------------------------------------------------
  835.   # ● 传送位图封闭曲线
  836.   #     x1 : 起始点 X 坐标
  837.   #     x2 : 起始点 Y 坐标
  838.   #     cx1 : 控制点1 X 坐标
  839.   #     cy1 : 控制点1 Y 坐标
  840.   #     cx2 : 控制点2 X 坐标
  841.   #     cx2 : 控制点2 Y 坐标
  842.   #     x2 : 终止点 X 坐标
  843.   #     y2 : 终止点 Y 坐标
  844.   #     args : 后续的参数,每多指定一个曲线节点,增加6个参数,分别表示从前终止
  845.   #            点起始的下一曲线段控制点1 X/Y、控制点2 X/Y、及该曲线终止点的X/Y
  846.   #            最后指定传送的位图, 偏移x,偏移y(比照起始点),(可选)不透明度
  847.   #--------------------------------------------------------------------------
  848.   def blt_closed_curve(x1, y1, cx1, cy1, cx2, cy2, x2, y2, *args)
  849.     if args[-3].is_a?(Bitmap)
  850.       start = -3
  851.       points = [x1, y1, cx1, cy1, cx2, cy2, x2, y2].concat(args[0...-3])
  852.     elsif args[-4].is_a?(Bitmap)
  853.       start = -4
  854.       points = [x1, y1, cx1, cy1, cx2, cy2, x2, y2].concat(args[0...-4])
  855.     else
  856.       raise ArgumentError
  857.     end
  858.     raise ArgumentError unless points.size % 6 == 2
  859.     edges = []
  860.     0.step(points.size - 8, 6) do |i|
  861.       edges.concat(get_curve_path(points[i, 8]))
  862.     end
  863.     blt_polygon(*edges.concat(args[start..-1]))
  864.   end
  865.   private
  866.   #--------------------------------------------------------------------------
  867.   # ● 内部函数:计算曲线点位
  868.   #     points : 接继点表
  869.   #--------------------------------------------------------------------------
  870.   def get_curve_path(points)
  871.     max_x = min_x = points[0]
  872.     max_y = min_y = points[1]
  873.     2.step(points.size - 2, 2) do |i|
  874.       max_x = [max_x, points[i]].max
  875.       min_x = [min_x, points[i]].min
  876.       max_y = [max_y, points[i + 1]].max
  877.       min_y = [min_y, points[i + 1]].min
  878.     end
  879.     curve_edge_count = [max_x + max_y - min_x - min_y >> 2, 2].max
  880.     (0..curve_edge_count).inject([]) do |a, i|
  881.       pt = points.clone
  882.       t = i / curve_edge_count.to_f
  883.       until pt.size == 2
  884.         pt = (0...(pt.size >> 1) - 1).to_a.inject([]) do |b, j|
  885.           x1, y1, x2, y2 = pt[j << 1, 4]
  886.           b.push((1 - t) * x1 + t * x2, (1 - t) * y1 + t * y2)
  887.         end
  888.       end
  889.       x = pt[0].round
  890.       y = pt[1].round
  891.       x == a[-2] && y == a[-1] ? a : a.push(x, y)
  892.     end
  893.   end
  894. end
复制代码

评分

参与人数 5星屑 +360 赞 +4 收起 理由
jienluck + 1
陈大帅帅帅哥 + 1 精品文章
fux2 + 360 精品文章
guoxiaomi + 1 精品文章
灯笼菜刀王 + 1 精品文章

查看全部评分

SailCat (小猫子·要开心一点) 共上站 24 次,发表过 11 篇文章 上 次 在: [2006年01月28日11:41:18 星期六] 从 [162.105.120.91] 到本站一游。
梦石
0
星屑
42345
在线时间
6022 小时
注册时间
2006-11-10
回帖
6975
发表于 2022-11-21 10:02:25 | 显示全部楼层
正好是我需要的, 猫大威武

20种描绘图形很够用了, 不过还少了一种 "粘贴入" , 即 将 bitmapA 传送入 bitmapB 非空白像素里的绘制, 我曾经用 循环X和Y逐点blt的方式画入, 太没效率, 猫大能有更效率的方法么?

回复

使用道具 举报

遠航の猫咪

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

开拓者

 楼主| 发表于 2022-11-21 10:21:23 | 显示全部楼层
灯笼菜刀王 发表于 2022-11-21 10:02
正好是我需要的, 猫大威武

20种描绘图形很够用了, 不过还少了一种 "粘贴入" , 即 将 bit ...

blt系的那些指令就是叠加粘贴啊,甚至你可以指定叠加不透明度的
bitmapB.blt_ellipse(x, y, rx, ry, bitmapA, x0, y0, opacity)
将bitmapA以x0,y0为圆心,rx, ry为长短轴的椭圆传送到bitmapB以x,y为圆心的位置
你看一下实现就知道,除了被blt的那些东西,并没有什么原来的像素被清除掉。

如果说真缺什么功能,那就是缺异型的stretch_blt,但这个我真的做不到,效率太低了。

点评

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

使用道具 举报

老黄鸡

梦石
4
星屑
46133
在线时间
7978 小时
注册时间
2009-7-6
回帖
13342

MZ评测员RM创作大赛01组委会开拓者贵宾

发表于 2022-11-21 11:50:39 | 显示全部楼层
很清晰地展示了各个方法的实现是最有参考价值的
不过效率方面一直是个麻烦的难题
RGDirect - DirectX驱动的RGSS,点我了解.
(排满,暂停)RM全系列成套系统定制请联系QQ1213237796
不接受对其他插件维护的委托
回复

使用道具 举报

梦石
2
星屑
13784
在线时间
2319 小时
注册时间
2011-6-4
回帖
586
发表于 2022-11-21 17:30:59 | 显示全部楼层
强大如猫佬
回复

使用道具 举报

梦石
0
星屑
39336
在线时间
11161 小时
注册时间
2009-3-15
回帖
4768
发表于 2022-11-21 18:07:02 | 显示全部楼层
有没拋物线的画法
回复

使用道具 举报

梦石
0
星屑
2349
在线时间
326 小时
注册时间
2018-7-12
回帖
379
发表于 2022-11-21 19:35:10 | 显示全部楼层
环形计量槽是个非常有意思的设定,欲望之花开发初期也准备使用环形计量槽来着,但当时只使用切图和位移的手法来伪造环形,看样子现在有全新的处理方式了
回复 0 1

使用道具 举报

梦石
0
星屑
923
在线时间
125 小时
注册时间
2014-12-5
回帖
95
发表于 2023-1-26 03:36:35 | 显示全部楼层
有没有范例工程?

点评

没有  发表于 2023-1-26 11:29
回复

使用道具 举报

梦石
0
星屑
5566
在线时间
274 小时
注册时间
2022-12-18
回帖
286
发表于 2023-1-26 15:59:56 | 显示全部楼层
很好很强大
回复

使用道具 举报

梦石
0
星屑
8201
在线时间
1331 小时
注册时间
2006-7-18
回帖
460
发表于 2023-1-26 16:35:37 | 显示全部楼层
有没有教学,例子啊!
回复

使用道具 举报

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

本版积分规则

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

在本版发帖返回顶部