Fenz 的在线魔方程序【更新变形魔方】

hubo5563

我看了3×3×3的数据文件3x3x3.js，确实不少。我没用过SVG+JS 技术，提不出什么建议。
如果魔方块多时，最好用程序生成那些块的坐标数据。
我也没有猜到其他两个的名字。

hubo5563

[ 本帖最后由 hubo5563 于 2014-5-5 11:53 编辑 ]

转动操作的块轮换我也是手工输入的，魔方复杂时数据很多，例如百慕大五角24面体，24个转动面，每个面有11个块，我用一个数组表示，这些数据也是手工输入的：
private static final int[][] PiceLunHuan=
{      //24个面转动360/11度角的各个块的位置轮换
      {37,92, 36, 93,38, 94,39, 95,25, 80,24},     //0
      {24,80, 25, 81,26, 82,27, 83,28, 84,29},     //1
      {29,84, 28, 85,30, 86,31, 87,32, 88,33},     //2
      {33,88, 32, 89,34, 90,35, 91,36, 92,37},     //3
      {54,113,53,117,56,116,57,115,58,114,59},     //4
      {59,114,58,118,38, 93,36, 91,35,109,60},     //5
      {60,109,35, 90,34,108,50,107,49,110,55},     //6
      {55,110,49,106,48,111,52,112,53,113,54},     //7
      {65,123,64,127,71,128,72,129,73,131,74},     //8      
      {74,131,73,130,26, 81,25, 95,39,125,67},     //9      
      {67,125,39, 94,38,118,58,115,57,124,66},     //10      
      {66,124,57,116,56,121,63,122,64,123,65},     //11      
      {76,139,75,134,44, 99,41, 97,40,137,79},     //12      
      {79,137,40, 96,30, 85,28, 83,27,138,78},     //13      
      {78,138,27, 82,26,130,73,129,72,132,77},     //14      
      {77,132,72,128,71,126,70,133,75,139,76},     //15      
      {47,102,46,105,48,106,49,107,50,103,51},     //16      
      {51,103,50,108,34, 89,32, 87,31,104,43},     //17      
      {43,104,31, 86,30, 96,40, 97,41, 98,42},     //18      
      {42, 98,41, 99,44,100,45,101,46,102,47},     //19
      {69,135,70,126,71,127,64,122,63,120,62},     //20
      {62,120,63,121,56,117,53,112,52,119,61},     //21
      {61,119,52,111,48,105,46,101,45,136,68},     //22      
      {68,136,45,100,44,134,75,133,70,135,69}      //23
        
};
里面都是块的顺序号。
处理转动群的程序简单：

void lunhuancz(int n)
{   //正向转动一层后的块轮换操作
   int i,k;
   k=CubeX[PiceLunHuan[n][0]];
   
   for(i=1;i<11;i++)
   {
      CubeX[PiceLunHuan[n][i-1]]=CubeX[PiceLunHuan[n][i] ];
   };
   CubeX[PiceLunHuan[n][10]]=k;
   CubeTurn[n]=(CubeTurn[n]+1) % 11;
};

void lunhuanczf(int n)
{   //反向转动一层后的块轮换操作
   int i,k;
   
   
   k=CubeX[PiceLunHuan[n][10]];
   
   for(i=10;i>0;i--)
   {
      CubeX[PiceLunHuan[n][i]]=CubeX[PiceLunHuan[n][i-1] ];
   };
   CubeX[PiceLunHuan[n][0]]=k;
   CubeTurn[n]=(CubeTurn[n]+10) % 11;   
};

CubeTurn[]是一个记录每个面的转动角度数组，用来判断相邻面是否可以转动的，初始都是根据面编码程序自动生成的。
CubeX是个数组，记录转动后魔方各个位置的块序号，初始是顺序的。
n是转动的面号，每次转动根据转动方向执行上面对应的轮换程序。
至于块的方向，都反映在坐标里了，不需要记录。

每次转动时只转动转面牵涉到的块：

      for(i=0;i<11;i++)
        {
        zhuandong(Cube[CubeX[PiceLunHuan[n][i]]]);     //面上的棱块和角块
        };
        zhuandong(Cube[n]);                         //中心块

zhuandong()
就是对块里的每个3D点坐标变换。Cube[]是Piece 数组。

那些数据是根据下面的图输入的，图中粉色数是中心块号，蓝色数是棱块和角块号，需要把图中数加上24：因为块数组前24个是中心块。

hubo5563

Fenz 发表于 2014-5-9 00:59
胡老师，请教一下视角转动的问题？
我的程序之前视角只有二维转动，现在写成三维转动，具体算法是这样的 ...

我处理的方法和你不同，鼠标拖动不改变模型的3D坐标。
我用一个矩阵记录转动积累，每次鼠标拖动计算x和y方向的转动角度，然后变换那个矩阵。
具体显示时，用当前矩阵变换模型中的点，再显示。
模型中的坐标只有转动魔方的某层时才变化，平常鼠标拖动是不变的。

hubo5563

Fenz 发表于 2014-5-9 19:32
其实我的也不会改变魔方的坐标，改变的是摄像机的坐标。然后再根据摄像机坐标来投影绘图。原理是一样的， ...

程序：
//////////////////////////////////////////////
//鼠标拖动事件处理
public void mouseDragged(MouseEvent e){
    int x = e.getX();
    int y = e.getY();
    if (pushed)
    return;
    if (dragging) {
    if(prevy>top && prevy<height+top)
    {
    if (painted) {
      painted = false;
      double xtheta = (y-prevy) * (360.0d / getSize().width);     //计算按x轴转动的角度
      double ytheta = (prevx-x) * (360.0d / getSize().height);    //计算按y轴转动的角度
      SpinX(xtheta);                //变换矩阵
      SpinY(ytheta);                //变换矩阵
      Graphics gg=getGraphics();
      xianshimq(gg);             //显示魔方
      drawButtons(gg);           //画底下的按钮
      painted = true;
       };   
     };  
     };
    prevx = x;
    prevy = y;
    e.consume();
};



        初始化矩阵
       //将坐标变换矩阵设为单位矩阵
        da11=1;        da12=0;        da13=0;
        da21=0;        da22=1;        da23=0;
        da31=0;        da32=0;        da33=1;


void  SpinX(double jiao)
{
double a11,a12,a13,a21,a22,a23,a31,a32,a33;
double sina,cosa;
sina=Math.sin( jiao*Math.PI/180);
cosa=Math.cos( jiao*Math.PI/180);
a11=da11;
a21=cosa*da21+sina*da31;
a31=-sina*da21+cosa*da31;
a12=da12;
a22=cosa*da22+sina*da32;
a32=-sina*da22+cosa*da32;
a13=da13;
a23=cosa*da23+sina*da33;
a33=-sina*da23+cosa*da33;
//给全局变量赋值
da11=a11;da12=a12;da13=a13;
da21=a21;da22=a22;da23=a23;
da31=a31;da32=a32;da33=a33;
};
//以Y轴为轴魔方整体顺时针旋转一个角度
void  SpinY(double jiao)
{

        double a11,a12,a13,a21,a22,a23,a31,a32,a33;
double sina,cosa;
sina=Math.sin( jiao*Math.PI/180);
cosa=Math.cos( jiao*Math.PI/180);
a11=cosa*da11+sina*da31;
a21=da21;
a31=-sina*da11+cosa*da31;
a12=cosa*da12+sina*da32;
a22=da22;
a32=-sina*da12+cosa*da32;
a13=cosa*da13+sina*da33;
a23=da23;
a33=-sina*da13+cosa*da33;
//给全局变量赋值
da11=a11;da12=a12;da13=a13;
da21=a21;da22=a22;da23=a23;
da31=a31;da32=a32;da33=a33;
};

//以当前旋转矩阵变换三维点，整体旋转时采用
void  dbh3(Point3d p,Point3d pp)
{
        p.x=(pp.x)*da11+(pp.y)*da12+(pp.z)*da13;
        p.y=(pp.x)*da21+(pp.y)*da22+(pp.z)*da23;
        p.z=(pp.x)*da31+(pp.y)*da32+(pp.z)*da33;
};

//将三维坐标转换为2维透视坐标，转换x坐标
int  dbh5x(Point3d p)
{
double xx,zz;int ii;
xx=p.x+xx1;
zz=p.z+zz1;
xx=xx*zz0/(zz0+zz);
xx=xx0+factor_x*xx;
ii=(int)xx;
return ii;
};
//将三维坐标转换为2维透视坐标，转换y坐标
int  dbh5y(Point3d p)
{
double yy,zz;int ii;
yy=p.y+yy1;
zz=p.z+zz1;
yy=yy*zz0/(zz0+zz);
yy=yy0-factor_y*yy;
ii=(int)yy;
return ii;
};

经过变换就是屏幕的实际坐标。

hubo5563

Fenz 发表于 2014-5-10 16:16
最后还是改用了您的方法，用矩阵表示摄像机位置和方向，这样比我原来的算法少了许多三角函数和反三角函数 ...