Revision 59b87d56
Added by Leszek Koltunski over 3 years ago
| src/main/java/org/distorted/objects/FactoryCubit.java | ||
|---|---|---|
| 38 | 38 |
static final float IVY_D = 0.003f; |
| 39 | 39 |
static final float IVY_C = 0.59f; |
| 40 | 40 |
static final float IVY_M = 0.35f; |
| 41 |
static final float REX_D = 0.03f; |
|
| 41 | 42 |
|
| 42 | 43 |
private static final float SQ2 = (float)Math.sqrt(2); |
| 43 | 44 |
private static final float SQ3 = (float)Math.sqrt(3); |
| 44 | 45 |
private static final float SQ6 = (float)Math.sqrt(6); |
| 45 | 46 |
|
| 46 | 47 |
private static final int IVY_N = 8; |
| 48 |
private static final int REX_N = 5; |
|
| 47 | 49 |
private static final Static1D RADIUS = new Static1D(1); |
| 48 | 50 |
private static FactoryCubit mThis; |
| 49 | 51 |
|
| ... | ... | |
| 192 | 194 |
} |
| 193 | 195 |
} |
| 194 | 196 |
|
| 197 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 198 |
// Compute (rx,ry) - coords of a point which is the result of rotation by angle 'angle' of the point |
|
| 199 |
// (px,py) along axis Z. Center of rotation: (cx,cy). |
|
| 200 |
// Write (rx,ry) to array[index] and array[index+1]. |
|
| 201 |
|
|
| 202 |
private void writeVertex( float cx, float cy, float px, float py, float angle, float[] array, int index) |
|
| 203 |
{
|
|
| 204 |
float vx = px-cx; |
|
| 205 |
float vy = py-cy; |
|
| 206 |
|
|
| 207 |
double radAngle = Math.PI*angle/180; |
|
| 208 |
float sinA = (float)Math.sin(radAngle); |
|
| 209 |
float cosA = (float)Math.cos(radAngle); |
|
| 210 |
|
|
| 211 |
float rvx = vx*cosA +vy*sinA; |
|
| 212 |
float rvy =-vx*sinA +vy*cosA; |
|
| 213 |
|
|
| 214 |
array[index ] = rvx + cx; |
|
| 215 |
array[index+1] = rvy + cy; |
|
| 216 |
} |
|
| 217 |
|
|
| 195 | 218 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 196 | 219 |
|
| 197 | 220 |
MeshBase createFacesCube(int sizeIndex) |
| ... | ... | |
| 578 | 601 |
return new MeshJoined(meshes); |
| 579 | 602 |
} |
| 580 | 603 |
|
| 604 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 605 |
|
|
| 606 |
MeshBase createFacesRexCorner() |
|
| 607 |
{
|
|
| 608 |
MeshBase[] meshes = new MeshBase[2]; |
|
| 609 |
|
|
| 610 |
final float angle = (float)Math.PI/(6*REX_N); |
|
| 611 |
float[] vertices = new float[6*REX_N]; |
|
| 612 |
final float H = SQ2*(SQ3/3 - 0.5f); |
|
| 613 |
final float D = 0.5f - REX_D; |
|
| 614 |
final float F = H*D; |
|
| 615 |
final float B = (float)Math.sqrt(12/(H*H) - 0.75f) - 0.5f; |
|
| 616 |
|
|
| 617 |
final float V1x = -F*0.5f; |
|
| 618 |
final float V1y = -F*SQ3/6; |
|
| 619 |
final float V2x = -V1x; |
|
| 620 |
final float V2y = V1y; |
|
| 621 |
final float V3x = 0.0f; |
|
| 622 |
final float V3y = -2*V1y; |
|
| 623 |
|
|
| 624 |
final float C1x = 0.0f; |
|
| 625 |
final float C1y = -D*( (SQ3/6)*H - (float)Math.sqrt(4.0f-0.25f*H*H) ); |
|
| 626 |
final float C2x = B*V2x; |
|
| 627 |
final float C2y = B*V2y; |
|
| 628 |
final float C3x = B*V3x; |
|
| 629 |
final float C3y = B*V3y; |
|
| 630 |
|
|
| 631 |
for(int i=0; i<REX_N; i++) |
|
| 632 |
{
|
|
| 633 |
writeVertex(C1x,C1y,V1x,V1y, i*angle, vertices, 2*i ); |
|
| 634 |
writeVertex(C2x,C2y,V2x,V2y, i*angle, vertices, 2*i + 2*REX_N); |
|
| 635 |
writeVertex(C3x,C3y,V3x,V3y, i*angle, vertices, 2*i + 4*REX_N); |
|
| 636 |
} |
|
| 637 |
|
|
| 638 |
float[] bands0 = computeBands(+0.03f,35,0.5f,0.5f,5); |
|
| 639 |
float[] bands1 = computeBands(-0.10f,45,0.5f,0.0f,2); |
|
| 640 |
|
|
| 641 |
meshes[0] = new MeshPolygon(vertices,bands0,1,1); |
|
| 642 |
meshes[0].setEffectAssociation(0,1,0); |
|
| 643 |
meshes[1] = new MeshPolygon(vertices,bands1,0,0); |
|
| 644 |
meshes[1].setEffectAssociation(0,2,0); |
|
| 645 |
|
|
| 646 |
return new MeshJoined(meshes); |
|
| 647 |
} |
|
| 648 |
|
|
| 649 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 650 |
|
|
| 651 |
MeshBase createFacesRexFace() |
|
| 652 |
{
|
|
| 653 |
MeshBase[] meshes = new MeshBase[2]; |
|
| 654 |
|
|
| 655 |
final float angle = (float)Math.PI/(6*REX_N); |
|
| 656 |
float[] vertices = new float[8*REX_N]; |
|
| 657 |
final float H = SQ3/2 - 0.5f; |
|
| 658 |
final float D = 0.5f - REX_D; |
|
| 659 |
final float F = H*D; |
|
| 660 |
|
|
| 661 |
final float V1x = 0.0f; |
|
| 662 |
final float V1y = +F; |
|
| 663 |
final float V2x = +F; |
|
| 664 |
final float V2y = 0.0f; |
|
| 665 |
final float V3x = 0.0f; |
|
| 666 |
final float V3y = -F; |
|
| 667 |
final float V4x = -F; |
|
| 668 |
final float V4y = 0.0f; |
|
| 669 |
|
|
| 670 |
final float C1x = -D; |
|
| 671 |
final float C1y = -D; |
|
| 672 |
final float C2x = -D; |
|
| 673 |
final float C2y = +D; |
|
| 674 |
final float C3x = +D; |
|
| 675 |
final float C3y = +D; |
|
| 676 |
final float C4x = +D; |
|
| 677 |
final float C4y = -D; |
|
| 678 |
|
|
| 679 |
for(int i=0; i<REX_N; i++) |
|
| 680 |
{
|
|
| 681 |
writeVertex(C1x,C1y,V1x,V1y, i*angle, vertices, 2*i ); |
|
| 682 |
writeVertex(C2x,C2y,V2x,V2y, i*angle, vertices, 2*i + 2*REX_N); |
|
| 683 |
writeVertex(C3x,C3y,V3x,V3y, i*angle, vertices, 2*i + 4*REX_N); |
|
| 684 |
writeVertex(C4x,C4y,V4x,V4y, i*angle, vertices, 2*i + 6*REX_N); |
|
| 685 |
} |
|
| 686 |
|
|
| 687 |
float[] bands0 = computeBands(+0.03f,35,0.5f,0.5f,5); |
|
| 688 |
float[] bands1 = computeBands(-0.10f,45,0.5f,0.0f,2); |
|
| 689 |
|
|
| 690 |
meshes[0] = new MeshPolygon(vertices,bands0,0,0); |
|
| 691 |
meshes[0].setEffectAssociation(0,1,0); |
|
| 692 |
meshes[1] = new MeshPolygon(vertices,bands1,0,0); |
|
| 693 |
meshes[1].setEffectAssociation(0,2,0); |
|
| 694 |
|
|
| 695 |
return new MeshJoined(meshes); |
|
| 696 |
} |
|
| 697 |
|
|
| 698 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 699 |
|
|
| 700 |
MeshBase createFacesRexEdge() |
|
| 701 |
{
|
|
| 702 |
MeshBase[] meshes = new MeshBase[4]; |
|
| 703 |
|
|
| 704 |
final float angle = (float)Math.PI/(6*REX_N); |
|
| 705 |
float[] vertices = new float[4*REX_N + 4]; |
|
| 706 |
final float H = 1.0f - SQ3/2; |
|
| 707 |
final float D = 0.5f - REX_D; |
|
| 708 |
final float F = H*D; |
|
| 709 |
|
|
| 710 |
final float V1x = -D; |
|
| 711 |
final float V1y = +D - D*SQ3/2; |
|
| 712 |
final float V2x = 0.0f; |
|
| 713 |
final float V2y = D*(SQ3-1) - D*SQ3/2; |
|
| 714 |
|
|
| 715 |
final float C1x = -D; |
|
| 716 |
final float C1y = -D - D*SQ3/2; |
|
| 717 |
final float C2x = +D; |
|
| 718 |
final float C2y = C1y; |
|
| 719 |
|
|
| 720 |
for(int i=0; i<REX_N; i++) |
|
| 721 |
{
|
|
| 722 |
writeVertex(C1x,C1y,V1x,V1y, i*angle, vertices, 2*i ); |
|
| 723 |
writeVertex(C2x,C2y,V2x,V2y, i*angle, vertices, 2*i + 2*REX_N); |
|
| 724 |
} |
|
| 725 |
|
|
| 726 |
vertices[4*REX_N ] = +D; |
|
| 727 |
vertices[4*REX_N+1] = +F + REX_D; |
|
| 728 |
vertices[4*REX_N+2] = -D; |
|
| 729 |
vertices[4*REX_N+3] = +F + REX_D; |
|
| 730 |
|
|
| 731 |
float[] bands0 = computeBands(+0.03f,35,0.5f,0.5f,5); |
|
| 732 |
float[] bands1 = computeBands(-0.10f,45,0.5f,0.0f,2); |
|
| 733 |
|
|
| 734 |
meshes[0] = new MeshPolygon(vertices,bands0,1,2); |
|
| 735 |
meshes[0].setEffectAssociation(0,1,0); |
|
| 736 |
meshes[1] = meshes[0].copy(true); |
|
| 737 |
meshes[1].setEffectAssociation(0,2,0); |
|
| 738 |
meshes[2] = new MeshPolygon(vertices,bands1,0,0); |
|
| 739 |
meshes[2].setEffectAssociation(0,4,0); |
|
| 740 |
meshes[3] = meshes[2].copy(true); |
|
| 741 |
meshes[3].setEffectAssociation(0,8,0); |
|
| 742 |
|
|
| 743 |
return new MeshJoined(meshes); |
|
| 744 |
} |
|
| 745 |
|
|
| 581 | 746 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 582 | 747 |
// EFFECTS |
| 583 | 748 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| ... | ... | |
| 1005 | 1170 |
return effect; |
| 1006 | 1171 |
} |
| 1007 | 1172 |
|
| 1173 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 1174 |
|
|
| 1175 |
VertexEffect[] createVertexEffectsRexEdge() |
|
| 1176 |
{
|
|
| 1177 |
final float H = 1.0f - SQ3/2; |
|
| 1178 |
final float D = 0.5f - REX_D; |
|
| 1179 |
final float F = H*D; |
|
| 1180 |
|
|
| 1181 |
Static3D move = new Static3D(0.0f, 0.5f - F, 0.0f); |
|
| 1182 |
Static3D center= new Static3D(0.0f, F, 0.0f); |
|
| 1183 |
Static3D axisX = new Static3D(1.0f, 0.0f, 0.0f); |
|
| 1184 |
Static3D axisY = new Static3D(0.0f, 1.0f, 0.0f); |
|
| 1185 |
|
|
| 1186 |
Static1D angle180 = new Static1D(180); |
|
| 1187 |
Static1D angle90 = new Static1D( 90); |
|
| 1188 |
|
|
| 1189 |
VertexEffect[] effect = new VertexEffect[3]; |
|
| 1190 |
|
|
| 1191 |
effect[0] = new VertexEffectRotate(angle180, axisY, center); |
|
| 1192 |
effect[1] = new VertexEffectRotate(angle90 , axisX, center); |
|
| 1193 |
effect[2] = new VertexEffectMove(move); |
|
| 1194 |
|
|
| 1195 |
effect[0].setMeshAssociation(10,-1); // meshes 1 & 3 |
|
| 1196 |
effect[1].setMeshAssociation(10,-1); // meshes 1 & 3 |
|
| 1197 |
|
|
| 1198 |
return effect; |
|
| 1199 |
} |
|
| 1200 |
|
|
| 1201 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 1202 |
|
|
| 1203 |
VertexEffect[] createVertexEffectsRexCorner() |
|
| 1204 |
{
|
|
| 1205 |
float F = SQ3/6*(1.0f-2*REX_D); |
|
| 1206 |
Static3D move = new Static3D(F,F,0.0f); |
|
| 1207 |
Static3D center= new Static3D(0.0f, 0.0f, 0.0f); |
|
| 1208 |
Static3D axisZ = new Static3D(0.0f, 0.0f, 1.0f); |
|
| 1209 |
Static1D angle = new Static1D(45); |
|
| 1210 |
|
|
| 1211 |
VertexEffect[] effect = new VertexEffect[2]; |
|
| 1212 |
|
|
| 1213 |
effect[0] = new VertexEffectRotate(angle, axisZ, center); |
|
| 1214 |
effect[1] = new VertexEffectMove(move); |
|
| 1215 |
|
|
| 1216 |
return effect; |
|
| 1217 |
} |
|
| 1218 |
|
|
| 1008 | 1219 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 1009 | 1220 |
// OBJECTS |
| 1010 | 1221 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| ... | ... | |
| 1298 | 1509 |
mesh.addEmptyTexComponent(); |
| 1299 | 1510 |
mesh.addEmptyTexComponent(); |
| 1300 | 1511 |
|
| 1512 |
return mesh; |
|
| 1513 |
} |
|
| 1514 |
|
|
| 1515 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 1516 |
|
|
| 1517 |
MeshBase createRexCornerMesh() |
|
| 1518 |
{
|
|
| 1519 |
MeshBase mesh = createFacesRexCorner(); |
|
| 1520 |
VertexEffect[] effects = createVertexEffectsRexCorner(); |
|
| 1521 |
for( VertexEffect effect : effects ) mesh.apply(effect); |
|
| 1522 |
|
|
| 1523 |
Static3D center = new Static3D(0.0f,0.0f,-0.25f); |
|
| 1524 |
Static3D[] vertices = new Static3D[1]; |
|
| 1525 |
vertices[0] = new Static3D(+0.25f,+0.25f,+0.0f); |
|
| 1526 |
roundCorners(mesh,center,vertices,0.03f,0.10f); |
|
| 1527 |
|
|
| 1528 |
mesh.mergeEffComponents(); |
|
| 1529 |
mesh.addEmptyTexComponent(); |
|
| 1530 |
mesh.addEmptyTexComponent(); |
|
| 1531 |
|
|
| 1532 |
return mesh; |
|
| 1533 |
} |
|
| 1534 |
|
|
| 1535 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 1536 |
|
|
| 1537 |
MeshBase createRexFaceMesh() |
|
| 1538 |
{
|
|
| 1539 |
MeshBase mesh = createFacesRexFace(); |
|
| 1540 |
|
|
| 1541 |
mesh.mergeEffComponents(); |
|
| 1542 |
mesh.addEmptyTexComponent(); |
|
| 1543 |
mesh.addEmptyTexComponent(); |
|
| 1544 |
|
|
| 1545 |
return mesh; |
|
| 1546 |
} |
|
| 1547 |
|
|
| 1548 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 1549 |
|
|
| 1550 |
MeshBase createRexEdgeMesh() |
|
| 1551 |
{
|
|
| 1552 |
MeshBase mesh = createFacesRexEdge(); |
|
| 1553 |
VertexEffect[] effects = createVertexEffectsRexEdge(); |
|
| 1554 |
for( VertexEffect effect : effects ) mesh.apply(effect); |
|
| 1555 |
|
|
| 1556 |
Static3D center = new Static3D(0.0f,-0.5f,-0.5f); |
|
| 1557 |
Static3D[] vertices = new Static3D[2]; |
|
| 1558 |
vertices[0] = new Static3D(+0.5f,+0.0f,+0.0f); |
|
| 1559 |
vertices[1] = new Static3D(-0.5f,+0.0f,+0.0f); |
|
| 1560 |
roundCorners(mesh,center,vertices,0.03f,0.10f); |
|
| 1561 |
|
|
| 1562 |
mesh.mergeEffComponents(); |
|
| 1563 |
|
|
| 1301 | 1564 |
return mesh; |
| 1302 | 1565 |
} |
| 1303 | 1566 |
} |
| src/main/java/org/distorted/objects/FactorySticker.java | ||
|---|---|---|
| 239 | 239 |
canvas.drawArc( left+cx3-halfR, top+cy3-halfR, left+cx3+halfR, top+cy3+halfR, 180, 90, false, paint); |
| 240 | 240 |
canvas.drawArc( left+cx4-halfR, top+cy4-halfR, left+cx4+halfR, top+cy4+halfR, 0, 90, false, paint); |
| 241 | 241 |
} |
| 242 |
|
|
| 243 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 244 |
// TODO |
|
| 245 |
|
|
| 246 |
void drawRexCornerSticker(Canvas canvas, Paint paint, int left, int top, int color, float stroke, float radius) |
|
| 247 |
{
|
|
| 248 |
paint.setColor(color); |
|
| 249 |
paint.setStyle(Paint.Style.FILL); |
|
| 250 |
canvas.drawRect(left,top,left+TEXTURE_HEIGHT,top+TEXTURE_HEIGHT,paint); |
|
| 251 |
} |
|
| 252 |
|
|
| 253 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 254 |
// TODO |
|
| 255 |
|
|
| 256 |
void drawRexFaceSticker(Canvas canvas, Paint paint, int left, int top, int color, float stroke, float radius) |
|
| 257 |
{
|
|
| 258 |
paint.setColor(color); |
|
| 259 |
paint.setStyle(Paint.Style.FILL); |
|
| 260 |
canvas.drawRect(left,top,left+TEXTURE_HEIGHT,top+TEXTURE_HEIGHT,paint); |
|
| 261 |
} |
|
| 262 |
|
|
| 263 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 264 |
// TODO |
|
| 265 |
|
|
| 266 |
void drawRexEdgeSticker(Canvas canvas, Paint paint, int left, int top, int color, float stroke, float radius) |
|
| 267 |
{
|
|
| 268 |
paint.setColor(color); |
|
| 269 |
paint.setStyle(Paint.Style.FILL); |
|
| 270 |
canvas.drawRect(left,top,left+TEXTURE_HEIGHT,top+TEXTURE_HEIGHT,paint); |
|
| 271 |
} |
|
| 242 | 272 |
} |
| src/main/java/org/distorted/objects/MovementRex.java | ||
|---|---|---|
| 1 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 2 |
// Copyright 2020 Leszek Koltunski // |
|
| 3 |
// // |
|
| 4 |
// This file is part of Magic Cube. // |
|
| 5 |
// // |
|
| 6 |
// Magic Cube is free software: you can redistribute it and/or modify // |
|
| 7 |
// it under the terms of the GNU General Public License as published by // |
|
| 8 |
// the Free Software Foundation, either version 2 of the License, or // |
|
| 9 |
// (at your option) any later version. // |
|
| 10 |
// // |
|
| 11 |
// Magic Cube is distributed in the hope that it will be useful, // |
|
| 12 |
// but WITHOUT ANY WARRANTY; without even the implied warranty of // |
|
| 13 |
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // |
|
| 14 |
// GNU General Public License for more details. // |
|
| 15 |
// // |
|
| 16 |
// You should have received a copy of the GNU General Public License // |
|
| 17 |
// along with Magic Cube. If not, see <http://www.gnu.org/licenses/>. // |
|
| 18 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 19 |
|
|
| 20 |
package org.distorted.objects; |
|
| 21 |
|
|
| 22 |
import org.distorted.library.type.Static3D; |
|
| 23 |
|
|
| 24 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 25 |
|
|
| 26 |
class MovementRex extends Movement |
|
| 27 |
{
|
|
| 28 |
static final float DIST3D = 0.5f; |
|
| 29 |
static final float DIST2D = 0.5f; |
|
| 30 |
|
|
| 31 |
static final Static3D[] FACE_AXIS = new Static3D[] |
|
| 32 |
{
|
|
| 33 |
new Static3D(1,0,0), new Static3D(-1,0,0), |
|
| 34 |
new Static3D(0,1,0), new Static3D(0,-1,0), |
|
| 35 |
new Static3D(0,0,1), new Static3D(0,0,-1) |
|
| 36 |
}; |
|
| 37 |
|
|
| 38 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 39 |
|
|
| 40 |
MovementRex() |
|
| 41 |
{
|
|
| 42 |
super(TwistyRex.ROT_AXIS, FACE_AXIS, DIST3D, DIST2D); |
|
| 43 |
} |
|
| 44 |
|
|
| 45 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 46 |
|
|
| 47 |
int computeRowFromOffset(int face, int size, float offset) |
|
| 48 |
{
|
|
| 49 |
return offset<DIST2D ? 0:2; |
|
| 50 |
} |
|
| 51 |
|
|
| 52 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 53 |
|
|
| 54 |
public float returnRotationFactor(int size, int row) |
|
| 55 |
{
|
|
| 56 |
return 1.0f; |
|
| 57 |
} |
|
| 58 |
|
|
| 59 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 60 |
// _____________ |
|
| 61 |
// | \ 0 / | |
|
| 62 |
// | \ / | |
|
| 63 |
// | 3 | | 1 | |
|
| 64 |
// | / \ | |
|
| 65 |
// | / 2 \ | |
|
| 66 |
// ------------- |
|
| 67 |
|
|
| 68 |
private int getQuarter(float[] touchPoint) |
|
| 69 |
{
|
|
| 70 |
boolean p0 = touchPoint[1] >= touchPoint[0]; |
|
| 71 |
boolean p1 = touchPoint[1] >=-touchPoint[0]; |
|
| 72 |
|
|
| 73 |
if( p0 ) return p1 ? 0:3; |
|
| 74 |
else return p1 ? 1:2; |
|
| 75 |
} |
|
| 76 |
|
|
| 77 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 78 |
|
|
| 79 |
boolean isInsideFace(int face, float[] p) |
|
| 80 |
{
|
|
| 81 |
return ( p[0]<=DIST2D && p[0]>=-DIST2D && p[1]<=DIST2D && p[1]>=-DIST2D ); |
|
| 82 |
} |
|
| 83 |
|
|
| 84 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 85 |
|
|
| 86 |
void computeEnabledAxis(int face, float[] touchPoint, int[] enabled) |
|
| 87 |
{
|
|
| 88 |
enabled[0] = 2; |
|
| 89 |
|
|
| 90 |
int quarter = getQuarter(touchPoint); |
|
| 91 |
|
|
| 92 |
switch(face) |
|
| 93 |
{
|
|
| 94 |
case 0: switch(quarter) |
|
| 95 |
{
|
|
| 96 |
case 0: enabled[1]=0; enabled[2]=1; break; |
|
| 97 |
case 1: enabled[1]=3; enabled[2]=1; break; |
|
| 98 |
case 2: enabled[1]=2; enabled[2]=3; break; |
|
| 99 |
case 3: enabled[1]=0; enabled[2]=2; break; |
|
| 100 |
} |
|
| 101 |
break; |
|
| 102 |
case 1: switch(quarter) |
|
| 103 |
{
|
|
| 104 |
case 0: enabled[1]=2; enabled[2]=3; break; |
|
| 105 |
case 1: enabled[1]=3; enabled[2]=1; break; |
|
| 106 |
case 2: enabled[1]=0; enabled[2]=1; break; |
|
| 107 |
case 3: enabled[1]=0; enabled[2]=2; break; |
|
| 108 |
} |
|
| 109 |
break; |
|
| 110 |
case 2: switch(quarter) |
|
| 111 |
{
|
|
| 112 |
case 0: enabled[1]=1; enabled[2]=2; break; |
|
| 113 |
case 1: enabled[1]=0; enabled[2]=1; break; |
|
| 114 |
case 2: enabled[1]=0; enabled[2]=3; break; |
|
| 115 |
case 3: enabled[1]=2; enabled[2]=3; break; |
|
| 116 |
} |
|
| 117 |
break; |
|
| 118 |
case 3: switch(quarter) |
|
| 119 |
{
|
|
| 120 |
case 0: enabled[1]=1; enabled[2]=2; break; |
|
| 121 |
case 1: enabled[1]=2; enabled[2]=3; break; |
|
| 122 |
case 2: enabled[1]=0; enabled[2]=3; break; |
|
| 123 |
case 3: enabled[1]=0; enabled[2]=1; break; |
|
| 124 |
} |
|
| 125 |
break; |
|
| 126 |
case 4: switch(quarter) |
|
| 127 |
{
|
|
| 128 |
case 0: enabled[1]=0; enabled[2]=3; break; |
|
| 129 |
case 1: enabled[1]=0; enabled[2]=2; break; |
|
| 130 |
case 2: enabled[1]=1; enabled[2]=2; break; |
|
| 131 |
case 3: enabled[1]=1; enabled[2]=3; break; |
|
| 132 |
} |
|
| 133 |
break; |
|
| 134 |
case 5: switch(quarter) |
|
| 135 |
{
|
|
| 136 |
case 0: enabled[1]=1; enabled[2]=2; break; |
|
| 137 |
case 1: enabled[1]=0; enabled[2]=2; break; |
|
| 138 |
case 2: enabled[1]=0; enabled[2]=3; break; |
|
| 139 |
case 3: enabled[1]=1; enabled[2]=3; break; |
|
| 140 |
} |
|
| 141 |
break; |
|
| 142 |
} |
|
| 143 |
} |
|
| 144 |
} |
|
| src/main/java/org/distorted/objects/ObjectList.java | ||
|---|---|---|
| 120 | 120 |
new MovementIvy(), |
| 121 | 121 |
3 |
| 122 | 122 |
), |
| 123 |
|
|
| 124 |
REX ( |
|
| 125 |
new int[][] {
|
|
| 126 |
{3 , 16, R.raw.ivy, R.drawable.ui_small_ivy, R.drawable.ui_medium_ivy, R.drawable.ui_big_ivy, R.drawable.ui_huge_ivy} ,
|
|
| 127 |
}, |
|
| 128 |
TwistyRex.class, |
|
| 129 |
new MovementRex(), |
|
| 130 |
3 |
|
| 131 |
), |
|
| 123 | 132 |
; |
| 124 | 133 |
|
| 125 | 134 |
public static final int NUM_OBJECTS = values().length; |
| ... | ... | |
| 501 | 510 |
case 6: return new TwistyHelicopter(size, quat, texture, mesh, effects, moves, res, scrWidth); |
| 502 | 511 |
case 7: return new TwistySkewb (size, quat, texture, mesh, effects, moves, res, scrWidth); |
| 503 | 512 |
case 8: return new TwistyIvy (size, quat, texture, mesh, effects, moves, res, scrWidth); |
| 513 |
case 9: return new TwistyRex (size, quat, texture, mesh, effects, moves, res, scrWidth); |
|
| 504 | 514 |
} |
| 505 | 515 |
|
| 506 | 516 |
return null; |
| src/main/java/org/distorted/objects/TwistyObject.java | ||
|---|---|---|
| 78 | 78 |
private static final float MAX_SIZE_CHANGE = 1.35f; |
| 79 | 79 |
private static final float MIN_SIZE_CHANGE = 0.8f; |
| 80 | 80 |
|
| 81 |
private static boolean mCreateFromDMesh = true;
|
|
| 81 |
private static boolean mCreateFromDMesh = false;
|
|
| 82 | 82 |
|
| 83 | 83 |
private static final Static3D CENTER = new Static3D(0,0,0); |
| 84 | 84 |
private static final int POST_ROTATION_MILLISEC = 500; |
| src/main/java/org/distorted/objects/TwistyRex.java | ||
|---|---|---|
| 1 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 2 |
// Copyright 2020 Leszek Koltunski // |
|
| 3 |
// // |
|
| 4 |
// This file is part of Magic Cube. // |
|
| 5 |
// // |
|
| 6 |
// Magic Cube is free software: you can redistribute it and/or modify // |
|
| 7 |
// it under the terms of the GNU General Public License as published by // |
|
| 8 |
// the Free Software Foundation, either version 2 of the License, or // |
|
| 9 |
// (at your option) any later version. // |
|
| 10 |
// // |
|
| 11 |
// Magic Cube is distributed in the hope that it will be useful, // |
|
| 12 |
// but WITHOUT ANY WARRANTY; without even the implied warranty of // |
|
| 13 |
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // |
|
| 14 |
// GNU General Public License for more details. // |
|
| 15 |
// // |
|
| 16 |
// You should have received a copy of the GNU General Public License // |
|
| 17 |
// along with Magic Cube. If not, see <http://www.gnu.org/licenses/>. // |
|
| 18 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 19 |
|
|
| 20 |
package org.distorted.objects; |
|
| 21 |
|
|
| 22 |
import android.content.res.Resources; |
|
| 23 |
import android.graphics.Canvas; |
|
| 24 |
import android.graphics.Paint; |
|
| 25 |
|
|
| 26 |
import org.distorted.library.effect.MatrixEffectQuaternion; |
|
| 27 |
import org.distorted.library.main.DistortedEffects; |
|
| 28 |
import org.distorted.library.main.DistortedTexture; |
|
| 29 |
import org.distorted.library.mesh.MeshBase; |
|
| 30 |
import org.distorted.library.mesh.MeshSquare; |
|
| 31 |
import org.distorted.library.type.Static3D; |
|
| 32 |
import org.distorted.library.type.Static4D; |
|
| 33 |
import org.distorted.main.R; |
|
| 34 |
import org.distorted.main.RubikSurfaceView; |
|
| 35 |
|
|
| 36 |
import java.util.Random; |
|
| 37 |
|
|
| 38 |
import static org.distorted.effects.scramble.ScrambleEffect.START_AXIS; |
|
| 39 |
|
|
| 40 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 41 |
|
|
| 42 |
public class TwistyRex extends TwistyObject |
|
| 43 |
{
|
|
| 44 |
private static final int FACES_PER_CUBIT =4; |
|
| 45 |
|
|
| 46 |
// the four rotation axis of a RubikRex. Must be normalized. |
|
| 47 |
static final Static3D[] ROT_AXIS = new Static3D[] |
|
| 48 |
{
|
|
| 49 |
new Static3D(+SQ3/3,+SQ3/3,+SQ3/3), |
|
| 50 |
new Static3D(+SQ3/3,+SQ3/3,-SQ3/3), |
|
| 51 |
new Static3D(+SQ3/3,-SQ3/3,+SQ3/3), |
|
| 52 |
new Static3D(+SQ3/3,-SQ3/3,-SQ3/3) |
|
| 53 |
}; |
|
| 54 |
|
|
| 55 |
private static final int[] FACE_COLORS = new int[] |
|
| 56 |
{
|
|
| 57 |
COLOR_YELLOW, COLOR_WHITE, |
|
| 58 |
COLOR_BLUE , COLOR_GREEN, |
|
| 59 |
COLOR_RED , COLOR_BROWN |
|
| 60 |
}; |
|
| 61 |
|
|
| 62 |
// All legal rotation quats of a RubikRex |
|
| 63 |
private static final Static4D[] QUATS = new Static4D[] |
|
| 64 |
{
|
|
| 65 |
new Static4D( 0.0f, 0.0f, 0.0f, 1.0f ), |
|
| 66 |
new Static4D( 1.0f, 0.0f, 0.0f, 0.0f ), |
|
| 67 |
new Static4D( 0.0f, 1.0f, 0.0f, 0.0f ), |
|
| 68 |
new Static4D( 0.0f, 0.0f, 1.0f, 0.0f ), |
|
| 69 |
|
|
| 70 |
new Static4D( 0.5f, 0.5f, 0.5f, 0.5f ), |
|
| 71 |
new Static4D( 0.5f, 0.5f, 0.5f, -0.5f ), |
|
| 72 |
new Static4D( 0.5f, 0.5f, -0.5f, 0.5f ), |
|
| 73 |
new Static4D( 0.5f, 0.5f, -0.5f, -0.5f ), |
|
| 74 |
new Static4D( 0.5f, -0.5f, 0.5f, 0.5f ), |
|
| 75 |
new Static4D( 0.5f, -0.5f, 0.5f, -0.5f ), |
|
| 76 |
new Static4D( 0.5f, -0.5f, -0.5f, 0.5f ), |
|
| 77 |
new Static4D( 0.5f, -0.5f, -0.5f, -0.5f ) |
|
| 78 |
}; |
|
| 79 |
|
|
| 80 |
private static final int[][] mFaceMap = |
|
| 81 |
{
|
|
| 82 |
{ 0, 18,18,18 },
|
|
| 83 |
{ 0, 18,18,18 },
|
|
| 84 |
{ 0, 18,18,18 },
|
|
| 85 |
{ 0, 18,18,18 },
|
|
| 86 |
{ 1, 18,18,18 },
|
|
| 87 |
{ 1, 18,18,18 },
|
|
| 88 |
{ 1, 18,18,18 },
|
|
| 89 |
{ 1, 18,18,18 },
|
|
| 90 |
{ 2, 18,18,18 },
|
|
| 91 |
{ 2, 18,18,18 },
|
|
| 92 |
{ 2, 18,18,18 },
|
|
| 93 |
{ 2, 18,18,18 },
|
|
| 94 |
{ 3, 18,18,18 },
|
|
| 95 |
{ 3, 18,18,18 },
|
|
| 96 |
{ 3, 18,18,18 },
|
|
| 97 |
{ 3, 18,18,18 },
|
|
| 98 |
{ 4, 18,18,18 },
|
|
| 99 |
{ 4, 18,18,18 },
|
|
| 100 |
{ 4, 18,18,18 },
|
|
| 101 |
{ 4, 18,18,18 },
|
|
| 102 |
{ 5, 18,18,18 },
|
|
| 103 |
{ 5, 18,18,18 },
|
|
| 104 |
{ 5, 18,18,18 },
|
|
| 105 |
{ 5, 18,18,18 },
|
|
| 106 |
|
|
| 107 |
{ 6, 18,18,18 },
|
|
| 108 |
{ 7, 18,18,18 },
|
|
| 109 |
{ 8, 18,18,18 },
|
|
| 110 |
{ 9, 18,18,18 },
|
|
| 111 |
{ 10, 18,18,18 },
|
|
| 112 |
{ 11, 18,18,18 },
|
|
| 113 |
|
|
| 114 |
{ 4, 2, 18,18 },
|
|
| 115 |
{ 4, 0, 18,18 },
|
|
| 116 |
{ 4, 3, 18,18 },
|
|
| 117 |
{ 4, 1, 18,18 },
|
|
| 118 |
{ 0, 2, 18,18 },
|
|
| 119 |
{ 3, 0, 18,18 },
|
|
| 120 |
{ 1, 3, 18,18 },
|
|
| 121 |
{ 3, 2, 18,18 },
|
|
| 122 |
{ 5, 2, 18,18 },
|
|
| 123 |
{ 5, 0, 18,18 },
|
|
| 124 |
{ 5, 3, 18,18 },
|
|
| 125 |
{ 5, 1, 18,18 },
|
|
| 126 |
}; |
|
| 127 |
|
|
| 128 |
private static MeshBase mCornerMesh, mFaceMesh, mEdgeMesh; |
|
| 129 |
|
|
| 130 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 131 |
|
|
| 132 |
TwistyRex(int size, Static4D quat, DistortedTexture texture, MeshSquare mesh, |
|
| 133 |
DistortedEffects effects, int[][] moves, Resources res, int scrWidth) |
|
| 134 |
{
|
|
| 135 |
super(size, size, 60, quat, texture, mesh, effects, moves, ObjectList.REX, res, scrWidth); |
|
| 136 |
} |
|
| 137 |
|
|
| 138 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 139 |
|
|
| 140 |
float getScreenRatio() |
|
| 141 |
{
|
|
| 142 |
return 1.0f; |
|
| 143 |
} |
|
| 144 |
|
|
| 145 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 146 |
|
|
| 147 |
Static4D[] getQuats() |
|
| 148 |
{
|
|
| 149 |
return QUATS; |
|
| 150 |
} |
|
| 151 |
|
|
| 152 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 153 |
|
|
| 154 |
int getNumFaces() |
|
| 155 |
{
|
|
| 156 |
return FACE_COLORS.length; |
|
| 157 |
} |
|
| 158 |
|
|
| 159 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 160 |
|
|
| 161 |
boolean shouldResetTextureMaps() |
|
| 162 |
{
|
|
| 163 |
return false; |
|
| 164 |
} |
|
| 165 |
|
|
| 166 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 167 |
|
|
| 168 |
int getNumStickerTypes() |
|
| 169 |
{
|
|
| 170 |
return 3; |
|
| 171 |
} |
|
| 172 |
|
|
| 173 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 174 |
|
|
| 175 |
float[] getCuts(int numLayers) |
|
| 176 |
{
|
|
| 177 |
float C = SQ3*0.15f; // bit less than 1/6 of the length of the main diagonal |
|
| 178 |
|
|
| 179 |
return new float[] {-C,+C};
|
|
| 180 |
} |
|
| 181 |
|
|
| 182 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 183 |
|
|
| 184 |
int getNumCubitFaces() |
|
| 185 |
{
|
|
| 186 |
return FACES_PER_CUBIT; |
|
| 187 |
} |
|
| 188 |
|
|
| 189 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 190 |
|
|
| 191 |
Static3D[] getCubitPositions(int numLayers) |
|
| 192 |
{
|
|
| 193 |
final float DIST = 0.50f; |
|
| 194 |
final float E = SQ3/3; |
|
| 195 |
|
|
| 196 |
final Static3D[] CENTERS = new Static3D[42]; |
|
| 197 |
|
|
| 198 |
CENTERS[ 0] = new Static3D( +DIST , +DIST*E, +DIST*E); |
|
| 199 |
CENTERS[ 1] = new Static3D( +DIST , +DIST*E, -DIST*E); |
|
| 200 |
CENTERS[ 2] = new Static3D( +DIST , -DIST*E, -DIST*E); |
|
| 201 |
CENTERS[ 3] = new Static3D( +DIST , -DIST*E, +DIST*E); |
|
| 202 |
CENTERS[ 4] = new Static3D( -DIST , +DIST*E, +DIST*E); |
|
| 203 |
CENTERS[ 5] = new Static3D( -DIST , +DIST*E, -DIST*E); |
|
| 204 |
CENTERS[ 6] = new Static3D( -DIST , -DIST*E, -DIST*E); |
|
| 205 |
CENTERS[ 7] = new Static3D( -DIST , -DIST*E, +DIST*E); |
|
| 206 |
CENTERS[ 8] = new Static3D( +DIST*E, +DIST , +DIST*E); |
|
| 207 |
CENTERS[ 9] = new Static3D( +DIST*E, +DIST , -DIST*E); |
|
| 208 |
CENTERS[10] = new Static3D( -DIST*E, +DIST , -DIST*E); |
|
| 209 |
CENTERS[11] = new Static3D( -DIST*E, +DIST , +DIST*E); |
|
| 210 |
CENTERS[12] = new Static3D( +DIST*E, -DIST , +DIST*E); |
|
| 211 |
CENTERS[13] = new Static3D( +DIST*E, -DIST , -DIST*E); |
|
| 212 |
CENTERS[14] = new Static3D( -DIST*E, -DIST , -DIST*E); |
|
| 213 |
CENTERS[15] = new Static3D( -DIST*E, -DIST , +DIST*E); |
|
| 214 |
CENTERS[16] = new Static3D( +DIST*E, +DIST*E, +DIST ); |
|
| 215 |
CENTERS[17] = new Static3D( +DIST*E, -DIST*E, +DIST ); |
|
| 216 |
CENTERS[18] = new Static3D( -DIST*E, -DIST*E, +DIST ); |
|
| 217 |
CENTERS[19] = new Static3D( -DIST*E, +DIST*E, +DIST ); |
|
| 218 |
CENTERS[20] = new Static3D( +DIST*E, +DIST*E, -DIST ); |
|
| 219 |
CENTERS[21] = new Static3D( +DIST*E, -DIST*E, -DIST ); |
|
| 220 |
CENTERS[22] = new Static3D( -DIST*E, -DIST*E, -DIST ); |
|
| 221 |
CENTERS[23] = new Static3D( -DIST*E, +DIST*E, -DIST ); |
|
| 222 |
|
|
| 223 |
CENTERS[24] = new Static3D( +DIST , +0.00f , +0.00f ); |
|
| 224 |
CENTERS[25] = new Static3D( -DIST , +0.00f , +0.00f ); |
|
| 225 |
CENTERS[26] = new Static3D( +0.00f , +DIST , +0.00f ); |
|
| 226 |
CENTERS[27] = new Static3D( +0.00f , -DIST , +0.00f ); |
|
| 227 |
CENTERS[28] = new Static3D( +0.00f , +0.00f , +DIST ); |
|
| 228 |
CENTERS[29] = new Static3D( +0.00f , +0.00f , -DIST ); |
|
| 229 |
|
|
| 230 |
CENTERS[30] = new Static3D( +0.00f , +DIST , +DIST ); |
|
| 231 |
CENTERS[31] = new Static3D( +DIST , +0.00f , +DIST ); |
|
| 232 |
CENTERS[32] = new Static3D( +0.00f , -DIST , +DIST ); |
|
| 233 |
CENTERS[33] = new Static3D( -DIST , +0.00f , +DIST ); |
|
| 234 |
CENTERS[34] = new Static3D( +DIST , +DIST , +0.00f ); |
|
| 235 |
CENTERS[35] = new Static3D( +DIST , -DIST , +0.00f ); |
|
| 236 |
CENTERS[36] = new Static3D( -DIST , -DIST , +0.00f ); |
|
| 237 |
CENTERS[37] = new Static3D( -DIST , +DIST , +0.00f ); |
|
| 238 |
CENTERS[38] = new Static3D( +0.00f , +DIST , -DIST ); |
|
| 239 |
CENTERS[39] = new Static3D( +DIST , +0.00f , -DIST ); |
|
| 240 |
CENTERS[40] = new Static3D( +0.00f , -DIST , -DIST ); |
|
| 241 |
CENTERS[41] = new Static3D( -DIST , +0.00f , -DIST ); |
|
| 242 |
|
|
| 243 |
return CENTERS; |
|
| 244 |
} |
|
| 245 |
|
|
| 246 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 247 |
// 1 +90 ( 1, 0, 0) = Static4D(+SQ2/2, 0, 0, SQ2/2); |
|
| 248 |
// 2 -90 ( 1, 0, 0) = Static4D(-SQ2/2, 0, 0, SQ2/2); |
|
| 249 |
// 3 +90 ( 0, 1, 0) = Static4D( 0,+SQ2/2, 0, SQ2/2); |
|
| 250 |
// 4 -90 ( 0, 1, 0) = Static4D( 0,-SQ2/2, 0, SQ2/2); |
|
| 251 |
// 5 +90 ( 0, 0, 1) = Static4D( 0, 0,+SQ2/2, SQ2/2); |
|
| 252 |
// 6 -90 ( 0, 0, 1) = Static4D( 0, 0,-SQ2/2, SQ2/2); |
|
| 253 |
// 7 180 ( 1, 0, 1) = Static4D(+SQ2/2, 0,+SQ2/2, 0); |
|
| 254 |
// 8 180 (-1, 0, 1) = Static4D(-SQ2/2, 0,+SQ2/2, 0); |
|
| 255 |
// 9 180 ( 0, 1, 1) = Static4D( 0,+SQ2/2,+SQ2/2, 0); |
|
| 256 |
//10 180 ( 0,-1, 1) = Static4D( 0,-SQ2/2,+SQ2/2, 0); |
|
| 257 |
//11 180 ( 1, 1, 0) = Static4D(+SQ2/2,+SQ2/2, 0, 0); |
|
| 258 |
//12 180 ( 1,-1, 0) = Static4D(+SQ2/2,-SQ2/2, 0, 0); |
|
| 259 |
|
|
| 260 |
private Static4D getQuat(int cubit) |
|
| 261 |
{
|
|
| 262 |
switch(cubit) |
|
| 263 |
{
|
|
| 264 |
case 0: return QUATS[5]; |
|
| 265 |
case 1: return new Static4D( 0,+SQ2/2, 0, SQ2/2); |
|
| 266 |
case 2: return QUATS[8]; |
|
| 267 |
case 3: return new Static4D(+SQ2/2, 0,+SQ2/2, 0); |
|
| 268 |
case 4: return QUATS[6]; |
|
| 269 |
case 5: return new Static4D( 0, 0,+SQ2/2, SQ2/2); |
|
| 270 |
case 6: return QUATS[11]; |
|
| 271 |
case 7: return new Static4D(-SQ2/2, 0,+SQ2/2, 0); |
|
| 272 |
case 8: return QUATS[10]; |
|
| 273 |
case 9: return new Static4D(+SQ2/2, 0, 0, SQ2/2); |
|
| 274 |
case 10: return new Static4D( 0,+SQ2/2,+SQ2/2, 0); |
|
| 275 |
case 11: return QUATS[4]; |
|
| 276 |
case 12: return QUATS[9]; |
|
| 277 |
case 13: return new Static4D(-SQ2/2, 0, 0, SQ2/2); |
|
| 278 |
case 14: return QUATS[7]; |
|
| 279 |
case 15: return new Static4D( 0,-SQ2/2,+SQ2/2, 0); |
|
| 280 |
case 16: return new Static4D( 0, 0,-SQ2/2, SQ2/2); |
|
| 281 |
case 17: return QUATS[0]; |
|
| 282 |
case 18: return new Static4D( 0, 0,+SQ2/2, SQ2/2); |
|
| 283 |
case 19: return QUATS[3]; |
|
| 284 |
case 20: return new Static4D(+SQ2/2,+SQ2/2, 0, 0); |
|
| 285 |
case 21: return QUATS[2]; |
|
| 286 |
case 22: return new Static4D(+SQ2/2,-SQ2/2, 0, 0); |
|
| 287 |
case 23: return QUATS[1]; |
|
| 288 |
|
|
| 289 |
case 24: return new Static4D( 0,+SQ2/2, 0, SQ2/2); |
|
| 290 |
case 25: return new Static4D( 0,-SQ2/2, 0, SQ2/2); |
|
| 291 |
case 26: return new Static4D(+SQ2/2, 0, 0, SQ2/2); |
|
| 292 |
case 27: return new Static4D(-SQ2/2, 0, 0, SQ2/2); |
|
| 293 |
case 28: return QUATS[0]; |
|
| 294 |
case 29: return QUATS[1]; |
|
| 295 |
|
|
| 296 |
case 30: return QUATS[0]; |
|
| 297 |
case 31: return new Static4D( 0, 0,+SQ2/2, SQ2/2); |
|
| 298 |
case 32: return QUATS[3]; |
|
| 299 |
case 33: return new Static4D( 0, 0,-SQ2/2, SQ2/2); |
|
| 300 |
case 34: return new Static4D( 0,+SQ2/2, 0, SQ2/2); |
|
| 301 |
case 35: return QUATS[7]; |
|
| 302 |
case 36: return QUATS[9]; |
|
| 303 |
case 37: return new Static4D( 0,-SQ2/2, 0, SQ2/2); |
|
| 304 |
case 38: return new Static4D(+SQ2/2, 0, 0, SQ2/2); |
|
| 305 |
case 39: return QUATS[8]; |
|
| 306 |
case 40: return QUATS[1]; |
|
| 307 |
case 41: return QUATS[6]; |
|
| 308 |
} |
|
| 309 |
|
|
| 310 |
return QUATS[0]; |
|
| 311 |
} |
|
| 312 |
|
|
| 313 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 314 |
|
|
| 315 |
MeshBase createCubitMesh(int cubit) |
|
| 316 |
{
|
|
| 317 |
MeshBase mesh; |
|
| 318 |
|
|
| 319 |
if( cubit<12 ) |
|
| 320 |
{
|
|
| 321 |
if( mCornerMesh==null ) mCornerMesh = FactoryCubit.getInstance().createRexCornerMesh(); |
|
| 322 |
mesh = mCornerMesh.copy(true); |
|
| 323 |
} |
|
| 324 |
else if( cubit<18 ) |
|
| 325 |
{
|
|
| 326 |
if( mFaceMesh==null ) mFaceMesh = FactoryCubit.getInstance().createRexFaceMesh(); |
|
| 327 |
mesh = mFaceMesh.copy(true); |
|
| 328 |
} |
|
| 329 |
else |
|
| 330 |
{
|
|
| 331 |
if( mEdgeMesh==null ) mEdgeMesh = FactoryCubit.getInstance().createRexEdgeMesh(); |
|
| 332 |
mesh = mEdgeMesh.copy(true); |
|
| 333 |
} |
|
| 334 |
|
|
| 335 |
MatrixEffectQuaternion quat = new MatrixEffectQuaternion( getQuat(cubit), new Static3D(0,0,0) ); |
|
| 336 |
mesh.apply(quat,0xffffffff,0); |
|
| 337 |
|
|
| 338 |
return mesh; |
|
| 339 |
} |
|
| 340 |
|
|
| 341 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 342 |
|
|
| 343 |
int getFaceColor(int cubit, int cubitface, int numLayers) |
|
| 344 |
{
|
|
| 345 |
return mFaceMap[cubit][cubitface]; |
|
| 346 |
} |
|
| 347 |
|
|
| 348 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 349 |
|
|
| 350 |
void createFaceTexture(Canvas canvas, Paint paint, int face, int left, int top) |
|
| 351 |
{
|
|
| 352 |
int COLORS = FACE_COLORS.length; |
|
| 353 |
FactorySticker factory = FactorySticker.getInstance(); |
|
| 354 |
float S = 0.08f; |
|
| 355 |
float R = 0.12f; |
|
| 356 |
|
|
| 357 |
if( face<COLORS ) |
|
| 358 |
{
|
|
| 359 |
factory.drawRexCornerSticker(canvas, paint, left, top, FACE_COLORS[face%COLORS], S, R); |
|
| 360 |
} |
|
| 361 |
else if( face<2*COLORS ) |
|
| 362 |
{
|
|
| 363 |
factory.drawRexFaceSticker(canvas, paint, left, top, FACE_COLORS[face%COLORS], S, R); |
|
| 364 |
} |
|
| 365 |
else |
|
| 366 |
{
|
|
| 367 |
factory.drawRexEdgeSticker(canvas, paint, left, top, FACE_COLORS[face%COLORS], S, R); |
|
| 368 |
} |
|
| 369 |
} |
|
| 370 |
|
|
| 371 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 372 |
|
|
| 373 |
float returnMultiplier() |
|
| 374 |
{
|
|
| 375 |
return 2.0f; |
|
| 376 |
} |
|
| 377 |
|
|
| 378 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 379 |
|
|
| 380 |
float[] getRowChances() |
|
| 381 |
{
|
|
| 382 |
return new float[] { 0.5f, 0.5f, 1.0f };
|
|
| 383 |
} |
|
| 384 |
|
|
| 385 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 386 |
// PUBLIC API |
|
| 387 |
|
|
| 388 |
public Static3D[] getRotationAxis() |
|
| 389 |
{
|
|
| 390 |
return ROT_AXIS; |
|
| 391 |
} |
|
| 392 |
|
|
| 393 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 394 |
|
|
| 395 |
public int getBasicAngle() |
|
| 396 |
{
|
|
| 397 |
return 3; |
|
| 398 |
} |
|
| 399 |
|
|
| 400 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 401 |
|
|
| 402 |
public int randomizeNewRotAxis(Random rnd, int oldRotAxis) |
|
| 403 |
{
|
|
| 404 |
int numAxis = ROTATION_AXIS.length; |
|
| 405 |
|
|
| 406 |
if( oldRotAxis == START_AXIS ) |
|
| 407 |
{
|
|
| 408 |
return rnd.nextInt(numAxis); |
|
| 409 |
} |
|
| 410 |
else |
|
| 411 |
{
|
|
| 412 |
int newVector = rnd.nextInt(numAxis-1); |
|
| 413 |
return (newVector>=oldRotAxis ? newVector+1 : newVector); |
|
| 414 |
} |
|
| 415 |
} |
|
| 416 |
|
|
| 417 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 418 |
|
|
| 419 |
public int randomizeNewRow(Random rnd, int oldRotAxis, int oldRow, int newRotAxis) |
|
| 420 |
{
|
|
| 421 |
float rowFloat = rnd.nextFloat(); |
|
| 422 |
|
|
| 423 |
for(int row=0; row<mRowChances.length; row++) |
|
| 424 |
{
|
|
| 425 |
if( rowFloat<=mRowChances[row] ) return row; |
|
| 426 |
} |
|
| 427 |
|
|
| 428 |
return 0; |
|
| 429 |
} |
|
| 430 |
|
|
| 431 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 432 |
// remember about the double cover or unit quaternions! |
|
| 433 |
|
|
| 434 |
private int mulQuat(int q1, int q2) |
|
| 435 |
{
|
|
| 436 |
Static4D result = RubikSurfaceView.quatMultiply(QUATS[q1],QUATS[q2]); |
|
| 437 |
|
|
| 438 |
float rX = result.get0(); |
|
| 439 |
float rY = result.get1(); |
|
| 440 |
float rZ = result.get2(); |
|
| 441 |
float rW = result.get3(); |
|
| 442 |
|
|
| 443 |
final float MAX_ERROR = 0.1f; |
|
| 444 |
float dX,dY,dZ,dW; |
|
| 445 |
|
|
| 446 |
for(int i=0; i<QUATS.length; i++) |
|
| 447 |
{
|
|
| 448 |
dX = QUATS[i].get0() - rX; |
|
| 449 |
dY = QUATS[i].get1() - rY; |
|
| 450 |
dZ = QUATS[i].get2() - rZ; |
|
| 451 |
dW = QUATS[i].get3() - rW; |
|
| 452 |
|
|
| 453 |
if( dX<MAX_ERROR && dX>-MAX_ERROR && |
|
| 454 |
dY<MAX_ERROR && dY>-MAX_ERROR && |
|
| 455 |
dZ<MAX_ERROR && dZ>-MAX_ERROR && |
|
| 456 |
dW<MAX_ERROR && dW>-MAX_ERROR ) return i; |
|
| 457 |
|
|
| 458 |
dX = QUATS[i].get0() + rX; |
|
| 459 |
dY = QUATS[i].get1() + rY; |
|
| 460 |
dZ = QUATS[i].get2() + rZ; |
|
| 461 |
dW = QUATS[i].get3() + rW; |
|
| 462 |
|
|
| 463 |
if( dX<MAX_ERROR && dX>-MAX_ERROR && |
|
| 464 |
dY<MAX_ERROR && dY>-MAX_ERROR && |
|
| 465 |
dZ<MAX_ERROR && dZ>-MAX_ERROR && |
|
| 466 |
dW<MAX_ERROR && dW>-MAX_ERROR ) return i; |
|
| 467 |
} |
|
| 468 |
|
|
| 469 |
return -1; |
|
| 470 |
} |
|
| 471 |
|
|
| 472 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 473 |
// The Rex is solved if and only if: |
|
| 474 |
// |
|
| 475 |
// TODO |
|
| 476 |
|
|
| 477 |
public boolean isSolved() |
|
| 478 |
{
|
|
| 479 |
int q = CUBITS[0].mQuatIndex; |
|
| 480 |
|
|
| 481 |
for(int i=1; i<42; i++) |
|
| 482 |
{
|
|
| 483 |
if( CUBITS[i].mQuatIndex != q) return false; |
|
| 484 |
} |
|
| 485 |
|
|
| 486 |
return true; |
|
| 487 |
} |
|
| 488 |
|
|
| 489 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 490 |
// only needed for solvers - there are no Rex solvers ATM) |
|
| 491 |
|
|
| 492 |
public String retObjectString() |
|
| 493 |
{
|
|
| 494 |
return ""; |
|
| 495 |
} |
|
| 496 |
|
|
| 497 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 498 |
|
|
| 499 |
public int getObjectName(int numLayers) |
|
| 500 |
{
|
|
| 501 |
return R.string.rex3; |
|
| 502 |
} |
|
| 503 |
|
|
| 504 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 505 |
|
|
| 506 |
public int getInventor(int numLayers) |
|
| 507 |
{
|
|
| 508 |
return R.string.rex3_inventor; |
|
| 509 |
} |
|
| 510 |
|
|
| 511 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 512 |
|
|
| 513 |
public int getComplexity(int numLayers) |
|
| 514 |
{
|
|
| 515 |
return 3; |
|
| 516 |
} |
|
| 517 |
} |
|
| src/main/res/values/strings.xml | ||
|---|---|---|
| 84 | 84 |
<string name="redi2" translatable="false">Redi Cube</string> |
| 85 | 85 |
<string name="heli3" translatable="false">Helicopter Cube</string> |
| 86 | 86 |
<string name="ivy2" translatable="false">Ivy Cube</string> |
| 87 |
<string name="rex3" translatable="false">Rex Cube</string> |
|
| 87 | 88 |
<string name="dino3" translatable="false">Dino Cube (6 color)</string> |
| 88 | 89 |
<string name="din43" translatable="false">Dino Cube (4 color)</string> |
| 89 | 90 |
|
| ... | ... | |
| 100 | 101 |
<string name="redi2_inventor" translatable="false">Oskar van Deventer, 2009</string> |
| 101 | 102 |
<string name="heli3_inventor" translatable="false">Adam G. Cowan, 2006</string> |
| 102 | 103 |
<string name="ivy2_inventor" translatable="false">Eitan Cher, 2009</string> |
| 104 |
<string name="rex3_inventor" translatable="false">Andrew Cormier, 2009</string> |
|
| 103 | 105 |
<string name="dino3_inventor" translatable="false">Robert Webb, 1985</string> |
| 104 | 106 |
<string name="din43_inventor" translatable="false">Robert Webb, 1985</string> |
| 105 | 107 |
|
Also available in: Unified diff
Adding Rex Cube - take 1 (doesn't work yet)