【算法】在文曲星平台上，用gvmaker实现3D场景渲染！（附：文曲星GVMaker开发环境下载，GVMaker模拟器下载，源码下载）

0xAA55

注：本文所指的“文曲星”是“文曲星A2008”机型。。




    文曲星不支持浮点数运算，而且运行也十分缓慢——其实不是文曲星慢，而是它上面运行的gvmaker虚拟机太慢了。所以我使用定点数来代替浮点数进行运算。

    所谓定点数，就是小数点位置被固定到指定位置的一种数据类型，比如我存储1.0，对于定点数，我把小数点固定在第10位，那么我实际存储的数值就是0x400（十进制1024）。这样的话，我的定点数的精度，最低也是1/1024。

    定点数的加减法和整数无异，直接+ - 就好。但乘除法的话，如果你用一个定点数去乘一个定点数，并且你直接用的是整数的乘法的处理方式的话，你需要把得到的积再除以定点数表示的1.0，你才能得到正确的结果。比如你的定点数1.0用整数方式存储是1024的话，为了得到2.0 * 2.0 = 4.0的效果，你实际做的整数乘法是2048 * 2048，得到的是4194304，你需要再除以1024（也就是你的定点数的1.0），你才能得到4096。同理除法也需要经过这样的处理，只不过除法是先让被除数乘上定点数1.0，再除以除数。比如1.0 / 2.0 = 0.5，用定点数做运算的话，就是1024 * 1024 / 2048 = 512。

    和浮点数做对比，定点数运算比较快，并且它的精度是可控的——因为浮点数的小数点位置是浮动的，它的精度与数值的大小有密切的关系，所以用定点数能保证精度的统一，而浮点数则不能。

    但定点数的缺点在于做乘除法的时候，会严重地损失精度，尤其是圆周率，32位浮点数能存储3.1415927，而定点数假设小数点在第10位，那么它只能用 3216 来表示圆周率（3216 = π×1024 取整）。而如果我把小数点放在第16位的位置上（1.0用65536表示）的话，我虽然能精确到1/65536，但我能存储的最大的数值也从之前的4294966272变成了65536，而且我每次做乘除法的时候，我都要用一个64位的整数来存储中间值，这会严重降低运算的效率（然而x86平台还好）。

    有关3D渲染的算法，其实就是很简单的矩阵变换和投影，其它并没有什么玄妙。顺带一提，很多人以为用了DirectX或者OpenGL才能算真3D，但其实3D渲染的“真伪”只取决于你用的算法，和你使用的媒介无关。事实上就算你用的是正交投影，某种程度上也算是“真3D”的。我之前就写过一篇帖子，讲如何用VB自带的Line进行3D画面的绘制的。

    文曲星运行用户程序，用的是一款叫“gvmaker”的开发环境，和它的启动器。这里放出下载：
gvmaker开发环境： GVmaker2.4开发环境_20071011_113832.rar (6.08 MB, 下载次数: 21)

2017-3-16 23:14 上传

点击文件名下载附件

文曲星端的gvmaker启动器： GVM2008.prg (69.67 KB, 下载次数: 9)

2017-3-17 12:07 上传

点击文件名下载附件

源码：（320x240，64K色）

1. 
   
2. #define FIXED 1024
   
3. #define FIXED_SHIFT 10
   
4. #define MSTACK_SIZE 16 // 矩阵栈的大小
   
5. 
   
6. #define VP_WIDTH 320
   
7. #define VP_HEIGHT 240
   
8. 
   
9. #define VP_CENTERX 160
   
10. #define VP_CENTERY 120
    
11. 
    
12. #define VP_RIGHT 319
    
13. #define VP_BOTTOM 239
    
14. 
    
15. // 触屏判断
    
16. struct point
    
17. {
    
18.         int x;
    
19.         int y;
    
20. };
    
21. struct point pt;
    
22. struct point pt_old;
    
23. 
    
24. //向量
    
25. struct vec3
    
26. {
    
27.         long x,y,z;
    
28. };
    
29. 
    
30. struct vec4
    
31. {
    
32.         long x,y,z,w;
    
33. };
    
34. 
    
35. // 矩阵
    
36. struct mat4
    
37. {
    
38.         struct vec4 x,y,z,w;
    
39. };
    
40. 
    
41. // 矩阵栈
    
42. struct mat4 m_stack[MSTACK_SIZE];
    
43. int m_stacktop; // 栈顶
    
44. struct mat4 m; // 临时矩阵（gvmaker不能把结构体变量作为局部变量定义）
    
45. struct mat4 m_modelview; // 模型矩阵
    
46. struct mat4 m_projection; // 投影矩阵
    
47. 
    
48. struct vec3 eye_pos; // 眼睛位置
    
49. long eye_yaw, eye_pitch; // 眼睛角度
    
50. struct vec3 eye_xaxis; // 眼睛右方向
    
51. struct vec3 eye_yaxis; // 眼睛上方向
    
52. struct vec3 eye_zaxis; // 眼睛前方向
    
53. 
    
54. long time_global; // 全局时间
    
55. long time_delta; // 帧时间
    
56. 
    
57. void mat_init();
    
58. void mat_push();
    
59. void mat_pop();
    
60. void mat_mult();
    
61. void mat_transpose();
    
62. void mat_load_identity();
    
63. void mat_load_RotXAxis(long deg);
    
64. void mat_load_RotYAxis(long deg);
    
65. void mat_load_RotZAxis(long deg);
    
66. void mat_load_RotAxis(long ax, long ay, long az, long deg);
    
67. void mat_load_EulerRotation(long yaw, long pitch, long roll);
    
68. void mat_load_view_lh(long x, long y, long z, long yaw, long pitch, long roll);
    
69. void mat_load_perspective_lh(long fovy, long aspect, long zn, long zf);
    
70. void mat_load_modelview();
    
71. void mat_load_projection();
    
72. void mat_set_modelview();
    
73. void mat_set_projection();
    
74. void mat_print(int x, int y);
    
75. 
    
76. long tan(long deg)
    
77. {
    
78.         return (sin(deg) << FIXED_SHIFT) / cos(deg);
    
79. }
    
80. 
    
81. long cot(long deg)
    
82. {
    
83.         return (cos(deg) << FIXED_SHIFT) / sin(deg);
    
84. }
    
85. 
    
86. // 初始化矩阵栈
    
87. void mat_init()
    
88. {
    
89.         m_stacktop = 0;
    
90.         mat_load_identity();
    
91. }
    
92. 
    
93. // 压入新矩阵
    
94. void mat_push()
    
95. {
    
96.         m_stacktop = (m_stacktop + 1) % MSTACK_SIZE;
    
97. }
    
98. 
    
99. // 压入栈顶
    
100. void mat_pushtop()
     
101. {
     
102.         int prev;
     
103.         prev = m_stacktop;
     
104.         m_stacktop = (m_stacktop + 1) % MSTACK_SIZE;
     
105.         memcpy(&m_stack[m_stacktop].x.x, &m_stack[prev].x.x, 64);
     
106. }
     
107. 
     
108. // 弹出矩阵
     
109. void mat_pop()
     
110. {
     
111.         m_stacktop = m_stacktop - 1;
     
112.         if(m_stacktop < 0)
     
113.                 m_stacktop = m_stacktop + MSTACK_SIZE;
     
114. }
     
115. 
     
116. // 将栈顶两个矩阵做矩阵乘法
     
117. void mat_mult()
     
118. {
     
119.         long ptr2;
     
120.         ptr2 = m_stacktop;
     
121.         mat_pop();
     
122. 
     
123.         m.x.x = (m_stack[m_stacktop].x.x * m_stack[ptr2].x.x >> FIXED_SHIFT) + (m_stack[m_stacktop].x.y * m_stack[ptr2].y.x >> FIXED_SHIFT) + (m_stack[m_stacktop].x.z * m_stack[ptr2].z.x >> FIXED_SHIFT) + (m_stack[m_stacktop].x.w * m_stack[ptr2].w.x >> FIXED_SHIFT);
     
124.         m.x.y = (m_stack[m_stacktop].x.x * m_stack[ptr2].x.y >> FIXED_SHIFT) + (m_stack[m_stacktop].x.y * m_stack[ptr2].y.y >> FIXED_SHIFT) + (m_stack[m_stacktop].x.z * m_stack[ptr2].z.y >> FIXED_SHIFT) + (m_stack[m_stacktop].x.w * m_stack[ptr2].w.y >> FIXED_SHIFT);
     
125.         m.x.z = (m_stack[m_stacktop].x.x * m_stack[ptr2].x.z >> FIXED_SHIFT) + (m_stack[m_stacktop].x.y * m_stack[ptr2].y.z >> FIXED_SHIFT) + (m_stack[m_stacktop].x.z * m_stack[ptr2].z.z >> FIXED_SHIFT) + (m_stack[m_stacktop].x.w * m_stack[ptr2].w.z >> FIXED_SHIFT);
     
126.         m.x.w = (m_stack[m_stacktop].x.x * m_stack[ptr2].x.w >> FIXED_SHIFT) + (m_stack[m_stacktop].x.y * m_stack[ptr2].y.w >> FIXED_SHIFT) + (m_stack[m_stacktop].x.z * m_stack[ptr2].z.w >> FIXED_SHIFT) + (m_stack[m_stacktop].x.w * m_stack[ptr2].w.w >> FIXED_SHIFT);
     
127. 
     
128.         m.y.x = (m_stack[m_stacktop].y.x * m_stack[ptr2].x.x >> FIXED_SHIFT) + (m_stack[m_stacktop].y.y * m_stack[ptr2].y.x >> FIXED_SHIFT) + (m_stack[m_stacktop].y.z * m_stack[ptr2].z.x >> FIXED_SHIFT) + (m_stack[m_stacktop].y.w * m_stack[ptr2].w.x >> FIXED_SHIFT);
     
129.         m.y.y = (m_stack[m_stacktop].y.x * m_stack[ptr2].x.y >> FIXED_SHIFT) + (m_stack[m_stacktop].y.y * m_stack[ptr2].y.y >> FIXED_SHIFT) + (m_stack[m_stacktop].y.z * m_stack[ptr2].z.y >> FIXED_SHIFT) + (m_stack[m_stacktop].y.w * m_stack[ptr2].w.y >> FIXED_SHIFT);
     
130.         m.y.z = (m_stack[m_stacktop].y.x * m_stack[ptr2].x.z >> FIXED_SHIFT) + (m_stack[m_stacktop].y.y * m_stack[ptr2].y.z >> FIXED_SHIFT) + (m_stack[m_stacktop].y.z * m_stack[ptr2].z.z >> FIXED_SHIFT) + (m_stack[m_stacktop].y.w * m_stack[ptr2].w.z >> FIXED_SHIFT);
     
131.         m.y.w = (m_stack[m_stacktop].y.x * m_stack[ptr2].x.w >> FIXED_SHIFT) + (m_stack[m_stacktop].y.y * m_stack[ptr2].y.w >> FIXED_SHIFT) + (m_stack[m_stacktop].y.z * m_stack[ptr2].z.w >> FIXED_SHIFT) + (m_stack[m_stacktop].y.w * m_stack[ptr2].w.w >> FIXED_SHIFT);
     
132. 
     
133.         m.z.x = (m_stack[m_stacktop].z.x * m_stack[ptr2].x.x >> FIXED_SHIFT) + (m_stack[m_stacktop].z.y * m_stack[ptr2].y.x >> FIXED_SHIFT) + (m_stack[m_stacktop].z.z * m_stack[ptr2].z.x >> FIXED_SHIFT) + (m_stack[m_stacktop].z.w * m_stack[ptr2].w.x >> FIXED_SHIFT);
     
134.         m.z.y = (m_stack[m_stacktop].z.x * m_stack[ptr2].x.y >> FIXED_SHIFT) + (m_stack[m_stacktop].z.y * m_stack[ptr2].y.y >> FIXED_SHIFT) + (m_stack[m_stacktop].z.z * m_stack[ptr2].z.y >> FIXED_SHIFT) + (m_stack[m_stacktop].z.w * m_stack[ptr2].w.y >> FIXED_SHIFT);
     
135.         m.z.z = (m_stack[m_stacktop].z.x * m_stack[ptr2].x.z >> FIXED_SHIFT) + (m_stack[m_stacktop].z.y * m_stack[ptr2].y.z >> FIXED_SHIFT) + (m_stack[m_stacktop].z.z * m_stack[ptr2].z.z >> FIXED_SHIFT) + (m_stack[m_stacktop].z.w * m_stack[ptr2].w.z >> FIXED_SHIFT);
     
136.         m.z.w = (m_stack[m_stacktop].z.x * m_stack[ptr2].x.w >> FIXED_SHIFT) + (m_stack[m_stacktop].z.y * m_stack[ptr2].y.w >> FIXED_SHIFT) + (m_stack[m_stacktop].z.z * m_stack[ptr2].z.w >> FIXED_SHIFT) + (m_stack[m_stacktop].z.w * m_stack[ptr2].w.w >> FIXED_SHIFT);
     
137. 
     
138.         m.w.x = (m_stack[m_stacktop].w.x * m_stack[ptr2].x.x >> FIXED_SHIFT) + (m_stack[m_stacktop].w.y * m_stack[ptr2].y.x >> FIXED_SHIFT) + (m_stack[m_stacktop].w.z * m_stack[ptr2].z.x >> FIXED_SHIFT) + (m_stack[m_stacktop].w.w * m_stack[ptr2].w.x >> FIXED_SHIFT);
     
139.         m.w.y = (m_stack[m_stacktop].w.x * m_stack[ptr2].x.y >> FIXED_SHIFT) + (m_stack[m_stacktop].w.y * m_stack[ptr2].y.y >> FIXED_SHIFT) + (m_stack[m_stacktop].w.z * m_stack[ptr2].z.y >> FIXED_SHIFT) + (m_stack[m_stacktop].w.w * m_stack[ptr2].w.y >> FIXED_SHIFT);
     
140.         m.w.z = (m_stack[m_stacktop].w.x * m_stack[ptr2].x.z >> FIXED_SHIFT) + (m_stack[m_stacktop].w.y * m_stack[ptr2].y.z >> FIXED_SHIFT) + (m_stack[m_stacktop].w.z * m_stack[ptr2].z.z >> FIXED_SHIFT) + (m_stack[m_stacktop].w.w * m_stack[ptr2].w.z >> FIXED_SHIFT);
     
141.         m.w.w = (m_stack[m_stacktop].w.x * m_stack[ptr2].x.w >> FIXED_SHIFT) + (m_stack[m_stacktop].w.y * m_stack[ptr2].y.w >> FIXED_SHIFT) + (m_stack[m_stacktop].w.z * m_stack[ptr2].z.w >> FIXED_SHIFT) + (m_stack[m_stacktop].w.w * m_stack[ptr2].w.w >> FIXED_SHIFT);
     
142.        
     
143.         memcpy(&m_stack[m_stacktop].x.x, &m.x.x, 64);
     
144. }
     
145. 
     
146. // 矩阵转置
     
147. void mat_transpose()
     
148. {
     
149.         long t;
     
150.        
     
151.         t = m_stack[m_stacktop].x.y;
     
152.         m_stack[m_stacktop].x.y = m_stack[m_stacktop].y.x;
     
153.         m_stack[m_stacktop].y.x = t;
     
154.        
     
155.         t = m_stack[m_stacktop].x.z;
     
156.         m_stack[m_stacktop].x.z = m_stack[m_stacktop].z.x;
     
157.         m_stack[m_stacktop].z.x = t;
     
158.        
     
159.         t = m_stack[m_stacktop].x.w;
     
160.         m_stack[m_stacktop].x.w = m_stack[m_stacktop].w.x;
     
161.         m_stack[m_stacktop].w.x = t;
     
162.        
     
163.         t = m_stack[m_stacktop].y.z;
     
164.         m_stack[m_stacktop].y.z = m_stack[m_stacktop].z.y;
     
165.         m_stack[m_stacktop].z.y = t;
     
166.        
     
167.         t = m_stack[m_stacktop].y.w;
     
168.         m_stack[m_stacktop].y.w = m_stack[m_stacktop].w.y;
     
169.         m_stack[m_stacktop].w.y = t;
     
170.        
     
171.         t = m_stack[m_stacktop].z.w;
     
172.         m_stack[m_stacktop].z.w = m_stack[m_stacktop].w.z;
     
173.         m_stack[m_stacktop].w.z = t;
     
174. }
     
175. 
     
176. // 载入单位矩阵
     
177. void mat_load_identity()
     
178. {
     
179.         m_stack[m_stacktop].x.x=FIXED;m_stack[m_stacktop].x.y=0;m_stack[m_stacktop].x.z=0;m_stack[m_stacktop].x.w=0;
     
180.         m_stack[m_stacktop].y.y=FIXED;m_stack[m_stacktop].y.x=0;m_stack[m_stacktop].y.z=0;m_stack[m_stacktop].y.w=0;
     
181.         m_stack[m_stacktop].z.z=FIXED;m_stack[m_stacktop].z.x=0;m_stack[m_stacktop].z.y=0;m_stack[m_stacktop].z.w=0;
     
182.         m_stack[m_stacktop].w.w=FIXED;m_stack[m_stacktop].w.x=0;m_stack[m_stacktop].w.y=0;m_stack[m_stacktop].w.z=0;
     
183. }
     
184. 
     
185. // 载入平移矩阵
     
186. void mat_load_translate(long x, long y, long z)
     
187. {
     
188.         m_stack[m_stacktop].x.x=FIXED;m_stack[m_stacktop].x.y=0;m_stack[m_stacktop].x.z=0;m_stack[m_stacktop].x.w=0;
     
189.         m_stack[m_stacktop].y.y=FIXED;m_stack[m_stacktop].y.x=0;m_stack[m_stacktop].y.z=0;m_stack[m_stacktop].y.w=0;
     
190.         m_stack[m_stacktop].z.z=FIXED;m_stack[m_stacktop].z.x=0;m_stack[m_stacktop].z.y=0;m_stack[m_stacktop].z.w=0;
     
191.         m_stack[m_stacktop].w.w=FIXED;m_stack[m_stacktop].w.x=x;m_stack[m_stacktop].w.y=y;m_stack[m_stacktop].w.z=z;
     
192. }
     
193. 
     
194. // 载入绕X轴旋转矩阵
     
195. void mat_load_RotXAxis(long deg)
     
196. {
     
197.         m_stack[m_stacktop].x.x = FIXED;
     
198.         m_stack[m_stacktop].x.y = 0;
     
199.         m_stack[m_stacktop].x.z = 0;
     
200.         m_stack[m_stacktop].x.w = 0;
     
201.        
     
202.         m_stack[m_stacktop].y.x = 0;
     
203.         m_stack[m_stacktop].y.y = cos(deg);
     
204.         m_stack[m_stacktop].y.z =-sin(deg);
     
205.         m_stack[m_stacktop].y.w = 0;
     
206.        
     
207.         m_stack[m_stacktop].z.x = 0;
     
208.         m_stack[m_stacktop].z.y = sin(deg);
     
209.         m_stack[m_stacktop].z.z = cos(deg);
     
210.         m_stack[m_stacktop].z.w = 0;
     
211.        
     
212.         m_stack[m_stacktop].w.x = 0;
     
213.         m_stack[m_stacktop].w.y = 0;
     
214.         m_stack[m_stacktop].w.z = 0;
     
215.         m_stack[m_stacktop].w.w = FIXED;
     
216. }
     
217. 
     
218. // 载入绕Y轴旋转矩阵
     
219. void mat_load_RotYAxis(long deg)
     
220. {
     
221.         m_stack[m_stacktop].x.x = cos(deg);
     
222.         m_stack[m_stacktop].x.y = 0;
     
223.         m_stack[m_stacktop].x.z = sin(deg);
     
224.         m_stack[m_stacktop].x.w = 0;
     
225.        
     
226.         m_stack[m_stacktop].y.x = 0;
     
227.         m_stack[m_stacktop].y.y = FIXED;
     
228.         m_stack[m_stacktop].y.z = 0;
     
229.         m_stack[m_stacktop].y.w = 0;
     
230.        
     
231.         m_stack[m_stacktop].z.x =-sin(deg);
     
232.         m_stack[m_stacktop].z.y = 0;
     
233.         m_stack[m_stacktop].z.z = cos(deg);
     
234.         m_stack[m_stacktop].z.w = 0;
     
235.        
     
236.         m_stack[m_stacktop].w.x = 0;
     
237.         m_stack[m_stacktop].w.y = 0;
     
238.         m_stack[m_stacktop].w.z = 0;
     
239.         m_stack[m_stacktop].w.w = FIXED;
     
240. }
     
241. 
     
242. // 载入绕Z轴旋转矩阵
     
243. void mat_load_RotZAxis(long deg)
     
244. {
     
245.         m_stack[m_stacktop].x.x = cos(deg);
     
246.         m_stack[m_stacktop].x.y = sin(deg);
     
247.         m_stack[m_stacktop].x.z = 0;
     
248.         m_stack[m_stacktop].x.w = 0;
     
249.        
     
250.         m_stack[m_stacktop].y.x =-sin(deg);
     
251.         m_stack[m_stacktop].y.y = cos(deg);
     
252.         m_stack[m_stacktop].y.z = 0;
     
253.         m_stack[m_stacktop].y.w = 0;
     
254.        
     
255.         m_stack[m_stacktop].z.x = 0;
     
256.         m_stack[m_stacktop].z.y = 0;
     
257.         m_stack[m_stacktop].z.z = FIXED;
     
258.         m_stack[m_stacktop].z.w = 0;
     
259.        
     
260.         m_stack[m_stacktop].w.x = 0;
     
261.         m_stack[m_stacktop].w.y = 0;
     
262.         m_stack[m_stacktop].w.z = 0;
     
263.         m_stack[m_stacktop].w.w = FIXED;
     
264. }
     
265. 
     
266. // 载入绕轴旋转矩阵
     
267. void mat_load_RotAxis(long ax, long ay, long az, long deg)
     
268. {
     
269.         m_stack[m_stacktop].x.x = (((FIXED - cos(deg)) * ax >> FIXED_SHIFT) * ax >> FIXED_SHIFT) + cos(deg);
     
270.         m_stack[m_stacktop].x.y = (((FIXED - cos(deg)) * ax >> FIXED_SHIFT) * ay >> FIXED_SHIFT) - sin(deg) * az >> FIXED_SHIFT;
     
271.         m_stack[m_stacktop].x.z = (((FIXED - cos(deg)) * ax >> FIXED_SHIFT) * az >> FIXED_SHIFT) + sin(deg) * ay >> FIXED_SHIFT;
     
272.         m_stack[m_stacktop].x.w = 0;
     
273.                                   
     
274.         m_stack[m_stacktop].y.x = (((FIXED - cos(deg)) * ay >> FIXED_SHIFT) * ax >> FIXED_SHIFT) + sin(deg) * az >> FIXED_SHIFT;
     
275.         m_stack[m_stacktop].y.y = (((FIXED - cos(deg)) * ay >> FIXED_SHIFT) * ay >> FIXED_SHIFT) + cos(deg);
     
276.         m_stack[m_stacktop].y.z = (((FIXED - cos(deg)) * ay >> FIXED_SHIFT) * az >> FIXED_SHIFT) - sin(deg) * ax >> FIXED_SHIFT;
     
277.         m_stack[m_stacktop].y.w = 0;
     
278.                                   
     
279.         m_stack[m_stacktop].z.x = (((FIXED - cos(deg)) * az >> FIXED_SHIFT) * ax >> FIXED_SHIFT) - sin(deg) * ay >> FIXED_SHIFT;
     
280.         m_stack[m_stacktop].z.y = (((FIXED - cos(deg)) * az >> FIXED_SHIFT) * ay >> FIXED_SHIFT) + sin(deg) * ax >> FIXED_SHIFT;
     
281.         m_stack[m_stacktop].z.z = (((FIXED - cos(deg)) * az >> FIXED_SHIFT) * az >> FIXED_SHIFT) + cos(deg);
     
282.         m_stack[m_stacktop].z.w = 0;
     
283.        
     
284.         m_stack[m_stacktop].w.x = 0;
     
285.         m_stack[m_stacktop].w.y = 0;
     
286.         m_stack[m_stacktop].w.z = 0;
     
287.         m_stack[m_stacktop].w.w = FIXED;
     
288. }
     
289. 
     
290. // 载入欧拉角旋转矩阵
     
291. void mat_load_EulerRotation(long yaw, long pitch, long roll)
     
292. {
     
293.         mat_load_RotZAxis(roll);
     
294.        
     
295.         mat_push();
     
296.         mat_load_RotXAxis(pitch);
     
297.        
     
298.         mat_mult();
     
299.        
     
300.         mat_push();
     
301.         mat_load_RotYAxis(yaw);
     
302.        
     
303.         mat_mult();
     
304. }
     
305. 
     
306. // 载入左手坐标系观察矩阵
     
307. void mat_load_view_lh(long x, long y, long z, long yaw, long pitch, long roll)
     
308. {
     
309.         long t;
     
310.         mat_load_EulerRotation(yaw, pitch, roll);
     
311.        
     
312.         eye_xaxis.x = m_stack[m_stacktop].x.x;
     
313.         eye_xaxis.y = m_stack[m_stacktop].x.y;
     
314.         eye_xaxis.z = m_stack[m_stacktop].x.z;
     
315.         eye_yaxis.x = m_stack[m_stacktop].y.x;
     
316.         eye_yaxis.y = m_stack[m_stacktop].y.y;
     
317.         eye_yaxis.z = m_stack[m_stacktop].y.z;
     
318.         eye_zaxis.x = m_stack[m_stacktop].z.x;
     
319.         eye_zaxis.y = m_stack[m_stacktop].z.y;
     
320.         eye_zaxis.z = m_stack[m_stacktop].z.z;
     
321.        
     
322.         m_stack[m_stacktop].w.x = -((eye_xaxis.x * x >> FIXED_SHIFT) + (eye_xaxis.y * y >> FIXED_SHIFT) + (eye_xaxis.z * z >> FIXED_SHIFT));
     
323.         m_stack[m_stacktop].w.y = -((eye_yaxis.x * x >> FIXED_SHIFT) + (eye_yaxis.y * y >> FIXED_SHIFT) + (eye_yaxis.z * z >> FIXED_SHIFT));
     
324.         m_stack[m_stacktop].w.z = -((eye_zaxis.x * x >> FIXED_SHIFT) + (eye_zaxis.y * y >> FIXED_SHIFT) + (eye_zaxis.z * z >> FIXED_SHIFT));
     
325.         m_stack[m_stacktop].w.w = FIXED;
     
326.        
     
327.         t = m_stack[m_stacktop].x.y;
     
328.         m_stack[m_stacktop].x.y = m_stack[m_stacktop].y.x;
     
329.         m_stack[m_stacktop].y.x = t;
     
330.        
     
331.         t = m_stack[m_stacktop].x.z;
     
332.         m_stack[m_stacktop].x.z = m_stack[m_stacktop].z.x;
     
333.         m_stack[m_stacktop].z.x = t;
     
334.        
     
335.         t = m_stack[m_stacktop].y.z;
     
336.         m_stack[m_stacktop].y.z = m_stack[m_stacktop].z.y;
     
337.         m_stack[m_stacktop].z.y = t;
     
338.        
     
339.         m_stack[m_stacktop].x.w = 0;
     
340.         m_stack[m_stacktop].y.w = 0;
     
341.         m_stack[m_stacktop].z.w = 0;
     
342. }
     
343. 
     
344. // 载入左手坐标系投影矩阵
     
345. void mat_load_perspective_lh(long fovy, long aspect, long zn, long zf)
     
346. {
     
347.         long xscale,yscale;
     
348.         long zdiff;
     
349.         zdiff = zf-zn;
     
350.         yscale = cot(fovy / 2);
     
351.         xscale = (yscale << FIXED_SHIFT) / aspect;
     
352.         m_stack[m_stacktop].x.x = xscale; m_stack[m_stacktop].x.y = 0; m_stack[m_stacktop].x.z = 0; m_stack[m_stacktop].x.w = 0;
     
353.         m_stack[m_stacktop].y.x = 0; m_stack[m_stacktop].y.y = yscale; m_stack[m_stacktop].y.z = 0; m_stack[m_stacktop].y.w = 0;
     
354.         m_stack[m_stacktop].z.x = 0; m_stack[m_stacktop].z.y = 0; m_stack[m_stacktop].z.z = (zf<<FIXED_SHIFT)/zdiff; m_stack[m_stacktop].z.w = FIXED;
     
355.         m_stack[m_stacktop].w.x = 0; m_stack[m_stacktop].w.y = 0; m_stack[m_stacktop].w.z = -zn*zf/zdiff; m_stack[m_stacktop].w.w = 0;
     
356. }
     
357. 
     
358. // 将模型矩阵复制到栈顶
     
359. void mat_load_modelview()
     
360. {
     
361.         memcpy(&m_stack[m_stacktop].x.x, &m_modelview.x.x, 64);
     
362. }
     
363. 
     
364. // 将投影矩阵复制到栈顶
     
365. void mat_load_projection()
     
366. {
     
367.         memcpy(&m_stack[m_stacktop].x.x, &m_projection.x.x, 64);
     
368. }
     
369. 
     
370. // 将栈顶的矩阵复制到模型矩阵
     
371. void mat_set_modelview()
     
372. {
     
373.         memcpy(&m_modelview.x.x, &m_stack[m_stacktop].x.x, 64);
     
374. }
     
375. 
     
376. // 将栈顶的矩阵复制到投影矩阵
     
377. void mat_set_projection()
     
378. {
     
379.         memcpy(&m_projection.x.x, &m_stack[m_stacktop].x.x, 64);
     
380. }
     
381. 
     
382. // 打印矩阵的值到屏幕上
     
383. void mat_print(int x, int y)
     
384. {
     
385.         char buf[256];
     
386.         sprintf(buf, "%d:",m_stacktop);
     
387.         TextOut(x,y,buf);y=y+GetFontSize();
     
388.         sprintf(buf, "%d,%d,%d,%d", m_stack[m_stacktop].x.x,m_stack[m_stacktop].x.y,m_stack[m_stacktop].x.z,m_stack[m_stacktop].x.w);
     
389.         TextOut(x,y,buf);y=y+GetFontSize();
     
390.         sprintf(buf, "%d,%d,%d,%d", m_stack[m_stacktop].y.x,m_stack[m_stacktop].y.y,m_stack[m_stacktop].y.z,m_stack[m_stacktop].y.w);
     
391.         TextOut(x,y,buf);y=y+GetFontSize();
     
392.         sprintf(buf, "%d,%d,%d,%d", m_stack[m_stacktop].z.x,m_stack[m_stacktop].z.y,m_stack[m_stacktop].z.z,m_stack[m_stacktop].z.w);
     
393.         TextOut(x,y,buf);y=y+GetFontSize();
     
394.         sprintf(buf, "%d,%d,%d,%d", m_stack[m_stacktop].w.x,m_stack[m_stacktop].w.y,m_stack[m_stacktop].w.z,m_stack[m_stacktop].w.w);
     
395.         TextOut(x,y,buf);
     
396. }
     
397. 
     
398. // 线性插值
     
399. long m_lerp(long v1, long v2, long s)
     
400. {
     
401.         return v1 + ((v2 - v1) * s >> FIXED_SHIFT);
     
402. }
     
403. 
     
404. // 画线
     
405. void g_draw_line(long x1, long y1, long x2, long y2)
     
406. {
     
407.         // gvmaker原版的画线函数不能处理坐标超出屏幕外的情况
     
408.         // 所以要做一个插值处理
     
409.         if(x1 < 0)
     
410.         {
     
411.                 if(x2 < 0)
     
412.                         return; // 防止除零异常
     
413.                 y1 = y1 + (y2 - y1) *-x1 / (x2 - x1);
     
414.                 x1 = 0;
     
415.         }
     
416.         if(y1 < 0)
     
417.         {
     
418.                 if(y2 < 0)
     
419.                         return;
     
420.                 x1 = x1 + (x2 - x1) *-y1 / (y2 - y1);
     
421.                 y1 = 0;
     
422.         }
     
423.         if(x2 < 0)
     
424.         {
     
425.                 if(x1 <= 0)
     
426.                         return;
     
427.                 y2 = y2 + (y1 - y2) *-x2 / (x1 - x2);
     
428.                 x2 = 0;
     
429.         }
     
430.         if(y2 < 0)
     
431.         {
     
432.                 if(y1 <= 0)
     
433.                         return;
     
434.                 x2 = x2 + (x1 - x2) *-y2 / (y1 - y2);
     
435.                 y2 = 0;
     
436.         }
     
437.         if(x1 > VP_RIGHT)
     
438.         {
     
439.                 if(x2 > VP_RIGHT)
     
440.                         return;
     
441.                 y1 = y1 + (y2 - y1) * (x1 - VP_RIGHT) / (x1 - x2);
     
442.                 x1 = VP_RIGHT;
     
443.         }
     
444.         if(y1 > VP_BOTTOM)
     
445.         {
     
446.                 if(y2 > VP_BOTTOM)
     
447.                         return;
     
448.                 x1 = x1 + (x2 - x1) * (y1 - VP_BOTTOM) / (y1 - y2);
     
449.                 y1 = VP_BOTTOM;
     
450.         }
     
451.         if(x2 > VP_RIGHT)
     
452.         {
     
453.                 if(x1 >= VP_RIGHT)
     
454.                         return;
     
455.                 y2 = y2 + (y1 - y2) * (x2 - VP_RIGHT) / (x2 - x1);
     
456.                 x2 = VP_RIGHT;
     
457.         }
     
458.         if(y2 > VP_BOTTOM)
     
459.         {
     
460.                 if(y1 >= VP_BOTTOM)
     
461.                         return;
     
462.                 x2 = x2 + (x1 - x2) * (y2 - VP_BOTTOM) / (y2 - y1);
     
463.                 y2 = VP_BOTTOM;
     
464.         }
     
465.         if(x1 == x2)
     
466.                 VLine(x1, y1, y2);
     
467.         else if(y1 == y2)
     
468.                 HLine(x1, x2, y1);
     
469.         else
     
470.                 Line(x1,y1,x2,y2);
     
471. }
     
472. 
     
473. // 画3D线，坐标将经过矩阵变换和投影处理。
     
474. void g_draw_3d_line(long x1, long y1, long z1, long x2, long y2, long z2)
     
475. {
     
476.         long pxt, pyt, pzt, pwt; // 临时坐标
     
477.         long px1, py1, pz1, pw1; // 坐标1
     
478.         long px2, py2, pz2, pw2; // 坐标2
     
479.         long ls;
     
480.        
     
481.         pxt = (x1 * m_modelview.x.x >> FIXED_SHIFT) + (y1 * m_modelview.y.x >> FIXED_SHIFT) + (z1 * m_modelview.z.x >> FIXED_SHIFT) + m_modelview.w.x;
     
482.         pyt = (x1 * m_modelview.x.y >> FIXED_SHIFT) + (y1 * m_modelview.y.y >> FIXED_SHIFT) + (z1 * m_modelview.z.y >> FIXED_SHIFT) + m_modelview.w.y;
     
483.         pzt = (x1 * m_modelview.x.z >> FIXED_SHIFT) + (y1 * m_modelview.y.z >> FIXED_SHIFT) + (z1 * m_modelview.z.z >> FIXED_SHIFT) + m_modelview.w.z;
     
484.         pwt = (x1 * m_modelview.x.w >> FIXED_SHIFT) + (y1 * m_modelview.y.w >> FIXED_SHIFT) + (z1 * m_modelview.z.w >> FIXED_SHIFT) + m_modelview.w.w;
     
485.        
     
486.         px1 = (pxt * m_projection.x.x >> FIXED_SHIFT) + (pyt * m_projection.y.x >> FIXED_SHIFT) + (pzt * m_projection.z.x >> FIXED_SHIFT) + (pwt * m_projection.w.x >> FIXED_SHIFT);
     
487.         py1 = (pxt * m_projection.x.y >> FIXED_SHIFT) + (pyt * m_projection.y.y >> FIXED_SHIFT) + (pzt * m_projection.z.y >> FIXED_SHIFT) + (pwt * m_projection.w.y >> FIXED_SHIFT);
     
488.         pz1 = (pxt * m_projection.x.z >> FIXED_SHIFT) + (pyt * m_projection.y.z >> FIXED_SHIFT) + (pzt * m_projection.z.z >> FIXED_SHIFT) + (pwt * m_projection.w.z >> FIXED_SHIFT);
     
489.         pw1 = (pxt * m_projection.x.w >> FIXED_SHIFT) + (pyt * m_projection.y.w >> FIXED_SHIFT) + (pzt * m_projection.z.w >> FIXED_SHIFT) + (pwt * m_projection.w.w >> FIXED_SHIFT);
     
490.        
     
491.         pxt = (x2 * m_modelview.x.x >> FIXED_SHIFT) + (y2 * m_modelview.y.x >> FIXED_SHIFT) + (z2 * m_modelview.z.x >> FIXED_SHIFT) + m_modelview.w.x;
     
492.         pyt = (x2 * m_modelview.x.y >> FIXED_SHIFT) + (y2 * m_modelview.y.y >> FIXED_SHIFT) + (z2 * m_modelview.z.y >> FIXED_SHIFT) + m_modelview.w.y;
     
493.         pzt = (x2 * m_modelview.x.z >> FIXED_SHIFT) + (y2 * m_modelview.y.z >> FIXED_SHIFT) + (z2 * m_modelview.z.z >> FIXED_SHIFT) + m_modelview.w.z;
     
494.         pwt = (x2 * m_modelview.x.w >> FIXED_SHIFT) + (y2 * m_modelview.y.w >> FIXED_SHIFT) + (z2 * m_modelview.z.w >> FIXED_SHIFT) + m_modelview.w.w;
     
495.        
     
496.         px2 = (pxt * m_projection.x.x >> FIXED_SHIFT) + (pyt * m_projection.y.x >> FIXED_SHIFT) + (pzt * m_projection.z.x >> FIXED_SHIFT) + (pwt * m_projection.w.x >> FIXED_SHIFT);
     
497.         py2 = (pxt * m_projection.x.y >> FIXED_SHIFT) + (pyt * m_projection.y.y >> FIXED_SHIFT) + (pzt * m_projection.z.y >> FIXED_SHIFT) + (pwt * m_projection.w.y >> FIXED_SHIFT);
     
498.         pz2 = (pxt * m_projection.x.z >> FIXED_SHIFT) + (pyt * m_projection.y.z >> FIXED_SHIFT) + (pzt * m_projection.z.z >> FIXED_SHIFT) + (pwt * m_projection.w.z >> FIXED_SHIFT);
     
499.         pw2 = (pxt * m_projection.x.w >> FIXED_SHIFT) + (pyt * m_projection.y.w >> FIXED_SHIFT) + (pzt * m_projection.z.w >> FIXED_SHIFT) + (pwt * m_projection.w.w >> FIXED_SHIFT);
     
500.        
     
501.         // 处理近视距剪切
     
502.         if(pz1 < FIXED)
     
503.         {
     
504.                 if(pz2 < FIXED)
     
505.                         return;
     
506.                
     
507.                 if(pz1 == pz2)
     
508.                         return;
     
509.                
     
510.                 ls = ((pz2 - FIXED) << FIXED_SHIFT) / (pz2 - pz1);
     
511.                
     
512.                 px1 = m_lerp(px2, px1, ls);
     
513.                 py1 = m_lerp(py2, py1, ls);
     
514.                 pz1 = m_lerp(pz2, pz1, ls);
     
515.                 pw1 = m_lerp(pw2, pw1, ls);
     
516.         }
     
517.        
     
518.         if(pz2 < FIXED)
     
519.         {
     
520.                 if(pz1 < FIXED)
     
521.                         return;
     
522.                
     
523.                 if(pz1 == pz2)
     
524.                         return;
     
525.                
     
526.                 ls = ((pz1 - FIXED) << FIXED_SHIFT) / (pz1 - pz2);
     
527.                
     
528.                 px2 = m_lerp(px1, px2, ls);
     
529.                 py2 = m_lerp(py1, py2, ls);
     
530.                 pz2 = m_lerp(pz1, pz2, ls);
     
531.                 pw2 = m_lerp(pw1, pw2, ls);
     
532.         }
     
533.        
     
534.         // 投影
     
535.         px1 = px1 * VP_CENTERX / pw1 + VP_CENTERX;
     
536.         py1 = VP_CENTERY - py1 * VP_CENTERY / pw1;
     
537.         px2 = px2 * VP_CENTERX / pw2 + VP_CENTERX;
     
538.         py2 = VP_CENTERY - py2 * VP_CENTERY / pw2;
     
539.         g_draw_line(px1,py1,px2,py2);
     
540. }
     
541. 
     
542. // 用线条画长方体
     
543. void g_draw_cube(long dx, long dy, long dz)
     
544. {
     
545.         // Up
     
546.         g_draw_3d_line(-dx, dy, dz, dx, dy, dz);
     
547.         g_draw_3d_line( dx, dy, dz, dx, dy,-dz);
     
548.         g_draw_3d_line( dx, dy,-dz,-dx, dy,-dz);
     
549.         g_draw_3d_line(-dx, dy,-dz,-dx, dy, dz);
     
550.        
     
551.         // Down
     
552.         g_draw_3d_line(-dx,-dy, dz, dx,-dy, dz);
     
553.         g_draw_3d_line( dx,-dy, dz, dx,-dy,-dz);
     
554.         g_draw_3d_line( dx,-dy,-dz,-dx,-dy,-dz);
     
555.         g_draw_3d_line(-dx,-dy,-dz,-dx,-dy, dz);
     
556.        
     
557.         // Pillars
     
558.         g_draw_3d_line(-dx, dy, dz,-dx,-dy, dz);
     
559.         g_draw_3d_line( dx, dy, dz, dx,-dy, dz);
     
560.         g_draw_3d_line( dx, dy,-dz, dx,-dy,-dz);
     
561.         g_draw_3d_line(-dx, dy,-dz,-dx,-dy,-dz);
     
562. }
     
563. 
     
564. // 输出16进制数
     
565. void XDigitOut(int x, int y, long digit)
     
566. {
     
567.         int ch;
     
568.         int w;
     
569.         int shifts;
     
570.        
     
571.         w = GetFontSize() / 2;
     
572.        
     
573.         if(!digit)
     
574.         {
     
575.                 TextOut(x, y, "00000000");
     
576.                 return;
     
577.         }
     
578.        
     
579.         x=x+w*7;
     
580.         shifts=32;
     
581.         while(shifts)
     
582.         {
     
583.                 ch=digit&0xF;
     
584.                 if(ch>=10)
     
585.                         CharOut(x, y, ch-10+'A');
     
586.                 else
     
587.                         CharOut(x, y, ch+'0');
     
588.                 x=x-w;
     
589.                 digit=digit>>4;
     
590.                 shifts=shifts-4;
     
591.         }
     
592. }
     
593. 
     
594. void main()
     
595. {
     
596.         long i;
     
597.         int x,y;
     
598.        
     
599.         SetFontSize(12);
     
600.         SetLCDMode(0);
     
601.        
     
602.         eye_pos.x=0;
     
603.         eye_pos.y=3 << FIXED_SHIFT;
     
604.         eye_pos.z=-10 << FIXED_SHIFT;
     
605.        
     
606.         mat_init();
     
607.        
     
608.         time_global = GetTickCount();
     
609.        
     
610.         for(;;)
     
611.         {
     
612.                 // 帧时间处理
     
613.                 i = GetTickCount();
     
614.                 time_delta = i - time_global;
     
615.                 time_global = i;
     
616.                
     
617.                 ClearScreen();
     
618.                
     
619.                 // 设置投影矩阵
     
620.                 mat_load_perspective_lh(60, (VP_WIDTH << FIXED_SHIFT) / VP_HEIGHT, FIXED, 1000 << FIXED_SHIFT);
     
621.                 mat_set_projection();
     
622.                
     
623.                 // 设置旋转立方体的矩阵
     
624.                 mat_load_RotYAxis(time_global * 60 / 1000);
     
625.                 mat_push();
     
626.                 mat_load_translate(0,FIXED,0);
     
627.                 mat_mult();
     
628.                 mat_push();
     
629.                 mat_load_view_lh(eye_pos.x, eye_pos.y, eye_pos.z, eye_yaw, eye_pitch, 0);
     
630.                 mat_mult();
     
631.                 mat_set_modelview();
     
632.                
     
633.                 // 画立方体
     
634.                 g_draw_cube(FIXED, FIXED, FIXED);
     
635.                
     
636.                 // 设置地面的矩阵
     
637.                 mat_load_view_lh(eye_pos.x, eye_pos.y, eye_pos.z, eye_yaw, eye_pitch, 0);
     
638.                 mat_set_modelview();
     
639.                
     
640.                 // 画地面
     
641.                 for(x = -10; x <= 10; x++)
     
642.                 {
     
643.                         g_draw_3d_line( x << FIXED_SHIFT, 0, 10 << FIXED_SHIFT, x << FIXED_SHIFT, 0, -10 << FIXED_SHIFT);
     
644.                 }
     
645.                 for(y = -10; y <= 10; y++)
     
646.                 {
     
647.                         g_draw_3d_line( 10 << FIXED_SHIFT, 0, y << FIXED_SHIFT,-10 << FIXED_SHIFT, 0, y << FIXED_SHIFT);
     
648.                 }
     
649.                
     
650.                 // 根据触屏操作来转动镜头
     
651.                 if(GetMousePos(pt) == 2)
     
652.                 {
     
653.                         eye_yaw = eye_yaw + pt_old.x - pt.x;
     
654.                         eye_pitch = eye_pitch + pt_old.y - pt.y;
     
655.                         if(eye_yaw < 0)
     
656.                                 eye_yaw = eye_yaw + 360;
     
657.                         if(eye_yaw > 360)
     
658.                                 eye_yaw = eye_yaw - 360;
     
659.                         if(eye_pitch < 0)
     
660.                                 eye_pitch = eye_pitch + 360;
     
661.                         if(eye_pitch > 360)
     
662.                                 eye_pitch = eye_pitch - 360;
     
663.                 }
     
664.                 pt_old.x = pt.x;
     
665.                 pt_old.y = pt.y;
     
666.                
     
667.                 // 键盘移动操作
     
668.                 if(CheckKey(KEY_LEFT))
     
669.                 {
     
670.                         eye_pos.x = eye_pos.x - eye_xaxis.x * time_delta * 10 / 1000;
     
671.                         eye_pos.y = eye_pos.y - eye_xaxis.y * time_delta * 10 / 1000;
     
672.                         eye_pos.z = eye_pos.z - eye_xaxis.z * time_delta * 10 / 1000;
     
673.                 }
     
674.                 if(CheckKey(KEY_RIGHT))
     
675.                 {
     
676.                         eye_pos.x = eye_pos.x + eye_xaxis.x * time_delta * 10 / 1000;
     
677.                         eye_pos.y = eye_pos.y + eye_xaxis.y * time_delta * 10 / 1000;
     
678.                         eye_pos.z = eye_pos.z + eye_xaxis.z * time_delta * 10 / 1000;
     
679.                 }
     
680.                 if(CheckKey(KEY_UP))
     
681.                 {
     
682.                         eye_pos.x = eye_pos.x + eye_zaxis.x * time_delta * 10 / 1000;
     
683.                         eye_pos.y = eye_pos.y + eye_zaxis.y * time_delta * 10 / 1000;
     
684.                         eye_pos.z = eye_pos.z + eye_zaxis.z * time_delta * 10 / 1000;
     
685.                 }
     
686.                 if(CheckKey(KEY_DOWN))
     
687.                 {
     
688.                         eye_pos.x = eye_pos.x - eye_zaxis.x * time_delta * 10 / 1000;
     
689.                         eye_pos.y = eye_pos.y - eye_zaxis.y * time_delta * 10 / 1000;
     
690.                         eye_pos.z = eye_pos.z - eye_zaxis.z * time_delta * 10 / 1000;
     
691.                 }
     
692.                
     
693.                 Refresh();
     
694.         }
     
695. }

复制代码

Src: main.txt (23.31 KB, 下载次数: 6)

2017-12-18 17:58 上传

点击文件名下载附件
阅读权限: 10

Bin: main.gvm (8.82 KB, 下载次数: 5)

2017-12-18 17:58 上传

点击文件名下载附件

Ayala

    但定点数的缺点在于做乘除法的时候，会严重地损失精度，尤其是圆周率，32位浮点数能存储3.1415927，而定点数假设小数点在第10位，那么它只能用 3216 来表示圆周率（3216 = π×1024 取整）。而如果我把小数点放在第16位的位置上（1.0用65536表示）的话，我虽然能精确到1/65536，但我能存储的最大的数值也从之前的4294966272变成了65536，而且我每次做乘除法的时候，我都要用一个64位的整数来存储中间值，这会严重降低运算的效率（然而x86平台还好）

这个问题其实可以用1024* PI*2**8 (定点数 π×1024 * 256 =0xC90FE)来解决 当然也可以用 1024*PI*2**15更高数值
另外PI*1024 取整也应该是3216.990877≈3217 而不是 3216

0xAA55

Ayala 发表于 2017-3-17 18:07
这个问题其实可以用1024* PI*2**8 (定点数 π×1024 * 256 =0xC90FE)来解决 当然也可以用 1024*PI*2**15更 ...

其实是说错，不是取整，而是“商”，所以是没有四舍五入的

0xAA55

另外因为文曲星的解释器特征，优化方面侧重于多调用它的函数进行绘图，少进行自己的绘图方式。比如它的画线函数，其实虽然明明可以自己写一个不使用乘除法的画线函数，但依然还是推荐使用它自己的画线函数（VLine、HLine、Line）。因为自己写的画线函数在运行的时候需要GVMaker虚拟机对其进行指令层面的判断和模拟执行的操作，而它自己的画线函数则是用文曲星本机的处理器指令执行的。