matrix3d.java

一个java写的魔方游戏

// FrontEnd Plus GUI for JAD
// DeCompiled : Matrix3D.class

import java.io.PrintStream;

class Matrix3D
{

    float xx;
    float xy;
    float xz;
    float xd;
    float yx;
    float yy;
    float yz;
    float yd;
    float zx;
    float zy;
    float zz;
    float zd;
    float dx;
    float dy;
    float dz;
    float dd;
    static final double pi = 3.1415926500000002D;

    Matrix3D()
    {
        xx = 1.0F;
        yy = 1.0F;
        zz = 1.0F;
        dd = 1.0F;
    }

    Matrix3D(float af[][])
    {
        xx = af[0][0];
        xy = af[0][1];
        xz = af[0][2];
        xd = af[0][3];
        yx = af[1][0];
        yy = af[1][1];
        yz = af[1][2];
        yd = af[1][3];
        zx = af[2][0];
        zy = af[2][1];
        zz = af[2][2];
        zd = af[2][3];
        dx = af[3][0];
        dy = af[3][1];
        dz = af[3][2];
        dd = af[3][3];
    }

    void SetValue(float f, float f1, float f2, float f3, float f4, float f5, float f6, 
            float f7, float f8)
    {
        xx = f;
        xy = f1;
        xz = f2;
        yx = f3;
        yy = f4;
        yz = f5;
        zx = f6;
        zy = f7;
        zz = f8;
        xd = 0.0F;
        yd = 0.0F;
        zd = 0.0F;
        dx = 0.0F;
        dy = 0.0F;
        dz = 0.0F;
        dd = 1.0F;
    }

    void PreScale(float f, float f1, float f2)
    {
        xx *= f;
        yx *= f;
        zx *= f;
        dx *= f;
        xy *= f1;
        yy *= f1;
        zy *= f1;
        dy *= f1;
        xz *= f2;
        yz *= f2;
        zz *= f2;
        dz *= f2;
    }

    void ProScale(float f, float f1, float f2)
    {
        xx *= f;
        xy *= f;
        xz *= f;
        xd *= f;
        yx *= f1;
        yy *= f1;
        yz *= f1;
        yd *= f1;
        zx *= f2;
        zy *= f2;
        zz *= f2;
        zd *= f2;
    }

    void PreTranslate(float f, float f1, float f2)
    {
        xd += f * xx;
        yd += f1 * yy;
        zd += f2 * zz;
    }

    void ProTranslate(float f, float f1, float f2)
    {
        xx += f * dx;
        xy += f * dy;
        xz += f * dz;
        xd += f * dd;
        yx += f1 * dx;
        yy += f1 * dy;
        yz += f1 * dz;
        yd += f1 * dd;
        zx += f2 * dx;
        zy += f2 * dy;
        zz += f2 * dz;
        zd += f2 * dd;
    }

    void PreXRotate(double d)
    {
        double d1 = Math.cos(d);
        double d2 = Math.sin(d);
        float f = (float)((double)xy * d1 + (double)xz * d2);
        float f1 = (float)((double)yy * d1 + (double)yz * d2);
        float f2 = (float)((double)zy * d1 + (double)zz * d2);
        float f3 = (float)((double)dy * d1 + (double)dz * d2);
        float f4 = (float)((double)xz * d1 - (double)xy * d2);
        float f5 = (float)((double)yz * d1 - (double)yy * d2);
        float f6 = (float)((double)zz * d1 - (double)zy * d2);
        float f7 = (float)((double)dz * d1 - (double)dy * d2);
        xy = f;
        yy = f1;
        zy = f2;
        dy = f3;
        xz = f4;
        yz = f5;
        zz = f6;
        dz = f7;
    }

    void PreYRotate(double d)
    {
        double d1 = Math.cos(d);
        double d2 = Math.sin(d);
        float f = (float)((double)xz * d1 + (double)xx * d2);
        float f1 = (float)((double)yz * d1 + (double)yx * d2);
        float f2 = (float)((double)zz * d1 + (double)zx * d2);
        float f3 = (float)((double)dz * d1 + (double)dx * d2);
        float f4 = (float)((double)xx * d1 - (double)xz * d2);
        float f5 = (float)((double)yx * d1 - (double)yz * d2);
        float f6 = (float)((double)zx * d1 - (double)zz * d2);
        float f7 = (float)((double)dx * d1 - (double)dz * d2);
        xz = f;
        yz = f1;
        zz = f2;
        dz = f3;
        xx = f4;
        yx = f5;
        zx = f6;
        dx = f7;
    }

    void PreZRotate(double d)
    {
        double d1 = Math.cos(d);
        double d2 = Math.sin(d);
        float f = (float)((double)xx * d1 + (double)xy * d2);
        float f1 = (float)((double)yx * d1 + (double)yy * d2);
        float f2 = (float)((double)zx * d1 + (double)zy * d2);
        float f3 = (float)((double)dx * d1 + (double)dy * d2);
        float f4 = (float)((double)xy * d1 - (double)xx * d2);
        float f5 = (float)((double)yy * d1 - (double)yx * d2);
        float f6 = (float)((double)zy * d1 - (double)zx * d2);
        float f7 = (float)((double)dy * d1 - (double)dx * d2);
        xx = f;
        yx = f1;
        zx = f2;
        dx = f3;
        xy = f4;
        yy = f5;
        zy = f6;
        dy = f7;
    }

    void ProXRotate(double d)
    {
        double d1 = Math.cos(d);
        double d2 = Math.sin(d);
        float f = (float)((double)yx * d1 - (double)zx * d2);
        float f1 = (float)((double)yy * d1 - (double)zy * d2);
        float f2 = (float)((double)yz * d1 - (double)zz * d2);
        float f3 = (float)((double)yd * d1 - (double)zd * d2);
        float f4 = (float)((double)zx * d1 + (double)yx * d2);
        float f5 = (float)((double)zy * d1 + (double)yy * d2);
        float f6 = (float)((double)zz * d1 + (double)yz * d2);
        float f7 = (float)((double)zd * d1 + (double)yd * d2);
        yx = f;
        yy = f1;
        yz = f2;
        yd = f3;
        zx = f4;
        zy = f5;
        zz = f6;
        zd = f7;
    }

    void ProYRotate(double d)
    {
        double d1 = Math.cos(d);
        double d2 = Math.sin(d);
        float f = (float)((double)zx * d1 - (double)xx * d2);
        float f1 = (float)((double)zy * d1 - (double)xy * d2);
        float f2 = (float)((double)zz * d1 - (double)xz * d2);
        float f3 = (float)((double)zd * d1 - (double)xd * d2);
        float f4 = (float)((double)xx * d1 + (double)zx * d2);
        float f5 = (float)((double)xy * d1 + (double)zy * d2);
        float f6 = (float)((double)xz * d1 + (double)zz * d2);
        float f7 = (float)((double)xd * d1 + (double)zd * d2);
        zx = f;
        zy = f1;
        zz = f2;
        zd = f3;
        xx = f4;
        xy = f5;
        xz = f6;
        xd = f7;
    }

    void ProZRotate(double d)
    {
        double d1 = Math.cos(d);
        double d2 = Math.sin(d);
        float f = (float)((double)xx * d1 - (double)yx * d2);
        float f1 = (float)((double)xy * d1 - (double)yy * d2);
        float f2 = (float)((double)xz * d1 - (double)yz * d2);
        float f3 = (float)((double)xd * d1 - (double)yd * d2);
        float f4 = (float)((double)yx * d1 + (double)xx * d2);
        float f5 = (float)((double)yy * d1 + (double)xy * d2);
        float f6 = (float)((double)yz * d1 + (double)xz * d2);
        float f7 = (float)((double)yd * d1 + (double)xd * d2);
        xx = f;
        xy = f1;
        xz = f2;
        xd = f3;
        yx = f4;
        yy = f5;
        yz = f6;
        yd = f7;
    }

    void Unify()
    {
        xx = 1.0F;
        xy = 0.0F;
        xz = 0.0F;
        xd = 0.0F;
        yx = 0.0F;
        yy = 1.0F;
        yz = 0.0F;
        yd = 0.0F;
        zx = 0.0F;
        zy = 0.0F;
        zz = 1.0F;
        zd = 0.0F;
        dx = 0.0F;
        dy = 0.0F;
        dz = 0.0F;
        dd = 1.0F;
    }

    void Transform(Vertex avertex[], Vertex avertex1[], int i)
    {
        for(int j = 0; j < i; j++)
        {
            float f = avertex[j].x;
            float f1 = avertex[j].y;
            float f2 = avertex[j].z;
            float f3 = f * dx + f1 * dy + f2 * dz + dd;
            avertex1[j].x = (f * xx + f1 * xy + f2 * xz + xd) / f3;
            avertex1[j].y = (f * yx + f1 * yy + f2 * yz + yd) / f3;
            avertex1[j].z = (f * zx + f1 * zy + f2 * zz + zd) / f3;
        }

    }

    void Transform(Vertex vertex, Vertex vertex1)
    {
        float f = vertex.x;
        float f1 = vertex.y;
        float f2 = vertex.z;
        float f3 = f * dx + f1 * dy + f2 * dz + dd;
        vertex1.x = (f * xx + f1 * xy + f2 * xz + xd) / f3;
        vertex1.y = (f * yx + f1 * yy + f2 * yz + yd) / f3;
        vertex1.z = (f * zx + f1 * zy + f2 * zz + zd) / f3;
    }

    Vertex Origin()
    {
        float f = -((xy * yz * zd + yy * zz * xd + zy * xz * yd) - xd * yz * zy - yd * zz * xy - zd * xz * yy);
        float f1 = (xx * yz * zd + yx * zz * xd + zx * xz * yd) - xd * yz * zx - yd * zz * xx - zd * xz * yx;
        float f2 = -((xx * yy * zd + yx * zy * xd + zx * xy * yd) - xd * yy * zx - yd * zy * xx - zd * xy * yx);
        float f3 = (xx * yy * zz + yx * zy * xz + zx * xy * yz) - xz * yy * zx - yz * zy * xx - zz * xy * yx;
        float f4 = dx * f + dy * f1 + dz * f2 + dd * f3;
        float f5 = f / f4;
        float f6 = f1 / f4;
        float f7 = f2 / f4;
        float f8 = f3 / f4;
        return new Vertex(f5 / f8, f6 / f8, f7 / f8);
    }

    Matrix3D Inverse()
    {
        float f = (yy * zz * dd + zy * dz * yd + dy * yz * zd) - yd * zz * dy - zd * dz * yy - dd * yz * zy;
        float f1 = -((yx * zz * dd + zx * dz * yd + dx * yz * zd) - yd * zz * dx - zd * dz * yx - dd * yz * zx);
        float f2 = (yx * zy * dd + zx * dy * yd + dx * yy * zd) - yd * zy * dx - zd * dy * yx - dd * yy * zx;
        float f3 = -((yx * zy * dz + zx * dy * yz + dx * yy * zz) - yz * zy * dx - zz * dy * yx - dz * yy * zx);
        float f4 = -((xy * zz * dd + zy * dz * xd + dy * xz * zd) - xd * zz * dy - zd * dz * xy - dd * xz * zy);
        float f5 = (xx * zz * dd + zx * dz * xd + dx * xz * zd) - xd * zz * dx - zd * dz * xx - dd * xz * zx;
        float f6 = -((xx * zy * dd + zx * dy * xd + dx * xy * zd) - xd * zy * dx - zd * dy * xx - dd * xy * zx);
        float f7 = (xx * zy * dz + zx * dy * xz + dx * xy * zz) - xz * zy * dx - zz * dy * xx - dz * xy * zx;
        float f8 = (xy * yz * dd + yy * dz * xd + dy * xz * yd) - xd * yz * dy - yd * dz * xy - dd * xz * yy;
        float f9 = -((xx * yz * dd + yx * dz * xd + dx * xz * yd) - xd * yz * dx - yd * dz * xx - dd * xz * yx);
        float f10 = (xx * yy * dd + yx * dy * xd + dx * xy * yd) - xd * yy * dx - yd * dy * xx - dd * xy * yx;
        float f11 = -((xx * yy * dz + yx * dy * xz + dx * xy * yz) - xz * yy * dx - yz * dy * xx - dz * xy * yx);
        float f12 = -((xy * yz * zd + yy * zz * xd + zy * xz * yd) - xd * yz * zy - yd * zz * xy - zd * xz * yy);
        float f13 = (xx * yz * zd + yx * zz * xd + zx * xz * yd) - xd * yz * zx - yd * zz * xx - zd * xz * yx;
        float f14 = -((xx * yy * zd + yx * zy * xd + zx * xy * yd) - xd * yy * zx - yd * zy * xx - zd * xy * yx);
        float f15 = (xx * yy * zz + yx * zy * xz + zx * xy * yz) - xz * yy * zx - yz * zy * xx - zz * xy * yx;
        float f16 = xx * f + xy * f1 + xz * f2 + xd * f3;
        float af[][] = {
            {
                f / f16, f4 / f16, f8 / f16, f12 / f16
            }, {
                f1 / f16, f5 / f16, f9 / f16, f13 / f16
            }, {
                f2 / f16, f6 / f16, f10 / f16, f14 / f16
            }, {
                f3 / f16, f7 / f16, f11 / f16, f15 / f16
            }
        };
        return new Matrix3D(af);
    }

    public void Print()
    {
        System.out.println("--------------------");
        System.out.println("|" + xx + " " + xy + " " + xz + " " + xd + "| ");
        System.out.println("|" + yx + " " + yy + " " + yz + " " + yd + "| ");
        System.out.println("|" + zx + " " + zy + " " + zz + " " + zd + "| ");
        System.out.println("|" + dx + " " + dy + " " + dz + " " + dd + "| ");
    }
}