Revision 45aedaa7
Added by Leszek Koltunski 10 months ago
| src/main/java/org/distorted/objectlib/bandaged/FactoryBandaged.java | ||
|---|---|---|
| 10 | 10 |
package org.distorted.objectlib.bandaged; |
| 11 | 11 |
|
| 12 | 12 |
import static org.distorted.objectlib.main.TwistyObject.MESH_NICE; |
| 13 |
import static org.distorted.objectlib.main.TwistyObject.SQ2; |
|
| 14 |
import static org.distorted.objectlib.main.TwistyObject.SQ5; |
|
| 13 | 15 |
import static org.distorted.objectlib.objects.TwistyBandagedCuboid.REGION_SIZE; |
| 14 | 16 |
import static org.distorted.objectlib.objects.TwistyBandagedCuboid.STRENGTH; |
| 15 | 17 |
|
| ... | ... | |
| 21 | 23 |
import org.distorted.objectlib.helpers.ObjectVertexEffects; |
| 22 | 24 |
|
| 23 | 25 |
import java.util.ArrayList; |
| 26 |
import java.util.Collections; |
|
| 27 |
import java.util.Comparator; |
|
| 24 | 28 |
|
| 25 | 29 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 26 | 30 |
|
| 27 | 31 |
abstract public class FactoryBandaged |
| 28 | 32 |
{
|
| 33 |
private static class BandagedCubitFace |
|
| 34 |
{
|
|
| 35 |
private static final float[] sortVect = new float[] { 1/(2*SQ2), SQ2/(2*SQ2), SQ5/(2*SQ2) };
|
|
| 36 |
|
|
| 37 |
float[] vertices; |
|
| 38 |
float[] center; |
|
| 39 |
float[] normal; |
|
| 40 |
float centerCast; |
|
| 41 |
|
|
| 42 |
BandagedCubitFace(float[] verts) |
|
| 43 |
{
|
|
| 44 |
vertices = verts; |
|
| 45 |
computeCenter(); |
|
| 46 |
computeNormal(); |
|
| 47 |
computeCenterCast(); |
|
| 48 |
} |
|
| 49 |
|
|
| 50 |
private void computeCenter() |
|
| 51 |
{
|
|
| 52 |
int num = vertices.length/3; |
|
| 53 |
center = new float[3]; |
|
| 54 |
|
|
| 55 |
for(int v=0; v<num; v++) |
|
| 56 |
{
|
|
| 57 |
center[0] += vertices[3*v ]; |
|
| 58 |
center[1] += vertices[3*v+1]; |
|
| 59 |
center[2] += vertices[3*v+2]; |
|
| 60 |
} |
|
| 61 |
|
|
| 62 |
center[0] /= num; |
|
| 63 |
center[1] /= num; |
|
| 64 |
center[2] /= num; |
|
| 65 |
} |
|
| 66 |
|
|
| 67 |
private void computeNormal() |
|
| 68 |
{
|
|
| 69 |
normal = new float[3]; |
|
| 70 |
|
|
| 71 |
float x1 = vertices[0]; |
|
| 72 |
float y1 = vertices[1]; |
|
| 73 |
float z1 = vertices[2]; |
|
| 74 |
float x2 = vertices[3]; |
|
| 75 |
float y2 = vertices[4]; |
|
| 76 |
float z2 = vertices[5]; |
|
| 77 |
float x3 = vertices[6]; |
|
| 78 |
float y3 = vertices[7]; |
|
| 79 |
float z3 = vertices[8]; |
|
| 80 |
|
|
| 81 |
float v1x = x2-x1; |
|
| 82 |
float v1y = y2-y1; |
|
| 83 |
float v1z = z2-z1; |
|
| 84 |
float v2x = x3-x1; |
|
| 85 |
float v2y = y3-y1; |
|
| 86 |
float v2z = z3-z1; |
|
| 87 |
|
|
| 88 |
normal[0] = v1y*v2z - v2y*v1z; |
|
| 89 |
normal[1] = v1z*v2x - v2z*v1x; |
|
| 90 |
normal[2] = v1x*v2y - v2x*v1y; |
|
| 91 |
|
|
| 92 |
double len = normal[0]*normal[0] + normal[1]*normal[1] + normal[2]*normal[2]; |
|
| 93 |
len = Math.sqrt(len); |
|
| 94 |
normal[0] /= len; |
|
| 95 |
normal[1] /= len; |
|
| 96 |
normal[2] /= len; |
|
| 97 |
} |
|
| 98 |
|
|
| 99 |
private void computeCenterCast() |
|
| 100 |
{
|
|
| 101 |
centerCast = center[0]*sortVect[0] + center[1]*sortVect[1] + center[2]*sortVect[2]; |
|
| 102 |
} |
|
| 103 |
} |
|
| 104 |
|
|
| 105 |
static class SortByCenterCast implements Comparator<BandagedCubitFace> |
|
| 106 |
{
|
|
| 107 |
public int compare(BandagedCubitFace a, BandagedCubitFace b) |
|
| 108 |
{
|
|
| 109 |
float diff = a.centerCast - b.centerCast; |
|
| 110 |
return diff>0 ? 1: diff==0 ? 0: -1; |
|
| 111 |
} |
|
| 112 |
} |
|
| 113 |
|
|
| 29 | 114 |
private ArrayList<float[]> mTmpArray; |
| 30 | 115 |
private float[] mDist3D; |
| 31 | 116 |
private int[][] mFaceBelongsBitmap; |
| ... | ... | |
| 63 | 148 |
abstract float[] getDist3D(); |
| 64 | 149 |
abstract float[][] getBands(boolean iconMode); |
| 65 | 150 |
abstract float[][] getCuts(int[] numLayers); |
| 66 |
abstract float[] elementVertices(int ax, boolean left, int element); |
|
| 67 |
abstract boolean elementFaceNotNull(int ax, boolean left, int element); |
|
| 68 | 151 |
abstract int getElementVariant(float x, float y, float z); |
| 69 | 152 |
abstract int diameterMap(float diameter); |
| 153 |
abstract float[][] getVertices(int variant); |
|
| 154 |
abstract int[][] getIndices(int variant); |
|
| 70 | 155 |
|
| 71 | 156 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 72 | 157 |
|
| ... | ... | |
| 335 | 420 |
} |
| 336 | 421 |
} |
| 337 | 422 |
|
| 338 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 339 |
|
|
| 340 |
boolean elementDoesntExist(int[] p) |
|
| 341 |
{
|
|
| 342 |
boolean res; |
|
| 343 |
|
|
| 344 |
for(int i=0; i<mNumElements; i++) |
|
| 345 |
{
|
|
| 346 |
int[] row = mElements[i].getRotRow(); |
|
| 347 |
res = true; |
|
| 348 |
|
|
| 349 |
for(int j=0; j<mNumAxis; j++) |
|
| 350 |
if( row[j]!=p[j] ) |
|
| 351 |
{
|
|
| 352 |
res = false; |
|
| 353 |
break; |
|
| 354 |
} |
|
| 355 |
|
|
| 356 |
if( res ) return false; |
|
| 357 |
} |
|
| 358 |
|
|
| 359 |
return true; |
|
| 360 |
} |
|
| 361 |
|
|
| 362 | 423 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 363 | 424 |
|
| 364 | 425 |
static boolean vertInFace(float[] vertex, float[] move, Static3D faceAxis, float dist) |
| ... | ... | |
| 505 | 566 |
|
| 506 | 567 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 507 | 568 |
|
| 508 |
private boolean elementsFormSection(int e1, int e2, int ax)
|
|
| 569 |
private float[] buildFaceVertices(float[][] vertices, int[] indices, float[] pos)
|
|
| 509 | 570 |
{
|
| 510 |
int[] r1 = mElements[e1].getRotRow();
|
|
| 511 |
int[] r2 = mElements[e2].getRotRow();
|
|
| 571 |
int num = indices.length;
|
|
| 572 |
float[] ret = new float[3*num];
|
|
| 512 | 573 |
|
| 513 |
if( r1[ax]==r2[ax] )
|
|
| 574 |
for(int i=0; i<num; i++)
|
|
| 514 | 575 |
{
|
| 515 |
int dist=0; |
|
| 576 |
float[] v = vertices[indices[i]]; |
|
| 577 |
ret[3*i ] = v[0] + pos[0]; |
|
| 578 |
ret[3*i+1] = v[1] + pos[1]; |
|
| 579 |
ret[3*i+2] = v[2] + pos[2]; |
|
| 580 |
} |
|
| 581 |
|
|
| 582 |
return ret; |
|
| 583 |
} |
|
| 584 |
|
|
| 585 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 516 | 586 |
|
| 517 |
for(int i=0; i<mNumAxis; i++) |
|
| 587 |
private void removeInternalWalls(ArrayList<BandagedCubitFace> list) |
|
| 588 |
{
|
|
| 589 |
Collections.sort(list,new SortByCenterCast()); |
|
| 590 |
|
|
| 591 |
int numElements = list.size(); |
|
| 592 |
final float MAXDIFF = 0.01f; |
|
| 593 |
|
|
| 594 |
for(int e=0; e<numElements; e++) |
|
| 595 |
{
|
|
| 596 |
int ne = e+1; |
|
| 597 |
BandagedCubitFace f1 = list.get(e); |
|
| 598 |
float[] center = f1.center; |
|
| 599 |
|
|
| 600 |
while( ne<numElements ) |
|
| 518 | 601 |
{
|
| 519 |
int d=r1[i]-r2[i]; |
|
| 520 |
dist+=d*d; |
|
| 521 |
} |
|
| 602 |
BandagedCubitFace f2 = list.get(ne); |
|
| 603 |
float diff = f2.centerCast-f1.centerCast; |
|
| 522 | 604 |
|
| 523 |
return dist==1; |
|
| 605 |
if( diff>-MAXDIFF && diff<MAXDIFF ) |
|
| 606 |
{
|
|
| 607 |
float[] c = f2.center; |
|
| 608 |
float dx = c[0]-center[0]; |
|
| 609 |
float dy = c[1]-center[1]; |
|
| 610 |
float dz = c[2]-center[2]; |
|
| 611 |
|
|
| 612 |
float d = dx*dx + dy*dy + dz*dz; |
|
| 613 |
|
|
| 614 |
if( d>-MAXDIFF && d<MAXDIFF ) |
|
| 615 |
{
|
|
| 616 |
list.remove(ne); |
|
| 617 |
list.remove(e); |
|
| 618 |
numElements -= 2; |
|
| 619 |
e--; |
|
| 620 |
break; |
|
| 621 |
} |
|
| 622 |
} |
|
| 623 |
else break; |
|
| 624 |
|
|
| 625 |
ne++; |
|
| 626 |
} |
|
| 524 | 627 |
} |
| 525 |
return false; |
|
| 526 | 628 |
} |
| 527 | 629 |
|
| 528 | 630 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 529 | 631 |
|
| 530 |
private int computeConnectedSection(int element, int ax, boolean[] walls, int[] output, int index)
|
|
| 632 |
private float[][] getNextSection(ArrayList<BandagedCubitFace> list)
|
|
| 531 | 633 |
{
|
| 532 |
int found = index; |
|
| 634 |
int numElements = list.size(); |
|
| 635 |
if( numElements==0 ) return null; |
|
| 533 | 636 |
|
| 534 |
for(int e=0; e<mNumElements; e++) |
|
| 535 |
if( walls[e] && elementsFormSection(element,e,ax) ) |
|
| 637 |
final float MAXDIFF = 0.01f; |
|
| 638 |
float[][] ret = new float[numElements][]; |
|
| 639 |
BandagedCubitFace bcf = list.remove(0); |
|
| 640 |
float[] normal = bcf.normal; |
|
| 641 |
int removed = 1; |
|
| 642 |
|
|
| 643 |
ret[0] = bcf.vertices; |
|
| 644 |
|
|
| 645 |
for(int e=0; e<numElements-1; e++) |
|
| 646 |
{
|
|
| 647 |
BandagedCubitFace f = list.get(e); |
|
| 648 |
float[] n = f.normal; |
|
| 649 |
|
|
| 650 |
float dx = n[0]-normal[0]; |
|
| 651 |
float dy = n[1]-normal[1]; |
|
| 652 |
float dz = n[2]-normal[2]; |
|
| 653 |
|
|
| 654 |
float diff = dx*dx + dy*dy + dz*dz; |
|
| 655 |
|
|
| 656 |
if( diff>-MAXDIFF && diff<MAXDIFF ) |
|
| 536 | 657 |
{
|
| 537 |
walls[e] = false; |
|
| 538 |
output[found++] = e; |
|
| 539 |
found = computeConnectedSection(e,ax,walls,output,found); |
|
| 658 |
list.remove(e); |
|
| 659 |
e--; |
|
| 660 |
numElements--; |
|
| 661 |
ret[removed++] = f.vertices; |
|
| 540 | 662 |
} |
| 663 |
} |
|
| 541 | 664 |
|
| 542 |
return found; |
|
| 665 |
float[][] ret2 = new float[removed][]; |
|
| 666 |
for(int i=0; i<removed; i++) ret2[i] = ret[i]; |
|
| 667 |
|
|
| 668 |
return ret2; |
|
| 543 | 669 |
} |
| 544 | 670 |
|
| 545 | 671 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 546 | 672 |
|
| 547 |
private void buildAllSections(int ax, boolean left, boolean[] walls, ArrayList<float[][]> list)
|
|
| 673 |
private boolean isConnected(float[] face1, float[] face2)
|
|
| 548 | 674 |
{
|
| 549 |
int numElements = 0; |
|
| 550 |
for(int i=0; i<mNumElements; i++) |
|
| 551 |
if( walls[i] ) numElements++; |
|
| 552 |
|
|
| 553 |
int[] tmp = new int[numElements]; |
|
| 675 |
float MAXDIFF = 0.01f; |
|
| 676 |
int l1 = face1.length/3; |
|
| 677 |
int l2 = face2.length/3; |
|
| 554 | 678 |
|
| 555 |
while( numElements>0 )
|
|
| 679 |
for(int i=0; i<l1; i++)
|
|
| 556 | 680 |
{
|
| 557 |
int element = 0; |
|
| 681 |
float x = face1[3*i ]; |
|
| 682 |
float y = face1[3*i+1]; |
|
| 683 |
float z = face1[3*i+2]; |
|
| 558 | 684 |
|
| 559 |
for( ; element<mNumElements; element++) |
|
| 560 |
if( walls[element] ) |
|
| 685 |
for(int j=0; j<l2; j++) |
|
| 686 |
{
|
|
| 687 |
float dx = x-face2[3*j ]; |
|
| 688 |
float dy = y-face2[3*j+1]; |
|
| 689 |
float dz = z-face2[3*j+2]; |
|
| 690 |
|
|
| 691 |
if( dx*dx + dy*dy + dz*dz < MAXDIFF ) |
|
| 561 | 692 |
{
|
| 562 |
walls[element] = false; |
|
| 563 |
tmp[0] = element; |
|
| 564 |
break; |
|
| 693 |
int inext = i==l1-1 ? 0 : i+1; |
|
| 694 |
int jprev = j==0 ? l2-1 : j-1; |
|
| 695 |
|
|
| 696 |
dx = face1[3*inext ] - face2[3*jprev ]; |
|
| 697 |
dy = face1[3*inext+1] - face2[3*jprev+1]; |
|
| 698 |
dz = face1[3*inext+2] - face2[3*jprev+2]; |
|
| 699 |
|
|
| 700 |
if( dx*dx + dy*dy + dz*dz < MAXDIFF ) return true; |
|
| 701 |
|
|
| 702 |
int iprev = i==0 ? l1-1 : i-1; |
|
| 703 |
int jnext = j==l2-1 ? 0 : j+1; |
|
| 704 |
|
|
| 705 |
dx = face1[3*iprev ] - face2[3*jnext ]; |
|
| 706 |
dy = face1[3*iprev+1] - face2[3*jnext+1]; |
|
| 707 |
dz = face1[3*iprev+2] - face2[3*jnext+2]; |
|
| 708 |
|
|
| 709 |
return dx*dx + dy*dy + dz*dz < MAXDIFF; |
|
| 565 | 710 |
} |
| 711 |
} |
|
| 712 |
} |
|
| 566 | 713 |
|
| 567 |
int elementsInSection = computeConnectedSection(element, ax, walls, tmp, 1);
|
|
| 568 |
float[][] newSection = new float[elementsInSection][];
|
|
| 714 |
return false;
|
|
| 715 |
}
|
|
| 569 | 716 |
|
| 570 |
for(int i=0; i<elementsInSection; i++) |
|
| 571 |
newSection[i] = elementVertices(ax, left, tmp[i]); |
|
| 717 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 572 | 718 |
|
| 573 |
list.add(newSection); |
|
| 719 |
private float[][] getNextConnected(float[][] section, int nonNull) |
|
| 720 |
{
|
|
| 721 |
float[][] ret = new float[nonNull][]; |
|
| 722 |
int start,len = section.length; |
|
| 723 |
|
|
| 724 |
for(start=0; start<len; start++) |
|
| 725 |
if( section[start]!=null ) |
|
| 726 |
{
|
|
| 727 |
ret[0] = section[start]; |
|
| 728 |
section[start] = null; |
|
| 729 |
break; |
|
| 730 |
} |
|
| 731 |
|
|
| 732 |
int current = 0; |
|
| 733 |
int last = start; |
|
| 734 |
|
|
| 735 |
do |
|
| 736 |
{
|
|
| 737 |
start++; |
|
| 574 | 738 |
|
| 575 |
numElements -= elementsInSection; |
|
| 739 |
for(int i=start; i<len; i++) |
|
| 740 |
if( section[i]!=null && isConnected(ret[current],section[i]) ) |
|
| 741 |
{
|
|
| 742 |
last++; |
|
| 743 |
current++; |
|
| 744 |
ret[current] = section[i]; |
|
| 745 |
section[i] = null; |
|
| 746 |
} |
|
| 576 | 747 |
} |
| 748 |
while(last>start); |
|
| 749 |
|
|
| 750 |
float[][] ret2 = new float[current+1][]; |
|
| 751 |
for(int i=0; i<=current; i++) ret2[i] = ret[i]; |
|
| 752 |
|
|
| 753 |
return ret2; |
|
| 577 | 754 |
} |
| 578 | 755 |
|
| 579 | 756 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 580 | 757 |
|
| 581 | 758 |
private void fillUpVertexArray() |
| 582 | 759 |
{
|
| 583 |
boolean[][][] walls = new boolean[mNumAxis][2][mNumElements]; |
|
| 584 |
|
|
| 585 |
int[] tmp = new int[mNumAxis]; |
|
| 760 |
ArrayList<BandagedCubitFace> list = new ArrayList<>(); |
|
| 586 | 761 |
|
| 587 | 762 |
for(int e=0; e<mNumElements; e++) |
| 588 | 763 |
{
|
| 589 |
int[] row = mElements[e].getRotRow(); |
|
| 590 |
for(int t=0; t<mNumAxis; t++) tmp[t]=row[t]; |
|
| 764 |
int variant = mElements[e].getVariant(); |
|
| 765 |
float[][] verts = getVertices(variant); |
|
| 766 |
int[][] inds = getIndices(variant); |
|
| 767 |
float[] pos = mElements[e].getPos(); |
|
| 591 | 768 |
|
| 592 |
for(int a=0; a<mNumAxis; a++)
|
|
| 769 |
for( int[] ind : inds)
|
|
| 593 | 770 |
{
|
| 594 |
tmp[a] = row[a]+1; |
|
| 595 |
walls[a][0][e] = (elementDoesntExist(tmp) && elementFaceNotNull(a,true ,e)); |
|
| 596 |
tmp[a] = row[a]-1; |
|
| 597 |
walls[a][1][e] = (elementDoesntExist(tmp) && elementFaceNotNull(a,false,e)); |
|
| 598 |
tmp[a] = row[a]; |
|
| 771 |
float[] vertices = buildFaceVertices(verts,ind,pos); |
|
| 772 |
BandagedCubitFace face = new BandagedCubitFace(vertices); |
|
| 773 |
list.add(face); |
|
| 599 | 774 |
} |
| 600 | 775 |
} |
| 601 | 776 |
|
| 602 |
for(int a=0; a<mNumAxis; a++) |
|
| 777 |
removeInternalWalls(list); |
|
| 778 |
|
|
| 779 |
while(true) |
|
| 603 | 780 |
{
|
| 604 |
buildAllSections(a, true, walls[a][0], mVertexArray ); |
|
| 605 |
buildAllSections(a, false, walls[a][1], mVertexArray ); |
|
| 781 |
float[][] section = getNextSection(list); |
|
| 782 |
|
|
| 783 |
if( section!=null ) |
|
| 784 |
{
|
|
| 785 |
int nonNull = section.length; |
|
| 786 |
|
|
| 787 |
while(nonNull>0) |
|
| 788 |
{
|
|
| 789 |
float[][] connected = getNextConnected(section,nonNull); |
|
| 790 |
nonNull -= connected.length; |
|
| 791 |
mVertexArray.add(connected); |
|
| 792 |
} |
|
| 793 |
} |
|
| 794 |
else break; |
|
| 606 | 795 |
} |
| 607 | 796 |
} |
| 608 | 797 |
|
| src/main/java/org/distorted/objectlib/bandaged/FactoryBandagedCuboid.java | ||
|---|---|---|
| 35 | 35 |
|
| 36 | 36 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 37 | 37 |
|
| 38 |
public float[] elementVertices(int ax, boolean left, int element)
|
|
| 38 |
public float[][] getVertices(int variant)
|
|
| 39 | 39 |
{
|
| 40 |
float[] pos = mElements[element].getPos(); |
|
| 41 |
float[] ret = new float[12]; |
|
| 42 |
|
|
| 43 |
switch(ax) |
|
| 40 |
return new float[][] |
|
| 44 | 41 |
{
|
| 45 |
case 0: if( left ) |
|
| 46 |
{
|
|
| 47 |
ret[ 0] = pos[0]-0.5f; |
|
| 48 |
ret[ 1] = pos[1]+0.5f; |
|
| 49 |
ret[ 2] = pos[2]-0.5f; |
|
| 50 |
ret[ 3] = pos[0]-0.5f; |
|
| 51 |
ret[ 4] = pos[1]-0.5f; |
|
| 52 |
ret[ 5] = pos[2]-0.5f; |
|
| 53 |
ret[ 6] = pos[0]-0.5f; |
|
| 54 |
ret[ 7] = pos[1]-0.5f; |
|
| 55 |
ret[ 8] = pos[2]+0.5f; |
|
| 56 |
ret[ 9] = pos[0]-0.5f; |
|
| 57 |
ret[10] = pos[1]+0.5f; |
|
| 58 |
ret[11] = pos[2]+0.5f; |
|
| 59 |
} |
|
| 60 |
else |
|
| 61 |
{
|
|
| 62 |
ret[ 0] = pos[0]+0.5f; |
|
| 63 |
ret[ 1] = pos[1]+0.5f; |
|
| 64 |
ret[ 2] = pos[2]+0.5f; |
|
| 65 |
ret[ 3] = pos[0]+0.5f; |
|
| 66 |
ret[ 4] = pos[1]-0.5f; |
|
| 67 |
ret[ 5] = pos[2]+0.5f; |
|
| 68 |
ret[ 6] = pos[0]+0.5f; |
|
| 69 |
ret[ 7] = pos[1]-0.5f; |
|
| 70 |
ret[ 8] = pos[2]-0.5f; |
|
| 71 |
ret[ 9] = pos[0]+0.5f; |
|
| 72 |
ret[10] = pos[1]+0.5f; |
|
| 73 |
ret[11] = pos[2]-0.5f; |
|
| 74 |
} |
|
| 75 |
break; |
|
| 76 |
case 1: if( left ) |
|
| 77 |
{
|
|
| 78 |
ret[ 0] = pos[0]-0.5f; |
|
| 79 |
ret[ 1] = pos[1]-0.5f; |
|
| 80 |
ret[ 2] = pos[2]+0.5f; |
|
| 81 |
ret[ 3] = pos[0]-0.5f; |
|
| 82 |
ret[ 4] = pos[1]-0.5f; |
|
| 83 |
ret[ 5] = pos[2]-0.5f; |
|
| 84 |
ret[ 6] = pos[0]+0.5f; |
|
| 85 |
ret[ 7] = pos[1]-0.5f; |
|
| 86 |
ret[ 8] = pos[2]-0.5f; |
|
| 87 |
ret[ 9] = pos[0]+0.5f; |
|
| 88 |
ret[10] = pos[1]-0.5f; |
|
| 89 |
ret[11] = pos[2]+0.5f; |
|
| 90 |
} |
|
| 91 |
else |
|
| 92 |
{
|
|
| 93 |
ret[ 0] = pos[0]-0.5f; |
|
| 94 |
ret[ 1] = pos[1]+0.5f; |
|
| 95 |
ret[ 2] = pos[2]-0.5f; |
|
| 96 |
ret[ 3] = pos[0]-0.5f; |
|
| 97 |
ret[ 4] = pos[1]+0.5f; |
|
| 98 |
ret[ 5] = pos[2]+0.5f; |
|
| 99 |
ret[ 6] = pos[0]+0.5f; |
|
| 100 |
ret[ 7] = pos[1]+0.5f; |
|
| 101 |
ret[ 8] = pos[2]+0.5f; |
|
| 102 |
ret[ 9] = pos[0]+0.5f; |
|
| 103 |
ret[10] = pos[1]+0.5f; |
|
| 104 |
ret[11] = pos[2]-0.5f; |
|
| 105 |
} |
|
| 106 |
break; |
|
| 107 |
case 2: if( left ) |
|
| 108 |
{
|
|
| 109 |
ret[ 0] = pos[0]+0.5f; |
|
| 110 |
ret[ 1] = pos[1]+0.5f; |
|
| 111 |
ret[ 2] = pos[2]-0.5f; |
|
| 112 |
ret[ 3] = pos[0]+0.5f; |
|
| 113 |
ret[ 4] = pos[1]-0.5f; |
|
| 114 |
ret[ 5] = pos[2]-0.5f; |
|
| 115 |
ret[ 6] = pos[0]-0.5f; |
|
| 116 |
ret[ 7] = pos[1]-0.5f; |
|
| 117 |
ret[ 8] = pos[2]-0.5f; |
|
| 118 |
ret[ 9] = pos[0]-0.5f; |
|
| 119 |
ret[10] = pos[1]+0.5f; |
|
| 120 |
ret[11] = pos[2]-0.5f; |
|
| 121 |
} |
|
| 122 |
else |
|
| 123 |
{
|
|
| 124 |
ret[ 0] = pos[0]-0.5f; |
|
| 125 |
ret[ 1] = pos[1]+0.5f; |
|
| 126 |
ret[ 2] = pos[2]+0.5f; |
|
| 127 |
ret[ 3] = pos[0]-0.5f; |
|
| 128 |
ret[ 4] = pos[1]-0.5f; |
|
| 129 |
ret[ 5] = pos[2]+0.5f; |
|
| 130 |
ret[ 6] = pos[0]+0.5f; |
|
| 131 |
ret[ 7] = pos[1]-0.5f; |
|
| 132 |
ret[ 8] = pos[2]+0.5f; |
|
| 133 |
ret[ 9] = pos[0]+0.5f; |
|
| 134 |
ret[10] = pos[1]+0.5f; |
|
| 135 |
ret[11] = pos[2]+0.5f; |
|
| 136 |
} |
|
| 137 |
break; |
|
| 138 |
} |
|
| 139 |
|
|
| 140 |
return ret; |
|
| 42 |
{ 0.5f, 0.5f, 0.5f },
|
|
| 43 |
{ 0.5f, 0.5f,-0.5f },
|
|
| 44 |
{ 0.5f,-0.5f, 0.5f },
|
|
| 45 |
{ 0.5f,-0.5f,-0.5f },
|
|
| 46 |
{-0.5f, 0.5f, 0.5f },
|
|
| 47 |
{-0.5f, 0.5f,-0.5f },
|
|
| 48 |
{-0.5f,-0.5f, 0.5f },
|
|
| 49 |
{-0.5f,-0.5f,-0.5f },
|
|
| 50 |
}; |
|
| 141 | 51 |
} |
| 142 | 52 |
|
| 143 | 53 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 144 | 54 |
|
| 145 |
public boolean elementFaceNotNull(int ax, boolean left, int element) |
|
| 146 |
{
|
|
| 147 |
return true; |
|
| 148 |
} |
|
| 55 |
public int[][] getIndices(int variant) |
|
| 56 |
{
|
|
| 57 |
return new int[][] |
|
| 58 |
{
|
|
| 59 |
{2,3,1,0},
|
|
| 60 |
{7,6,4,5},
|
|
| 61 |
{4,0,1,5},
|
|
| 62 |
{7,3,2,6},
|
|
| 63 |
{6,2,0,4},
|
|
| 64 |
{3,7,5,1}
|
|
| 65 |
}; |
|
| 66 |
} |
|
| 149 | 67 |
|
| 150 | 68 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 151 | 69 |
|
| src/main/java/org/distorted/objectlib/bandaged/FactoryBandagedMegaminx.java | ||
|---|---|---|
| 80 | 80 |
|
| 81 | 81 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 82 | 82 |
|
| 83 |
public float[] elementVertices(int ax, boolean left, int element)
|
|
| 83 |
public float[][] getVertices(int variant)
|
|
| 84 | 84 |
{
|
| 85 |
int variant = mElements[element].getVariant(); |
|
| 86 |
float[] pos = mElements[element].getPos(); |
|
| 87 |
|
|
| 88 | 85 |
return null; |
| 89 | 86 |
} |
| 90 | 87 |
|
| 91 | 88 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 92 | 89 |
|
| 93 |
public boolean elementFaceNotNull(int ax, boolean left, int element)
|
|
| 90 |
public int[][] getIndices(int variant)
|
|
| 94 | 91 |
{
|
| 95 |
int variant = mElements[element].getVariant(); |
|
| 96 |
return ( variant==0 || !left ); |
|
| 92 |
return null; |
|
| 97 | 93 |
} |
| 98 | 94 |
|
| 99 | 95 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| src/main/java/org/distorted/objectlib/bandaged/FactoryBandagedPyraminx.java | ||
|---|---|---|
| 14 | 14 |
import static org.distorted.objectlib.main.TwistyObject.SQ6; |
| 15 | 15 |
|
| 16 | 16 |
import org.distorted.library.type.Static3D; |
| 17 |
import org.distorted.objectlib.touchcontrol.TouchControlDodecahedron; |
|
| 18 | 17 |
import org.distorted.objectlib.touchcontrol.TouchControlTetrahedron; |
| 19 | 18 |
|
| 20 | 19 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 21 | 20 |
|
| 22 | 21 |
public class FactoryBandagedPyraminx extends FactoryBandaged |
| 23 | 22 |
{
|
| 24 |
private static final float[][] TET_VER = |
|
| 25 |
{
|
|
| 26 |
{ 0,-SQ2/4,-0.5f },
|
|
| 27 |
{ 0,-SQ2/4, 0.5f },
|
|
| 28 |
{ 0.5f, SQ2/4, 0 },
|
|
| 29 |
{-0.5f, SQ2/4, 0 }
|
|
| 30 |
}; |
|
| 31 |
private static final float[][] OCT_VER = |
|
| 32 |
{
|
|
| 33 |
{ 0, SQ2/2, 0 },
|
|
| 34 |
{ 0,-SQ2/2, 0 },
|
|
| 35 |
{ 0.5f, 0, 0.5f },
|
|
| 36 |
{ 0.5f, 0,-0.5f },
|
|
| 37 |
{-0.5f, 0,-0.5f },
|
|
| 38 |
{-0.5f, 0, 0.5f },
|
|
| 39 |
}; |
|
| 40 |
|
|
| 41 | 23 |
private static FactoryBandagedPyraminx mThis; |
| 42 | 24 |
|
| 43 | 25 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| ... | ... | |
| 57 | 39 |
|
| 58 | 40 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 59 | 41 |
|
| 60 |
private float[] tetVertices(int ax, boolean left, float[] pos)
|
|
| 42 |
public float[][] getVertices(int variant)
|
|
| 61 | 43 |
{
|
| 62 |
if( !left )
|
|
| 44 |
if( variant==0 )
|
|
| 63 | 45 |
{
|
| 64 |
int i1=-1,i2=-1,i3=-1; |
|
| 65 |
|
|
| 66 |
switch(ax) |
|
| 67 |
{
|
|
| 68 |
case 0: i1=1; i2=2; i3=3; break; |
|
| 69 |
case 1: i1=0; i2=3; i3=2; break; |
|
| 70 |
case 2: i1=0; i2=1; i3=3; break; |
|
| 71 |
case 3: i1=0; i2=2; i3=1; break; |
|
| 72 |
} |
|
| 73 |
|
|
| 74 |
float[] T1 = TET_VER[i1]; |
|
| 75 |
float[] T2 = TET_VER[i2]; |
|
| 76 |
float[] T3 = TET_VER[i3]; |
|
| 77 |
|
|
| 78 |
return new float[] { pos[0]+T1[0], pos[1]+T1[1], pos[2]+T1[2],
|
|
| 79 |
pos[0]+T2[0], pos[1]+T2[1], pos[2]+T2[2], |
|
| 80 |
pos[0]+T3[0], pos[1]+T3[1], pos[2]+T3[2] }; |
|
| 46 |
return new float[][] { { 0.5f,0.0f,0.5f},{ 0.5f,0.0f,-0.5f},{-0.5f,0.0f,-0.5f},{-0.5f,0.0f,0.5f},{ 0.0f,SQ2/2,0.0f},{ 0.0f,-SQ2/2,0.0f} };
|
|
| 47 |
} |
|
| 48 |
else |
|
| 49 |
{
|
|
| 50 |
return new float[][] { {-0.5f, SQ2/4, 0.0f},{ 0.5f, SQ2/4, 0.0f},{ 0.0f,-SQ2/4, 0.5f},{ 0.0f,-SQ2/4,-0.5f} };
|
|
| 81 | 51 |
} |
| 82 |
|
|
| 83 |
return null; |
|
| 84 | 52 |
} |
| 85 | 53 |
|
| 86 | 54 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 87 | 55 |
|
| 88 |
private float[] octVertices(int ax, boolean left, float[] pos)
|
|
| 56 |
public int[][] getIndices(int variant)
|
|
| 89 | 57 |
{
|
| 90 |
int i1=-1,i2=-1,i3=-1; |
|
| 91 |
|
|
| 92 |
if( left ) |
|
| 58 |
if( variant==0 ) |
|
| 93 | 59 |
{
|
| 94 |
switch(ax) |
|
| 95 |
{
|
|
| 96 |
case 0: i1=1; i2=4; i3=3; break; |
|
| 97 |
case 1: i1=1; i2=2; i3=5; break; |
|
| 98 |
case 2: i1=0; i2=2; i3=3; break; |
|
| 99 |
case 3: i1=0; i2=4; i3=5; break; |
|
| 100 |
} |
|
| 60 |
return new int[][] { {3,0,4},{0,1,4},{1,2,4},{2,3,4},{5,0,3},{5,1,0},{5,2,1},{5,3,2} };
|
|
| 101 | 61 |
} |
| 102 | 62 |
else |
| 103 | 63 |
{
|
| 104 |
switch(ax) |
|
| 105 |
{
|
|
| 106 |
case 0: i1=0; i2=5; i3=2; break; |
|
| 107 |
case 1: i1=0; i2=3; i3=4; break; |
|
| 108 |
case 2: i1=1; i2=5; i3=4; break; |
|
| 109 |
case 3: i1=1; i2=3; i3=2; break; |
|
| 110 |
} |
|
| 64 |
return new int[][] { {2,1,0},{3,0,1},{3,2,0},{2,3,1} };
|
|
| 111 | 65 |
} |
| 112 |
|
|
| 113 |
float[] T1 = OCT_VER[i1]; |
|
| 114 |
float[] T2 = OCT_VER[i2]; |
|
| 115 |
float[] T3 = OCT_VER[i3]; |
|
| 116 |
|
|
| 117 |
return new float[] { pos[0]+T1[0], pos[1]+T1[1], pos[2]+T1[2],
|
|
| 118 |
pos[0]+T2[0], pos[1]+T2[1], pos[2]+T2[2], |
|
| 119 |
pos[0]+T3[0], pos[1]+T3[1], pos[2]+T3[2] }; |
|
| 120 |
} |
|
| 121 |
|
|
| 122 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 123 |
|
|
| 124 |
public float[] elementVertices(int ax, boolean left, int element) |
|
| 125 |
{
|
|
| 126 |
int variant = mElements[element].getVariant(); |
|
| 127 |
float[] pos = mElements[element].getPos(); |
|
| 128 |
|
|
| 129 |
if( variant==0 ) return octVertices(ax,left,pos); |
|
| 130 |
else return tetVertices(ax,left,pos); |
|
| 131 |
} |
|
| 132 |
|
|
| 133 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 134 |
|
|
| 135 |
public boolean elementFaceNotNull(int ax, boolean left, int element) |
|
| 136 |
{
|
|
| 137 |
int variant = mElements[element].getVariant(); |
|
| 138 |
return ( variant==0 || !left ); |
|
| 139 | 66 |
} |
| 140 | 67 |
|
| 141 | 68 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
Also available in: Unified diff
Progress with a generic FactoryBandaged.