Revision 53ca4624
Added by Leszek Koltunski over 1 year ago
| src/main/java/org/distorted/objectlib/objects/TwistyBandagedCuboid.java | ||
|---|---|---|
| 163 | 163 |
private int[][] mSolvedQuatsAbstract; |
| 164 | 164 |
private float[][] mPosition; |
| 165 | 165 |
private ObjectSignature mSignature; |
| 166 |
private ObjectShape[] mTmpShapes; |
|
| 167 |
private int mNumVariants; |
|
| 166 | 168 |
|
| 167 | 169 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 168 | 170 |
|
| ... | ... | |
| 382 | 384 |
|
| 383 | 385 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 384 | 386 |
|
| 385 |
public ObjectShape getObjectShape(int variant) |
|
| 387 |
private void produceTmpShape(int variant) |
|
| 388 |
{
|
|
| 389 |
float[][] positions = getPositions(); |
|
| 390 |
int cubit,numCubits = positions.length; |
|
| 391 |
|
|
| 392 |
for(cubit=0; cubit<numCubits; cubit++) |
|
| 393 |
{
|
|
| 394 |
if( mCubitVariantMap[cubit]==variant ) break; |
|
| 395 |
} |
|
| 396 |
|
|
| 397 |
if( cubit>=numCubits ) |
|
| 398 |
{
|
|
| 399 |
android.util.Log.e("D", "unknown variant: "+variant);
|
|
| 400 |
} |
|
| 401 |
else |
|
| 402 |
{
|
|
| 403 |
FactoryBandagedCubit factory = FactoryBandagedCubit.getInstance(); |
|
| 404 |
mTmpShapes[variant] = factory.createIrregularShape(variant,positions[cubit]); |
|
| 405 |
} |
|
| 406 |
} |
|
| 407 |
|
|
| 408 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 409 |
|
|
| 410 |
private float[][] getVertices(int variant) |
|
| 386 | 411 |
{
|
| 387 | 412 |
int type,numTypes = mDims.length; |
| 388 | 413 |
for(type=0; type<numTypes; type++) if( mTypeVariantMap[type]==variant ) break; |
| ... | ... | |
| 393 | 418 |
int Y = mDims[type][1]; |
| 394 | 419 |
int Z = mDims[type][2]; |
| 395 | 420 |
|
| 396 |
float[][] vertices =
|
|
| 421 |
return new float[][]
|
|
| 397 | 422 |
{
|
| 398 | 423 |
{ 0.5f*X, 0.5f*Y, 0.5f*Z},
|
| 399 | 424 |
{ 0.5f*X, 0.5f*Y,-0.5f*Z},
|
| ... | ... | |
| 404 | 429 |
{-0.5f*X,-0.5f*Y, 0.5f*Z},
|
| 405 | 430 |
{-0.5f*X,-0.5f*Y,-0.5f*Z}
|
| 406 | 431 |
}; |
| 432 |
} |
|
| 433 |
|
|
| 434 |
if( mTmpShapes==null ) mTmpShapes = new ObjectShape[mNumVariants]; |
|
| 435 |
if( mTmpShapes[variant]==null ) produceTmpShape(variant); |
|
| 436 |
return mTmpShapes[variant].getVertices(); |
|
| 437 |
} |
|
| 438 |
|
|
| 439 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 440 |
|
|
| 441 |
public ObjectShape getObjectShape(int variant) |
|
| 442 |
{
|
|
| 443 |
int type,numTypes = mDims.length; |
|
| 444 |
for(type=0; type<numTypes; type++) if( mTypeVariantMap[type]==variant ) break; |
|
| 407 | 445 |
|
| 446 |
if( type<numTypes ) |
|
| 447 |
{
|
|
| 408 | 448 |
int[][] indices = |
| 409 | 449 |
{
|
| 410 | 450 |
{2,3,1,0},
|
| ... | ... | |
| 415 | 455 |
{3,7,5,1},
|
| 416 | 456 |
}; |
| 417 | 457 |
|
| 418 |
return new ObjectShape(vertices, indices); |
|
| 419 |
} |
|
| 420 |
|
|
| 421 |
float[][] positions = getPositions(); |
|
| 422 |
int cubit,numCubits = positions.length; |
|
| 423 |
|
|
| 424 |
for(cubit=0; cubit<numCubits; cubit++) |
|
| 425 |
{
|
|
| 426 |
if( mCubitVariantMap[cubit]==variant ) break; |
|
| 427 |
} |
|
| 428 |
|
|
| 429 |
if( cubit>=numCubits ) |
|
| 430 |
{
|
|
| 431 |
android.util.Log.e("D", "unknown variant: "+variant);
|
|
| 432 |
return null; |
|
| 458 |
return new ObjectShape( getVertices(variant), indices); |
|
| 433 | 459 |
} |
| 434 | 460 |
|
| 435 |
FactoryBandagedCubit factory = FactoryBandagedCubit.getInstance(); |
|
| 436 |
return factory.createIrregularShape(variant,positions[cubit]); |
|
| 461 |
if( mTmpShapes==null ) mTmpShapes = new ObjectShape[mNumVariants]; |
|
| 462 |
if( mTmpShapes[variant]==null )produceTmpShape(variant); |
|
| 463 |
return mTmpShapes[variant]; |
|
| 437 | 464 |
} |
| 438 | 465 |
|
| 439 | 466 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| ... | ... | |
| 484 | 511 |
int[] numLayers = getNumLayers(); |
| 485 | 512 |
int size = (numLayers[0]+numLayers[1]+numLayers[2])/3; |
| 486 | 513 |
boolean round = (DistortedLibrary.fastCompilationTF() && size<=5 && !isInIconMode()); |
| 514 |
|
|
| 487 | 515 |
int type,numTypes = mDims.length; |
| 488 | 516 |
for(type=0; type<numTypes; type++) if( mTypeVariantMap[type]==variant ) break; |
| 489 | 517 |
|
| 490 | 518 |
if( type<numTypes ) |
| 491 | 519 |
{
|
| 492 |
int X = mDims[type][0]; |
|
| 493 |
int Y = mDims[type][1]; |
|
| 494 |
int Z = mDims[type][2]; |
|
| 495 |
|
|
| 496 |
float[][] centers = |
|
| 497 |
{
|
|
| 498 |
{ 0.5f*X, 0.5f*Y, 0.5f*Z},
|
|
| 499 |
{ 0.5f*X, 0.5f*Y,-0.5f*Z},
|
|
| 500 |
{ 0.5f*X,-0.5f*Y, 0.5f*Z},
|
|
| 501 |
{ 0.5f*X,-0.5f*Y,-0.5f*Z},
|
|
| 502 |
{-0.5f*X, 0.5f*Y, 0.5f*Z},
|
|
| 503 |
{-0.5f*X, 0.5f*Y,-0.5f*Z},
|
|
| 504 |
{-0.5f*X,-0.5f*Y, 0.5f*Z},
|
|
| 505 |
{-0.5f*X,-0.5f*Y,-0.5f*Z}
|
|
| 506 |
}; |
|
| 507 |
|
|
| 520 |
float[][] vertices = getVertices(variant); |
|
| 508 | 521 |
float strength = -0.04f; |
| 509 | 522 |
|
| 510 | 523 |
float[][] variables = |
| 511 | 524 |
{
|
| 512 |
{ 0, strength*centers[0][0], strength*centers[0][1], strength*centers[0][2], 1 },
|
|
| 513 |
{ 0, strength*centers[1][0], strength*centers[1][1], strength*centers[1][2], 1 },
|
|
| 514 |
{ 0, strength*centers[2][0], strength*centers[2][1], strength*centers[2][2], 1 },
|
|
| 515 |
{ 0, strength*centers[3][0], strength*centers[3][1], strength*centers[3][2], 1 },
|
|
| 516 |
{ 0, strength*centers[4][0], strength*centers[4][1], strength*centers[4][2], 1 },
|
|
| 517 |
{ 0, strength*centers[5][0], strength*centers[5][1], strength*centers[5][2], 1 },
|
|
| 518 |
{ 0, strength*centers[6][0], strength*centers[6][1], strength*centers[6][2], 1 },
|
|
| 519 |
{ 0, strength*centers[7][0], strength*centers[7][1], strength*centers[7][2], 1 },
|
|
| 525 |
{ 0, strength*vertices[0][0], strength*vertices[0][1], strength*vertices[0][2], 1 },
|
|
| 526 |
{ 0, strength*vertices[1][0], strength*vertices[1][1], strength*vertices[1][2], 1 },
|
|
| 527 |
{ 0, strength*vertices[2][0], strength*vertices[2][1], strength*vertices[2][2], 1 },
|
|
| 528 |
{ 0, strength*vertices[3][0], strength*vertices[3][1], strength*vertices[3][2], 1 },
|
|
| 529 |
{ 0, strength*vertices[4][0], strength*vertices[4][1], strength*vertices[4][2], 1 },
|
|
| 530 |
{ 0, strength*vertices[5][0], strength*vertices[5][1], strength*vertices[5][2], 1 },
|
|
| 531 |
{ 0, strength*vertices[6][0], strength*vertices[6][1], strength*vertices[6][2], 1 },
|
|
| 532 |
{ 0, strength*vertices[7][0], strength*vertices[7][1], strength*vertices[7][2], 1 },
|
|
| 520 | 533 |
}; |
| 521 | 534 |
|
| 522 | 535 |
String name = EffectName.DEFORM.name(); |
| ... | ... | |
| 526 | 539 |
float[][] regions = {reg,reg,reg,reg,reg,reg,reg,reg};
|
| 527 | 540 |
boolean[] uses = {round,round,round,round,round,round,round,round};
|
| 528 | 541 |
|
| 529 |
return new ObjectVertexEffects(names,variables,centers,regions,uses);
|
|
| 542 |
return new ObjectVertexEffects(names,variables,vertices,regions,uses);
|
|
| 530 | 543 |
} |
| 531 | 544 |
|
| 532 | 545 |
FactoryBandagedCubit factory = FactoryBandagedCubit.getInstance(); |
| ... | ... | |
| 564 | 577 |
|
| 565 | 578 |
public int getNumCubitVariants(int[] numLayers) |
| 566 | 579 |
{
|
| 567 |
int numVariants = 0; |
|
| 568 |
float[][] positions = getPositions(); |
|
| 569 |
boolean C111=false; |
|
| 570 |
boolean C211=false; |
|
| 571 |
boolean C311=false; |
|
| 572 |
boolean C221=false; |
|
| 573 |
boolean C222=false; |
|
| 574 |
|
|
| 575 |
int numCubits = positions.length; |
|
| 576 |
mCubitVariantMap = new int[numCubits]; |
|
| 580 |
if( mNumVariants==0 ) |
|
| 581 |
{
|
|
| 582 |
float[][] positions = getPositions(); |
|
| 583 |
boolean C111=false; |
|
| 584 |
boolean C211=false; |
|
| 585 |
boolean C311=false; |
|
| 586 |
boolean C221=false; |
|
| 587 |
boolean C222=false; |
|
| 577 | 588 |
|
| 578 |
int numTypes = mDims.length; |
|
| 579 |
mTypeVariantMap = new int[numTypes]; |
|
| 580 |
for(int i=0; i<numTypes; i++) mTypeVariantMap[i] = -1; |
|
| 589 |
int numCubits = positions.length; |
|
| 590 |
mCubitVariantMap = new int[numCubits]; |
|
| 581 | 591 |
|
| 582 |
for (int cubit=0; cubit<numCubits; cubit++)
|
|
| 583 |
{
|
|
| 584 |
int type = getType(positions[cubit]);
|
|
| 592 |
int numTypes = mDims.length;
|
|
| 593 |
mTypeVariantMap = new int[numTypes];
|
|
| 594 |
for(int i=0; i<numTypes; i++) mTypeVariantMap[i] = -1;
|
|
| 585 | 595 |
|
| 586 |
switch (type)
|
|
| 596 |
for (int cubit=0; cubit<numCubits; cubit++)
|
|
| 587 | 597 |
{
|
| 588 |
case CUBIT_111: if (!C111) { C111 = true; mTypeVariantMap[CUBIT_111]=numVariants++; }
|
|
| 589 |
mCubitVariantMap[cubit]=mTypeVariantMap[CUBIT_111]; |
|
| 590 |
break; |
|
| 591 |
case CUBIT_211: if (!C211) { C211 = true; mTypeVariantMap[CUBIT_211]=numVariants++; }
|
|
| 592 |
mCubitVariantMap[cubit]=mTypeVariantMap[CUBIT_211]; |
|
| 593 |
break; |
|
| 594 |
case CUBIT_311: if (!C311) { C311 = true; mTypeVariantMap[CUBIT_311]=numVariants++; }
|
|
| 595 |
mCubitVariantMap[cubit]=mTypeVariantMap[CUBIT_311]; |
|
| 596 |
break; |
|
| 597 |
case CUBIT_221: if (!C221) { C221 = true; mTypeVariantMap[CUBIT_221]=numVariants++; }
|
|
| 598 |
mCubitVariantMap[cubit]=mTypeVariantMap[CUBIT_221]; |
|
| 599 |
break; |
|
| 600 |
case CUBIT_222: if (!C222) { C222 = true; mTypeVariantMap[CUBIT_222]=numVariants++; }
|
|
| 601 |
mCubitVariantMap[cubit]=mTypeVariantMap[CUBIT_222]; |
|
| 602 |
break; |
|
| 603 |
default : mCubitVariantMap[cubit] = numVariants++; |
|
| 598 |
int type = getType(positions[cubit]); |
|
| 599 |
|
|
| 600 |
switch (type) |
|
| 601 |
{
|
|
| 602 |
case CUBIT_111: if (!C111) { C111 = true; mTypeVariantMap[CUBIT_111]=mNumVariants++; }
|
|
| 603 |
mCubitVariantMap[cubit]=mTypeVariantMap[CUBIT_111]; |
|
| 604 |
break; |
|
| 605 |
case CUBIT_211: if (!C211) { C211 = true; mTypeVariantMap[CUBIT_211]=mNumVariants++; }
|
|
| 606 |
mCubitVariantMap[cubit]=mTypeVariantMap[CUBIT_211]; |
|
| 607 |
break; |
|
| 608 |
case CUBIT_311: if (!C311) { C311 = true; mTypeVariantMap[CUBIT_311]=mNumVariants++; }
|
|
| 609 |
mCubitVariantMap[cubit]=mTypeVariantMap[CUBIT_311]; |
|
| 610 |
break; |
|
| 611 |
case CUBIT_221: if (!C221) { C221 = true; mTypeVariantMap[CUBIT_221]=mNumVariants++; }
|
|
| 612 |
mCubitVariantMap[cubit]=mTypeVariantMap[CUBIT_221]; |
|
| 613 |
break; |
|
| 614 |
case CUBIT_222: if (!C222) { C222 = true; mTypeVariantMap[CUBIT_222]=mNumVariants++; }
|
|
| 615 |
mCubitVariantMap[cubit]=mTypeVariantMap[CUBIT_222]; |
|
| 616 |
break; |
|
| 617 |
default : mCubitVariantMap[cubit] = mNumVariants++; |
|
| 618 |
} |
|
| 604 | 619 |
} |
| 605 |
} |
|
| 606 | 620 |
|
| 607 |
FactoryBandagedCubit factory = FactoryBandagedCubit.getInstance(); |
|
| 608 |
factory.prepare(numVariants,numLayers[0],numLayers[1],numLayers[2]); |
|
| 621 |
FactoryBandagedCubit factory = FactoryBandagedCubit.getInstance(); |
|
| 622 |
factory.prepare(mNumVariants,numLayers[0],numLayers[1],numLayers[2]); |
|
| 623 |
} |
|
| 609 | 624 |
|
| 610 |
return numVariants;
|
|
| 625 |
return mNumVariants;
|
|
| 611 | 626 |
} |
| 612 | 627 |
|
| 613 | 628 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
Also available in: Unified diff
Preparation for Camouflage Cubes.