• 或许你也想做一个这样的动态魔方吗？

    上效果图：

    操作方法

    鼠标左键拖动能观察不同角度下的魔方。

    鼠标右键拖动能拧动魔方。

    简单说明

    关于观察魔方的各个角度，可以看我之前的“一个正方体“的程序，那里讲解比较详细，这个程序主要讲如何判断哪些面是要展示出来的以及如何判断点在哪个面的哪个小平面上，以及旋转时的逻辑。

    要判断哪些面是要展示出来的，就需要投影面的法向量 m 和每个面的法向量 n，若 m * n 为负数，说明这两个向量夹角为钝角，也就是不用展示出来，反之就要展示出来。数学基础就这么两句话，但是要用代码实现出来得有几十行，这里我将魔方 8 个顶点固定住，6 个面的法向量也是固定的，略一计算，我们只需要根据投影面的法向量的 x，y，z 值的正负就能判断 6 个面中哪些面是要展示出来的。这里判断正负要注意，c 语言中的浮点数无法表示 0，最接近 0 的浮点数是 2^(-128)，因此浮点数的 0 会比 0 略大或者略小，我这里用一个宏 ZERO 表示 0，只要浮点数比这个宏大就是大于 0。

    同时在透视投影中，当观察点没有倾斜一定角度无法看到侧面，这个倾斜的角度的 cos 值为魔方边长的一半除以观察点到投影面的距离。也就是当观察点在某一个平面上，就只能看到距离最近的两个点形成的直线，看不到这个平面上的其他点。这时候 ZERO 值就表示能看到侧面的最小 cos 值。

    不信的话可以吧 ZERO 值改小一点。

    （魔方数学模型）

    判断点在哪个面的哪个小平面上需要建一个模型，不然你不知道一个平面的起点在哪里，也就不能判断每个小平面的位置。魔方的 8 个顶点中，头四个表示底部，尾四个表示顶部，逆时针挨个排序，在空间直角坐标系中，魔方中心点为原点，x 轴正方向为右边平面的法向量，也就是 Right 表示的平面，y 轴正方向为后面平面的法向量，也就是 Back 表示的平面，z 轴正方向为上平面的法向量，也就是 Up 平面。用 8 个顶点来表示平面为

    前面（Front）：0、1、5、4

    后面（Back）：3、2、6、7

    左面（Left）：0、3、7、4

    右面（Right）：1、2、6、5

    上面（Up）：4、5、6、7

    下面（Down）：0、1、2、3

    判断时先根据投影面得到每个魔方面的二维点值，对于魔方面的每个角，可以连接顶点与点中的地方构成一个二维向量 i，再从这个顶点往两边做两个二维向量求这两个二维向量与 i 的夹角余弦值，余弦值可以表示 180 度以内的角的大小，若这两个余弦值有一个比两边向量夹角的余弦值要小，说明点中的点与某条边所形成的夹角比这个顶点的夹角要大，也就是点在平面外。对任意多边形都可以用这个方法判断点是否在平面内，判断次数为多边形顶点的个数。

    判断完点是否在平面内后判断在该平面的位置，每个平面的起点上面已经给出，根据每个平面的起点与点中的位置构成一个向量，起点与两边的向量的 1/3 长度为横纵坐标单位向量。这里做个简单的数学计算，a，b 是两个不平行的二维向量，m、n 为常数，m * a + n * b = c，c 为点中的位置与起点构成的二维向量，求出 m、n 就能得到点在平面内的位置。这方法只对平行投影有效，透视投影则将一个面的横纵方向各分为三个平面，判断点在第 m 个横平面的第 n 个纵平面，根据 m，n 值求出点在平面上的坐标。

    旋转时的逻辑比以上两个都要复杂，我的做法是用一个数组保存六个面的颜色，旋转时先画出旋转时的效果，旋转结束后改变颜色数组。

    代码实现：

    1.  
    2. // 程序：魔方
    3. // 编译环境：Visual Studio 2019，EasyX_20211109
    4.  
    5. #include 
    6. #include 
    7. #include 
    8. #define WIDTH 640						// 窗口宽度
    9. #define HEIGHT 480						// 窗口高度
    10. #define PI 3.14159265					// π
    11. #define SIDE (min(WIDTH, HEIGHT) / 4)	// 正方体边长
    12. #define GAMEPAD (SIDE / 2)				// 手柄，控制面旋转幅度的量
    13. #define ZERO 0.1				// 对于浮点数来说的 0 值
    14. #define PIECE 180						// 将一个 π 分为 PIECE 份
    15. COLORREF DifferentColor = RGB(193, 181, 62);
    16.  
    17. // 旋转时是否相反
    18. bool isOpposite(double Fi)
    19. {
    20. 	int degree = Fi / PI * PIECE;
    21. 	int judge = abs(degree) % (2 * PIECE);
    22. 	if (judge > (PIECE / 2) && judge <= (PIECE / 2 * 3))
    23. 		return true;
    24. 	return false;
    25. }
    26.  
    27. enum Plane
    28. {
    29. 	Up, Down, Left, Right, Front, Back
    30. };
    31.  
    32. // 六个面的颜色
    33. COLORREF SurfaceColor[6] =
    34. {
    35. 	RED, YELLOW, BLUE, GREEN, BROWN, MAGENTA
    36. };
    37.  
    38. // 表示在正方体上的哪一面
    39. struct CubeIndex
    40. {
    41. 	Plane plane;
    42. 	int index;
    43. };
    44.  
    45. // 判断旋转时是哪一层旋转
    46. struct RotationPoint
    47. {
    48. 	bool isAcrossAxis;
    49. 	bool isStraightAxis;
    50. 	bool isVerticalAxis;
    51. 	unsigned int Across_Judge;
    52. 	unsigned int Straight_Judge;
    53. 	unsigned int Vertical_Judge;
    54. };
    55.  
    56. // 二维向量，也可以表示一个坐标
    57. struct Vec2
    58. {
    59. 	double x, y;
    60. };
    61. typedef struct Vec2;
    62.  
    63. Vec2 operator + (Vec2 a, Vec2 b)
    64. {
    65. 	return { a.x + b.x, a.y + b.y };
    66. }
    67.  
    68. Vec2 operator - (Vec2 a, Vec2 b)
    69. {
    70. 	return { a.x - b.x, a.y - b.y };
    71. }
    72.  
    73.  
    74. // 得到向量缩短 num 倍后的向量
    75. Vec2 operator / (Vec2 a, long double num)
    76. {
    77. 	Vec2 result;
    78. 	result.x = a.x / num;
    79. 	result.y = a.y / num;
    80. 	return result;
    81. }
    82.  
    83. // 得到向量延长 num 倍后的向量
    84. Vec2 operator * (Vec2 a, long double num)
    85. {
    86. 	Vec2 result;
    87. 	result.x = a.x * num;
    88. 	result.y = a.y * num;
    89. 	return result;
    90. }
    91.  
    92. double operator * (Vec2 a, Vec2 b)
    93. {
    94. 	return a.x * b.x + a.y * b.y;
    95. }
    96.  
    97. // 三维向量，也可以表示一个坐标
    98. struct Vec3
    99. {
    100. 	double x, y, z;
    101. };
    102. typedef struct Vec3;
    103.  
    104. // 求两向量相减
    105. Vec3 operator - (Vec3 a, Vec3 b)
    106. {
    107. 	return { a.x - b.x, a.y - b.y, a.z - b.z };
    108. }
    109.  
    110. // 求两向量相加
    111. Vec3 operator + (Vec3 a, Vec3 b)
    112. {
    113. 	return { a.x + b.x, a.y + b.y, a.z + b.z };
    114. }
    115.  
    116. // 得到两向量点乘的值
    117. double operator * (Vec3 a, Vec3 b)
    118. {
    119. 	return a.x * b.x + a.y * b.y + a.z * b.z;
    120. }
    121.  
    122. // 得到向量缩短 num 倍后的向量
    123. Vec3 operator / (Vec3 a, long double num)
    124. {
    125. 	Vec3 result;
    126. 	result.x = a.x / num;
    127. 	result.y = a.y / num;
    128. 	result.z = a.z / num;
    129. 	return result;
    130. }
    131.  
    132. // 得到向量延长 num 倍后的向量
    133. Vec3 operator * (Vec3 a, long double num)
    134. {
    135. 	Vec3 result;
    136. 	result.x = a.x * num;
    137. 	result.y = a.y * num;
    138. 	result.z = a.z * num;
    139. 	return result;
    140. }
    141.  
    142. // 得到一个向量的模长
    143. double GetVec3Length(Vec3 vec)
    144. {
    145. 	return sqrt(vec.x * vec.x + vec.y * vec.y + vec.z * vec.z);
    146. }
    147.  
    148. double GetVec2Length(Vec2 vec)
    149. {
    150. 	return sqrt(vec.x * vec.x + vec.y * vec.y);
    151. }
    152.  
    153. // 得到向量 a 与向量 b 的夹角余弦值
    154. double GetCosineOfTheAngle(Vec3 a, Vec3 b)
    155. {
    156. 	return a * b / GetVec3Length(a) / GetVec3Length(b);
    157. }
    158.  
    159. double GetCosineOfTheAngle(Vec2 a, Vec2 b)
    160. {
    161. 	return a * b / GetVec2Length(a) / GetVec2Length(b);
    162. }
    163.  
    164. // 得到向量 A 在向量 B 上的投影
    165. Vec3 GetProjectionAOntoB(Vec3 A, Vec3 B)
    166. {
    167. 	double num = GetCosineOfTheAngle(A, B);				// 得到向量 A，B 的夹角余弦值
    168. 	double length = GetVec3Length(A) * num;					// 向量 A 的模长乘 num 为向量 A 在向量 B 上投影的模长
    169. 	Vec3 result = B * (abs(length) / GetVec3Length(B));	// 向量 B 延长 length 倍再缩短 B 的模长倍就是向量 A 在向量 B 上的投影
    170. 	// 如果 length 比 0 小说明 num 小于 0，也就是两向量夹角大于 90 度，结果要变为相反向量
    171. 	if (length > 0)return result;
    172. 	return result * (-1.0);
    173. }
    174.  
    175. // 根据投影面 x，y 轴正方向向量求出投影面法向量
    176. Vec3 getVerticalAxis(Vec3 AuxiliaryVector[2])
    177. {
    178. 	double x0 = AuxiliaryVector[0].x;
    179. 	double y0 = AuxiliaryVector[0].y;
    180. 	double z0 = AuxiliaryVector[0].z;
    181. 	double x1 = AuxiliaryVector[1].x;
    182. 	double y1 = AuxiliaryVector[1].y;
    183. 	double z1 = AuxiliaryVector[1].z;
    184. 	return { y0 * z1 - y1 * z0, x1 * z0 - x0 * z1, x0 * y1 - x1 * y0 };
    185. }
    186.  
    187. // 将三维的点的值转换为在对应 xoy 面上的投影的坐标
    188. typedef Vec3 DoubleVec3[2];
    189. Vec2 Transform3DTo2D(Vec3 vertex, DoubleVec3 AuxiliaryVector)
    190. {
    191. 	Vec2 result;
    192. 	Vec3 tempX = GetProjectionAOntoB(vertex, AuxiliaryVector[0]);	// 得到三维向量在 x 轴上的投影
    193. 	Vec3 tempY = GetProjectionAOntoB(vertex, AuxiliaryVector[1]);	// 得到三维向量在 y 轴上的投影
    194. 	result.x = GetVec3Length(tempX);								// 得到 tempX 的模长，模长就是结果的 x 值的绝对值
    195. 	result.y = GetVec3Length(tempY);								// 得到 tempY 的模长，模长就是结果的 y 值的绝对值
    196. 	if (tempX * AuxiliaryVector[0] < 0)result.x *= -1;				// 如果 tempX 向量与 x 轴正方向的向量夹角大于 90 度，也就是向量点乘为负数，那么结果的 x 值为负数
    197. 	if (tempY * AuxiliaryVector[1] < 0)result.y *= -1;				// 如果 tempY 向量与 y 轴正方向的向量夹角大于 90 度，也就是向量点乘为负数，那么结果的 y 值为负数
    198. 	// 以下为透视投影所做的操作，不需透视投影只需直接返回 result 值
    199. 	Vec3 Vec_Z = getVerticalAxis(AuxiliaryVector) * SIDE * 5;
    200. 	Vec3 target = vertex - Vec_Z;
    201. 	return result * (SIDE * 5 / GetVec3Length(GetProjectionAOntoB(target, Vec_Z)));
    202. }
    203.  
    204. // 得到当前投影面的法向量，用于判断哪些面要显示出来
    205. Vec3 getVerticalAxis(double Fi, double Th)
    206. {
    207. 	return { cos(Fi) * sin(Th), -cos(Fi) * cos(Th), sin(Fi) };
    208. }
    209.  
    210. void Line_Vec2(Vec2 a, Vec2 b)
    211. {
    212. 	line(a.x, a.y, b.x, b.y);
    213. }
    214.  
    215. // 画表面
    216. void drawSurface(Vec3 Surface[4], Vec3 AuxiliaryVector[2], Vec2 pericenter_Sur, COLORREF color[9])
    217. {
    218. 	setlinestyle(PS_SOLID, 2);
    219. 	Vec3 add_X = (Surface[1] - Surface[0]) / 3;
    220. 	Vec3 add_Y = (Surface[3] - Surface[0]) / 3;
    221. 	Vec3 add_All = add_X + add_Y;
    222. 	for (int i = 0; i < 3; i++)
    223. 	{
    224. 		for (int j = 0; j < 3; j++)
    225. 		{
    226. 			Vec3 position = Surface[0] + add_X * j + add_Y * i;
    227. 			// Vec2 pos_2d = Transform3DTo2D(position, AuxiliaryVector);
    228. 			setlinecolor(DifferentColor);
    229. 			Line_Vec2(Transform3DTo2D(position, AuxiliaryVector) + pericenter_Sur,
    230. 				Transform3DTo2D(position + add_X, AuxiliaryVector) + pericenter_Sur);
    231. 			Line_Vec2(Transform3DTo2D(position, AuxiliaryVector) + pericenter_Sur,
    232. 				Transform3DTo2D(position + add_Y, AuxiliaryVector) + pericenter_Sur);
    233. 			Line_Vec2(Transform3DTo2D(position + add_All, AuxiliaryVector) + pericenter_Sur,
    234. 				Transform3DTo2D(position + add_X, AuxiliaryVector) + pericenter_Sur);
    235. 			Line_Vec2(Transform3DTo2D(position + add_All, AuxiliaryVector) + pericenter_Sur,
    236. 				Transform3DTo2D(position + add_Y, AuxiliaryVector) + pericenter_Sur);
    237. 			Vec2 pericenter = Transform3DTo2D(position + add_All / 2, AuxiliaryVector) + pericenter_Sur;
    238. 			setfillcolor(color[i * 3 + j]);
    239. 			floodfill(pericenter.x, pericenter.y, DifferentColor);
    240. 			setlinecolor(WHITE);
    241. 			Line_Vec2(Transform3DTo2D(position, AuxiliaryVector) + pericenter_Sur,
    242. 				Transform3DTo2D(position + add_X, AuxiliaryVector) + pericenter_Sur);
    243. 			Line_Vec2(Transform3DTo2D(position, AuxiliaryVector) + pericenter_Sur,
    244. 				Transform3DTo2D(position + add_Y, AuxiliaryVector) + pericenter_Sur);
    245. 			Line_Vec2(Transform3DTo2D(position + add_All, AuxiliaryVector) + pericenter_Sur,
    246. 				Transform3DTo2D(position + add_X, AuxiliaryVector) + pericenter_Sur);
    247. 			Line_Vec2(Transform3DTo2D(position + add_All, AuxiliaryVector) + pericenter_Sur,
    248. 				Transform3DTo2D(position + add_Y, AuxiliaryVector) + pericenter_Sur);
    249. 		}
    250. 	}
    251. }
    252.  
    253. // 画正方体
    254. void drawCube(Vec3 Vertex[8], Vec3 AuxiliaryVector[2], Vec2 pericenter, COLORREF ColorArray[6][9])
    255. {
    256. 	Vec2 Temp[8];
    257. 	Vec3 Vector_Z = getVerticalAxis(AuxiliaryVector);
    258. 	Vector_Z = Vector_Z / GetVec3Length(Vector_Z);
    259. 	Vec3 Surface[6][4] =
    260. 	{
    261. 		Vertex[1], Vertex[2], Vertex[6], Vertex[5],
    262. 		Vertex[0], Vertex[3], Vertex[7], Vertex[4],
    263. 		Vertex[3], Vertex[2], Vertex[6], Vertex[7],
    264. 		Vertex[0], Vertex[1], Vertex[5], Vertex[4],
    265. 		Vertex[4], Vertex[5], Vertex[6], Vertex[7],
    266. 		Vertex[0], Vertex[1], Vertex[2], Vertex[3],
    267. 	};
    268. 	if (Vector_Z.x > ZERO)drawSurface(Surface[0], AuxiliaryVector, pericenter, ColorArray[Right]);
    269. 	else if (Vector_Z.x < -ZERO)drawSurface(Surface[1], AuxiliaryVector, pericenter, ColorArray[Left]);
    270. 	if (Vector_Z.y > ZERO)drawSurface(Surface[2], AuxiliaryVector, pericenter
  • 相关阅读:
    Hadoop第五章：序列化
    通过free命令了解Linux系统内存状态
    P3-Python学习当中的两大法宝函数
    基于Python的篮球场共享储物箱管理系统
    机器学习之支持向量机
    SpringBoot学习（1） —— 初始化SpringBoot开发环境
    【Java八股40天-Day3】 集合类1
    集成学习（一）：简述集成学习
    AMD HSA 异构计算架构和内核驱动
    基于python的汽车数据可视化、推荐及预测系统
  • 原文地址：https://blog.csdn.net/weixin_58045538/article/details/126772155