РБМК и движок OpenGL на MASM

Вечер 25.04.2026. Сорок лет
Во вложении - пятак РБМК на самопальном OpenGL-движке
Ходить - стрелками, летать - PgUp/PgDn,
крутить объект - WSAD,
крутить камеру - кнопки мыши и колесо, колесо можно крутить и нажимать
F1 для справки
Bonus0: то же самое на VBA для Excel. Тот случай, когда пишешь на ассемблере, но это VBA
Bonus1: то же самое на С. Перевод на С с ассемблера

 

Спасибо за интерес!!! Перезалил. Даже бонусов добавил

 

ОБАЛДЕТЬ ! ! ! ! ! ! Вот это проект, так проект ! ! ! ! Можно сказать, что ПРОЕКТИЩЕ !!!!! Я аж прослезился от радости за автора этого проекта - от БЕЛОЙ ЗАВИСТИ ! ! ! :=)

P.S. По-моему, в шапку нужно добавить, что есть проект для MASM x64 ! ! ! !

 

Чтобы не менять название темы, я добавил движок под 32 бита.

По идее, должен запускаться на всём, что имеет SSE, т.е. PIII Katmai и новее.
Летает на Compaq Presario 1700T с Celeron 700E, 128Мб RAM и ATI Rage Mobility-M1.

Дописал пока не всё. Как и в случае с "Москвичом", упёрся в парсер.
Я не могу определиться, что я хочу от этого парсера, поэтому не могу решить несформулированную задачу.

Что касается геометрии, то тут всё в порядке.
Я не использую штатные glTranslatef и glRotatef. Всё своими ручками.
Матрицу Projection я настраиваю на перспективу и больше не трогаю.
Матрицу ModelView не преобразую вообще. Просто загружаю в неё результаты обработки двух кастомных матриц.
А кастомные матрицы - это разделённые Model и View,
только я их для различия назвал ObjectVolatile и CameraVolatile соответственно.
Разделение позволяет независимо преобразовывать координаты модели и координаты камеры - К.О.
Плюс для быстрого сброса я добавил ещё две матрицы: ObjectDefault и CameraDefault.
Их я сразу проинициализировал в сегменте .code значениями, которые подбирал весь предыдущий год.

Вот так мы ходим на SSE (матрица Camera):

Спойлер: Перенос со сменой базиса

Код (ASM):

1. ;dx_local = dStep * mtxCameraVolatile(0i)
2. ;dy_local = dStep * mtxCameraVolatile(1i)
3. ;dz_local = dStep * mtxCameraVolatile(2i)
4. mulss xmm0,dword ptr[eax+0*4]
5. mulss xmm1,dword ptr[eax+4*4]
6. mulss xmm2,dword ptr[eax+8*4]
7.  
8. ;Fill all 4 xmm lanes
9. shufps xmm0,xmm0,0 ;dx_local
10. shufps xmm1,xmm1,0 ;dy_local
11. shufps xmm2,xmm2,0 ;dz_local
12.  
13. ;Accumulate world-space displacement
14.  
15. ;dx contributes to world via column 0
16. ;dy contributes to world via column 1
17. ;dz contributes to world via column 2
18.  
19. ;dx_world = dx_local*m[00] + dy_local*m[04] + dz_local*m[08]
20. ;dy_world = dx_local*m[01] + dy_local*m[05] + dz_local*m[09]
21. ;dz_world = dx_local*m[02] + dy_local*m[06] + dz_local*m[10]
22.  
23. movaps xmm3,oword ptr[ecx+0*4] ;old[00..03]
24. movaps xmm4,oword ptr[ecx+4*4] ;old[04..07]
25. movaps xmm5,oword ptr[ecx+8*4] ;old[08..11]
26. mulps xmm0,xmm3
27. mulps xmm1,xmm4
28. mulps xmm2,xmm5
29. addps xmm0,xmm1
30. addps xmm0,xmm2
31.  
32. ;Add to the Translation Column
33. ;x_world = x_world + dx_world
34. ;y_world = y_world + dy_world
35. ;z_world = z_world + dz_world
36. movaps xmm6,oword ptr[ecx+12*4] ;old[12..15]
37. addps xmm0,xmm6

Вот так мы поворачиваем модель на SSE (матрица Object):

Спойлер: Поворот в другом базисе

Код (ASM):

1. Rx:
2. ;1   0    0 0
3. ;0 cos -sin 0
4. ;0 sin  cos 0
5. ;0   0    0 1
6.  
7. ;Load Values
8. movaps xmm2,oword ptr[ecx+4*4] ;old[04..07]
9. movaps xmm3,oword ptr[ecx+8*4] ;old[08..11]
10. movaps xmm4,xmm2 ;old[04..07]
11. movaps xmm5,xmm3 ;old[08..11]
12.  
13. ;new[04] = c * old[04] + s * old[08]
14. ;new[05] = c * old[05] + s * old[09]
15. ;new[06] = c * old[06] + s * old[10]
16. ;new[07] = c * old[07] + s * old[11]
17. mulps xmm2,xmm1 ;old[04..07]*cos
18. mulps xmm3,xmm0 ;old[08..11]*sin
19. addps xmm2,xmm3
20. movaps oword ptr[ecx+4*4],xmm2 ;new[04..07]
21.  
22. ;new[08] = c * old[08] - s * old[04]
23. ;new[09] = c * old[09] - s * old[05]
24. ;new[10] = c * old[10] - s * old[06]
25. ;new[11] = c * old[11] - s * old[07]
26. mulps xmm5,xmm1 ;old[08..11]*cos
27. mulps xmm4,xmm0 ;old[04..07]*sin
28. subps xmm5,xmm4
29. movaps oword ptr[ecx+8*4],xmm5 ;new[08..11]
30.  
31. jmp ModelRotate_End
32.  
33. Ry:
34. ; cos 0 sin 0
35. ;   0 1   0 0
36. ;-sin 0 cos 0
37. ;   0 0   0 1
38.  
39. ;Load Values
40. movaps xmm2,oword ptr[ecx+0*4] ;old[00..03]
41. movaps xmm3,oword ptr[ecx+8*4] ;old[08..11]
42. movaps xmm4,xmm2 ;old[00..03]
43. movaps xmm5,xmm3 ;old[08..11]
44.  
45. ;new[00] =  c * old[00] - s * old[08]
46. ;new[01] =  c * old[01] - s * old[09]
47. ;new[02] =  c * old[02] - s * old[10]
48. ;new[03] =  c * old[03] - s * old[11]
49. mulps xmm2,xmm1 ;old[00..03]*cos
50. mulps xmm3,xmm0 ;old[08..11]*sin
51. subps xmm2,xmm3
52. movaps oword ptr[ecx+0*4],xmm2 ;new[00..03]
53.  
54. ;new[08] =  s * old[00] + c * old[08]
55. ;new[09] =  s * old[01] + c * old[09]
56. ;new[10] =  s * old[02] + c * old[10]
57. ;new[11] =  s * old[03] + c * old[11]
58. mulps xmm4,xmm0 ;old[00..03]*sin
59. mulps xmm5,xmm1 ;old[08..11]*cos
60. addps xmm4,xmm5
61. movaps oword ptr[ecx+8*4],xmm4 ;new[08..11]
62.  
63. jmp ModelRotate_End
64.  
65. Rz:
66. ;cos -sin 0 0
67. ;sin  cos 0 0
68. ;  0    0 1 0
69. ;  0    0 0 1
70.  
71. ;Load Values
72. movaps xmm2,oword ptr[ecx+0*4] ;old[00..03]
73. movaps xmm3,oword ptr[ecx+4*4] ;old[04..07]
74. movaps xmm4,xmm2 ;old[00..03]
75. movaps xmm5,xmm3 ;old[04..07]
76.  
77. ;new[00] = c * old[00] + s * old[04]
78. ;new[01] = c * old[01] + s * old[05]
79. ;new[02] = c * old[02] + s * old[06]
80. ;new[03] = c * old[03] + s * old[07]
81. mulps xmm2,xmm1 ;old[00..03]*cos
82. mulps xmm3,xmm0 ;old[04..07]*sin
83. addps xmm2,xmm3
84. movaps oword ptr[ecx+0*4],xmm2 ;new[00..03]
85.  
86. ;new[04] = c * old[04] - s * old[00]
87. ;new[05] = c * old[05] - s * old[01]
88. ;new[06] = c * old[06] - s * old[02]
89. ;new[07] = c * old[07] - s * old[03]
90. mulps xmm4,xmm0 ;old[00..03]*sin
91. mulps xmm5,xmm1 ;old[04..07]*cos
92. subps xmm5,xmm4
93. movaps oword ptr[ecx+4*4],xmm5 ;new[04..07]

Управление WSAD (поворот модели) + стрелки, PgUp, PgDn (движение камеры) + shift (ускорение)

 

ml64, спасибо вам от всех любителей ассемблеров ! :=) К сожалению, ваш EXE-файл у меня выдаёт не то, что нужно, а сам я пока не компилировал, нужно будет MASM32 на досуге установить.

 

Так это и есть то, что нужно!
Там просто болванка - белый прямоугольник, на нём можно проверить работу всех матриц.
Я же говорю: будет парсер - будет графика, а сейчас пока красоту надо искать в чистоте решений.
Это же поэзия:

Код (ASM):

1. ;2.1. Activate the ModelView Matrix
2. push 1700h ;GL_MODELVIEW
3. call glMatrixMode
4.  
5. ;2.2. Load the current Camera matrix
6. push offset mtxCameraVolatile
7. call glLoadMatrixf
8.  
9. ;2.3. Multiply by the current Object matrix
10. push offset mtxObjectVolatile
11. call glMultMatrixf

Вместо всех конских преобразований в матрицах Projection и ModelView

...Для того, чтобы повернуть матрицу в другом базисе, нужно всего лишь 12 инструкций.
А на современных процессорах - ещё меньше

 

- А, понятно.
- А у вас нет такого-же, но с парсером, без крыльев и с перламутровыми пуговицами?
- Нет, да. Ну, будем искать. Будем искать.

​

 

Обновление с полным функционалом мыши.
Экранные координаты проецируются на сферу.
По просьбам коллег поздние версии SSE и AVX не используются. Только SSE1, только OpenGL1.0, только хардкор:

Код (ASM):

1. ArcballRotation proc
2. ;Computes the arcball rotation
3. ;from two unit vectors (vecOld and vecNew)
4. ;on the virtual sphere, expressed in Camera's Local Coordinates
5. ;and produces a 3x3 rotation matrix in WORLD coordinates
6. ;stored in mtxArcball.
7. ;Assumes the camera's 3x3 block (columns 0,1,2 of mtxCameraVolatile)
8. ;is orthonormal, so its transpose is its inverse.
9. ;Returns True on success, False on degenerate (skip rotation).
10.  
11. ;1. Read the two unit vectors
12. movaps xmm0,oword ptr[xVectorOld]
13. movaps xmm1,oword ptr[xVectorNew]
14.  
15. ;2. Cross product vecCam = vecOld * vecNew
16. ;xCam = y0*z1 - z0*y1
17. ;yCam = z0*x1 - x0*z1
18. ;zCam = x0*y1 - y0*x1
19. movaps xmm2,xmm0 ;vecOld
20. shufps xmm2,xmm0,11001001b
21. movaps xmm3,xmm1 ;vecNew
22. shufps xmm3,xmm1,11010010b
23. movaps xmm4,xmm0 ;vecOld
24. shufps xmm4,xmm0,11010010b
25. movaps xmm5,xmm1 ;vecNew
26. shufps xmm5,xmm1,11001001b
27. mulps xmm2,xmm3
28. mulps xmm4,xmm5
29. subps xmm2,xmm4 ;xmm2 = vecCam
30.  
31. ;3. Dot product cosA = old * new
32. ;cosA = x0*x1 + y0*y1 + z0*z1
33. movaps xmm3,xmm0 ;vecOld
34. mulps xmm3,xmm1 ;vecNew
35. movaps xmm4,xmm3
36. shufps xmm4,xmm4,00111001b ;rotate right
37. addss xmm3,xmm4
38. shufps xmm4,xmm4,00111001b ;rotate right
39. addss xmm3,xmm4 ;xmm3 = cosA
40. shufps xmm3,xmm3,0 ;broadcast cosA
41.  
42. ;4. Magnitude of the cross product
43. ;sinA = |vecCam| = Sqr(xCam*xCam + yCam*yCam + zCam*zCam)
44. movaps xmm4,xmm2 ;vecCam
45. mulps xmm4,xmm4
46. movaps xmm5,xmm4
47. shufps xmm5,xmm5,00111001b ;rotate right
48. addss xmm4,xmm5
49. shufps xmm5,xmm5,00111001b ;rotate right
50. addss xmm4,xmm5
51. sqrtss xmm4,xmm4 ;xmm4 = sinA
52. shufps xmm4,xmm4,0 ;broadcast sinA
53.  
54. ;5. Degenerate case
55. ;If sinA is too small, the rotation is
56. ;either identity (cosA > 0) or 180 deg (cosA < 0)
57. ;The latter has no defined axis from the cross product.
58. ;Skip both for now.
59. comiss xmm4,eps ;Compare against epsilon
60. jb Degenerate
61.  
62. ;6. Normalize the axis
63. ;xCam = xCam / sinA
64. ;yCam = yCam / sinA
65. ;zCam = zCam / sinA
66. divps xmm2,xmm4
67.  
68. ;7. Transform axis from CAMERA-LOCAL to WORLD
69. ;vecWorld = M_camera_3x3_transpose * vecCam
70.  
71. ;In memory (column-major), mtxCameraVolatile's columns are:
72. ;[m00 m04 m08]
73. ;[m01 m05 m09]
74. ;[m02 m06 m10]
75. lea eax,mtxCameraVolatile
76.  
77. ;Its transpose multiplied by (xCam, yCam, zCam) is:
78. ;xWorld = m00*xCam + m01*yCam + m02*zCam
79. ;yWorld = m04*xCam + m05*yCam + m06*zCam
80. ;zWorld = m08*xCam + m09*yCam + m10*zCam
81. movaps xmm5,xmm2
82. movaps xmm6,xmm2
83. movaps xmm7,xmm2
84.  
85. mulps xmm5,oword ptr[eax+00*4] ;m[00..03] * xCam
86. mulps xmm6,oword ptr[eax+04*4] ;m[04..07] * yCam
87. mulps xmm7,oword ptr[eax+08*4] ;m[08..11] * zCam
88.  
89. movaps xmm0,xmm5 ;wx[0]
90. movaps xmm1,xmm5
91. shufps xmm1,xmm1,00111001b ;rotate right
92. addss xmm0,xmm1
93. shufps xmm1,xmm1,00111001b ;rotate right
94. addss xmm0,xmm1
95. movss xmm5,xmm0 ;xWorld
96.  
97. movaps xmm0,xmm6 ;wy[0]
98. movaps xmm1,xmm6
99. shufps xmm1,xmm1,00111001b ;rotate right
100. addss xmm0,xmm1
101. shufps xmm1,xmm1,00111001b ;rotate right
102. addss xmm0,xmm1
103. movss xmm6,xmm0 ;yWorld
104.  
105. movaps xmm0,xmm7 ;wz[0]
106. movaps xmm1,xmm7
107. shufps xmm1,xmm1,00111001b ;rotate right
108. addss xmm0,xmm1
109. shufps xmm1,xmm1,00111001b ;rotate right
110. addss xmm0,xmm1
111. movss xmm7,xmm0 ;zWorld
112.  
113. ;8. Build the Rodrigues 3x3 rotation matrix (world space)
114. ;c = cosA = xmm3
115. ;s = sinA = xmm4
116. ;t = 1 - cosA
117. movss xmm2,posOne
118. subss xmm2,xmm3 ;xmm2 = t
119. shufps xmm2,xmm2,0 ;broadcast t
120.  
121. ;9. Compute Rodrigues and store Store in mtxArcball (column-major)
122. ;[m00 m04 m08] <- [r00 r01 r02]
123. ;[m01 m05 m09] <- [r10 r11 r12]
124. ;[m02 m06 m10] <- [r20 r21 r22]
125. lea ecx,mtxArcball
126.  
127. ;So memory layout is:
128. ;mtxArcball(00) = R00 = t*wx*wx + c
129. ;mtxArcball(01) = R10 = t*wx*wy + s*wz ;
130. ;mtxArcball(02) = R20 = t*wx*wz - s*wy
131. ;mtxArcball(03) = 0
132. ;mtxArcball(04) = R01 = t*wx*wy - s*wz ;
133. ;mtxArcball(05) = R11 = t*wy*wy + c
134. ;mtxArcball(06) = R21 = t*wy*wz + s*wx
135. ;mtxArcball(07) = 0
136. ;mtxArcball(08) = R02 = t*wx*wz + s*wy
137. ;mtxArcball(09) = R12 = t*wy*wz - s*wx
138. ;mtxArcball(10) = R22 = t*wz*wz + c
139. ;mtxArcball(11) = 0
140. ;mtxArcball(12) = 0
141. ;mtxArcball(13) = 0
142. ;mtxArcball(14) = 0
143. ;mtxArcball(15) = 1
144.  
145. movss xmm0,xmm2 ;t
146. mulss xmm0,xmm5 ;t*wx
147. movss dword ptr[ecx+00*4],xmm0 ;t*wx
148. movss dword ptr[ecx+02*4],xmm0 ;t*wx
149. mulss xmm0,xmm6 ;t*wx*wy
150. movss dword ptr[ecx+01*4],xmm0 ;t*wx*wy
151. movss xmm1,xmm4 ;s
152. mulss xmm1,xmm7 ;s*wz
153. subss xmm0,xmm1 ;t*wx*wy - s*wz
154. movss dword ptr[ecx+04*4],xmm0 ;Done
155. addss xmm1,dword ptr[ecx+01*4] ;t*wx*wy + s*wz
156. movss dword ptr[ecx+01*4],xmm1 ;Done
157.  
158. movss xmm0,dword ptr[ecx+02*4] ;t*wx
159. mulss xmm0,xmm7 ;t*wx*wz
160. movss dword ptr[ecx+08*4],xmm0 ;t*wx*wz
161. movss xmm1,xmm4 ;s
162. mulss xmm1,xmm6 ;s*wy
163. subss xmm0,xmm1 ;t*wx*wz - s*wy
164. movss dword ptr[ecx+02*4],xmm0 ;Done
165. addss xmm1,dword ptr[ecx+08*4] ;t*wx*wz + s*wy
166. movss dword ptr[ecx+08*4],xmm1 ;Done
167.  
168. movss xmm0,xmm5 ;wx
169. mulss xmm0,dword ptr[ecx+00*4] ;t*wx*wx
170. addss xmm0,xmm3 ;t*wx*wx + c
171. movss dword ptr[ecx+00*4],xmm0 ;Done
172.  
173. movss xmm0,xmm2 ;t
174. mulss xmm0,xmm6 ;t*wy
175. movss dword ptr[ecx+05*4],xmm0 ;t*wy
176. mulss xmm0,xmm7 ;t*wy*wz
177. movss dword ptr[ecx+06*4],xmm0 ;t*wy*wz
178. movss xmm1,xmm4 ;s
179. mulss xmm1,xmm5 ;s*wx
180. subss xmm0,xmm1 ;t*wy*wz - s*wx
181. movss dword ptr[ecx+09*4],xmm0 ;Done
182. addss xmm1,dword ptr[ecx+06*4] ;t*wy*wz + s*wx
183. movss dword ptr[ecx+06*4],xmm1 ;Done
184.  
185. movss xmm0,xmm6 ;wy
186. mulss xmm0,dword ptr[ecx+05*4] ;t*wy*wy
187. addss xmm0,xmm3 ;t*wy*wy + c
188. movss dword ptr[ecx+05*4],xmm0 ;Done
189.  
190. movss xmm0,xmm2 ;t
191. mulss xmm0,xmm7 ;t*wz
192. mulss xmm0,xmm7 ;t*wz*wz
193. addss xmm0,xmm3 ;t*wz*wz + c
194. movss dword ptr[ecx+10*4],xmm0 ;Done
195.  
196. mov dword ptr[ecx+07*4],0
197. mov dword ptr[ecx+11*4],0
198. mov dword ptr[ecx+12*4],0
199. mov dword ptr[ecx+13*4],0
200. mov dword ptr[ecx+14*4],0
201. movss xmm0,posOne
202. movss dword ptr[ecx+15*4],xmm0
203.  
204. jmp Success
205.  
206. ;Failure
207. Degenerate:
208. invoke WriteLog,offset szErrArcball
209. mov eax,-1
210. ret
211.  
212. ;Report Success
213. Success:
214. xor eax,eax
215. ret
216.  
217. ArcballRotation endp
218.  
219.  

 

Вчера перемудрил с формулой Родрига, сегодня поравил.
Получилось красиво, уместился в 6 регистров.

Код (ASM):

1. ;10. Compute Rodrigues and store Store in mtxArcball (column-major)
2. ;[m00 m04 m08] <- [r00 r01 r02]
3. ;[m01 m05 m09] <- [r10 r11 r12]
4. ;[m02 m06 m10] <- [r20 r21 r22]
5. lea ecx,mtxArcball
6.  
7. ;So memory layout is:
8. ;mtxArcball(00) = R00 = t*xw*xw+cosA
9. ;mtxArcball(01) = R10 = t*xw*yw+sinA*zw
10. ;mtxArcball(02) = R20 = t*xw*zw-sinA*yw
11. ;mtxArcball(03) = 0
12. ;mtxArcball(04) = R01 = t*yw*xw-sinA*zw
13. ;mtxArcball(05) = R11 = t*yw*yw+cosA
14. ;mtxArcball(06) = R21 = t*yw*zw+sinA*xw
15. ;mtxArcball(07) = 0
16. ;mtxArcball(08) = R02 = t*zw*xw+sinA*yw
17. ;mtxArcball(09) = R12 = t*zw*yw-sinA*xw
18. ;mtxArcball(10) = R22 = t*zw*zw+cosA
19. ;mtxArcball(11) = 0
20. ;mtxArcball(12) = 0
21. ;mtxArcball(13) = 0
22. ;mtxArcball(14) = 0
23. ;mtxArcball(15) = 1
24.  
25. ;Initial state:
26. ;xmm0 = 0,zw,yw,xw
27. ;xmm1 = free (junk)
28. ;xmm2 = t,t,t,t
29. ;xmm3 = cosA,cosA,cosA,cosA
30. ;xmm4 = sinA,sinA,sinA,sinA
31. ;xmm5 = xw,xw,xw,xw
32. ;xmm6 = yw,yw,yw,yw
33. ;xmm7 = zw,zw,zw,zw
34.  
35. ;Comment style: little-endian
36. mulps xmm0,xmm2 ;0,t*zw,t*yw,t*xw
37. movaps xmm1,xmm0 ;0,t*zw,t*yw,t*xw
38. movaps xmm2,xmm0 ;0,t*zw,t*yw,t*xw
39.  
40. mulps xmm0,xmm5 ;0,t*zw*xw,t*yw*xw,t*xw*xw
41. mulps xmm1,xmm6 ;0,t*zw*yw,t*yw*yw,t*xw*yw
42. mulps xmm2,xmm7 ;0,t*zw*zw,t*yw*zw,t*xw*zw
43.  
44. mulss xmm5,xmm4 ;?,?,?,sinA*xw
45. mulss xmm6,xmm4 ;?,?,?,sinA*yw
46. mulss xmm7,xmm4 ;?,?,?,sinA*zw
47.  
48. addss xmm0,xmm3 ;0,t*zw*xw,t*yw*xw,t*xw*xw+cosA
49. movss dword ptr[ecx+00*4],xmm0
50. shufps xmm0,xmm0,00111001b ;a00,0,t*zw*xw,t*yw*xw
51. subss xmm0,xmm7 ;a00,0,t*zw*xw,t*yw*xw-sinA*zw
52. movss dword ptr[ecx+04*4],xmm0
53. shufps xmm0,xmm0,00111001b ;a04,a00,0,t*zw*xw
54. addss xmm0,xmm6 ;a04,a00,0,t*zw*xw+sinA*yw
55. movss dword ptr[ecx+08*4],xmm0
56.  
57. addss xmm1,xmm7 ;0,t*zw*yw,t*yw*yw,t*xw*yw+sinA*zw
58. movss dword ptr[ecx+01*4],xmm1
59. shufps xmm1,xmm1,00111001b ;a01,0,t*zw*yw,t*yw*yw
60. addss xmm1,xmm3 ;a01,0,t*zw*yw,t*yw*yw+cosA
61. movss dword ptr[ecx+05*4],xmm1
62. shufps xmm1,xmm1,00111001b ;a05,a01,t*zw*yw
63. subss xmm1,xmm5 ;a05,a01,t*zw*yw-sinA*xw
64. movss dword ptr[ecx+09*4],xmm1
65.  
66. subss xmm2,xmm6 ;0,t*zw*zw,t*yw*zw,t*xw*zw-sinA*yw
67. movss dword ptr[ecx+02*4],xmm2
68. shufps xmm2,xmm2,00111001b ;a02,0,t*zw*zw,t*yw*zw
69. addss xmm2,xmm5 ;a02,0,t*zw*zw,t*yw*zw+sinA*xw
70. movss dword ptr[ecx+06*4],xmm2
71. shufps xmm2,xmm2,00111001b ;a06,a02,0,t*zw*zw
72. addss xmm2,xmm3 ;a06,a02,0,t*zw*zw+cosA
73. movss dword ptr[ecx+10*4],xmm2

 

А я, вообще, по-моему, вчера свою какую-то формулу изобрёл. Так и не понял даже какую, я же не математик. Назвал эту формулу, на всякий случай "Гипотеза Пуанкаре - отдыхает". По-моему, получилось даже чуть покрасивее, чем у ml64. Регистры не считал. Что их считать - все равно все умрём, а регистры останутся.

 

Пошла жара!
Мне очень нравится. Залип минут на десять.

--- Сообщение объединено, 27 сен 2026 ---

Однозначно! И отлично крутится на Celeron 700E

 

Не всё так однозначно. Идея-то однозначно ваша и движок ваш. Если бы не вы, мне бы и в голову подобное не пришло. Осталось теперь в 64-х битную версию сконвертировать, да может кое-какие ошибки устранить. У меня в логах, при управлении с клавиатуры и с мыши, накапливаются ошибки, но это по-моему, с других камер (или как их правильно назвать?) не связанных с моими цилиндрами. Может там половину можно отключить ?

 

Там трекбол даёт такую погрешность, что я его вообще заменю на последовательные повороты в плоскостях.
Сижу, вычищаю

--- Сообщение объединено, 27 сен 2026 ---

Заменил трекбол на обычные повороты в плоскостях.
Проще, точнее. Хотя не так эффектно.

 

Переписал конвертер float -> string под x32
Оживил статусную строку
Вернул счётчик кадров (шестнадцатеричный)
Добавил счётчик FPS

--- Сообщение объединено, 27 сен 2026 ---

Выдаёт более 90 FPS, если я правильно считаю

--- Сообщение объединено, 27 сен 2026 ---

101 FPS под Windows Me:

 

А Windows 98 там у вас нет случайно? А то у родителей где-то в кладовке стоит Пентиум-3 1 Ггц. c 512 Мб. памяти и Win 98. Папа выбрасывать не даёт. Могу попросить, чтобы испытал.

 

??? Pentium III 1 ГГц - это легенда. Берегите его!
У меня был PIII Katmai-550. Я его в 2022 году отнёс на помойку. По семейным обстоятельствам. Теперь жалею.
Памяти там было 128, и это в 2001 году считалось очень много, а у Вас 512.
Если видеокарта ещё MX460, то это просто эталонный артефакт.
Если верить бенчмаркам тех лет, то машины на последних Coppermine были быстрее, чем Willamette и Northwood.

--- Сообщение объединено, 27 сен 2026 ---

Давайте доработаем Вашу идею: разберёмся с нормалями и добавим свет.
Будет круто!

 

Давайте. А что для этого нужно ? Я, только, если честно, в графике слабоват. Мне эту идею с цилиндрами сосед, студент посоветовал. Он на играх специализируется. Так что где-то сосед, где-то у ИИ что-то спросишь, где-то в гугле что-то поищешь... В результате имеем то, что имеем... Но мне понравилось...

 

Договориться об интерфейсах. Чтобы Вы были в комфорте с изменениями движка.
Т.е. я меняю (условно) алгоритм поворота стрелками, а Ваш код остаётся в своём модуле.
Сейчас так и есть. Где-то вызывающие функции по максимуму высвободить.
И всё будет взаимно независимо. И портируемо (пригодно для х64 или Вулкана, например)

 

ml64, в общем, можете брать эти вращающиеся цилиндры и делать с ними всё, что считаете нужным. Чувствуется, что у вас к этому делу более профессиональный подход, чем у меня. Я всё-таки в графике и движках OPENGL - любитель, а может даже и делитант. Если что-то будет нужно от меня - напишете в этот тред или в личку, чем смогу - постараюсь помочь.