制作魔方的全过程：提问遇到的问题和进行的总结

hunter_wwq

想画个魔方，osg::Box支持支着一种颜色，就想自己绘制一个立方体，然后给每个面都桌上不同的颜色，但是这个地方不会，请各位前辈指教啊！

hunter_wwq

要怎么弄啊，本人很菜，求关注。。。。

liuzhiyu123

osg::Box 没这个功能   自己实现一个Drawable吧

hunter_wwq

我是准备自己来绘制，但是我不知道怎么给画好的立方体来指定每个面的颜色

the_mercury

用着色器，根据表面法线的方向指定颜色就行了呗。

garyliyong

这个不是很难吧 使用geometry，设置几何顶点颜色数组和索引就可以了啦

hunter_wwq

garyliyong 发表于 2013-6-22 21:53
这个不是很难吧 使用geometry，设置几何顶点颜色数组和索引就可以了啦

刚刚试了一下，这个方法确实就可以了！

hunter_wwq

the_mercury 发表于 2013-6-21 17:46
用着色器，根据表面法线的方向指定颜色就行了呗。

着色器暂时还没学到，刚刚用的是颜色数组的方式来实现的

hunter_wwq

刚刚试了下设置颜色数组的方式来为立方体每个面定义一种颜色，这其中颜色对顶点的修饰规则我大致总结了下，以后像我这样的菜鸟们可以参考一下，前辈们看到有总结的不对的地方还希望能指点出来啊

例举颜色修饰顶点的规则：(以绘制一个六个面均为不同颜色的立方体为例)
首先分析下立方体的构造：立方体有8个顶点、六个面，每个面有4个顶点，若以osg:: PrimitiveSet:: QUADS进行绘制，则会以4个顶点为一组进行绘制，所以 绘制几何体有两种方案：第一种，顶点数组添加4*6个顶点，依次以4个顶点为一组定义一个平面；第二种，顶点数组添加8个顶点，然后设置顶点索引，顶点索引是从顶点数组中选出顶点进行组合，也是以4个顶点为一组来定义一个平面。第一种方案的代码：

1. 
   
2.         // 设置顶点
   
3.         ref_ptr<Vec3Array> vertextArr = new Vec3Array;
   
4.         // 前
   
5.         vertextArr->push_back(Vec3(0.0f, 0.0f, 0.0f));
   
6.         vertextArr->push_back(Vec3(1.0f, 0.0f, 0.0f));
   
7.         vertextArr->push_back(Vec3(1.0f, 0.0f, 1.0f));
   
8.         vertextArr->push_back(Vec3(0.0f, 0.0f, 1.0f));
   
9.         // 左
   
10.         vertextArr->push_back(Vec3(0.0f, 0.0f, 0.0f));
    
11.         vertextArr->push_back(Vec3(0.0f, 1.0f, 0.0f));
    
12.         vertextArr->push_back(Vec3(0.0f, 1.0f, 1.0f));
    
13.         vertextArr->push_back(Vec3(0.0f, 0.0f, 1.0f));
    
14.         // 底
    
15.         vertextArr->push_back(Vec3(0.0f, 0.0f, 0.0f));
    
16.         vertextArr->push_back(Vec3(1.0f, 0.0f, 0.0f));
    
17.         vertextArr->push_back(Vec3(1.0f, 1.0f, 0.0f));
    
18.         vertextArr->push_back(Vec3(0.0f, 1.0f, 0.0f));
    
19.         // 顶
    
20.         vertextArr->push_back(Vec3(1.0f, 1.0f, 1.0f));
    
21.         vertextArr->push_back(Vec3(0.0f, 1.0f, 1.0f));
    
22.         vertextArr->push_back(Vec3(0.0f, 0.0f, 1.0f));
    
23.         vertextArr->push_back(Vec3(1.0f, 0.0f, 1.0f));
    
24.         // 右
    
25.         vertextArr->push_back(Vec3(1.0f, 1.0f, 1.0f));
    
26.         vertextArr->push_back(Vec3(1.0f, 0.0f, 1.0f));
    
27.         vertextArr->push_back(Vec3(1.0f, 0.0f, 0.0f));
    
28.         vertextArr->push_back(Vec3(1.0f, 1.0f, 0.0f));
    
29.         // 后
    
30.         vertextArr->push_back(Vec3(1.0f, 1.0f, 1.0f));
    
31.         vertextArr->push_back(Vec3(0.0f, 1.0f, 1.0f));
    
32.         vertextArr->push_back(Vec3(0.0f, 1.0f, 0.0f));
    
33.         vertextArr->push_back(Vec3(1.0f, 1.0f, 0.0f));
    
34.         geometry->setVertexArray(vertextArr.get());
    

复制代码

第二种方案的代码：

1. 
   
2.         // 设置顶点
   
3.         ref_ptr<Vec3Array> vertextArr = new Vec3Array;
   
4.         vertextArr->push_back(Vec3(0.0f, 0.0f, 0.0f));
   
5.         vertextArr->push_back(Vec3(1.0f, 0.0f, 0.0f));
   
6.         vertextArr->push_back(Vec3(1.0f, 0.0f, 1.0f));
   
7.         vertextArr->push_back(Vec3(0.0f, 0.0f, 1.0f));
   
8.         vertextArr->push_back(Vec3(1.0f, 1.0f, 1.0f));
   
9.         vertextArr->push_back(Vec3(0.0f, 1.0f, 1.0f));
   
10.         vertextArr->push_back(Vec3(0.0f, 1.0f, 0.0f));
    
11.         vertextArr->push_back(Vec3(1.0f, 1.0f, 0.0f));
    
12.         geometry->setVertexArray(vertextArr.get());
    
13. 
    
14.         ref_ptr<DrawElementsUInt> vertexIndex = new DrawElementsUInt(PrimitiveSet::QUADS, 0);
    
15.         vertexIndex->push_back(0);
    
16.         vertexIndex->push_back(1);
    
17.         vertexIndex->push_back(2);
    
18.         vertexIndex->push_back(3);
    
19.         vertexIndex->push_back(0);
    
20.         vertexIndex->push_back(1);
    
21.         vertexIndex->push_back(7);
    
22.         vertexIndex->push_back(6);
    
23.         vertexIndex->push_back(0);
    
24.         vertexIndex->push_back(6);
    
25.         vertexIndex->push_back(5);
    
26.         vertexIndex->push_back(3);
    
27.         vertexIndex->push_back(4);
    
28.         vertexIndex->push_back(5);
    
29.         vertexIndex->push_back(3);
    
30.         vertexIndex->push_back(2);
    
31.         vertexIndex->push_back(4);
    
32.         vertexIndex->push_back(5);
    
33.         vertexIndex->push_back(6);
    
34.         vertexIndex->push_back(7);
    
35.         vertexIndex->push_back(4);
    
36.         vertexIndex->push_back(2);
    
37.         vertexIndex->push_back(1);
    
38.         vertexIndex->push_back(7);
    
39.         geometry->addPrimitiveSet(vertexIndex.get());
    

复制代码

接下来为每个面定义颜色，因为一个面均为一种填充颜色，所以一个面上的四个顶点均为同一种颜色，每个顶点都得定义一种颜色，一个立方体有6个面，则相当于要定义6*4个颜色值，而颜色值只是针对顶点数组中的顶点值去一一对应，并不会与设置的顶点索引去挂钩，所以在绘制立方体时若采用第二种方案，是没有办法为每个面第一种不同的颜色的(一个面只有一种填充色)。所以若要给立方体每个面定义一种不同的颜色时，在构造立方体就只能采用第一种方案。现在设置颜色也有两种方案，第一种是设置仅颜色数组，设置24个，对应上每个顶点；第二种是先设置颜色数组，设置6个，然后设置颜色索引，定义24个，其中每个平面上的四个点的颜色值应该一致。这里只列举第二种方案的代码：

1. 
   
2.         // 设置颜色
   
3.         ref_ptr<Vec4Array> colorArr = new Vec4Array;
   
4.         colorArr->push_back(m_mccWhite);
   
5.         colorArr->push_back(m_mccYellow);
   
6.         colorArr->push_back(m_mccBlue);
   
7.         colorArr->push_back(m_mccGreen);
   
8.         colorArr->push_back(m_mccRed);
   
9.         colorArr->push_back(m_mccOrange);
   
10.         geometry->setColorArray(colorArr.get());
    
11. 
    
12.         ref_ptr<TemplateIndexArray<unsigned int, Array::Vec3ArrayType, 4, 4>> colorIndex = new TemplateIndexArray<unsigned int, Array::Vec3ArrayType, 4, 4>;
    
13.         for (int i = 0; i < 6; i++)
    
14.         {
    
15.                 colorIndex->push_back(i);
    
16.                 colorIndex->push_back(i);
    
17.                 colorIndex->push_back(i);
    
18.                 colorIndex->push_back(i);
    
19.         }
    
20.         geometry->setColorIndices(colorIndex.get());
    
21.         geometry->setColorBinding(Geometry::BIND_PER_VERTEX);
    

复制代码

hunter_wwq

设计的魔方的操作类如下，CMagicCube->构造并存储魔方的属性数据，包括存储魔方的单元面的颜色值、单元方格节点，和旋转中心索引；CHandleMagicCube->对魔方进行旋转，添加旋转的效果；CSolveMagicCube->解魔方用。此三类的关联关系如图所示：

魔方类设计图

其中CMagicCube中对魔方属性数据的存储都是用三维数组来存储，用来标记是处在那个位置上的。
这三个类均采用的模板类进行设计，举例，CMagicCube的类为：

1. 
   
2. template<int orderNum>
   
3. class CMagicCube
   
4. {};
   

复制代码

其中非类型模板参数orderNum代表魔方的阶数，理论上可以有达到任意阶数！

hunter_wwq

在对魔方进行旋转的时候，开始始终不能理解@鸩婚 和 @小白 等前辈们说的什么原点，中心点，后来才发现对魔方单元方块进行旋转的时候它是绕着原点进行旋转地，而不是绕着单元方块上的某个顶点进行旋转，所以也就明白了把魔方的中心点设置为原点的说法！现在要做的就是找到如何将魔方的中心年设置为原点的方法。
图例[0][0][1][单元方块绕原点进行旋转：

单元方块绕原点旋转示例

array

旋转无非就是translate(-c) * rotate() * translate(c)，明白这一点就可以最快地实现了

hunter_wwq

我今天也在群里讨论了，他们也有说到用这个，但是我的想法是：我不想知道旋转至目的坐标是什么，我只知道单元方块的初始位置，和原点位置，然后我再通过设置这个旋转角度，就能到将单元方块直接旋转到目的坐标。其中最关键的一点是我想让魔方在旋转的时候是绕着原点进行旋转地，而不是先平移再旋转在平移，就是在视觉上也要达到那种看上去是旋转到目的位置的效果。

hunter_wwq

根据@鸩婚 的建议，将魔方的中心点设置为坐标原点。
将魔方的中心点置为坐标原点，即在绘制魔方的时候明确好各单元方块中心点的坐标以及框架中心点坐标，分别如下：

1. 
   
2.                 float xp = (DEFAULT_CELL_LENGTH + DEFAULT_SPACE)*x;
   
3.                 float yp = (DEFAULT_CELL_LENGTH + DEFAULT_SPACE)*y;
   
4.                 float zp = (DEFAULT_CELL_LENGTH + DEFAULT_SPACE)*z;
   
5.                 xp -= (DEFAULT_CELL_LENGTH+DEFAULT_SPACE)*(orderNum-1)/2;
   
6.                 yp -= (DEFAULT_CELL_LENGTH+DEFAULT_SPACE)*(orderNum-1)/2;
   
7.                 zp -= (DEFAULT_CELL_LENGTH+DEFAULT_SPACE)*(orderNum-1)/2;
   

复制代码

1. 
   
2.         float points[orderNum];///<存储绘制间隙所需要的点，其中最后一个点存储的是一个中心点
   
3.         for (int i = 0; i <= orderNum-2; i++)
   
4.         {
   
5.                 points[i] = DEFAULT_CELL_LENGTH + DEFAULT_SPACE/2 +
   
6.                                                         (DEFAULT_CELL_LENGTH + DEFAULT_SPACE)*i;
   
7.                 points[i] -= (DEFAULT_CELL_LENGTH*orderNum + DEFAULT_SPACE*(orderNum-1))/2;
   
8.         }
   
9.         points[orderNum-1] = 0;
   

复制代码

魔方旋转功能搞定！！

hunter_wwq

根据@鸩婚 的建议，将魔方的中心点设置为坐标原点。
将魔方的中心点置为坐标原点，即在绘制魔方的时候明确好各单元方块中心点的坐标以及框架中心点坐标，分别如下：

1. 
   
2.                 float xp = (DEFAULT_CELL_LENGTH + DEFAULT_SPACE)*x;
   
3.                 float yp = (DEFAULT_CELL_LENGTH + DEFAULT_SPACE)*y;
   
4.                 float zp = (DEFAULT_CELL_LENGTH + DEFAULT_SPACE)*z;
   
5.                 xp -= (DEFAULT_CELL_LENGTH+DEFAULT_SPACE)*(orderNum-1)/2;
   
6.                 yp -= (DEFAULT_CELL_LENGTH+DEFAULT_SPACE)*(orderNum-1)/2;
   
7.                 zp -= (DEFAULT_CELL_LENGTH+DEFAULT_SPACE)*(orderNum-1)/2;
   

复制代码

1. 
   
2.         float points[orderNum];///<存储绘制间隙所需要的点，其中最后一个点存储的是一个中心点
   
3.         for (int i = 0; i <= orderNum-2; i++)
   
4.         {
   
5.                 points[i] = DEFAULT_CELL_LENGTH + DEFAULT_SPACE/2 +
   
6.                                                         (DEFAULT_CELL_LENGTH + DEFAULT_SPACE)*i;
   
7.                 points[i] -= (DEFAULT_CELL_LENGTH*orderNum + DEFAULT_SPACE*(orderNum-1))/2;
   
8.         }
   
9.         points[orderNum-1] = 0;
   

复制代码

魔方旋转功能搞定！！

hunter_wwq

先对魔方组件类进行重新设计，如图所示：

魔方类设计图二

为魔方类CMagicCube增加三个方法：

1. 
   
2. void swapCellplaneColorArrayPos(const SRotateParam& rsRP);
   
3. void swapCellcubeArrayPos(const SRotateParam& rsRP);
   
4. std::vector<osg::ref_ptr<osg::MatrixTransform>> getCellcubes(const SRotateParam& rsRP);
   

复制代码

swapCellplaneColorArrayPos: 根据旋转参数来对调单元面颜色数组中的位置
swapCellcubeArrayPos: 根据旋转参数来对调单元方块节点的位置
getCellcubes: 根据旋转参数来获取要旋转的单元方块数组

hunter_wwq

总结：关于旋转矩阵节点osg::MatrixTransform设置矩阵对其进行变换操作(平移、旋转、缩放)
旋转矩阵节点有一个最初状态，当设置某个变换矩阵对其进行变换操作后，它的状态(位置/大小)会改变，此时状态为状态2，当再次设置某个变换矩阵对其进行变换操作后，它的状态的改变仍然是参考最初状态而不是参考状态2。比如说，对某个单元方块最初状态是在上面，逆转90度后，到了后面，在顺转90度，它到了前面，而不是回到上面，因为它的变换始终是参考其最初状态的。
所以在对魔方进行旋转是，声明一个静态变量来保存它的角度值：

1. 
   
2.         static double xAngle = 0.0f, yAngle = 0.0f, zAngle = 0.0f;
   

复制代码

当对其进行旋转时，若逆转，则减PI/2，若顺转，则加PI/2，然后再带入矩阵：

1. 
   
2.                 Matrix mtr;
   
3.                 if (rsRP._rotateDir == SRotateParam::RD_ANTICLOCKWISE)
   
4.                 {
   
5.                         xAngle -= PI/2;
   
6.                 }
   
7.                 else
   
8.                 {
   
9.                         xAngle += PI/2;
   
10.                 }
    
11.                 mtr.makeRotate(xAngle, 1.0f, 0.0f, 0.0f);
    

复制代码

同理，若对魔方进行平移操作，也可以声明一个静态变量来保存它的平移值。

hunter_wwq

提问：但是旋转矩阵节点osg::MatrixTransform这样的旋转特点会很大不利于对魔方的旋转，若要达到如下图所示的旋转结果：

旋转结果示例

第一步是将[0][0][0]位置的方块经过绕X轴逆时针旋转90°至[0][0][3]位置，然后再从[0][0][3]位置绕Z轴逆时针旋转至[3][0][3]位置。但是因为osg::MatrixTransform旋转始终是参考其节点的初始状态进行旋转的，所以执行step1操作时设置的矩阵是Matrix::makeRotate(PI/2, 1.0f, 0.0f, 0.0f)，执行step2操作时设置的矩阵是Matrix::makeRotate(PI/2, 0.0f, 0.0f, 1.0f)，但是这样一转只会转到[3][0][0]位置，而不会转到[3][0][3]位置。
问：有没有什么方法可以让旋转矩阵节点在做变换时都是参考其前一个状态进行旋转而不是始终参考其初始状态进行旋转的？

array

相对值的旋转可以直接对矩阵postMultRotate（如果之前没有translate的话），或者自己保存一个Quat然后叠加新的Quat值给它

hunter_wwq

array 发表于 2013-7-16 10:12
相对值的旋转可以直接对矩阵postMultRotate（如果之前没有translate的话），或者自己保存一个Quat然后叠加新 ...

谢谢array的解答，我上次也在群里问了，@黎曼球 和 @HelloWorld 说用osg:: MatrixTransform的两个方法preMult和postMult试一下，经测试，得出：使用preMult方法，就是让节点先经过现设置的变换矩阵进行变换，然后再进行之前设置的变换矩阵进行变换；使用postMult方法，就是让节点先经过之前设置的变换矩阵进行变换，然后再经过现设置的变换矩阵进行变换，使用这个方法，正是我说的参考旋转节点的前一个状态来进行变换，所以使用postMult方法可行！

hunter_wwq

魔方节点的旋转效果已经搞定！接下来是在旋转时对应魔方单元方块数组中位置的对换以及对应单元面颜色数组中位置的对换。前面也已经提到了这两个数组采用的三维数组arrays[x][y][z]，其中x,y,z代表三维空间中的一个具体的位置。经过分析发现，这两块值的旋转均可采用迭代的形式来进行旋转，即可将其迭代为n个魔方，比如魔方为orderNum阶，则迭代下去有orderNum-2阶，orderNum-4阶，直到2阶或3阶，到此结束迭代。分析如下图所示：

偶数阶非边界单元方块的旋转

通过在方法中设置魔方阶数和偏移量，即可进行数组位置迭代对换，定义的两个方法如下：

1. 
   
2.         /**
   
3.          * 根据旋转参数来对调 侧面/非侧面 单元面颜色数组中的位置
   
4.          * @param [in] bSideFlag 标识是否为侧面
   
5.          * @exception trow std::exception
   
6.          * @warning 当bSideFlag=false时，addOffset必须等于0，否则抛异常并退出函数
   
7.          */
   
8.         void swapCellplaneColorArrayPos(const SRotateParam& rsRP,
   
9.                                                                         const int orderNum, const int addOffset = 0,
   
10.                                                                         bool bSideFlag = false);
    
11. 
    
12.         /**
    
13.          * 根据旋转参数来对调单元方块节点的位置
    
14.          * @param [in] orderNum 阶数
    
15.          * @param [in] addOffset 表示在x\y\z轴上需要增加的偏移量
    
16.          * @warning 除旋转参数外的参数均是用来模拟orderNum魔方的
    
17.          */
    
18.         void swapCellcubeArrayPos(const SRotateParam& rsRP,
    
19.                                                                 const int orderNum,
    
20.                                                                 const int addOffset = 0);
    

复制代码

经测试可得，迭代方法可行！
至此魔方的旋转问题已经解决，包括旋转矩阵节点的旋转、单元方块在数组位置中的对换、单元面颜色在数组位置中的对换！
下一步想做的事是：在魔方区域内操作，根据鼠标滑动的速度、方向、以及停留等来转动魔方；在非魔方区域内操作，则用以调整魔方视图。

hunter_wwq

在定义操作器场景漫游操作的时候终于还是要了解以下几个概念了：
1. 有了矩阵，为什么还需要逆矩阵？逆矩阵起到什么作用？
2. 相机的作用？相机控制器起到的作用？
哎，还是要摸索下这几个概念了！！

hunter_wwq

hunter_wwq 发表于 2013-7-19 13:36
在定义操作器场景漫游操作的时候终于还是要了解以下几个概念了：
1. 有了矩阵，为什么还需要逆矩阵？逆矩 ...

此块知识的学习我重新开了个帖子
探索3D数学-矩阵知识，以及矩阵在OSG中相机和相机操纵器的应用

hunter_wwq

在这里先说一个C++中类设计的一点经验和教训，因为对n阶魔方的构造和操作都有共性，所以我在设计魔方的时候直接将魔方设计为模板类，而这样直接导致在设计的其他类中如果要声明魔方类的属性变量时不得不将该类也设计成模板类，这样就大大限制了其他类的自由，所以我在后来为魔方类定义了一个抽象基类，这个基类仅仅引出我需要调用的接口。在我的类的实现中，将抽象基类定义为了：

1. 
   
2. #pragma once
   
3. #include <osg/Array>
   
4. #include <osg/Geode>
   
5. 
   
6. #include <vector>
   
7. #include <sstream>
   
8. #include <string>
   
9. 
   
10. /**
    
11. * 魔方旋转参数结构
    
12. */
    
13. struct SRotateParam
    
14. {
    
15.         enum AxisType
    
16.         {
    
17.                 AT_X,
    
18.                 AT_Y,
    
19.                 AT_Z
    
20.         };
    
21.         enum RotateDir
    
22.         {
    
23.                 RD_CLOCKWISE,
    
24.                 RD_ANTICLOCKWISE
    
25.         };
    
26. 
    
27.         void reset() { _num = -1; }
    
28.         bool isValid() { return _num >= 0; }
    
29.         bool operator== (const SRotateParam& sRP) const
    
30.         {
    
31.                 return _axisType == sRP._axisType && _rotateDir == sRP._rotateDir && _num == sRP._num;
    
32.         }
    
33. 
    
34.         const SRotateParam& operator= (const SRotateParam& sRP)
    
35.         {
    
36.                 _axisType = sRP._axisType;
    
37.                 _rotateDir = sRP._rotateDir;
    
38.                 _num = sRP._num;
    
39.                 return *this;
    
40.         }
    
41. 
    
42.         AxisType        _axisType;        ///<旋转轴
    
43.         RotateDir        _rotateDir;        ///<旋转方向
    
44.         int                        _num;                ///<旋转轴上第几个面,从0开始计数！
    
45. };
    
46. 
    
47. /**
    
48. * 定义魔方接口
    
49. */
    
50. class CMagicCube
    
51. {
    
52. protected:
    
53.         CMagicCube(void) {};
    
54.         virtual ~CMagicCube(void) {};
    
55. 
    
56. public:
    
57.         typedef std::vector<osg::ref_ptr<osg::MatrixTransform>> cellcube_vec_type;
    
58. 
    
59. // methods
    
60. public:
    
61.         /**
    
62.          * 获得魔方
    
63.          */
    
64.         virtual osg::ref_ptr<osg::Node> getMagicCube() = 0;
    
65. 
    
66.         /**
    
67.          * 获取魔方的中心点坐标
    
68.          */
    
69.         virtual osg::Vec3 getMagicCubeCenter() = 0;
    
70. 
    
71.         /**
    
72.          * 根据单元方块的中心点来获取单元方块在方块数组中的位置Vec3(x, y, z)
    
73.          * @return 返回false表示中心点并不是模仿中某个单元方块的中心点，true则表示是
    
74.          */
    
75.         virtual bool getCellCubeArrayPos(const osg::ref_ptr<osg::Node> node, osg::Vec3s& cellcubeArrayPos) = 0;
    
76. 
    
77.         /**
    
78.          * 处理旋转
    
79.          */
    
80.         virtual void handleRotate(const SRotateParam& rsRP) = 0;
    
81.        
    
82.         /**
    
83.          * 根据旋转参数来获取要旋转的单元方块数组
    
84.          * @exception trow std::exception
    
85.          * @warning 此方法与swapCellcubeArrayPos方法都是对单元方块节点数组进行操作，
    
86.          *       前者为读操作，后者为修改操作，在使用时应该注意两方法的调用顺序
    
87.          */
    
88.         virtual cellcube_vec_type getNeedRotateCellcubes(const SRotateParam& rsRP) = 0;
    
89. };
    

复制代码

将魔方类的实现类定义为：

1. 
   
2. #pragma once
   
3. #include <osg/MatrixTransform>
   
4. #include <osg/Array>
   
5. #include <osg/Shape>
   
6. #include <osg/Geode>
   
7. #include <osg/ShapeDrawable>
   
8. 
   
9. #include <vector>
   
10. #include <sstream>
    
11. #include <string>
    
12. 
    
13. #include "MagicCube.h"
    
14. #include "ColorsBox.h"
    
15. 
    
16. /**
    
17. * @warn orderNum 必须大于0
    
18. */
    
19. template<int orderNum>
    
20. class CMagicCubeImpl : public CMagicCube
    
21. {
    
22. public:
    
23.         CMagicCubeImpl(void);
    
24.         ~CMagicCubeImpl(void);
    
25. 
    
26. // methods
    
27. public:
    
28.         /**
    
29.          * 获得魔方
    
30.          */
    
31.         virtual osg::ref_ptr<osg::Node> getMagicCube();
    
32. 
    
33.         /**
    
34.          * 获取魔方的中心点坐标
    
35.          */
    
36.         virtual osg::Vec3 getMagicCubeCenter() { return osg::Vec3(0.0f, 0.0f, 0.0f); }
    
37. 
    
38.         /**
    
39.          * 根据单元方块的中心点来获取单元方块在方块数组中的位置Vec3(x, y, z)
    
40.          * @return 返回false表示中心点并不是模仿中某个单元方块的中心点，true则表示是
    
41.          */
    
42.         virtual bool getCellCubeArrayPos(const osg::ref_ptr<osg::Node> node, osg::Vec3s& cellcubeArrayPos);
    
43. 
    
44.         /**
    
45.          * 处理旋转
    
46.          * @exception throw string
    
47.          */
    
48.         virtual void handleRotate(const SRotateParam& rsRP);
    
49.        
    
50.         /**
    
51.          * 根据旋转参数来获取要旋转的单元方块数组
    
52.          * @exception trow std::exception
    
53.          * @warning 此方法与swapCellcubeArrayPos方法都是对单元方块节点数组进行操作，
    
54.          *       前者为读操作，后者为修改操作，在使用时应该注意两方法的调用顺序
    
55.          */
    
56.         virtual cellcube_vec_type getNeedRotateCellcubes(const SRotateParam& rsRP);
    
57. 
    
58. protected:
    
59.         /**
    
60.          * 创建魔方框架
    
61.          */
    
62.         osg::ref_ptr<osg::Node> createFrame();
    
63. 
    
64.         /**
    
65.          * 创建魔方，并构造颜色数组
    
66.          */
    
67.         osg::ref_ptr<osg::Node> createMagicCube();
    
68. 
    
69.         /**
    
70.          * 构造单元面颜色数组
    
71.          */
    
72.         void constructCellplaneColors();
    
73. 
    
74.         /**
    
75.          * 根据旋转参数来对调单元面颜色数组中的位置
    
76.          * @exception trow std::exception
    
77.          */
    
78.         void swapCellplaneColorArrayPos(const SRotateParam& rsRP);
    
79. 
    
80.         /**
    
81.          * 根据旋转参数来对调单元方块节点的位置
    
82.          * @exception trow std::exception
    
83.          * @warning 此方法与getCellcubes方法都是对单元方块节点数组进行操作，
    
84.          *       前者为修改操作，后者为读操作，在使用时应该注意两方法的调用顺序
    
85.          */
    
86.         void swapCellcubeArrayPos(const SRotateParam& rsRP);
    
87. 
    
88.         /**
    
89.          * 判断某节点是否是模仿的单元方块节点
    
90.          */
    
91.         bool isCellCubeNode(osg::ref_ptr<osg::Node> node) const { return node->getName() == "magiccube_cellcube"; }
    
92. private:
    
93. 
    
94.         /**
    
95.          * 根据旋转参数来对调 侧面/非侧面 单元面颜色数组中的位置
    
96.          * @param [in] bSideFlag 标识是否为侧面
    
97.          * @exception trow std::exception
    
98.          * @warning 当bSideFlag=false时，addOffset必须等于0，否则抛异常并退出函数
    
99.          */
    
100.         void swapCellplaneColorArrayPos(const SRotateParam& rsRP,
     
101.                                                                         const int orderNum, const int addOffset = 0,
     
102.                                                                         bool bSideFlag = false);
     
103. 
     
104.         /**
     
105.          * 根据旋转参数来对调单元方块节点的位置
     
106.          * @param [in] orderNum 阶数
     
107.          * @param [in] addOffset 表示在x\y\z轴上需要增加的偏移量
     
108.          * @warning 除旋转参数外的参数均是用来模拟orderNum魔方的
     
109.          */
     
110.         void swapCellcubeArrayPos(const SRotateParam& rsRP,
     
111.                                                                 const int orderNum,
     
112.                                                                 const int addOffset = 0);
     
113. 
     
114. // properties
     
115. protected:
     
116.         // 魔方颜色
     
117.         static const osg::Vec4 m_mccFront;
     
118.         static const osg::Vec4 m_mccBack;
     
119.         static const osg::Vec4 m_mccLeft;
     
120.         static const osg::Vec4 m_mccRight;
     
121.         static const osg::Vec4 m_mccTop;
     
122.         static const osg::Vec4 m_mccBottom;
     
123.         // 魔方颜色索引
     
124.         enum ColorIndex
     
125.         {
     
126.                 CI_FRONT,
     
127.                 CI_BACK,
     
128.                 CI_LEFT,
     
129.                 CI_RIGHT,
     
130.                 CI_TOP,
     
131.                 CI_BOTTOM
     
132.         };
     
133. 
     
134.         static const osg::Vec4        SPACE_COLOR;                        ///< 间距填充颜色
     
135.         static const double                DEFAULT_CELL_LENGTH;        ///< 单元格默认长度
     
136.         static const double                DEFAULT_SPACE;                        ///< 单元格之间默认的间距长度
     
137. 
     
138.         osg::ref_ptr<osg::MatrixTransform>        ***m_cellcubes;        ///<单元方块
     
139.         osg::ref_ptr<osg::Group> m_cellcubesNode;                                                        ///<魔方单元格节点
     
140.         osg::ref_ptr<osg::Geode> m_frame;                                                                ///<魔方框架
     
141.         osg::ref_ptr<osg::Group> m_magicCube;                                                        ///<魔方
     
142. 
     
143.         unsigned int                                                ***m_cellplaneColors;        ///<平面颜色，数组[0][0][0]位置不可用
     
144. };
     

复制代码

hunter_wwq

现在讲一下我通过鼠标操作来实现对魔方的旋转，原来的想法是通过重实现事件处理器osgGA::GAEventHandler的方式来达到鼠标操作旋转魔方的效果，当时觉得我只要能够捕捉到鼠标所点击的位置是魔方的哪个单元方块即可，后来想到在旋转魔方的时候我需要判断它是拖向那个面去旋转的，这时候我想到得用到轨迹球漫游器中的trackball方法：通过模拟出一个轨迹球，然后计算从一个点拖动到另一个点，这个旋转过程中所用到的旋转轴axis，和旋转角度angle，这样我就能够在通过简易的计算来得出它是要朝着那个面去旋转。这个简单的计算思路是：知道旋转轴axis，我通过计算单位向量axis分别到x, y, z轴的距离，距离最小的则认为是在那个轴上做的旋转，然后判断angle为正值还是为负值，为正值则为向逆时针方向旋转，为负值则为向顺时针方向旋转。代码实现如下：

1. 
   
2. SRotateParam CMagicCubeManipulator::calcRotateParam(const osg::Vec3d& axis, const float angle)
   
3. {
   
4.         SRotateParam sRP;
   
5. 
   
6.         double disX, disY, disZ;
   
7.         disX = sqrt(axis.length2() - (axis.x()*axis.x()));
   
8.         disY = sqrt(axis.length2() - (axis.y()*axis.y()));
   
9.         disZ = sqrt(axis.length2() - (axis.z()*axis.z()));
   
10.         char axisFlag;
    
11.         double minDis = std::min<double>(disX, disY);
    
12.         axisFlag = disX < disY ? 'X':'Y';
    
13.         axisFlag = minDis < disZ ? axisFlag:'Z';
    
14. 
    
15.         if (axisFlag == 'X')
    
16.         {
    
17.                 sRP._axisType = SRotateParam::AT_X;
    
18.                 sRP._num = m_cellcubeArrayPos[0];
    
19.                 if (axis.x()*angle > 0.0)
    
20.                 {
    
21.                         sRP._rotateDir = SRotateParam::RD_CLOCKWISE;
    
22.                 }
    
23.                 else
    
24.                 {
    
25.                         sRP._rotateDir = SRotateParam::RD_ANTICLOCKWISE;
    
26.                 }
    
27.         }
    
28.         else if (axisFlag == 'Y')
    
29.         {
    
30.                 sRP._axisType = SRotateParam::AT_Y;
    
31.                 sRP._num = m_cellcubeArrayPos[1];
    
32.                 if (axis.x()*angle > 0.0)
    
33.                 {
    
34.                         sRP._rotateDir = SRotateParam::RD_CLOCKWISE;
    
35.                 }
    
36.                 else
    
37.                 {
    
38.                         sRP._rotateDir = SRotateParam::RD_ANTICLOCKWISE;
    
39.                 }
    
40.         }
    
41.         else
    
42.         {
    
43.                 sRP._axisType = SRotateParam::AT_Z;
    
44.                 sRP._num = m_cellcubeArrayPos[2];
    
45.                 if (axis.x()*angle > 0.0)
    
46.                 {
    
47.                         sRP._rotateDir = SRotateParam::RD_CLOCKWISE;
    
48.                 }
    
49.                 else
    
50.                 {
    
51.                         sRP._rotateDir = SRotateParam::RD_ANTICLOCKWISE;
    
52.                 }
    
53.         }
    
54. 
    
55.         return sRP;
    
56. }
    

复制代码

所以最终还是确定通过继承轨迹球漫游器osgGA::TrackballManipulator的方式来实现鼠标操作旋转魔方，定义的类如下：

1. 
   
2. class CMagicCubeManipulator : public osgGA::TrackballManipulator
   
3. {
   
4.         friend void rotate_thread/*<orderNum>*/(void* obj);
   
5. public:
   
6.         CMagicCubeManipulator(CMagicCube* pMagicCube, osg::ref_ptr<osgText::Text>updateText);
   
7.         virtual ~CMagicCubeManipulator(void) { };
   
8. 
   
9. // operations
   
10. public:
    
11.        
    
12. protected:
    
13.         /**
    
14.          * 拾取魔方
    
15.          * @retval true标识拾取到，false标识没拾取到
    
16.          */
    
17.         bool pickMagicCube(osg::ref_ptr<osgViewer::Viewer> viewer, float x, float y);
    
18. 
    
19.         /**
    
20.          * 计算旋转参数
    
21.          */
    
22.         SRotateParam calcRotateParam(const osg::Vec3d& axis, const float angle);
    
23. 
    
24.         /**
    
25.          * 旋转魔方
    
26.          * @param [in] rRotateParam 旋转参数
    
27.          * @param [in] rotateNum 旋转次数
    
28.          * @param [in] valPerRotate 旋转一次转的度数, 此参数为正数
    
29.          * @param [in] speed
    
30.          * @warning rotateNum>=0
    
31.          * #Q: 是否有限定valPerRotate为正数的必要性
    
32.          */
    
33.         void doRotate(const SRotateParam& rRotateParam, const int rotateNum, const double valPerRotate, const int speed = 100);
    
34. 
    
35.         /**
    
36.          * 检测是否可以进行旋转操作
    
37.          */
    
38.         bool checkAccessRotate(const osg::Vec3d& axis, const float angle);
    
39. 
    
40.         /**
    
41.          * 进行旋转
    
42.          */
    
43.         void doRotate();
    
44. 
    
45.         // 重载以下三个方法
    
46.         virtual bool handleMouseDrag( const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& us );
    
47.         virtual bool handleMousePush( const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& us );
    
48.         virtual bool handleMouseRelease( const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& us );
    
49. 
    
50. // properties
    
51. protected:
    
52.         static const double m_valPerRotate;
    
53. 
    
54.         CMagicCube*                m_pMagicCube;
    
55.         osg::ref_ptr<osgText::Text> m_updateText;
    
56.         bool                        m_bPickMagicCube;///< 标识已经拾取魔方
    
57.         osg::Vec3s                m_cellcubeArrayPos;///< 拾取的魔方方块
    
58.         SRotateParam        m_rotateParam;///< 旋转参数
    
59.         bool                        m_bReleased;///< 在drag之后有没有release
    
60. };
    

复制代码

hunter_wwq

之前想的是在重载方法handleMouseDrag中通过设置矩阵来实现魔方的连续渐渐旋转的效果，结果显示的效果却是直接旋转90度而不是渐渐旋转的效果，经调试发现在视景器执行frame时是先处理完所有的事件后再进行渲染的，所以在handle方法还没有返回前不会执行渲染的动作，而我再handleMouseDrag方法中进行设计旋转矩阵效果并没有体现出来，它是在做完所有的旋转矩阵后用到最后一次旋转矩阵结果来对指定面上的单元魔方方格进行旋转的。所以我将设计旋转矩阵来实现魔方渐渐旋转的动作放在了另一个工作线程中，然后通过信号量来限定魔方旋转和旋转事件处理的同步问题。响应一次旋转事件是旋转90度，在旋转的过程中不再响应旋转事件的处理动作。
最终这个方法可行。但是上一楼所说的那个判断旋转参数的方法calcRotateParam实现并没有很精确，老是顺逆不分，而且对鼠标旋转动作的识别也不是很准确，所以在这部分仍然需要继续优化一下。现在优化也正在进行，等做好了后再把代码分享给跟我一样菜的菜鸟们吧。。。。。。。