commit ca3300c30d8c72196d26bf98be72e709aa65359f Author: Leszek Koltunski Date: Fri Sep 25 09:29:38 2020 +0100 Rename 'RubikMovement' to 'Movement' diff --git a/src/main/java/org/distorted/main/RubikSurfaceView.java b/src/main/java/org/distorted/main/RubikSurfaceView.java index 2df60531..e22e4578 100644 --- a/src/main/java/org/distorted/main/RubikSurfaceView.java +++ b/src/main/java/org/distorted/main/RubikSurfaceView.java @@ -33,7 +33,7 @@ import com.google.firebase.crashlytics.FirebaseCrashlytics; import org.distorted.library.type.Static2D; import org.distorted.library.type.Static4D; import org.distorted.objects.RubikObject; -import org.distorted.objects.RubikMovement; +import org.distorted.objects.Movement; import org.distorted.solvers.SolverMain; import org.distorted.states.RubikState; import org.distorted.states.RubikStatePlay; @@ -61,7 +61,7 @@ public class RubikSurfaceView extends GLSurfaceView private RubikRenderer mRenderer; private RubikPreRender mPreRender; - private RubikMovement mMovement; + private Movement mMovement; private boolean mDragging, mBeginningRotation, mContinuingRotation; private int mScreenWidth, mScreenHeight, mScreenMin; @@ -130,7 +130,7 @@ public class RubikSurfaceView extends GLSurfaceView /////////////////////////////////////////////////////////////////////////////////////////////////// - void setMovement(RubikMovement movement) + void setMovement(Movement movement) { mMovement = movement; } diff --git a/src/main/java/org/distorted/objects/Movement.java b/src/main/java/org/distorted/objects/Movement.java new file mode 100644 index 00000000..88e8dfcd --- /dev/null +++ b/src/main/java/org/distorted/objects/Movement.java @@ -0,0 +1,309 @@ +/////////////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2020 Leszek Koltunski // +// // +// This file is part of Magic Cube. // +// // +// Magic Cube is free software: you can redistribute it and/or modify // +// it under the terms of the GNU General Public License as published by // +// the Free Software Foundation, either version 2 of the License, or // +// (at your option) any later version. // +// // +// Magic Cube is distributed in the hope that it will be useful, // +// but WITHOUT ANY WARRANTY; without even the implied warranty of // +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // +// GNU General Public License for more details. // +// // +// You should have received a copy of the GNU General Public License // +// along with Magic Cube. If not, see . // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.objects; + +import org.distorted.library.type.Static2D; +import org.distorted.library.type.Static3D; +import org.distorted.library.type.Static4D; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +public abstract class Movement + { + private int mLastTouchedFace, mNumFaceAxis; + private float[] mPoint, mCamera, mTouch; + private float[] mPoint2D, mMove2D; + private float[][][] mCastedRotAxis; + private Static4D[][] mCastedRotAxis4D; + private int[] mEnabledRotAxis; + private float mDistanceCenterFace3D, mDistanceCenterFace2D; + private Static3D[] mFaceAxis; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + abstract boolean isInsideFace(float[] point); + abstract void computeEnabledAxis(int face, float[] touchPoint, int[] enabledAxis); + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + Movement(Static3D[] rotAxis, Static3D[] faceAxis, float distance3D, float distance2D) + { + mPoint = new float[3]; + mCamera= new float[3]; + mTouch = new float[3]; + + mPoint2D = new float[2]; + mMove2D = new float[2]; + + mFaceAxis = faceAxis; + mNumFaceAxis= mFaceAxis.length; + + mEnabledRotAxis = new int[rotAxis.length+1]; + + mDistanceCenterFace3D = distance3D; // distance from the center of the object to each of its faces + mDistanceCenterFace2D = distance2D; // distance from the center of a face to its edge + + // mCastedRotAxis[1][2]{0,1} are the 2D coords of the 2nd axis cast onto the face defined by the + // 1st pair (axis,lr) + mCastedRotAxis = new float[mNumFaceAxis][rotAxis.length][2]; + mCastedRotAxis4D = new Static4D[mNumFaceAxis][rotAxis.length]; + + float fx,fy,fz,f; + + for( int casted=0; casted mDistanceCenterFace3D; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// given precomputed mCamera and mPoint, respectively camera and touch point positions in ScreenSpace, +// compute point 'output[]' which: +// 1) lies on a face of the Object, i.e. surface defined by (axis, distance from (0,0,0)) [and this +// distance is +-mDistanceCenterFace, depending if it is the face on the left or the right end of +// the axis] (lr=0 or 1, so (2lr-1)*mDistanceCenterFace) +// 2) is co-linear with mCamera and mPoint +// +// output = camera + alpha*(point-camera), where alpha = [dist-axis*camera] / [axis*(point-camera)] + + private void castTouchPointOntoFace(Static3D faceAxis, float[] output) + { + float d0 = mPoint[0]-mCamera[0]; + float d1 = mPoint[1]-mCamera[1]; + float d2 = mPoint[2]-mCamera[2]; + float a0 = faceAxis.get0(); + float a1 = faceAxis.get1(); + float a2 = faceAxis.get2(); + + float denom = a0*d0 + a1*d1 + a2*d2; + + if( denom != 0.0f ) + { + float axisCam = a0*mCamera[0] + a1*mCamera[1] + a2*mCamera[2]; + float distance = mDistanceCenterFace3D; + float alpha = (distance-axisCam)/denom; + + output[0] = mCamera[0] + d0*alpha; + output[1] = mCamera[1] + d1*alpha; + output[2] = mCamera[2] + d2*alpha; + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// Convert the 3D point3D into a 2D point on the same face surface, but in a different +// coordinate system: a in-plane 2D coord where the origin is in the point where the axis intersects +// the surface, and whose Y axis points 'north' i.e. is in the plane given by the 3D origin, the +// original 3D Y axis and our 2D in-plane origin. +// If those 3 points constitute a degenerate triangle which does not define a plane - which can only +// happen if axis is vertical (or in theory when 2D origin and 3D origin meet, but that would have to +// mean that the distance between the center of the Object and its faces is 0) - then we arbitrarily +// decide that 2D Y = (0,0,-1) in the North Pole and (0,0,1) in the South Pole) + + private void convertTo2Dcoords(float[] point3D, Static3D faceAxis, float[] output) + { + float y0,y1,y2; // base Y vector of the 2D coord system + float a0 = faceAxis.get0(); + float a1 = faceAxis.get1(); + float a2 = faceAxis.get2(); + + if( a0==0.0f && a2==0.0f ) + { + y0=0; y1=0; y2=-a1; + } + else if( a1==0.0f ) + { + y0=0; y1=1; y2=0; + } + else + { + float norm = (float)(-a1/Math.sqrt(1-a1*a1)); + y0 = norm*a0; y1= norm*(a1-1/a1); y2=norm*a2; + } + + float x0 = y1*a2 - y2*a1; // + float x1 = y2*a0 - y0*a2; // (2D coord baseY) x (axis) = 2D coord baseX + float x2 = y0*a1 - y1*a0; // + + float originAlpha = point3D[0]*a0 + point3D[1]*a1 + point3D[2]*a2; + + float origin0 = originAlpha*a0; // coords of the point where axis + float origin1 = originAlpha*a1; // intersects surface plane i.e. + float origin2 = originAlpha*a2; // the origin of our 2D coord system + + float v0 = point3D[0] - origin0; + float v1 = point3D[1] - origin1; + float v2 = point3D[2] - origin2; + + output[0] = v0*x0 + v1*x1 + v2*x2; + output[1] = v0*y0 + v1*y1 + v2*y2; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// PUBLIC API +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public boolean faceTouched(Static4D rotatedTouchPoint, Static4D rotatedCamera) + { + float objectRatio = RubikObject.getObjectRatio(); + + mPoint[0] = rotatedTouchPoint.get0()/objectRatio; + mPoint[1] = rotatedTouchPoint.get1()/objectRatio; + mPoint[2] = rotatedTouchPoint.get2()/objectRatio; + + mCamera[0] = rotatedCamera.get0()/objectRatio; + mCamera[1] = rotatedCamera.get1()/objectRatio; + mCamera[2] = rotatedCamera.get2()/objectRatio; + + for( mLastTouchedFace=0; mLastTouchedFace. // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.objects; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +class MovementCube extends Movement +{ + MovementCube() + { + super(RubikCube.ROT_AXIS, RubikCube.FACE_AXIS, 0.5f, 0.5f); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + boolean isInsideFace(float[] p) + { + return ( p[0]<=0.5f && p[0]>=-0.5f && p[1]<=0.5f && p[1]>=-0.5f ); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + void computeEnabledAxis(int face, float[] touchPoint, int[] enabled) + { + enabled[0] = 2; + + switch(face) + { + case 0: + case 1: enabled[1]=1; enabled[2]=2; break; + case 2: + case 3: enabled[1]=0; enabled[2]=2; break; + case 4: + case 5: enabled[1]=0; enabled[2]=1; break; + } + } +} diff --git a/src/main/java/org/distorted/objects/MovementDiamond.java b/src/main/java/org/distorted/objects/MovementDiamond.java new file mode 100644 index 00000000..879c6a09 --- /dev/null +++ b/src/main/java/org/distorted/objects/MovementDiamond.java @@ -0,0 +1,116 @@ +/////////////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2020 Leszek Koltunski // +// // +// This file is part of Magic Cube. // +// // +// Magic Cube is free software: you can redistribute it and/or modify // +// it under the terms of the GNU General Public License as published by // +// the Free Software Foundation, either version 2 of the License, or // +// (at your option) any later version. // +// // +// Magic Cube is distributed in the hope that it will be useful, // +// but WITHOUT ANY WARRANTY; without even the implied warranty of // +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // +// GNU General Public License for more details. // +// // +// You should have received a copy of the GNU General Public License // +// along with Magic Cube. If not, see . // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.objects; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +class MovementDiamond extends Movement +{ + MovementDiamond() + { + super(RubikDiamond.ROT_AXIS, RubikDiamond.FACE_AXIS, 0.25f, 0.25f); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// _____________ +// | \ 0 / | +// | \ / | +// | 3 | | 1 | +// | / \ | +// | / 2 \ | +// ------------- + + private int getQuarter(float[] touchPoint) + { + boolean p0 = touchPoint[1] >= touchPoint[0]; + boolean p1 = touchPoint[1] >=-touchPoint[0]; + + if( p0 ) return p1 ? 0:3; + else return p1 ? 1:2; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + boolean isInsideFace(float[] p) + { + return ( p[0]<=0.25f && p[0]>=-0.25f && p[1]<=0.25f && p[1]>=-0.25f ); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + void computeEnabledAxis(int face, float[] touchPoint, int[] enabled) + { + enabled[0] = 2; + + int quarter = getQuarter(touchPoint); + + switch(face) + { + case 0: switch(quarter) + { + case 0: enabled[1]=0; enabled[2]=1; break; + case 1: enabled[1]=3; enabled[2]=1; break; + case 2: enabled[1]=2; enabled[2]=3; break; + case 3: enabled[1]=0; enabled[2]=2; break; + } + break; + case 1: switch(quarter) + { + case 0: enabled[1]=2; enabled[2]=3; break; + case 1: enabled[1]=3; enabled[2]=1; break; + case 2: enabled[1]=0; enabled[2]=1; break; + case 3: enabled[1]=0; enabled[2]=2; break; + } + break; + case 2: switch(quarter) + { + case 0: enabled[1]=1; enabled[2]=2; break; + case 1: enabled[1]=0; enabled[2]=1; break; + case 2: enabled[1]=0; enabled[2]=3; break; + case 3: enabled[1]=2; enabled[2]=3; break; + } + break; + case 3: switch(quarter) + { + case 0: enabled[1]=1; enabled[2]=2; break; + case 1: enabled[1]=2; enabled[2]=3; break; + case 2: enabled[1]=0; enabled[2]=3; break; + case 3: enabled[1]=0; enabled[2]=1; break; + } + break; + case 4: switch(quarter) + { + case 0: enabled[1]=0; enabled[2]=3; break; + case 1: enabled[1]=0; enabled[2]=2; break; + case 2: enabled[1]=1; enabled[2]=2; break; + case 3: enabled[1]=1; enabled[2]=3; break; + } + break; + case 5: switch(quarter) + { + case 0: enabled[1]=1; enabled[2]=2; break; + case 1: enabled[1]=0; enabled[2]=2; break; + case 2: enabled[1]=0; enabled[2]=3; break; + case 3: enabled[1]=1; enabled[2]=3; break; + } + break; + } + } +} diff --git a/src/main/java/org/distorted/objects/MovementDino.java b/src/main/java/org/distorted/objects/MovementDino.java new file mode 100644 index 00000000..ea60bbdc --- /dev/null +++ b/src/main/java/org/distorted/objects/MovementDino.java @@ -0,0 +1,116 @@ +/////////////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2020 Leszek Koltunski // +// // +// This file is part of Magic Cube. // +// // +// Magic Cube is free software: you can redistribute it and/or modify // +// it under the terms of the GNU General Public License as published by // +// the Free Software Foundation, either version 2 of the License, or // +// (at your option) any later version. // +// // +// Magic Cube is distributed in the hope that it will be useful, // +// but WITHOUT ANY WARRANTY; without even the implied warranty of // +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // +// GNU General Public License for more details. // +// // +// You should have received a copy of the GNU General Public License // +// along with Magic Cube. If not, see . // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.objects; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +class MovementDino extends Movement +{ + MovementDino() + { + super(RubikDino.ROT_AXIS, RubikDino.FACE_AXIS, 0.5f, 0.5f); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// _____________ +// | \ 0 / | +// | \ / | +// | 3 | | 1 | +// | / \ | +// | / 2 \ | +// ------------- + + private int getQuarter(float[] touchPoint) + { + boolean p0 = touchPoint[1] >= touchPoint[0]; + boolean p1 = touchPoint[1] >=-touchPoint[0]; + + if( p0 ) return p1 ? 0:3; + else return p1 ? 1:2; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + boolean isInsideFace(float[] p) + { + return ( p[0]<=0.5f && p[0]>=-0.5f && p[1]<=0.5f && p[1]>=-0.5f ); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + void computeEnabledAxis(int face, float[] touchPoint, int[] enabled) + { + enabled[0] = 2; + + int quarter = getQuarter(touchPoint); + + switch(face) + { + case 0: switch(quarter) + { + case 0: enabled[1]=0; enabled[2]=1; break; + case 1: enabled[1]=3; enabled[2]=1; break; + case 2: enabled[1]=2; enabled[2]=3; break; + case 3: enabled[1]=0; enabled[2]=2; break; + } + break; + case 1: switch(quarter) + { + case 0: enabled[1]=2; enabled[2]=3; break; + case 1: enabled[1]=3; enabled[2]=1; break; + case 2: enabled[1]=0; enabled[2]=1; break; + case 3: enabled[1]=0; enabled[2]=2; break; + } + break; + case 2: switch(quarter) + { + case 0: enabled[1]=1; enabled[2]=2; break; + case 1: enabled[1]=0; enabled[2]=1; break; + case 2: enabled[1]=0; enabled[2]=3; break; + case 3: enabled[1]=2; enabled[2]=3; break; + } + break; + case 3: switch(quarter) + { + case 0: enabled[1]=1; enabled[2]=2; break; + case 1: enabled[1]=2; enabled[2]=3; break; + case 2: enabled[1]=0; enabled[2]=3; break; + case 3: enabled[1]=0; enabled[2]=1; break; + } + break; + case 4: switch(quarter) + { + case 0: enabled[1]=0; enabled[2]=3; break; + case 1: enabled[1]=0; enabled[2]=2; break; + case 2: enabled[1]=1; enabled[2]=2; break; + case 3: enabled[1]=1; enabled[2]=3; break; + } + break; + case 5: switch(quarter) + { + case 0: enabled[1]=1; enabled[2]=2; break; + case 1: enabled[1]=0; enabled[2]=2; break; + case 2: enabled[1]=0; enabled[2]=3; break; + case 3: enabled[1]=1; enabled[2]=3; break; + } + break; + } + } +} diff --git a/src/main/java/org/distorted/objects/MovementHelicopter.java b/src/main/java/org/distorted/objects/MovementHelicopter.java new file mode 100644 index 00000000..b92f494c --- /dev/null +++ b/src/main/java/org/distorted/objects/MovementHelicopter.java @@ -0,0 +1,116 @@ +/////////////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2020 Leszek Koltunski // +// // +// This file is part of Magic Cube. // +// // +// Magic Cube is free software: you can redistribute it and/or modify // +// it under the terms of the GNU General Public License as published by // +// the Free Software Foundation, either version 2 of the License, or // +// (at your option) any later version. // +// // +// Magic Cube is distributed in the hope that it will be useful, // +// but WITHOUT ANY WARRANTY; without even the implied warranty of // +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // +// GNU General Public License for more details. // +// // +// You should have received a copy of the GNU General Public License // +// along with Magic Cube. If not, see . // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.objects; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +class MovementHelicopter extends Movement +{ + MovementHelicopter() + { + super(RubikHelicopter.ROT_AXIS, RubikHelicopter.FACE_AXIS, 0.166f, 0.166f); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// _____________ +// | | | +// | 3 | 0 | +// |-----------| +// | | | +// | 2 | 1 | +// ------------- + + private int getQuarter(float[] touchPoint) + { + boolean p0 = touchPoint[0] > 0; + boolean p1 = touchPoint[1] > 0; + + if( p0 ) return p1 ? 0:1; + else return p1 ? 3:2; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + boolean isInsideFace(float[] p) + { + return ( p[0]<=0.166f && p[0]>=-0.166f && p[1]<=0.166f && p[1]>=-0.166f ); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + void computeEnabledAxis(int face, float[] touchPoint, int[] enabled) + { + enabled[0] = 2; + + int quarter = getQuarter(touchPoint); + + switch(face) + { + case 0: switch(quarter) + { + case 0: enabled[1]=2; enabled[2]=5; break; + case 1: enabled[1]=2; enabled[2]=4; break; + case 2: enabled[1]=3; enabled[2]=4; break; + case 3: enabled[1]=3; enabled[2]=5; break; + } + break; + case 1: switch(quarter) + { + case 0: enabled[1]=2; enabled[2]=4; break; + case 1: enabled[1]=2; enabled[2]=5; break; + case 2: enabled[1]=5; enabled[2]=3; break; + case 3: enabled[1]=3; enabled[2]=4; break; + } + break; + case 2: switch(quarter) + { + case 0: enabled[1]=0; enabled[2]=5; break; + case 1: enabled[1]=1; enabled[2]=5; break; + case 2: enabled[1]=1; enabled[2]=4; break; + case 3: enabled[1]=0; enabled[2]=4; break; + } + break; + case 3: switch(quarter) + { + case 0: enabled[1]=0; enabled[2]=4; break; + case 1: enabled[1]=1; enabled[2]=4; break; + case 2: enabled[1]=1; enabled[2]=5; break; + case 3: enabled[1]=0; enabled[2]=5; break; + } + break; + case 4: switch(quarter) + { + case 0: enabled[1]=1; enabled[2]=3; break; + case 1: enabled[1]=0; enabled[2]=3; break; + case 2: enabled[1]=0; enabled[2]=2; break; + case 3: enabled[1]=1; enabled[2]=2; break; + } + break; + case 5: switch(quarter) + { + case 0: enabled[1]=0; enabled[2]=3; break; + case 1: enabled[1]=1; enabled[2]=3; break; + case 2: enabled[1]=1; enabled[2]=2; break; + case 3: enabled[1]=0; enabled[2]=2; break; + } + break; + } + } +} diff --git a/src/main/java/org/distorted/objects/MovementPyraminx.java b/src/main/java/org/distorted/objects/MovementPyraminx.java new file mode 100644 index 00000000..49430de6 --- /dev/null +++ b/src/main/java/org/distorted/objects/MovementPyraminx.java @@ -0,0 +1,61 @@ +/////////////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2020 Leszek Koltunski // +// // +// This file is part of Magic Cube. // +// // +// Magic Cube is free software: you can redistribute it and/or modify // +// it under the terms of the GNU General Public License as published by // +// the Free Software Foundation, either version 2 of the License, or // +// (at your option) any later version. // +// // +// Magic Cube is distributed in the hope that it will be useful, // +// but WITHOUT ANY WARRANTY; without even the implied warranty of // +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // +// GNU General Public License for more details. // +// // +// You should have received a copy of the GNU General Public License // +// along with Magic Cube. If not, see . // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.objects; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +class MovementPyraminx extends Movement +{ + private static final float SQ6 = (float)Math.sqrt(6); + private static final float SQ3 = (float)Math.sqrt(3); + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + MovementPyraminx() + { + super(RubikPyraminx.ROT_AXIS, RubikPyraminx.FACE_AXIS, SQ6/12, SQ3/6); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + boolean isInsideFace(float[] p) + { + boolean a1 = p[1] >= -SQ3/6; + boolean a2 = p[1] <= SQ3*(1.0f/3 + p[0]); + boolean a3 = p[1] <= SQ3*(1.0f/3 - p[0]); + + return a1 && a2 && a3; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + void computeEnabledAxis(int face, float[] touchPoint, int[] enabled) + { + enabled[0] = 3; + + switch(face) + { + case 0: enabled[1]=1; enabled[2]=2; enabled[3]=3; break; + case 1: enabled[1]=0; enabled[2]=2; enabled[3]=3; break; + case 2: enabled[1]=0; enabled[2]=1; enabled[3]=3; break; + case 3: enabled[1]=0; enabled[2]=1; enabled[3]=2; break; + } + } +} diff --git a/src/main/java/org/distorted/objects/MovementSkewb.java b/src/main/java/org/distorted/objects/MovementSkewb.java new file mode 100644 index 00000000..a4a78132 --- /dev/null +++ b/src/main/java/org/distorted/objects/MovementSkewb.java @@ -0,0 +1,116 @@ +/////////////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2020 Leszek Koltunski // +// // +// This file is part of Magic Cube. // +// // +// Magic Cube is free software: you can redistribute it and/or modify // +// it under the terms of the GNU General Public License as published by // +// the Free Software Foundation, either version 2 of the License, or // +// (at your option) any later version. // +// // +// Magic Cube is distributed in the hope that it will be useful, // +// but WITHOUT ANY WARRANTY; without even the implied warranty of // +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // +// GNU General Public License for more details. // +// // +// You should have received a copy of the GNU General Public License // +// along with Magic Cube. If not, see . // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.objects; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +class MovementSkewb extends Movement +{ + MovementSkewb() + { + super(RubikSkewb.ROT_AXIS, RubikSkewb.FACE_AXIS, 0.25f, 0.25f); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// _____________ +// | \ 0 / | +// | \ / | +// | 3 | | 1 | +// | / \ | +// | / 2 \ | +// ------------- + + private int getQuarter(float[] touchPoint) + { + boolean p0 = touchPoint[1] >= touchPoint[0]; + boolean p1 = touchPoint[1] >=-touchPoint[0]; + + if( p0 ) return p1 ? 0:3; + else return p1 ? 1:2; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + boolean isInsideFace(float[] p) + { + return ( p[0]<=0.25f && p[0]>=-0.25f && p[1]<=0.25f && p[1]>=-0.25f ); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + void computeEnabledAxis(int face, float[] touchPoint, int[] enabled) + { + enabled[0] = 2; + + int quarter = getQuarter(touchPoint); + + switch(face) + { + case 0: switch(quarter) + { + case 0: enabled[1]=0; enabled[2]=1; break; + case 1: enabled[1]=3; enabled[2]=1; break; + case 2: enabled[1]=2; enabled[2]=3; break; + case 3: enabled[1]=0; enabled[2]=2; break; + } + break; + case 1: switch(quarter) + { + case 0: enabled[1]=2; enabled[2]=3; break; + case 1: enabled[1]=3; enabled[2]=1; break; + case 2: enabled[1]=0; enabled[2]=1; break; + case 3: enabled[1]=0; enabled[2]=2; break; + } + break; + case 2: switch(quarter) + { + case 0: enabled[1]=1; enabled[2]=2; break; + case 1: enabled[1]=0; enabled[2]=1; break; + case 2: enabled[1]=0; enabled[2]=3; break; + case 3: enabled[1]=2; enabled[2]=3; break; + } + break; + case 3: switch(quarter) + { + case 0: enabled[1]=1; enabled[2]=2; break; + case 1: enabled[1]=2; enabled[2]=3; break; + case 2: enabled[1]=0; enabled[2]=3; break; + case 3: enabled[1]=0; enabled[2]=1; break; + } + break; + case 4: switch(quarter) + { + case 0: enabled[1]=0; enabled[2]=3; break; + case 1: enabled[1]=0; enabled[2]=2; break; + case 2: enabled[1]=1; enabled[2]=2; break; + case 3: enabled[1]=1; enabled[2]=3; break; + } + break; + case 5: switch(quarter) + { + case 0: enabled[1]=1; enabled[2]=2; break; + case 1: enabled[1]=0; enabled[2]=2; break; + case 2: enabled[1]=0; enabled[2]=3; break; + case 3: enabled[1]=1; enabled[2]=3; break; + } + break; + } + } +} diff --git a/src/main/java/org/distorted/objects/RubikMovement.java b/src/main/java/org/distorted/objects/RubikMovement.java deleted file mode 100644 index 53d504a2..00000000 --- a/src/main/java/org/distorted/objects/RubikMovement.java +++ /dev/null @@ -1,309 +0,0 @@ -/////////////////////////////////////////////////////////////////////////////////////////////////// -// Copyright 2020 Leszek Koltunski // -// // -// This file is part of Magic Cube. // -// // -// Magic Cube is free software: you can redistribute it and/or modify // -// it under the terms of the GNU General Public License as published by // -// the Free Software Foundation, either version 2 of the License, or // -// (at your option) any later version. // -// // -// Magic Cube is distributed in the hope that it will be useful, // -// but WITHOUT ANY WARRANTY; without even the implied warranty of // -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // -// GNU General Public License for more details. // -// // -// You should have received a copy of the GNU General Public License // -// along with Magic Cube. If not, see . // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.objects; - -import org.distorted.library.type.Static2D; -import org.distorted.library.type.Static3D; -import org.distorted.library.type.Static4D; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -public abstract class RubikMovement - { - private int mLastTouchedFace, mNumFaceAxis; - private float[] mPoint, mCamera, mTouch; - private float[] mPoint2D, mMove2D; - private float[][][] mCastedRotAxis; - private Static4D[][] mCastedRotAxis4D; - private int[] mEnabledRotAxis; - private float mDistanceCenterFace3D, mDistanceCenterFace2D; - private Static3D[] mFaceAxis; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - abstract boolean isInsideFace(float[] point); - abstract void computeEnabledAxis(int face, float[] touchPoint, int[] enabledAxis); - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - RubikMovement(Static3D[] rotAxis, Static3D[] faceAxis, float distance3D, float distance2D) - { - mPoint = new float[3]; - mCamera= new float[3]; - mTouch = new float[3]; - - mPoint2D = new float[2]; - mMove2D = new float[2]; - - mFaceAxis = faceAxis; - mNumFaceAxis= mFaceAxis.length; - - mEnabledRotAxis = new int[rotAxis.length+1]; - - mDistanceCenterFace3D = distance3D; // distance from the center of the object to each of its faces - mDistanceCenterFace2D = distance2D; // distance from the center of a face to its edge - - // mCastedRotAxis[1][2]{0,1} are the 2D coords of the 2nd axis cast onto the face defined by the - // 1st pair (axis,lr) - mCastedRotAxis = new float[mNumFaceAxis][rotAxis.length][2]; - mCastedRotAxis4D = new Static4D[mNumFaceAxis][rotAxis.length]; - - float fx,fy,fz,f; - - for( int casted=0; casted mDistanceCenterFace3D; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// given precomputed mCamera and mPoint, respectively camera and touch point positions in ScreenSpace, -// compute point 'output[]' which: -// 1) lies on a face of the Object, i.e. surface defined by (axis, distance from (0,0,0)) [and this -// distance is +-mDistanceCenterFace, depending if it is the face on the left or the right end of -// the axis] (lr=0 or 1, so (2lr-1)*mDistanceCenterFace) -// 2) is co-linear with mCamera and mPoint -// -// output = camera + alpha*(point-camera), where alpha = [dist-axis*camera] / [axis*(point-camera)] - - private void castTouchPointOntoFace(Static3D faceAxis, float[] output) - { - float d0 = mPoint[0]-mCamera[0]; - float d1 = mPoint[1]-mCamera[1]; - float d2 = mPoint[2]-mCamera[2]; - float a0 = faceAxis.get0(); - float a1 = faceAxis.get1(); - float a2 = faceAxis.get2(); - - float denom = a0*d0 + a1*d1 + a2*d2; - - if( denom != 0.0f ) - { - float axisCam = a0*mCamera[0] + a1*mCamera[1] + a2*mCamera[2]; - float distance = mDistanceCenterFace3D; - float alpha = (distance-axisCam)/denom; - - output[0] = mCamera[0] + d0*alpha; - output[1] = mCamera[1] + d1*alpha; - output[2] = mCamera[2] + d2*alpha; - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// Convert the 3D point3D into a 2D point on the same face surface, but in a different -// coordinate system: a in-plane 2D coord where the origin is in the point where the axis intersects -// the surface, and whose Y axis points 'north' i.e. is in the plane given by the 3D origin, the -// original 3D Y axis and our 2D in-plane origin. -// If those 3 points constitute a degenerate triangle which does not define a plane - which can only -// happen if axis is vertical (or in theory when 2D origin and 3D origin meet, but that would have to -// mean that the distance between the center of the Object and its faces is 0) - then we arbitrarily -// decide that 2D Y = (0,0,-1) in the North Pole and (0,0,1) in the South Pole) - - private void convertTo2Dcoords(float[] point3D, Static3D faceAxis, float[] output) - { - float y0,y1,y2; // base Y vector of the 2D coord system - float a0 = faceAxis.get0(); - float a1 = faceAxis.get1(); - float a2 = faceAxis.get2(); - - if( a0==0.0f && a2==0.0f ) - { - y0=0; y1=0; y2=-a1; - } - else if( a1==0.0f ) - { - y0=0; y1=1; y2=0; - } - else - { - float norm = (float)(-a1/Math.sqrt(1-a1*a1)); - y0 = norm*a0; y1= norm*(a1-1/a1); y2=norm*a2; - } - - float x0 = y1*a2 - y2*a1; // - float x1 = y2*a0 - y0*a2; // (2D coord baseY) x (axis) = 2D coord baseX - float x2 = y0*a1 - y1*a0; // - - float originAlpha = point3D[0]*a0 + point3D[1]*a1 + point3D[2]*a2; - - float origin0 = originAlpha*a0; // coords of the point where axis - float origin1 = originAlpha*a1; // intersects surface plane i.e. - float origin2 = originAlpha*a2; // the origin of our 2D coord system - - float v0 = point3D[0] - origin0; - float v1 = point3D[1] - origin1; - float v2 = point3D[2] - origin2; - - output[0] = v0*x0 + v1*x1 + v2*x2; - output[1] = v0*y0 + v1*y1 + v2*y2; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// PUBLIC API -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public boolean faceTouched(Static4D rotatedTouchPoint, Static4D rotatedCamera) - { - float objectRatio = RubikObject.getObjectRatio(); - - mPoint[0] = rotatedTouchPoint.get0()/objectRatio; - mPoint[1] = rotatedTouchPoint.get1()/objectRatio; - mPoint[2] = rotatedTouchPoint.get2()/objectRatio; - - mCamera[0] = rotatedCamera.get0()/objectRatio; - mCamera[1] = rotatedCamera.get1()/objectRatio; - mCamera[2] = rotatedCamera.get2()/objectRatio; - - for( mLastTouchedFace=0; mLastTouchedFace. // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.objects; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -class RubikMovementCube extends RubikMovement -{ - RubikMovementCube() - { - super(RubikCube.ROT_AXIS, RubikCube.FACE_AXIS, 0.5f, 0.5f); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - boolean isInsideFace(float[] p) - { - return ( p[0]<=0.5f && p[0]>=-0.5f && p[1]<=0.5f && p[1]>=-0.5f ); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - void computeEnabledAxis(int face, float[] touchPoint, int[] enabled) - { - enabled[0] = 2; - - switch(face) - { - case 0: - case 1: enabled[1]=1; enabled[2]=2; break; - case 2: - case 3: enabled[1]=0; enabled[2]=2; break; - case 4: - case 5: enabled[1]=0; enabled[2]=1; break; - } - } -} diff --git a/src/main/java/org/distorted/objects/RubikMovementDiamond.java b/src/main/java/org/distorted/objects/RubikMovementDiamond.java deleted file mode 100644 index b8c1961f..00000000 --- a/src/main/java/org/distorted/objects/RubikMovementDiamond.java +++ /dev/null @@ -1,116 +0,0 @@ -/////////////////////////////////////////////////////////////////////////////////////////////////// -// Copyright 2020 Leszek Koltunski // -// // -// This file is part of Magic Cube. // -// // -// Magic Cube is free software: you can redistribute it and/or modify // -// it under the terms of the GNU General Public License as published by // -// the Free Software Foundation, either version 2 of the License, or // -// (at your option) any later version. // -// // -// Magic Cube is distributed in the hope that it will be useful, // -// but WITHOUT ANY WARRANTY; without even the implied warranty of // -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // -// GNU General Public License for more details. // -// // -// You should have received a copy of the GNU General Public License // -// along with Magic Cube. If not, see . // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.objects; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -class RubikMovementDiamond extends RubikMovement -{ - RubikMovementDiamond() - { - super(RubikDiamond.ROT_AXIS, RubikDiamond.FACE_AXIS, 0.25f, 0.25f); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// _____________ -// | \ 0 / | -// | \ / | -// | 3 | | 1 | -// | / \ | -// | / 2 \ | -// ------------- - - private int getQuarter(float[] touchPoint) - { - boolean p0 = touchPoint[1] >= touchPoint[0]; - boolean p1 = touchPoint[1] >=-touchPoint[0]; - - if( p0 ) return p1 ? 0:3; - else return p1 ? 1:2; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - boolean isInsideFace(float[] p) - { - return ( p[0]<=0.25f && p[0]>=-0.25f && p[1]<=0.25f && p[1]>=-0.25f ); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - void computeEnabledAxis(int face, float[] touchPoint, int[] enabled) - { - enabled[0] = 2; - - int quarter = getQuarter(touchPoint); - - switch(face) - { - case 0: switch(quarter) - { - case 0: enabled[1]=0; enabled[2]=1; break; - case 1: enabled[1]=3; enabled[2]=1; break; - case 2: enabled[1]=2; enabled[2]=3; break; - case 3: enabled[1]=0; enabled[2]=2; break; - } - break; - case 1: switch(quarter) - { - case 0: enabled[1]=2; enabled[2]=3; break; - case 1: enabled[1]=3; enabled[2]=1; break; - case 2: enabled[1]=0; enabled[2]=1; break; - case 3: enabled[1]=0; enabled[2]=2; break; - } - break; - case 2: switch(quarter) - { - case 0: enabled[1]=1; enabled[2]=2; break; - case 1: enabled[1]=0; enabled[2]=1; break; - case 2: enabled[1]=0; enabled[2]=3; break; - case 3: enabled[1]=2; enabled[2]=3; break; - } - break; - case 3: switch(quarter) - { - case 0: enabled[1]=1; enabled[2]=2; break; - case 1: enabled[1]=2; enabled[2]=3; break; - case 2: enabled[1]=0; enabled[2]=3; break; - case 3: enabled[1]=0; enabled[2]=1; break; - } - break; - case 4: switch(quarter) - { - case 0: enabled[1]=0; enabled[2]=3; break; - case 1: enabled[1]=0; enabled[2]=2; break; - case 2: enabled[1]=1; enabled[2]=2; break; - case 3: enabled[1]=1; enabled[2]=3; break; - } - break; - case 5: switch(quarter) - { - case 0: enabled[1]=1; enabled[2]=2; break; - case 1: enabled[1]=0; enabled[2]=2; break; - case 2: enabled[1]=0; enabled[2]=3; break; - case 3: enabled[1]=1; enabled[2]=3; break; - } - break; - } - } -} diff --git a/src/main/java/org/distorted/objects/RubikMovementDino.java b/src/main/java/org/distorted/objects/RubikMovementDino.java deleted file mode 100644 index a8b51e9f..00000000 --- a/src/main/java/org/distorted/objects/RubikMovementDino.java +++ /dev/null @@ -1,116 +0,0 @@ -/////////////////////////////////////////////////////////////////////////////////////////////////// -// Copyright 2020 Leszek Koltunski // -// // -// This file is part of Magic Cube. // -// // -// Magic Cube is free software: you can redistribute it and/or modify // -// it under the terms of the GNU General Public License as published by // -// the Free Software Foundation, either version 2 of the License, or // -// (at your option) any later version. // -// // -// Magic Cube is distributed in the hope that it will be useful, // -// but WITHOUT ANY WARRANTY; without even the implied warranty of // -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // -// GNU General Public License for more details. // -// // -// You should have received a copy of the GNU General Public License // -// along with Magic Cube. If not, see . // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.objects; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -class RubikMovementDino extends RubikMovement -{ - RubikMovementDino() - { - super(RubikDino.ROT_AXIS, RubikDino.FACE_AXIS, 0.5f, 0.5f); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// _____________ -// | \ 0 / | -// | \ / | -// | 3 | | 1 | -// | / \ | -// | / 2 \ | -// ------------- - - private int getQuarter(float[] touchPoint) - { - boolean p0 = touchPoint[1] >= touchPoint[0]; - boolean p1 = touchPoint[1] >=-touchPoint[0]; - - if( p0 ) return p1 ? 0:3; - else return p1 ? 1:2; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - boolean isInsideFace(float[] p) - { - return ( p[0]<=0.5f && p[0]>=-0.5f && p[1]<=0.5f && p[1]>=-0.5f ); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - void computeEnabledAxis(int face, float[] touchPoint, int[] enabled) - { - enabled[0] = 2; - - int quarter = getQuarter(touchPoint); - - switch(face) - { - case 0: switch(quarter) - { - case 0: enabled[1]=0; enabled[2]=1; break; - case 1: enabled[1]=3; enabled[2]=1; break; - case 2: enabled[1]=2; enabled[2]=3; break; - case 3: enabled[1]=0; enabled[2]=2; break; - } - break; - case 1: switch(quarter) - { - case 0: enabled[1]=2; enabled[2]=3; break; - case 1: enabled[1]=3; enabled[2]=1; break; - case 2: enabled[1]=0; enabled[2]=1; break; - case 3: enabled[1]=0; enabled[2]=2; break; - } - break; - case 2: switch(quarter) - { - case 0: enabled[1]=1; enabled[2]=2; break; - case 1: enabled[1]=0; enabled[2]=1; break; - case 2: enabled[1]=0; enabled[2]=3; break; - case 3: enabled[1]=2; enabled[2]=3; break; - } - break; - case 3: switch(quarter) - { - case 0: enabled[1]=1; enabled[2]=2; break; - case 1: enabled[1]=2; enabled[2]=3; break; - case 2: enabled[1]=0; enabled[2]=3; break; - case 3: enabled[1]=0; enabled[2]=1; break; - } - break; - case 4: switch(quarter) - { - case 0: enabled[1]=0; enabled[2]=3; break; - case 1: enabled[1]=0; enabled[2]=2; break; - case 2: enabled[1]=1; enabled[2]=2; break; - case 3: enabled[1]=1; enabled[2]=3; break; - } - break; - case 5: switch(quarter) - { - case 0: enabled[1]=1; enabled[2]=2; break; - case 1: enabled[1]=0; enabled[2]=2; break; - case 2: enabled[1]=0; enabled[2]=3; break; - case 3: enabled[1]=1; enabled[2]=3; break; - } - break; - } - } -} diff --git a/src/main/java/org/distorted/objects/RubikMovementHelicopter.java b/src/main/java/org/distorted/objects/RubikMovementHelicopter.java deleted file mode 100644 index bfea69c2..00000000 --- a/src/main/java/org/distorted/objects/RubikMovementHelicopter.java +++ /dev/null @@ -1,116 +0,0 @@ -/////////////////////////////////////////////////////////////////////////////////////////////////// -// Copyright 2020 Leszek Koltunski // -// // -// This file is part of Magic Cube. // -// // -// Magic Cube is free software: you can redistribute it and/or modify // -// it under the terms of the GNU General Public License as published by // -// the Free Software Foundation, either version 2 of the License, or // -// (at your option) any later version. // -// // -// Magic Cube is distributed in the hope that it will be useful, // -// but WITHOUT ANY WARRANTY; without even the implied warranty of // -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // -// GNU General Public License for more details. // -// // -// You should have received a copy of the GNU General Public License // -// along with Magic Cube. If not, see . // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.objects; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -class RubikMovementHelicopter extends RubikMovement -{ - RubikMovementHelicopter() - { - super(RubikHelicopter.ROT_AXIS, RubikHelicopter.FACE_AXIS, 0.166f, 0.166f); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// _____________ -// | | | -// | 3 | 0 | -// |-----------| -// | | | -// | 2 | 1 | -// ------------- - - private int getQuarter(float[] touchPoint) - { - boolean p0 = touchPoint[0] > 0; - boolean p1 = touchPoint[1] > 0; - - if( p0 ) return p1 ? 0:1; - else return p1 ? 3:2; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - boolean isInsideFace(float[] p) - { - return ( p[0]<=0.166f && p[0]>=-0.166f && p[1]<=0.166f && p[1]>=-0.166f ); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - void computeEnabledAxis(int face, float[] touchPoint, int[] enabled) - { - enabled[0] = 2; - - int quarter = getQuarter(touchPoint); - - switch(face) - { - case 0: switch(quarter) - { - case 0: enabled[1]=2; enabled[2]=5; break; - case 1: enabled[1]=2; enabled[2]=4; break; - case 2: enabled[1]=3; enabled[2]=4; break; - case 3: enabled[1]=3; enabled[2]=5; break; - } - break; - case 1: switch(quarter) - { - case 0: enabled[1]=2; enabled[2]=4; break; - case 1: enabled[1]=2; enabled[2]=5; break; - case 2: enabled[1]=5; enabled[2]=3; break; - case 3: enabled[1]=3; enabled[2]=4; break; - } - break; - case 2: switch(quarter) - { - case 0: enabled[1]=0; enabled[2]=5; break; - case 1: enabled[1]=1; enabled[2]=5; break; - case 2: enabled[1]=1; enabled[2]=4; break; - case 3: enabled[1]=0; enabled[2]=4; break; - } - break; - case 3: switch(quarter) - { - case 0: enabled[1]=0; enabled[2]=4; break; - case 1: enabled[1]=1; enabled[2]=4; break; - case 2: enabled[1]=1; enabled[2]=5; break; - case 3: enabled[1]=0; enabled[2]=5; break; - } - break; - case 4: switch(quarter) - { - case 0: enabled[1]=1; enabled[2]=3; break; - case 1: enabled[1]=0; enabled[2]=3; break; - case 2: enabled[1]=0; enabled[2]=2; break; - case 3: enabled[1]=1; enabled[2]=2; break; - } - break; - case 5: switch(quarter) - { - case 0: enabled[1]=0; enabled[2]=3; break; - case 1: enabled[1]=1; enabled[2]=3; break; - case 2: enabled[1]=1; enabled[2]=2; break; - case 3: enabled[1]=0; enabled[2]=2; break; - } - break; - } - } -} diff --git a/src/main/java/org/distorted/objects/RubikMovementPyraminx.java b/src/main/java/org/distorted/objects/RubikMovementPyraminx.java deleted file mode 100644 index 878b3d04..00000000 --- a/src/main/java/org/distorted/objects/RubikMovementPyraminx.java +++ /dev/null @@ -1,61 +0,0 @@ -/////////////////////////////////////////////////////////////////////////////////////////////////// -// Copyright 2020 Leszek Koltunski // -// // -// This file is part of Magic Cube. // -// // -// Magic Cube is free software: you can redistribute it and/or modify // -// it under the terms of the GNU General Public License as published by // -// the Free Software Foundation, either version 2 of the License, or // -// (at your option) any later version. // -// // -// Magic Cube is distributed in the hope that it will be useful, // -// but WITHOUT ANY WARRANTY; without even the implied warranty of // -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // -// GNU General Public License for more details. // -// // -// You should have received a copy of the GNU General Public License // -// along with Magic Cube. If not, see . // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.objects; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -class RubikMovementPyraminx extends RubikMovement -{ - private static final float SQ6 = (float)Math.sqrt(6); - private static final float SQ3 = (float)Math.sqrt(3); - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - RubikMovementPyraminx() - { - super(RubikPyraminx.ROT_AXIS, RubikPyraminx.FACE_AXIS, SQ6/12, SQ3/6); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - boolean isInsideFace(float[] p) - { - boolean a1 = p[1] >= -SQ3/6; - boolean a2 = p[1] <= SQ3*(1.0f/3 + p[0]); - boolean a3 = p[1] <= SQ3*(1.0f/3 - p[0]); - - return a1 && a2 && a3; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - void computeEnabledAxis(int face, float[] touchPoint, int[] enabled) - { - enabled[0] = 3; - - switch(face) - { - case 0: enabled[1]=1; enabled[2]=2; enabled[3]=3; break; - case 1: enabled[1]=0; enabled[2]=2; enabled[3]=3; break; - case 2: enabled[1]=0; enabled[2]=1; enabled[3]=3; break; - case 3: enabled[1]=0; enabled[2]=1; enabled[3]=2; break; - } - } -} diff --git a/src/main/java/org/distorted/objects/RubikMovementSkewb.java b/src/main/java/org/distorted/objects/RubikMovementSkewb.java deleted file mode 100644 index 82453b42..00000000 --- a/src/main/java/org/distorted/objects/RubikMovementSkewb.java +++ /dev/null @@ -1,116 +0,0 @@ -/////////////////////////////////////////////////////////////////////////////////////////////////// -// Copyright 2020 Leszek Koltunski // -// // -// This file is part of Magic Cube. // -// // -// Magic Cube is free software: you can redistribute it and/or modify // -// it under the terms of the GNU General Public License as published by // -// the Free Software Foundation, either version 2 of the License, or // -// (at your option) any later version. // -// // -// Magic Cube is distributed in the hope that it will be useful, // -// but WITHOUT ANY WARRANTY; without even the implied warranty of // -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // -// GNU General Public License for more details. // -// // -// You should have received a copy of the GNU General Public License // -// along with Magic Cube. If not, see . // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.objects; - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -class RubikMovementSkewb extends RubikMovement -{ - RubikMovementSkewb() - { - super(RubikSkewb.ROT_AXIS, RubikSkewb.FACE_AXIS, 0.25f, 0.25f); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// _____________ -// | \ 0 / | -// | \ / | -// | 3 | | 1 | -// | / \ | -// | / 2 \ | -// ------------- - - private int getQuarter(float[] touchPoint) - { - boolean p0 = touchPoint[1] >= touchPoint[0]; - boolean p1 = touchPoint[1] >=-touchPoint[0]; - - if( p0 ) return p1 ? 0:3; - else return p1 ? 1:2; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - boolean isInsideFace(float[] p) - { - return ( p[0]<=0.25f && p[0]>=-0.25f && p[1]<=0.25f && p[1]>=-0.25f ); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - void computeEnabledAxis(int face, float[] touchPoint, int[] enabled) - { - enabled[0] = 2; - - int quarter = getQuarter(touchPoint); - - switch(face) - { - case 0: switch(quarter) - { - case 0: enabled[1]=0; enabled[2]=1; break; - case 1: enabled[1]=3; enabled[2]=1; break; - case 2: enabled[1]=2; enabled[2]=3; break; - case 3: enabled[1]=0; enabled[2]=2; break; - } - break; - case 1: switch(quarter) - { - case 0: enabled[1]=2; enabled[2]=3; break; - case 1: enabled[1]=3; enabled[2]=1; break; - case 2: enabled[1]=0; enabled[2]=1; break; - case 3: enabled[1]=0; enabled[2]=2; break; - } - break; - case 2: switch(quarter) - { - case 0: enabled[1]=1; enabled[2]=2; break; - case 1: enabled[1]=0; enabled[2]=1; break; - case 2: enabled[1]=0; enabled[2]=3; break; - case 3: enabled[1]=2; enabled[2]=3; break; - } - break; - case 3: switch(quarter) - { - case 0: enabled[1]=1; enabled[2]=2; break; - case 1: enabled[1]=2; enabled[2]=3; break; - case 2: enabled[1]=0; enabled[2]=3; break; - case 3: enabled[1]=0; enabled[2]=1; break; - } - break; - case 4: switch(quarter) - { - case 0: enabled[1]=0; enabled[2]=3; break; - case 1: enabled[1]=0; enabled[2]=2; break; - case 2: enabled[1]=1; enabled[2]=2; break; - case 3: enabled[1]=1; enabled[2]=3; break; - } - break; - case 5: switch(quarter) - { - case 0: enabled[1]=1; enabled[2]=2; break; - case 1: enabled[1]=0; enabled[2]=2; break; - case 2: enabled[1]=0; enabled[2]=3; break; - case 3: enabled[1]=1; enabled[2]=3; break; - } - break; - } - } -} diff --git a/src/main/java/org/distorted/objects/RubikObjectList.java b/src/main/java/org/distorted/objects/RubikObjectList.java index f3e3f6f5..b392f6b6 100644 --- a/src/main/java/org/distorted/objects/RubikObjectList.java +++ b/src/main/java/org/distorted/objects/RubikObjectList.java @@ -42,7 +42,7 @@ public enum RubikObjectList {5 , 24, R.raw.cube5, R.drawable.ui_small_cube5, R.drawable.ui_medium_cube5, R.drawable.ui_big_cube5, R.drawable.ui_huge_cube5} }, RubikCube.class, - new RubikMovementCube(), + new MovementCube(), 0 ), @@ -53,7 +53,7 @@ public enum RubikObjectList {5 , 20, R.raw.pyra5, R.drawable.ui_small_pyra5, R.drawable.ui_medium_pyra5, R.drawable.ui_big_pyra5, R.drawable.ui_huge_pyra5} }, RubikPyraminx.class, - new RubikMovementPyraminx(), + new MovementPyraminx(), 1 ), @@ -62,7 +62,7 @@ public enum RubikObjectList {2 , 10, R.raw.dino, R.drawable.ui_small_dino, R.drawable.ui_medium_dino, R.drawable.ui_big_dino, R.drawable.ui_huge_dino} , }, RubikDiamond.class, - new RubikMovementDiamond(), + new MovementDiamond(), 1 ), @@ -71,7 +71,7 @@ public enum RubikObjectList {3 , 10, R.raw.dino, R.drawable.ui_small_dino, R.drawable.ui_medium_dino, R.drawable.ui_big_dino, R.drawable.ui_huge_dino} , }, RubikDino6.class, - new RubikMovementDino(), + new MovementDino(), 2 ), @@ -80,7 +80,7 @@ public enum RubikObjectList {3 , 7, R.raw.dino, R.drawable.ui_small_din4, R.drawable.ui_medium_din4, R.drawable.ui_big_din4, R.drawable.ui_huge_din4} , }, RubikDino4.class, - new RubikMovementDino(), + new MovementDino(), 2 ), @@ -89,7 +89,7 @@ public enum RubikObjectList {2 , 11, R.raw.skewb, R.drawable.ui_small_skewb, R.drawable.ui_medium_skewb, R.drawable.ui_big_skewb, R.drawable.ui_huge_skewb} , }, RubikSkewb.class, - new RubikMovementSkewb(), + new MovementSkewb(), 2 ), @@ -98,7 +98,7 @@ public enum RubikObjectList {3 , 18, R.raw.heli, R.drawable.ui_small_heli, R.drawable.ui_medium_heli, R.drawable.ui_big_heli, R.drawable.ui_huge_heli} , }, RubikHelicopter.class, - new RubikMovementHelicopter(), + new MovementHelicopter(), 2 ), ; @@ -110,7 +110,7 @@ public enum RubikObjectList private final int[] mObjectSizes, mMaxLevels, mSmallIconIDs, mMediumIconIDs, mBigIconIDs, mHugeIconIDs, mResourceIDs; private final Class mObjectClass; - private final RubikMovement mObjectMovementClass; + private final Movement mObjectMovementClass; private final int mColumn, mNumSizes; private static final RubikObjectList[] objects; @@ -392,7 +392,7 @@ public enum RubikObjectList /////////////////////////////////////////////////////////////////////////////////////////////////// - RubikObjectList(int[][] info, Class object , RubikMovement movement, int column) + RubikObjectList(int[][] info, Class object , Movement movement, int column) { mNumSizes = info.length; @@ -487,7 +487,7 @@ public enum RubikObjectList /////////////////////////////////////////////////////////////////////////////////////////////////// - public RubikMovement getObjectMovementClass() + public Movement getObjectMovementClass() { return mObjectMovementClass; }