rubik.java

3D效果......很好的效果

   { 

    if (!twisting && OKtoDrag)

     { 

      OKtoDrag = false; 

      boolean flag = false; 

      for (this.i = 0; this.i < dragReg; this.i++) { 

        double d1 = dragCorn[this.i * 8 + 1] - dragCorn[this.i * 8]; 

        double d2 = dragCorn[this.i * 8 + 5] - dragCorn[this.i * 8 + 4]; 

        double d3 = dragCorn[this.i * 8 + 3] - dragCorn[this.i * 8]; 

        double d4 = dragCorn[this.i * 8 + 7] - dragCorn[this.i * 8 + 4]; 

        double d5 = (d4 * ((double) lastX - dragCorn[this.i * 8]) - d3 

            * ((double) lastY - dragCorn[this.i * 8 + 4])) 

            / (d1 * d4 - d3 * d2); 

        double d6 = (-d2 * ((double) lastX - dragCorn[this.i * 8]) + d1 

            * ((double) lastY - dragCorn[this.i * 8 + 4])) 

            / (d1 * d4 - d3 * d2); 

        if (d5 > 0.0 && d5 < 1.0 && d6 > 0.0 && d6 < 1.0) { 

          currDragDir[0] = dragDir[this.i * 2]; 

          currDragDir[1] = dragDir[this.i * 2 + 1]; 

          d = currDragDir[0] * (i - lastX) + currDragDir[1] * (j - lastY); 

          d = d 

              * d 

              / ((currDragDir[0] * currDragDir[0] + currDragDir[1] 

                  * currDragDir[1]) * ((i - lastX) * (i - lastX) + (j - lastY) 

                  * (j - lastY))); 

          if (d > 0.6) { 

            flag = true; 

            twistSide = nearSide[this.i]; 

            this.i = 100; 

          } 

        } 

      } 

      if (flag) { 

        if (naturalState) { 

          cutUpCube(); 

          naturalState = false; 

        } 

        twisting = true; 

        phi = 0.02 

            * (currDragDir[0] * (i - lastX) + currDragDir[1] * (j - lastY)) 

            / Math.sqrt(currDragDir[0] * currDragDir[0] + currDragDir[1] 

                * currDragDir[1]); 

        repaint(); 

        return false; 

      } 

    } 

    OKtoDrag = false; 

    if (!twisting) { 

      dx = lastX - i; 

      copyVec(eX, 0, temp, 0); 

      scalMult(temp, 0, (double) dx * 0.016); 

      addVec(temp, 0, eye, 0); 

      vecProd(eY, 0, eye, 0, eX, 0); 

      normalize(eX, 0); 

      normalize(eye, 0); 

      dy = j - lastY; 

      copyVec(eY, 0, temp, 0); 

      scalMult(temp, 0, (double) dy * 0.016); 

      addVec(temp, 0, eye, 0); 

      vecProd(eye, 0, eX, 0, eY, 0); 

      normalize(eY, 0); 

      normalize(eye, 0); 

      lastX = i; 

      lastY = j; 

      repaint(); 

    } else { 

      phi = 0.02 

          * (currDragDir[0] * (i - lastX) + currDragDir[1] * (j - lastY)) 

          / Math.sqrt(currDragDir[0] * currDragDir[0] + currDragDir[1] 

              * currDragDir[1]); 

      repaint(); 

    } 

    return false; 

  } 


  public boolean mouseDown(Event event, int i, int j) 

  { 

    lastX = i; 

    lastY = j; 

    OKtoDrag = true; 

    return false; 

  } 


  public boolean mouseUp(Event event, int i, int j)

   { 

    if (twisting) { 

      double d; 

      twisting = false; 

      phibase += phi; 

      phi = 0.0; 

      for (d = phibase; d < 0.0; d += 125.662) /* null body */; 

      int k = (int) (d * 3.183); 

      if (k % 5 == 0 || k % 5 == 4) { 

        k = (k + 1) / 5 % 4; 

        if (colDir[twistSide] < 0) k = (4 - k) % 4; 

        phibase = 0.0; 

        naturalState = true; 

        colorTwist(twistSide, k); 

      } 

      repaint(); 

    } 

    return false; 

  } 


  public void colorTwist(int i1, int j1) { 

    int k4 = 0; 

    int j4 = j1 * 2; 

    for (int k1 = 0; k1 < 8; k1++) { 

      buffer[j4] = sideCols[i1 * 9 + circleOrder[k1]]; 

      j4 = (j4 + 1) % 8; 

    } 

    for (int i2 = 0; i2 < 8; i2++) 

      sideCols[i1 * 9 + circleOrder[i2]] = buffer[i2]; 

    j4 = j1 * 3; 

    for (int j2 = 0; j2 < 4; j2++) { 

      for (int i3 = 0; i3 < 4; i3++) 

        if (nextSide[nextSide[i1 * 4 + j2] * 4 + i3] == i1) k4 = i3; 

      for (int j3 = 0; j3 < 3; j3++) { 

        switch (k4) { 

          case 0: 

            buffer[j4] = sideCols[nextSide[i1 * 4 + j2] * 9 + j3]; 

          break; 


          case 1: 

            buffer[j4] = sideCols[nextSide[i1 * 4 + j2] * 9 + 2 + 3 * j3]; 

          break; 


          case 2: 

            buffer[j4] = sideCols[nextSide[i1 * 4 + j2] * 9 + 8 - j3]; 

          break; 


          case 3: 

            buffer[j4] = sideCols[nextSide[i1 * 4 + j2] * 9 + 6 - 3 * j3]; 

          break; 

        } 

        j4 = (j4 + 1) % 12; 

      } 

    } 

    j4 = 0; 

    for (int k2 = 0; k2 < 4; k2++) { 

      for (int k3 = 0; k3 < 4; k3++) 

        if (nextSide[nextSide[i1 * 4 + k2] * 4 + k3] == i1) k4 = k3; 

      for (int i4 = 0; i4 < 3; i4++) { 

        switch (k4) { 

          case 0: 

            sideCols[nextSide[i1 * 4 + k2] * 9 + i4] = buffer[j4]; 

          break; 


          case 1: 

            sideCols[nextSide[i1 * 4 + k2] * 9 + 2 + 3 * i4] = buffer[j4]; 

          break; 


          case 2: 

            sideCols[nextSide[i1 * 4 + k2] * 9 + 8 - i4] = buffer[j4]; 

          break; 


          case 3: 

            sideCols[nextSide[i1 * 4 + k2] * 9 + 6 - 3 * i4] = buffer[j4]; 

          break; 

        } 

        j4++; 

      } 

    } 

  } 


  public void paint(Graphics g) 

  { 

    dragReg = 0; 

    offGraphics.setColor(bgcolor); 

    offGraphics.fillRect(0, 0, 120, 120);

     

    if (naturalState) fixBlock(eye, eX, eY, corners, mainBlocks, 0); 

    else { 

      copyVec(eye, 0, Teye, 0); 

      copyVec(eX, 0, TeX, 0); 

      Cphi = Math.cos(phi + phibase); 

      Sphi = -Math.sin(phi + phibase); 

      switch (twistSide) { 

        case 0: 

          Teye[0] = Cphi * eye[0] + Sphi * eye[1]; 

          TeX[0] = Cphi * eX[0] + Sphi * eX[1]; 

          Teye[1] = -Sphi * eye[0] + Cphi * eye[1]; 

          TeX[1] = -Sphi * eX[0] + Cphi * eX[1]; 

        break; 


        case 1: 

          Teye[0] = Cphi * eye[0] - Sphi * eye[1]; 

          TeX[0] = Cphi * eX[0] - Sphi * eX[1]; 

          Teye[1] = Sphi * eye[0] + Cphi * eye[1]; 

          TeX[1] = Sphi * eX[0] + Cphi * eX[1]; 

        break; 


        case 2: 

          Teye[0] = Cphi * eye[0] - Sphi * eye[2]; 

          TeX[0] = Cphi * eX[0] - Sphi * eX[2]; 

          Teye[2] = Sphi * eye[0] + Cphi * eye[2]; 

          TeX[2] = Sphi * eX[0] + Cphi * eX[2]; 

        break; 


        case 3: 

          Teye[1] = Cphi * eye[1] + Sphi * eye[2]; 

          TeX[1] = Cphi * eX[1] + Sphi * eX[2]; 

          Teye[2] = -Sphi * eye[1] + Cphi * eye[2]; 

          TeX[2] = -Sphi * eX[1] + Cphi * eX[2]; 

        break; 


        case 4: 

          Teye[0] = Cphi * eye[0] + Sphi * eye[2]; 

          TeX[0] = Cphi * eX[0] + Sphi * eX[2]; 

          Teye[2] = -Sphi * eye[0] + Cphi * eye[2]; 

          TeX[2] = -Sphi * eX[0] + Cphi * eX[2]; 

        break; 


        case 5: 

          Teye[1] = Cphi * eye[1] - Sphi * eye[2]; 

          TeX[1] = Cphi * eX[1] - Sphi * eX[2]; 

          Teye[2] = Sphi * eye[1] + Cphi * eye[2]; 

          TeX[2] = Sphi * eX[1] + Cphi * eX[2]; 

        break; 

      } 

      vecProd(Teye, 0, TeX, 0, TeY, 0); 

      if (scalProd(eye, 0, sideVec, twistSide * 3) < 0.0) { 

        fixBlock(Teye, TeX, TeY, topCorners, topBlocks, 2); 

        fixBlock(eye, eX, eY, botCorners, botBlocks, 1); 

      } else { 

        fixBlock(eye, eX, eY, botCorners, botBlocks, 1); 

        fixBlock(Teye, TeX, TeY, topCorners, topBlocks, 2); 

      } 

    } 

    g.drawImage(offImage, 0, 0, this); 

  } 


  public void update(Graphics g)

   { 

    paint(g); 

  } 


  public void fixBlock(double ad1[], double ad2[], double ad3[], double ad4[], 

      int an[], int i) { 

    copyVec(ad1, 0, light, 0); 

    scalMult(light, 0, -3); 

    addVec(ad2, 0, light, 0); 

    subVec(ad3, 0, light, 0); 

    for (this.i = 0; this.i < 8; this.i++) { 

      newCoord[this.i * 2] = 60 + 35.1 * scalProd(ad4, this.i * 3, ad2, 0); 

      newCoord[this.i * 2 + 1] = 60 - 35.1 * scalProd(ad4, this.i * 3, ad3, 0); 

    } 

    for (this.i = 0; this.i < 6; this.i++) { 

      if (scalProd(ad1, 0, sideVec, 3 * this.i) > 0.001) { 

        k = (int) (9.6 * (1.0 - cosAng(light, 0, sideVec, 3 * this.i))); 

        offGraphics.setColor(Color.black); 

        for (j = 0; j < 4; j++) { 

          rectX[j] = (int) newCoord[2 * sides[this.i * 4 + j]]; 

          rectY[j] = (int) newCoord[2 * sides[this.i * 4 + j] + 1]; 

        } 

        offGraphics.fillPolygon(rectX, rectY, 4); 

        sideW = an[this.i * 4 + 1] - an[this.i * 4]; 

        sideH = an[this.i * 4 + 3] - an[this.i * 4 + 2]; 

        if (sideW > 0) { 

          sx = newCoord[2 * sides[this.i * 4]]; 

          sy = newCoord[2 * sides[this.i * 4] + 1]; 

          sdxh = (newCoord[2 * sides[this.i * 4 + 1]] - sx) / sideW; 

          sdxv = (newCoord[2 * sides[this.i * 4 + 3]] - sx) / sideH; 

          sdyh = (newCoord[2 * sides[this.i * 4 + 1] + 1] - sy) / sideW; 

          sdyv = (newCoord[2 * sides[this.i * 4 + 3] + 1] - sy) / sideH; 

          p = an[this.i * 4 + 2]; 

          for (n = 0; n < sideH; n++) { 

            q = an[this.i * 4]; 

            for (o = 0; o < sideW; o++) { 

              rectX[0] = (int) (sx + ((double) o + 0.1) * sdxh + ((double) n + 0.1) 

                  * sdxv); 

              rectX[1] = (int) (sx + ((double) o + 0.9) * sdxh + ((double) n + 0.1) 

                  * sdxv); 

              rectX[2] = (int) (sx + ((double) o + 0.9) * sdxh + ((double) n + 0.9) 

                  * sdxv); 

              rectX[3] = (int) (sx + ((double) o + 0.1) * sdxh + ((double) n + 0.9) 

                  * sdxv); 

              rectY[0] = (int) (sy + ((double) o + 0.1) * sdyh + ((double) n + 0.1) 

                  * sdyv); 

              rectY[1] = (int) (sy + ((double) o + 0.9) * sdyh + ((double) n + 0.1) 

                  * sdyv); 

              rectY[2] = (int) (sy + ((double) o + 0.9) * sdyh + ((double) n + 0.9) 

                  * sdyv); 

              rectY[3] = (int) (sy + ((double) o + 0.1) * sdyh + ((double) n + 0.9) 

                  * sdyv); 

              offGraphics.setColor(colList[20 

                  * sideCols[this.i * 9 + p * 3 + q] + k]); 

              offGraphics.fillPolygon(rectX, rectY, 4); 

              q++; 

            } 

            p++; 

          } 

        } 

        switch (i) { 

          case 0: 

            t1 = sx; 

            t2 = sy; 

            t3 = sdxh; 

            t4 = sdyh; 

            t5 = sdxv; 

            t6 = sdyv; 

            for (j = 0; j < 4; j++) { 

              dragCorn[8 * dragReg] = t1; 

              dragCorn[8 * dragReg + 4] = t2; 

              dragCorn[8 * dragReg + 3] = t1 + t5; 

              dragCorn[8 * dragReg + 7] = t2 + t6; 

              t1 = t1 + t3 * 3; 

              t2 = t2 + t4 * 3; 

              dragCorn[8 * dragReg + 1] = t1; 

              dragCorn[8 * dragReg + 5] = t2; 

              dragCorn[8 * dragReg + 2] = t1 + t5; 

              dragCorn[8 * dragReg + 6] = t2 + t6; 

              dragDir[dragReg * 2] = t3 * twistDir[this.i * 4 + j]; 

              dragDir[dragReg * 2 + 1] = t4 * twistDir[this.i * 4 + j]; 

              d = t3; 

              t3 = t5; 

              t5 = -d; 

              d = t4; 

              t4 = t6; 

              t6 = -d; 

              nearSide[dragReg] = nextSide[this.i * 4 + j]; 

              dragReg++; 

            } 

          break; 


          case 2: 

            if (this.i != twistSide && sideW > 0) { 

              if (sideW == 3) { 

                if (an[this.i * 4 + 2] == 0) { 

                  dragDir[dragReg * 2] = sdxh * twistDir[this.i * 4]; 

                  dragDir[dragReg * 2 + 1] = sdyh * twistDir[this.i * 4]; 

                } else { 

                  dragDir[dragReg * 2] = -sdxh * twistDir[this.i * 4 + 2]; 

                  dragDir[dragReg * 2 + 1] = -sdyh * twistDir[this.i * 4 + 2]; 

                } 

              } else if (an[this.i * 4] == 0) { 

                dragDir[dragReg * 2] = -sdxv * twistDir[this.i * 4 + 3]; 

                dragDir[dragReg * 2 + 1] = -sdyv * twistDir[this.i * 4 + 3]; 

              } else { 

                dragDir[dragReg * 2] = sdxv * twistDir[this.i * 4 + 1]; 

                dragDir[dragReg * 2 + 1] = sdyv * twistDir[this.i * 4 + 1]; 

              } 

              for (j = 0; j < 4; j++) { 

                dragCorn[dragReg * 8 + j] = newCoord[2 * sides[this.i * 4 + j]]; 

                dragCorn[dragReg * 8 + 4 + j] = newCoord[2 * sides[this.i * 4 

                    + j] + 1]; 

              } 

              nearSide[dragReg] = twistSide; 

              dragReg++; 

            } 

          break; 

        } 

      } 

    } 

  } 


  public rubik() { 

    twistSide = -1; 

    //eye = { 0.3651, 0.1826, -0.9129 }; 

    //eX = { 0.9309, -0.0716, 0.3581 }; 

    //temp = { 0.0, 0.0, 0.0 }; 

    //temp2 = { 0.0, 0.0, 0.0 }; 

    naturalState = true; 

    twisting = false; 

    OKtoDrag = false; 

  } 

}