Revision 03ad46a9
Added by Leszek Koltunski over 2 years ago
| src/main/java/org/distorted/objectlib/objects/TwistyBandagedAbstract.java | ||
|---|---|---|
| 286 | 286 |
return 0; |
| 287 | 287 |
} |
| 288 | 288 |
|
| 289 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 290 |
|
|
| 291 |
public ObjectSticker retSticker(int sticker) |
|
| 292 |
{
|
|
| 293 |
if( mStickers==null ) |
|
| 294 |
{
|
|
| 295 |
int numStickers = mStickerCoords.length; |
|
| 296 |
mStickers = new ObjectSticker[numStickers]; |
|
| 297 |
|
|
| 298 |
for(int s=0; s<numStickers; s++) |
|
| 299 |
{
|
|
| 300 |
float scale = mStickerScales[s]; |
|
| 301 |
float radius = 0.10f / scale; |
|
| 302 |
float stroke = 0.08f / scale; |
|
| 303 |
float[] radii = new float[] {radius,radius,radius,radius};
|
|
| 304 |
if( ObjectControl.isInIconMode() ) stroke*=2.0f; |
|
| 305 |
mStickers[s] = new ObjectSticker(mStickerCoords[s],null,radii,stroke); |
|
| 306 |
} |
|
| 307 |
} |
|
| 308 |
|
|
| 309 |
return mStickers[sticker]; |
|
| 310 |
} |
|
| 311 |
|
|
| 312 | 289 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 313 | 290 |
|
| 314 | 291 |
public float[][] getCubitPositions(int[] numLayers) |
| ... | ... | |
| 409 | 386 |
return 6; |
| 410 | 387 |
} |
| 411 | 388 |
|
| 412 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 413 |
|
|
| 414 |
public int getVariantFaceColor(int variant, int face, int[] numLayers) |
|
| 415 |
{
|
|
| 416 |
return face>=mStickerVariants[variant].length ? -1 : mStickerVariants[variant][face]; |
|
| 417 |
} |
|
| 418 |
|
|
| 419 | 389 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 420 | 390 |
|
| 421 | 391 |
public int getCubitFaceColor(int cubit, int cubitface, int[] numLayers) |
| ... | ... | |
| 460 | 430 |
return reaches ? face : -1; |
| 461 | 431 |
} |
| 462 | 432 |
|
| 433 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 434 |
|
|
| 435 |
public int getVariantFaceColor(int variant, int face, int[] numLayers) |
|
| 436 |
{
|
|
| 437 |
return face>=mStickerVariants[variant].length ? -1 : mStickerVariants[variant][face]; |
|
| 438 |
} |
|
| 439 |
|
|
| 440 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 441 |
|
|
| 442 |
public ObjectSticker retSticker(int sticker) |
|
| 443 |
{
|
|
| 444 |
if( mStickers==null ) |
|
| 445 |
{
|
|
| 446 |
int numStickers = mStickerCoords.length; |
|
| 447 |
mStickers = new ObjectSticker[numStickers]; |
|
| 448 |
|
|
| 449 |
for(int s=0; s<numStickers; s++) |
|
| 450 |
{
|
|
| 451 |
float scale = mStickerScales[s]; |
|
| 452 |
float radius = 0.10f / scale; |
|
| 453 |
float stroke = 0.08f / scale; |
|
| 454 |
float[] radii = new float[] {radius,radius,radius,radius};
|
|
| 455 |
if( ObjectControl.isInIconMode() ) stroke*=2.0f; |
|
| 456 |
mStickers[s] = new ObjectSticker(mStickerCoords[s],null,radii,stroke); |
|
| 457 |
} |
|
| 458 |
} |
|
| 459 |
|
|
| 460 |
return mStickers[sticker]; |
|
| 461 |
} |
|
| 462 |
|
|
| 463 | 463 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 464 | 464 |
// PUBLIC API |
| 465 | 465 |
|
| src/main/java/org/distorted/objectlib/objects/TwistyCuboid.java | ||
|---|---|---|
| 518 | 518 |
return 2; |
| 519 | 519 |
} |
| 520 | 520 |
|
| 521 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 522 |
|
|
| 523 |
public int getVariantFaceColor(int variant, int face, int[] numLayers) |
|
| 524 |
{
|
|
| 525 |
return face>=mStickerVariants[variant].length ? -1 : mStickerVariants[variant][face]; |
|
| 526 |
} |
|
| 527 |
|
|
| 528 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 529 |
|
|
| 530 |
public int getCubitFaceColor(int cubit, int face, int[] numLayers) |
|
| 531 |
{
|
|
| 532 |
int variant = getCubitVariant(cubit,numLayers); |
|
| 533 |
|
|
| 534 |
switch(variant) |
|
| 535 |
{
|
|
| 536 |
case 0: int axis = face/2; |
|
| 537 |
return CUBITS[cubit].getRotRow(axis) == (face%2==0 ? (1<<(numLayers[axis]-1)):1) ? face : -1; |
|
| 538 |
case 1: if( face!=3 && face !=5 ) return -1; |
|
| 539 |
int edge = getEdgeNum(cubit,numLayers); |
|
| 540 |
|
|
| 541 |
switch(edge) |
|
| 542 |
{
|
|
| 543 |
case 0: return face==3 ? 3 : 5; |
|
| 544 |
case 1: return face==3 ? 4 : 3; |
|
| 545 |
case 2: return face==3 ? 5 : 2; |
|
| 546 |
case 3: return face==3 ? 2 : 4; |
|
| 547 |
case 4: return face==3 ? 5 : 1; |
|
| 548 |
case 5: return face==3 ? 1 : 4; |
|
| 549 |
case 6: return face==3 ? 5 : 0; |
|
| 550 |
case 7: return face==3 ? 0 : 4; |
|
| 551 |
case 8: return face==3 ? 1 : 3; |
|
| 552 |
case 9: return face==3 ? 2 : 1; |
|
| 553 |
case 10: return face==3 ? 0 : 3; |
|
| 554 |
case 11: return face==3 ? 2 : 0; |
|
| 555 |
default: return 0; |
|
| 556 |
} |
|
| 557 |
|
|
| 558 |
case 2: return face==4 ? getCenterNum(cubit,numLayers) : -1; |
|
| 559 |
} |
|
| 560 |
|
|
| 561 |
return -1; |
|
| 562 |
} |
|
| 563 |
|
|
| 564 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 565 |
|
|
| 566 |
public ObjectSticker retSticker(int sticker) |
|
| 567 |
{
|
|
| 568 |
if( mStickers==null ) |
|
| 569 |
{
|
|
| 570 |
int numStickers = mStickerCoords.length; |
|
| 571 |
mStickers = new ObjectSticker[numStickers]; |
|
| 572 |
|
|
| 573 |
for(int s=0; s<numStickers; s++) |
|
| 574 |
{
|
|
| 575 |
float scale = mStickerScales[s]; |
|
| 576 |
float radius = 0.10f / scale; |
|
| 577 |
float stroke = 0.08f / scale; |
|
| 578 |
float[] radii = new float[] {radius,radius,radius,radius};
|
|
| 579 |
|
|
| 580 |
if( ObjectControl.isInIconMode() ) |
|
| 581 |
{
|
|
| 582 |
int[] numLayers = getNumLayers(); |
|
| 583 |
|
|
| 584 |
switch(numLayers[0]) |
|
| 585 |
{
|
|
| 586 |
case 2: stroke*=1.8f; break; |
|
| 587 |
case 3: stroke*=2.0f; break; |
|
| 588 |
case 4: stroke*=2.1f; break; |
|
| 589 |
default:stroke*=2.2f; break; |
|
| 590 |
} |
|
| 591 |
} |
|
| 592 |
|
|
| 593 |
mStickers[s] = new ObjectSticker(mStickerCoords[s],null,radii,stroke); |
|
| 594 |
} |
|
| 595 |
} |
|
| 596 |
|
|
| 597 |
return mStickers[sticker]; |
|
| 598 |
} |
|
| 599 |
|
|
| 600 | 521 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 601 | 522 |
|
| 602 | 523 |
public Static4D[] getQuats() |
| ... | ... | |
| 700 | 621 |
return 6; |
| 701 | 622 |
} |
| 702 | 623 |
|
| 624 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 625 |
|
|
| 626 |
public int getCubitFaceColor(int cubit, int face, int[] numLayers) |
|
| 627 |
{
|
|
| 628 |
int variant = getCubitVariant(cubit,numLayers); |
|
| 629 |
|
|
| 630 |
switch(variant) |
|
| 631 |
{
|
|
| 632 |
case 0: int axis = face/2; |
|
| 633 |
return CUBITS[cubit].getRotRow(axis) == (face%2==0 ? (1<<(numLayers[axis]-1)):1) ? face : -1; |
|
| 634 |
case 1: if( face!=3 && face !=5 ) return -1; |
|
| 635 |
int edge = getEdgeNum(cubit,numLayers); |
|
| 636 |
|
|
| 637 |
switch(edge) |
|
| 638 |
{
|
|
| 639 |
case 0: return face==3 ? 3 : 5; |
|
| 640 |
case 1: return face==3 ? 4 : 3; |
|
| 641 |
case 2: return face==3 ? 5 : 2; |
|
| 642 |
case 3: return face==3 ? 2 : 4; |
|
| 643 |
case 4: return face==3 ? 5 : 1; |
|
| 644 |
case 5: return face==3 ? 1 : 4; |
|
| 645 |
case 6: return face==3 ? 5 : 0; |
|
| 646 |
case 7: return face==3 ? 0 : 4; |
|
| 647 |
case 8: return face==3 ? 1 : 3; |
|
| 648 |
case 9: return face==3 ? 2 : 1; |
|
| 649 |
case 10: return face==3 ? 0 : 3; |
|
| 650 |
case 11: return face==3 ? 2 : 0; |
|
| 651 |
default: return 0; |
|
| 652 |
} |
|
| 653 |
|
|
| 654 |
case 2: return face==4 ? getCenterNum(cubit,numLayers) : -1; |
|
| 655 |
} |
|
| 656 |
|
|
| 657 |
return -1; |
|
| 658 |
} |
|
| 659 |
|
|
| 660 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 661 |
|
|
| 662 |
public int getVariantFaceColor(int variant, int face, int[] numLayers) |
|
| 663 |
{
|
|
| 664 |
return face>=mStickerVariants[variant].length ? -1 : mStickerVariants[variant][face]; |
|
| 665 |
} |
|
| 666 |
|
|
| 667 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 668 |
|
|
| 669 |
public ObjectSticker retSticker(int sticker) |
|
| 670 |
{
|
|
| 671 |
if( mStickers==null ) |
|
| 672 |
{
|
|
| 673 |
int numStickers = mStickerCoords.length; |
|
| 674 |
mStickers = new ObjectSticker[numStickers]; |
|
| 675 |
|
|
| 676 |
for(int s=0; s<numStickers; s++) |
|
| 677 |
{
|
|
| 678 |
float scale = mStickerScales[s]; |
|
| 679 |
float radius = 0.10f / scale; |
|
| 680 |
float stroke = 0.08f / scale; |
|
| 681 |
float[] radii = new float[] {radius,radius,radius,radius};
|
|
| 682 |
|
|
| 683 |
if( ObjectControl.isInIconMode() ) |
|
| 684 |
{
|
|
| 685 |
int[] numLayers = getNumLayers(); |
|
| 686 |
|
|
| 687 |
switch(numLayers[0]) |
|
| 688 |
{
|
|
| 689 |
case 2: stroke*=1.8f; break; |
|
| 690 |
case 3: stroke*=2.0f; break; |
|
| 691 |
case 4: stroke*=2.1f; break; |
|
| 692 |
default:stroke*=2.2f; break; |
|
| 693 |
} |
|
| 694 |
} |
|
| 695 |
|
|
| 696 |
mStickers[s] = new ObjectSticker(mStickerCoords[s],null,radii,stroke); |
|
| 697 |
} |
|
| 698 |
} |
|
| 699 |
|
|
| 700 |
return mStickers[sticker]; |
|
| 701 |
} |
|
| 702 |
|
|
| 703 | 703 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 704 | 704 |
// PUBLIC API |
| 705 | 705 |
|
| src/main/java/org/distorted/objectlib/objects/TwistyDiamond.java | ||
|---|---|---|
| 464 | 464 |
return cubit<getNumOctahedrons(numLayers[0]) ? 0 : 1; |
| 465 | 465 |
} |
| 466 | 466 |
|
| 467 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 468 |
|
|
| 469 |
public int getVariantFaceColor(int variant, int face, int[] numLayers) |
|
| 470 |
{
|
|
| 471 |
return face>=mStickerVariants[variant].length ? -1 : mStickerVariants[variant][face]; |
|
| 472 |
} |
|
| 473 |
|
|
| 474 | 467 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 475 | 468 |
|
| 476 | 469 |
public int getCubitFaceColor(int cubit, int face, int[] numLayers) |
| ... | ... | |
| 503 | 496 |
} |
| 504 | 497 |
} |
| 505 | 498 |
|
| 499 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 500 |
|
|
| 501 |
public int getVariantFaceColor(int variant, int face, int[] numLayers) |
|
| 502 |
{
|
|
| 503 |
return face>=mStickerVariants[variant].length ? -1 : mStickerVariants[variant][face]; |
|
| 504 |
} |
|
| 505 |
|
|
| 506 | 506 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 507 | 507 |
|
| 508 | 508 |
public ObjectSticker retSticker(int sticker) |
| src/main/java/org/distorted/objectlib/objects/TwistyDino.java | ||
|---|---|---|
| 224 | 224 |
|
| 225 | 225 |
public int getVariantFaceColor(int variant, int face, int[] numLayers) |
| 226 | 226 |
{
|
| 227 |
return 0;
|
|
| 227 |
return face>=mStickerVariants[variant].length ? -1 : mStickerVariants[variant][face];
|
|
| 228 | 228 |
} |
| 229 | 229 |
|
| 230 | 230 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| ... | ... | |
| 233 | 233 |
{
|
| 234 | 234 |
if( mStickers==null ) |
| 235 | 235 |
{
|
| 236 |
float[][] STICKERS = new float[][] { { 0.0f, -1.0f/3, 0.5f, 1.0f/6, -0.5f, 1.0f/6 } };
|
|
| 237 |
float radius = 0.025f; |
|
| 238 |
float stroke = 0.050f; |
|
| 239 |
float[] radii = new float[] {radius,radius,radius};
|
|
| 236 |
int numStickers = mStickerCoords.length; |
|
| 237 |
mStickers = new ObjectSticker[numStickers]; |
|
| 240 | 238 |
|
| 241 |
if( ObjectControl.isInIconMode() )
|
|
| 239 |
for(int s=0; s<numStickers; s++)
|
|
| 242 | 240 |
{
|
| 243 |
stroke*=1.5f; |
|
| 244 |
} |
|
| 241 |
float scale = mStickerScales[s]; |
|
| 242 |
float radius = 0.07f / scale; |
|
| 243 |
float stroke = 0.15f / scale; |
|
| 244 |
float[] radii = new float[] {radius,radius,radius};
|
|
| 245 | 245 |
|
| 246 |
mStickers = new ObjectSticker[STICKERS.length]; |
|
| 247 |
mStickers[0] = new ObjectSticker(STICKERS[0],null,radii,stroke); |
|
| 246 |
if( ObjectControl.isInIconMode() ) stroke*=1.5f; |
|
| 247 |
|
|
| 248 |
mStickers[s] = new ObjectSticker(mStickerCoords[s],null,radii,stroke); |
|
| 249 |
} |
|
| 248 | 250 |
} |
| 249 | 251 |
|
| 250 | 252 |
return mStickers[sticker]; |
| src/main/java/org/distorted/objectlib/objects/TwistyHelicopter.java | ||
|---|---|---|
| 360 | 360 |
return cubit<8 ? 0:1; |
| 361 | 361 |
} |
| 362 | 362 |
|
| 363 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 364 |
|
|
| 365 |
public int getVariantFaceColor(int variant, int face, int[] numLayers) |
|
| 366 |
{
|
|
| 367 |
return 0; |
|
| 368 |
} |
|
| 369 |
|
|
| 370 | 363 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 371 | 364 |
|
| 372 | 365 |
public int getCubitFaceColor(int cubit, int face, int[] numLayers) |
| ... | ... | |
| 419 | 412 |
return mFaceMap[cubit][face]; |
| 420 | 413 |
} |
| 421 | 414 |
|
| 415 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 416 |
|
|
| 417 |
public int getVariantFaceColor(int variant, int face, int[] numLayers) |
|
| 418 |
{
|
|
| 419 |
return face>=mStickerVariants[variant].length ? -1 : mStickerVariants[variant][face]; |
|
| 420 |
} |
|
| 421 |
|
|
| 422 | 422 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 423 | 423 |
|
| 424 | 424 |
public ObjectSticker retSticker(int sticker) |
| 425 | 425 |
{
|
| 426 | 426 |
if( mStickers==null ) |
| 427 | 427 |
{
|
| 428 |
float[][] STICKERS = new float[][] { { -0.5f, 0.25f, 0.25f, -0.5f, 0.25f, 0.25f } };
|
|
| 429 |
float radius = 0.03f; |
|
| 430 |
float stroke = 0.05f; |
|
| 431 |
float[] radii = new float[] {radius,radius,radius};
|
|
| 428 |
int numStickers = mStickerCoords.length; |
|
| 429 |
mStickers = new ObjectSticker[numStickers]; |
|
| 432 | 430 |
|
| 433 |
if( ObjectControl.isInIconMode() )
|
|
| 431 |
for(int s=0; s<numStickers; s++)
|
|
| 434 | 432 |
{
|
| 435 |
stroke*=2.0f; |
|
| 433 |
float scale = mStickerScales[s]; |
|
| 434 |
float radius = 0.06f / scale; |
|
| 435 |
float stroke = 0.10f / scale; |
|
| 436 |
float[] radii = new float[] {radius,radius,radius};
|
|
| 437 |
if( ObjectControl.isInIconMode() ) stroke*=2.0f; |
|
| 438 |
mStickers[s] = new ObjectSticker(mStickerCoords[s],null,radii,stroke); |
|
| 436 | 439 |
} |
| 437 |
|
|
| 438 |
mStickers = new ObjectSticker[STICKERS.length]; |
|
| 439 |
mStickers[0] = new ObjectSticker(STICKERS[0],null,radii,stroke); |
|
| 440 | 440 |
} |
| 441 | 441 |
|
| 442 | 442 |
return mStickers[sticker]; |
Also available in: Unified diff
Progress standarising stickering.