Project

General

Profile

« Previous | Next » 

Revision 3290a98d

Added by Leszek Koltunski 11 months ago

Progress with 6x6 Pyramid

View differences:

src/main/java/org/distorted/objectlib/objects/TwistyJing.java
64 64
  public void adjustStickerCoords()
65 65
    {
66 66
    int[] numLayers = getNumLayers();
67
    float CENTER_CORR = 0.85f;
67
    int numL = numLayers[0];
68 68

  
69
    if( numLayers[0]==3 || numLayers[0]==5 )
69
    if( numL==3 || numL==5 )
70 70
      {
71
      mStickerCoords[3][0][2][0] *= CENTER_CORR;
72
      mStickerCoords[3][0][2][1] *= CENTER_CORR;
71
      float CENTER_CORR = 0.85f;
72
      int index = numL==3 ? 3 : 4;
73

  
74
      if( numL==3 )
75
        {
76
        mStickerCoords[index][0][2][0] *= CENTER_CORR;
77
        mStickerCoords[index][0][2][1] *= CENTER_CORR;
78
        }
73 79
      }
74 80
    }
75 81

  
......
320 326
        }
321 327
      else if( numL==5 )
322 328
        {
329
        final float A = numL*0.25f;
330
        final float B = numL*0.50f;
331
        final float C = numL*(1.0f/6);
332
        final float D = numL*(SQ2/12);
333
        final float F = JING_F[numL];
334
        final float X = F/2;
335
        final float Y = F*SQ2/2;
336
        final float Z = -F/2;
337

  
323 338
        mCenters = new float[][]
324 339
          {
325
          // TODO
340
            {  0, -SQ2*A     ,  B      },
341
            {  X, -SQ2*A +  Y,  B +  Z },
342
            { -X, -SQ2*A +  Y,  B +  Z },
343
            {  0, -SQ2*A     ,  B -  F },
344
            {  0, -SQ2*A +2*Y,  B +2*Z },
345
            {  X, -SQ2*A +  Y,  B +Z-F },
346
            { -X, -SQ2*A +  Y,  B +Z-F },
347

  
348
            {  0, -SQ2*A     , -B      },
349
            {  X, -SQ2*A +  Y, -B -  Z },
350
            { -X, -SQ2*A +  Y, -B -  Z },
351
            {  0, -SQ2*A     , -B +  F },
352
            {  0, -SQ2*A +2*Y, -B -2*Z },
353
            {  X, -SQ2*A +  Y, -B -Z+F },
354
            { -X, -SQ2*A +  Y, -B -Z+F },
355

  
356
            {-B     ,  SQ2*A     ,   0 },
357
            {-B -  Z,  SQ2*A -  Y,   X },
358
            {-B -  Z,  SQ2*A -  Y,  -X },
359
            {-B +  F,  SQ2*A     ,   0 },
360
            {-B -2*Z,  SQ2*A -2*Y,   0 },
361
            {-B -Z+F,  SQ2*A -  Y,  -X },
362
            {-B -Z+F,  SQ2*A -  Y,   X },
363

  
364
            { B     ,  SQ2*A     ,   0 },
365
            { B +  Z,  SQ2*A -  Y,   X },
366
            { B +  Z,  SQ2*A -  Y,  -X },
367
            { B -  F,  SQ2*A     ,   0 },
368
            { B +2*Z,  SQ2*A -2*Y,   0 },
369
            { B +Z-F,  SQ2*A -  Y,  -X },
370
            { B +Z-F,  SQ2*A -  Y,   X },
371

  
372
            { 2*X, -SQ2*A +2*Y, B+2*Z },
373
            {-2*X, -SQ2*A +2*Y, B+2*Z },
374
            {   0, -SQ2*A     , B-2*F },
375
            { 2*X, -SQ2*A +2*Y,-B-2*Z },
376
            {-2*X, -SQ2*A +2*Y,-B-2*Z },
377
            {   0, -SQ2*A     ,-B+2*F },
378

  
379
            {-B-2*Z, SQ2*A -2*Y,  2*X },
380
            {-B-2*Z, SQ2*A -2*Y, -2*X },
381
            {-B+2*F, SQ2*A     ,    0 },
382
            { B+2*Z, SQ2*A -2*Y,  2*X },
383
            { B+2*Z, SQ2*A -2*Y, -2*X },
384
            { B-2*F, SQ2*A     ,    0 },
385

  
386
            {   X, -SQ2*A+3*Y ,  B+3*Z     },
387
            {-2*X, -SQ2*A+2*Y ,  B-2*F     },
388
            {   X, -SQ2*A+Y   ,  B-2.5f*F  },
389
            { 2*X, -SQ2*A+2*Y , -B+2*F     },
390
            {  -X, -SQ2*A+3*Y , -B-3*Z     },
391
            {  -X, -SQ2*A+Y   , -B+2.5f*F  },
392
            {  -B+   2*F,  SQ2*A-2*Y ,-2*Z },
393
            {  -B+2.5f*F,  SQ2*A-  Y ,   Z },
394
            {  -B+1.5f*F,  SQ2*A-3*Y ,   Z },
395
            {   B-1.5f*F,  SQ2*A-3*Y ,  -Z },
396
            {   B-   2*F,  SQ2*A-2*Y , 2*Z },
397
            {   B-2.5f*F,  SQ2*A-  Y ,  -Z },
398

  
399
            {  -X, -SQ2*A+3*Y ,  B+3*Z     },
400
            { 2*X, -SQ2*A+2*Y ,  B-2*F     },
401
            {  -X, -SQ2*A+Y   ,  B-2.5f*F  },
402
            {-2*X, -SQ2*A+2*Y , -B+2*F     },
403
            {   X, -SQ2*A+3*Y , -B-3*Z     },
404
            {   X, -SQ2*A+Y   , -B+2.5f*F  },
405
            {  -B+   2*F,  SQ2*A-2*Y , 2*Z },
406
            {  -B+2.5f*F,  SQ2*A-  Y ,  -Z },
407
            {  -B+1.5f*F,  SQ2*A-3*Y ,  -Z },
408
            {   B-1.5f*F,  SQ2*A-3*Y ,   Z },
409
            {   B-   2*F,  SQ2*A-2*Y ,-2*Z },
410
            {   B-2.5f*F,  SQ2*A-  Y ,   Z },
411

  
412
            {   0, -SQ2*A+4*Y, B+4*Z }
326 413
          };
327 414
        }
328 415
      }
......
353 440
                                 0,0,5,5,8,8,6,6,7,7,9,9,
354 441
                                 0,10,7,3 };
355 442
      else
356
        mQuatIndex = new int[] {  }; // TODO
443
        mQuatIndex = new int[] { 0,0,0,0,0,0,0,10,10,10,10,10,10,10,5,5,5,5,5,5,5,8,8,8,8,8,8,8,
444
                                 4,3,0, 7,6,10, 5,2,11, 8,1,9,
445
                                 4,3,0, 7,6,10, 5,11,2, 8,1,9,
446
                                 5,8,10,2,1, 0, 6, 9,3, 7,4,11,
447
                                 0, }; // TODO
357 448
      }
358 449

  
359 450
    return mObjectQuats[mQuatIndex[cubit]];
......
381 472
    final float X3 = G2/2;
382 473
    final float Y3 = G2*SQ2/2;
383 474
    final float Z3 =-G2/2;
475
    final float G3 = G1 - F;
476
    final float X4 = G3/2;
477
    final float Y4 = G3*SQ2/2;
478
    final float Z4 =-G3/2;
384 479
    final float K  = 0.2f*(1 - F/(2*G2));
385 480

  
386 481
    if( variant==0 )
......
438 533
            {-X,   Y,  -Z-G2},
439 534
        };
440 535
      }
441
    else if( variant==2 && (numL==3 || numL==5) )
536
    else if( variant==2 && numL==5 )
537
      {
538
      return new float[][]
539
        {
540
            { 0,   0,   0 },
541
            { X,   Y,   Z },
542
            { 0, 2*Y, 2*Z },
543
            {-X,   Y,   Z },
544
            { 0,   0, -G2 },
545
            { X,   Y, -G2 },
546
            {-X,   Y, -G2 },
547
        };
548
      }
549
    else if( variant==3 && numL==5 )
550
      {
551
      return new float[][]
552
        {
553
            { 0,   0,   0 },
554
            {-X,   Y,  -Z },
555
            { 0, 2*Y,-2*Z },
556
            { X,   Y,  -Z },
557
            { 0,   0,  G2 },
558
            {-X,   Y,  G2 },
559
            { X,   Y,  G2 },
560
        };
561
      }
562
    else if( variant==2 && numL==3 )
442 563
      {
443 564
      return new float[][]
444 565
        {
......
452 573
            {-K*X3,   K*Y3,  K*Z3-G2 },
453 574
        };
454 575
      }
576
    else if( variant==4 && numL==5 )
577
      {
578
      return new float[][]
579
        {
580
            {  0,    0,    0 },
581
            { X4,   Y4,   Z4 },
582
            {  0, (2*SQ2/3)*G3, (-2.0f/3)*G3 },
583
            {-X4,   Y4,   Z4 },
584
            {  0,    0,  -G3 },
585
            { K*X4,   K*Y4,  K*Z4-G3 },
586
            {  0, K*(2*SQ2/3)*G3, K*(-2.0f/3)*G3 - G3 },
587
            {-K*X4,   K*Y4,  K*Z4-G3 },
588
        };
589
      }
455 590
    else
456 591
      {
457 592
      return new float[][]
......
487 622

  
488 623
      return new ObjectShape(getVertices(variant), indices);
489 624
      }
490
    else if( (variant==1 && (numL==2 || numL==4)) || (numL>3 && variant==2)  )
625
    else if( (variant==1 && (numL==2 || numL==4)) || (variant==2 && numL==4)  )
491 626
      {
492 627
      int[][] indices =
493 628
          {
......
501 636

  
502 637
      return new ObjectShape(getVertices(variant), indices);
503 638
      }
504
    else if(  (numL==3 && variant==2) || (numL==5 && variant==3) )
639
    else if( (variant==2 && numL==3) || (variant==4 && numL==5) )
505 640
      {
506 641
      int[][] indices =
507 642
          {
......
515 650

  
516 651
      return new ObjectShape(getVertices(variant), indices);
517 652
      }
518
    else if( variant==1 && (numL==3 || numL==5) )
653
    else if( (variant==1 && (numL==3 || numL==5)) || ((variant==2 || variant==3) && numL==5) )
519 654
      {
520 655
      int[][] indices =
521 656
          {
......
557 692

  
558 693
    if( variant==0 )
559 694
      {
695
      int I = numL<5 ? 1:0;
696
      int V = numL<5 ? 1:0;
560 697
      float height = isInIconMode() ? 0.001f : H;
561
      float[][] bands = { {height,35,R,S,5,1,1},{0.001f,1,R,S,5,1,1} };
698
      float[][] bands = { {height,35,R,S,5,I,V},{0.001f,1,R,S,5,I,V} };
562 699
      int[] indices   = { 0,0,0,1,1,1 };
563 700
      return new ObjectFaceShape(bands,indices,null);
564 701
      }
......
579 716
      int[] indices   = { 0,0,1,1,1,1,1 };
580 717
      return new ObjectFaceShape(bands,indices,null);
581 718
      }
719
    else if( (variant==2 || variant==3) && numL==5 )
720
      {
721
      int N = 5;
722
      float height = isInIconMode() ? 0.001f : H;
723
      float[][] bands = { {height,35,R,S,N,0,0},{0.001f,1,R,S,4,0,0} };
724
      int[] indices   = { 0,1,1,1,1,1,1 };
725
      return new ObjectFaceShape(bands,indices,null);
726
      }
582 727
    else if( variant==2 && numL==4 )
583 728
      {
584 729
      float height = isInIconMode() ? 0.001f : H;
585 730
      float[][] bands = { {height,35,R,S,6,0,0},{0.001f,1,R,S,4,0,0} };
586
      int[] indices   = { 0,0,1,1,1,1 };
731
      int[] indices   = { 0,1,1,1,1,1 };
587 732
      return new ObjectFaceShape(bands,indices,null);
588 733
      }
589 734
    else

Also available in: Unified diff