Revision 7b832206
Added by Leszek Koltunski over 2 years ago
src/main/java/org/distorted/objectlib/main/TwistyObject.java | ||
---|---|---|
1382 | 1382 |
protected abstract int getNumFaceColors(); |
1383 | 1383 |
protected abstract int getColor(int face); |
1384 | 1384 |
protected abstract int getNumCubitFaces(); |
1385 |
protected abstract float[][] getCubitPositions(int[] numLayers); |
|
1386 |
protected abstract Static4D getQuat(int cubit, int[] numLayers); |
|
1387 |
protected abstract int[] getSolvedQuats(int cubit, int[] numLayers); |
|
1388 | 1385 |
protected abstract int getFaceColor(int cubit, int cubitface, int[] numLayers); |
1389 | 1386 |
protected abstract int getResource(int[] numLayers); |
1390 | 1387 |
protected abstract ObjectType intGetObjectType(int[] numLayers); |
... | ... | |
1405 | 1402 |
public abstract int getCubitVariant(int cubit, int[] numLayers); |
1406 | 1403 |
public abstract ObjectShape getObjectShape(int variant); |
1407 | 1404 |
public abstract int getNumCubitVariants(int[] numLayers); |
1405 |
public abstract float[][] getCubitPositions(int[] numLayers); |
|
1406 |
public abstract Static4D getQuat(int cubit, int[] numLayers); |
|
1407 |
public abstract int[] getSolvedQuats(int cubit, int[] numLayers); |
|
1408 |
|
|
1408 | 1409 |
|
1409 | 1410 |
public abstract Static3D[] getRotationAxis(); |
1410 | 1411 |
public abstract int[] getBasicAngle(); |
src/main/java/org/distorted/objectlib/objects/TwistyBandagedAbstract.java | ||
---|---|---|
121 | 121 |
|
122 | 122 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
123 | 123 |
|
124 |
protected int[] getSolvedQuats(int cubit, int[] numLayers)
|
|
124 |
public int[] getSolvedQuats(int cubit, int[] numLayers)
|
|
125 | 125 |
{ |
126 | 126 |
if( mQuats==null ) initializeQuats(); |
127 | 127 |
int status = retCubitSolvedStatus(cubit,numLayers); |
... | ... | |
216 | 216 |
|
217 | 217 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
218 | 218 |
|
219 |
protected Static4D getQuat(int cubit, int[] numLayers)
|
|
219 |
public Static4D getQuat(int cubit, int[] numLayers)
|
|
220 | 220 |
{ |
221 | 221 |
if( mInitQuats ==null ) |
222 | 222 |
{ |
... | ... | |
306 | 306 |
|
307 | 307 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
308 | 308 |
|
309 |
protected float[][] getCubitPositions(int[] numLayers)
|
|
309 |
public float[][] getCubitPositions(int[] numLayers)
|
|
310 | 310 |
{ |
311 | 311 |
int numCubits = getNumCubits(); |
312 | 312 |
float[][] tmp = new float[numCubits][]; |
src/main/java/org/distorted/objectlib/objects/TwistyCuboid.java | ||
---|---|---|
234 | 234 |
|
235 | 235 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
236 | 236 |
|
237 |
protected int[] getSolvedQuats(int cubit, int[] numLayers)
|
|
237 |
public int[] getSolvedQuats(int cubit, int[] numLayers)
|
|
238 | 238 |
{ |
239 | 239 |
if( mQuats ==null ) initializeQuats(); |
240 | 240 |
int status = retCubitSolvedStatus(cubit,numLayers); |
... | ... | |
351 | 351 |
|
352 | 352 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
353 | 353 |
|
354 |
protected float[][] getCubitPositions(int[] numLayers)
|
|
354 |
public float[][] getCubitPositions(int[] numLayers)
|
|
355 | 355 |
{ |
356 | 356 |
final int X = numLayers[0]; |
357 | 357 |
final int Y = numLayers[1]; |
... | ... | |
441 | 441 |
|
442 | 442 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
443 | 443 |
|
444 |
protected Static4D getQuat(int cubit, int[] numLayers)
|
|
444 |
public Static4D getQuat(int cubit, int[] numLayers)
|
|
445 | 445 |
{ |
446 | 446 |
if( mQuats ==null ) initializeQuats(); |
447 | 447 |
|
src/main/java/org/distorted/objectlib/objects/TwistyDiamond.java | ||
---|---|---|
132 | 132 |
|
133 | 133 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
134 | 134 |
|
135 |
protected int[] getSolvedQuats(int cubit, int[] numLayers)
|
|
135 |
public int[] getSolvedQuats(int cubit, int[] numLayers)
|
|
136 | 136 |
{ |
137 | 137 |
if( mQuats==null ) initializeQuats(); |
138 | 138 |
if( mFaceMap==null ) mFaceMap = new int[] {4,0,6,2,7,3,5,1}; |
... | ... | |
350 | 350 |
|
351 | 351 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
352 | 352 |
|
353 |
protected float[][] getCubitPositions(int[] numLayers)
|
|
353 |
public float[][] getCubitPositions(int[] numLayers)
|
|
354 | 354 |
{ |
355 | 355 |
int layers = numLayers[0]; |
356 | 356 |
int numO = getNumOctahedrons(layers); |
... | ... | |
452 | 452 |
|
453 | 453 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
454 | 454 |
|
455 |
protected Static4D getQuat(int cubit, int[] numLayers)
|
|
455 |
public Static4D getQuat(int cubit, int[] numLayers)
|
|
456 | 456 |
{ |
457 | 457 |
if( mQuats==null ) initializeQuats(); |
458 | 458 |
|
src/main/java/org/distorted/objectlib/objects/TwistyDino.java | ||
---|---|---|
178 | 178 |
|
179 | 179 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
180 | 180 |
|
181 |
protected float[][] getCubitPositions(int[] numLayers)
|
|
181 |
public float[][] getCubitPositions(int[] numLayers)
|
|
182 | 182 |
{ |
183 | 183 |
if( mCenters ==null ) |
184 | 184 |
{ |
... | ... | |
219 | 219 |
|
220 | 220 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
221 | 221 |
|
222 |
protected Static4D getQuat(int cubit, int[] numLayers)
|
|
222 |
public Static4D getQuat(int cubit, int[] numLayers)
|
|
223 | 223 |
{ |
224 | 224 |
if( mQuats==null ) initializeQuats(); |
225 | 225 |
return mQuats[cubit]; |
src/main/java/org/distorted/objectlib/objects/TwistyDino4.java | ||
---|---|---|
70 | 70 |
|
71 | 71 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
72 | 72 |
|
73 |
protected int[] getSolvedQuats(int cubit, int[] numLayers)
|
|
73 |
public int[] getSolvedQuats(int cubit, int[] numLayers)
|
|
74 | 74 |
{ |
75 | 75 |
return null; |
76 | 76 |
} |
src/main/java/org/distorted/objectlib/objects/TwistyDino6.java | ||
---|---|---|
70 | 70 |
|
71 | 71 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
72 | 72 |
|
73 |
protected int[] getSolvedQuats(int cubit, int[] numLayers)
|
|
73 |
public int[] getSolvedQuats(int cubit, int[] numLayers)
|
|
74 | 74 |
{ |
75 | 75 |
return null; |
76 | 76 |
} |
src/main/java/org/distorted/objectlib/objects/TwistyHelicopter.java | ||
---|---|---|
142 | 142 |
|
143 | 143 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
144 | 144 |
|
145 |
protected int[] getSolvedQuats(int cubit, int[] numLayers)
|
|
145 |
public int[] getSolvedQuats(int cubit, int[] numLayers)
|
|
146 | 146 |
{ |
147 | 147 |
if( mQuats==null ) initializeQuats(); |
148 | 148 |
int status = retCubitSolvedStatus(cubit,numLayers); |
... | ... | |
241 | 241 |
|
242 | 242 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
243 | 243 |
|
244 |
protected float[][] getCubitPositions(int[] numLayers)
|
|
244 |
public float[][] getCubitPositions(int[] numLayers)
|
|
245 | 245 |
{ |
246 | 246 |
if( mCenters==null ) |
247 | 247 |
{ |
... | ... | |
358 | 358 |
|
359 | 359 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
360 | 360 |
|
361 |
protected Static4D getQuat(int cubit, int[] numLayers)
|
|
361 |
public Static4D getQuat(int cubit, int[] numLayers)
|
|
362 | 362 |
{ |
363 | 363 |
if( mQuats==null ) initializeQuats(); |
364 | 364 |
if( mQuatIndices==null ) mQuatIndices = new int[] { 0,13,14,1,12,2,3,7,20,6,13,17,7,23,18,12,22,10,8,16,11,21,19,9,3,15,14,0,5,2,1,4 }; |
src/main/java/org/distorted/objectlib/objects/TwistyIvy.java | ||
---|---|---|
118 | 118 |
|
119 | 119 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
120 | 120 |
|
121 |
protected int[] getSolvedQuats(int cubit, int[] numLayers)
|
|
121 |
public int[] getSolvedQuats(int cubit, int[] numLayers)
|
|
122 | 122 |
{ |
123 | 123 |
if( mQuats==null ) initializeQuats(); |
124 | 124 |
int status = retCubitSolvedStatus(cubit,numLayers); |
... | ... | |
221 | 221 |
|
222 | 222 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
223 | 223 |
|
224 |
protected float[][] getCubitPositions(int[] numLayers)
|
|
224 |
public float[][] getCubitPositions(int[] numLayers)
|
|
225 | 225 |
{ |
226 | 226 |
final float DIST_CORNER = numLayers[0]-1; |
227 | 227 |
final float DIST_CENTER = numLayers[0]-1; |
... | ... | |
399 | 399 |
|
400 | 400 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
401 | 401 |
|
402 |
protected Static4D getQuat(int cubit, int[] numLayers)
|
|
402 |
public Static4D getQuat(int cubit, int[] numLayers)
|
|
403 | 403 |
{ |
404 | 404 |
if( mQuats==null ) initializeQuats(); |
405 | 405 |
|
src/main/java/org/distorted/objectlib/objects/TwistyJing.java | ||
---|---|---|
119 | 119 |
|
120 | 120 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
121 | 121 |
|
122 |
protected int[] getSolvedQuats(int cubit, int[] numLayers)
|
|
122 |
public int[] getSolvedQuats(int cubit, int[] numLayers)
|
|
123 | 123 |
{ |
124 | 124 |
if( mQuats==null ) initializeQuats(); |
125 | 125 |
int status = retCubitSolvedStatus(cubit,numLayers); |
... | ... | |
128 | 128 |
|
129 | 129 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
130 | 130 |
|
131 |
protected float[][] getCubitPositions(int[] numLayers)
|
|
131 |
public float[][] getCubitPositions(int[] numLayers)
|
|
132 | 132 |
{ |
133 | 133 |
if( mCenters==null ) |
134 | 134 |
{ |
... | ... | |
387 | 387 |
|
388 | 388 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
389 | 389 |
|
390 |
protected Static4D getQuat(int cubit, int[] numLayers)
|
|
390 |
public Static4D getQuat(int cubit, int[] numLayers)
|
|
391 | 391 |
{ |
392 | 392 |
if( mQuats==null ) initializeQuats(); |
393 | 393 |
if( mRotQuat ==null ) mRotQuat = new int[] {0,1,2,7,0,2,7,6,3,10,0,1,3,5}; |
src/main/java/org/distorted/objectlib/objects/TwistyKilominx.java | ||
---|---|---|
248 | 248 |
|
249 | 249 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
250 | 250 |
|
251 |
protected float[][] getCubitPositions(int[] numLayers)
|
|
251 |
public float[][] getCubitPositions(int[] numLayers)
|
|
252 | 252 |
{ |
253 | 253 |
if( mCorners==null ) initializeCorners(); |
254 | 254 |
|
... | ... | |
505 | 505 |
|
506 | 506 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
507 | 507 |
|
508 |
protected Static4D getQuat(int cubit, int[] numLayers)
|
|
508 |
public Static4D getQuat(int cubit, int[] numLayers)
|
|
509 | 509 |
{ |
510 | 510 |
if( mQuats==null ) initializeQuats(); |
511 | 511 |
|
src/main/java/org/distorted/objectlib/objects/TwistyMegaminx.java | ||
---|---|---|
209 | 209 |
|
210 | 210 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
211 | 211 |
|
212 |
protected float[][] getCubitPositions(int[] numLayers)
|
|
212 |
public float[][] getCubitPositions(int[] numLayers)
|
|
213 | 213 |
{ |
214 | 214 |
int numL = numLayers[0]; |
215 | 215 |
int numCubitsPerCorner = numCubitsPerCorner(numL); |
... | ... | |
419 | 419 |
|
420 | 420 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
421 | 421 |
|
422 |
protected Static4D getQuat(int cubit, int[] numLayers)
|
|
422 |
public Static4D getQuat(int cubit, int[] numLayers)
|
|
423 | 423 |
{ |
424 | 424 |
if( mQuats==null ) initializeQuats(); |
425 | 425 |
|
src/main/java/org/distorted/objectlib/objects/TwistyMinx.java | ||
---|---|---|
493 | 493 |
|
494 | 494 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
495 | 495 |
|
496 |
protected int[] getSolvedQuats(int cubit, int[] numLayers)
|
|
496 |
public int[] getSolvedQuats(int cubit, int[] numLayers)
|
|
497 | 497 |
{ |
498 | 498 |
if( mQuats==null ) initializeQuats(); |
499 | 499 |
if( mFaceMap==null ) mFaceMap = new int[] {8,10,3,7,1,9,11,2,4,0,5,6}; |
src/main/java/org/distorted/objectlib/objects/TwistyMirror.java | ||
---|---|---|
193 | 193 |
// we cannot do this the standard, automatic way because there's only 1 color in the FACE_COLORS |
194 | 194 |
// table and retCubitSolvedStatus() always returns -1,-1 or 0. |
195 | 195 |
|
196 |
protected int[] getSolvedQuats(int cubit, int[] numLayers)
|
|
196 |
public int[] getSolvedQuats(int cubit, int[] numLayers)
|
|
197 | 197 |
{ |
198 | 198 |
if( numLayers[0]==3 ) |
199 | 199 |
{ |
... | ... | |
493 | 493 |
|
494 | 494 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
495 | 495 |
|
496 |
protected Static4D getQuat(int cubit, int[] numLayers)
|
|
496 |
public Static4D getQuat(int cubit, int[] numLayers)
|
|
497 | 497 |
{ |
498 | 498 |
if( mQuats ==null ) initializeQuats(); |
499 | 499 |
return mQuats[0]; |
... | ... | |
523 | 523 |
|
524 | 524 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
525 | 525 |
|
526 |
protected float[][] getCubitPositions(int[] numLayers)
|
|
526 |
public float[][] getCubitPositions(int[] numLayers)
|
|
527 | 527 |
{ |
528 | 528 |
if( mPositions==null ) |
529 | 529 |
{ |
src/main/java/org/distorted/objectlib/objects/TwistyPyraminx.java | ||
---|---|---|
151 | 151 |
|
152 | 152 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
153 | 153 |
|
154 |
protected int[] getSolvedQuats(int cubit, int[] numLayers)
|
|
154 |
public int[] getSolvedQuats(int cubit, int[] numLayers)
|
|
155 | 155 |
{ |
156 | 156 |
if( mQuats==null ) initializeQuats(); |
157 | 157 |
int status = retCubitSolvedStatus(cubit,numLayers); |
... | ... | |
198 | 198 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
199 | 199 |
// there are (n^3-n)/6 octahedrons and ((n+1)^3 - (n+1))/6 tetrahedrons |
200 | 200 |
|
201 |
protected float[][] getCubitPositions(int[] numLayers)
|
|
201 |
public float[][] getCubitPositions(int[] numLayers)
|
|
202 | 202 |
{ |
203 | 203 |
int numL = numLayers[0]; |
204 | 204 |
int numOcta = (numL-1)*numL*(numL+1)/6; |
... | ... | |
381 | 381 |
|
382 | 382 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
383 | 383 |
|
384 |
protected Static4D getQuat(int cubit, int[] numLayers)
|
|
384 |
public Static4D getQuat(int cubit, int[] numLayers)
|
|
385 | 385 |
{ |
386 | 386 |
if( mQuats==null ) initializeQuats(); |
387 | 387 |
return mQuats[0]; |
src/main/java/org/distorted/objectlib/objects/TwistyRedi.java | ||
---|---|---|
121 | 121 |
|
122 | 122 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
123 | 123 |
|
124 |
protected int[] getSolvedQuats(int cubit, int[] numLayers)
|
|
124 |
public int[] getSolvedQuats(int cubit, int[] numLayers)
|
|
125 | 125 |
{ |
126 | 126 |
if( mQuats==null ) initializeQuats(); |
127 | 127 |
int status = retCubitSolvedStatus(cubit,numLayers); |
... | ... | |
221 | 221 |
|
222 | 222 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
223 | 223 |
|
224 |
protected float[][] getCubitPositions(int[] numLayers)
|
|
224 |
public float[][] getCubitPositions(int[] numLayers)
|
|
225 | 225 |
{ |
226 | 226 |
if( mCenters==null ) |
227 | 227 |
{ |
... | ... | |
333 | 333 |
|
334 | 334 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
335 | 335 |
|
336 |
protected Static4D getQuat(int cubit, int[] numLayers)
|
|
336 |
public Static4D getQuat(int cubit, int[] numLayers)
|
|
337 | 337 |
{ |
338 | 338 |
if( mQuats==null ) initializeQuats(); |
339 | 339 |
|
src/main/java/org/distorted/objectlib/objects/TwistyRex.java | ||
---|---|---|
116 | 116 |
|
117 | 117 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
118 | 118 |
|
119 |
protected int[] getSolvedQuats(int cubit, int[] numLayers)
|
|
119 |
public int[] getSolvedQuats(int cubit, int[] numLayers)
|
|
120 | 120 |
{ |
121 | 121 |
if( mQuats==null ) initializeQuats(); |
122 | 122 |
int status = retCubitSolvedStatus(cubit,numLayers); |
... | ... | |
216 | 216 |
|
217 | 217 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
218 | 218 |
|
219 |
protected float[][] getCubitPositions(int[] numLayers)
|
|
219 |
public float[][] getCubitPositions(int[] numLayers)
|
|
220 | 220 |
{ |
221 | 221 |
final float DIST1= 1.50f; |
222 | 222 |
final float DIST2= (1+2*REX_D)/2; |
... | ... | |
319 | 319 |
|
320 | 320 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
321 | 321 |
|
322 |
protected Static4D getQuat(int cubit, int[] numLayers)
|
|
322 |
public Static4D getQuat(int cubit, int[] numLayers)
|
|
323 | 323 |
{ |
324 | 324 |
if( mQuats==null ) initializeQuats(); |
325 | 325 |
|
src/main/java/org/distorted/objectlib/objects/TwistySkewb.java | ||
---|---|---|
123 | 123 |
|
124 | 124 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
125 | 125 |
|
126 |
protected int[] getSolvedQuats(int cubit, int[] numLayers)
|
|
126 |
public int[] getSolvedQuats(int cubit, int[] numLayers)
|
|
127 | 127 |
{ |
128 | 128 |
if( mQuats==null ) initializeQuats(); |
129 | 129 |
int status = retCubitSolvedStatus(cubit,numLayers); |
... | ... | |
243 | 243 |
|
244 | 244 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
245 | 245 |
|
246 |
protected float[][] getCubitPositions(int[] numLayers)
|
|
246 |
public float[][] getCubitPositions(int[] numLayers)
|
|
247 | 247 |
{ |
248 | 248 |
int numL = numLayers[0]; |
249 | 249 |
final float DIST_CORNER = numL-1; |
... | ... | |
372 | 372 |
|
373 | 373 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
374 | 374 |
|
375 |
protected Static4D getQuat(int cubit, int[] numLayers)
|
|
375 |
public Static4D getQuat(int cubit, int[] numLayers)
|
|
376 | 376 |
{ |
377 | 377 |
if( mQuats==null ) initializeQuats(); |
378 | 378 |
|
src/main/java/org/distorted/objectlib/objects/TwistySquare1.java | ||
---|---|---|
78 | 78 |
|
79 | 79 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
80 | 80 |
|
81 |
protected int[] getSolvedQuats(int cubit, int[] numLayers)
|
|
81 |
public int[] getSolvedQuats(int cubit, int[] numLayers)
|
|
82 | 82 |
{ |
83 | 83 |
if( mQuats==null ) initializeQuats(); |
84 | 84 |
int status = retCubitSolvedStatus(cubit,numLayers); |
... | ... | |
188 | 188 |
|
189 | 189 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
190 | 190 |
|
191 |
protected Static4D getQuat(int cubit, int[] numLayers)
|
|
191 |
public Static4D getQuat(int cubit, int[] numLayers)
|
|
192 | 192 |
{ |
193 | 193 |
if( mQuats==null ) initializeQuats(); |
194 | 194 |
if( mQuatNumber ==null ) |
... | ... | |
274 | 274 |
|
275 | 275 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
276 | 276 |
|
277 |
protected float[][] getCubitPositions(int[] numLayers)
|
|
277 |
public float[][] getCubitPositions(int[] numLayers)
|
|
278 | 278 |
{ |
279 | 279 |
if( mCenters==null ) |
280 | 280 |
{ |
src/main/java/org/distorted/objectlib/objects/TwistySquare2.java | ||
---|---|---|
89 | 89 |
|
90 | 90 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
91 | 91 |
|
92 |
protected int[] getSolvedQuats(int cubit, int[] numLayers)
|
|
92 |
public int[] getSolvedQuats(int cubit, int[] numLayers)
|
|
93 | 93 |
{ |
94 | 94 |
return null; |
95 | 95 |
} |
... | ... | |
191 | 191 |
|
192 | 192 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
193 | 193 |
|
194 |
protected Static4D getQuat(int cubit, int[] numLayers)
|
|
194 |
public Static4D getQuat(int cubit, int[] numLayers)
|
|
195 | 195 |
{ |
196 | 196 |
if( mQuats==null ) initializeQuats(); |
197 | 197 |
|
... | ... | |
279 | 279 |
|
280 | 280 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
281 | 281 |
|
282 |
protected float[][] getCubitPositions(int[] numLayers)
|
|
282 |
public float[][] getCubitPositions(int[] numLayers)
|
|
283 | 283 |
{ |
284 | 284 |
if( mCenters ==null ) |
285 | 285 |
{ |
src/main/java/org/distorted/objectlib/objects/TwistyUltimate.java | ||
---|---|---|
123 | 123 |
|
124 | 124 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
125 | 125 |
|
126 |
protected int[] getSolvedQuats(int cubit, int[] numLayers)
|
|
126 |
public int[] getSolvedQuats(int cubit, int[] numLayers)
|
|
127 | 127 |
{ |
128 | 128 |
if( mQuats==null ) initializeQuats(); |
129 | 129 |
int status = retCubitSolvedStatus(cubit,numLayers); |
... | ... | |
236 | 236 |
|
237 | 237 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
238 | 238 |
|
239 |
protected Static4D getQuat(int cubit, int[] numLayers)
|
|
239 |
public Static4D getQuat(int cubit, int[] numLayers)
|
|
240 | 240 |
{ |
241 | 241 |
if( mQuats ==null ) initializeQuats(); |
242 | 242 |
if( mQuatIndex ==null ) mQuatIndex = new int[] { 0,6,1,2,0,4,6,5,0,1,4,9,5,2 }; |
... | ... | |
259 | 259 |
|
260 | 260 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
261 | 261 |
|
262 |
protected float[][] getCubitPositions(int[] numLayers)
|
|
262 |
public float[][] getCubitPositions(int[] numLayers)
|
|
263 | 263 |
{ |
264 | 264 |
if( mCenters==null ) |
265 | 265 |
{ |
Also available in: Unified diff
Progress with serializing object to JSON: cubits.
Only faceColorMap remains now.