Revision d38f1397
Added by Leszek Koltunski over 3 years ago
| src/main/java/org/distorted/objects/TwistyMegaminx.java | ||
|---|---|---|
| 43 | 43 |
private static final int NUM_CENTERS = 12; |
| 44 | 44 |
private static final int NUM_EDGES = 30; |
| 45 | 45 |
|
| 46 |
private static final int[][] mFaceVertexMap = |
|
| 46 |
// the five vertices that form a given face. Order: the same as colors |
|
| 47 |
// of the faces in TwistyMinx. |
|
| 48 |
private static final int[][] mCenterMap = |
|
| 47 | 49 |
{
|
| 48 |
{ 0, 12, 8, 10, 16},
|
|
| 49 | 50 |
{ 0, 12, 4, 14, 2},
|
| 50 |
{ 2, 14, 9, 11, 18},
|
|
| 51 | 51 |
{ 0, 2, 18, 6, 16},
|
| 52 |
{ 8, 13, 5, 4, 12},
|
|
| 53 |
{ 4, 5, 15, 9, 14},
|
|
| 54 | 52 |
{ 6, 18, 11, 19, 7},
|
| 55 |
{10, 16, 6, 7, 17},
|
|
| 56 |
{ 1, 13, 8, 10, 17},
|
|
| 57 |
{ 1, 13, 5, 15, 3},
|
|
| 58 | 53 |
{ 3, 15, 9, 11, 19},
|
| 54 |
{ 4, 5, 15, 9, 14},
|
|
| 55 |
{ 1, 13, 5, 15, 3},
|
|
| 59 | 56 |
{ 1, 3, 19, 7, 17},
|
| 57 |
{10, 16, 6, 7, 17},
|
|
| 58 |
{ 0, 12, 8, 10, 16},
|
|
| 59 |
{ 8, 13, 5, 4, 12},
|
|
| 60 |
{ 1, 13, 8, 10, 17},
|
|
| 61 |
{ 2, 14, 9, 11, 18},
|
|
| 60 | 62 |
}; |
| 61 | 63 |
|
| 62 |
private static MeshBase[] mCenterMeshes, mCornerMeshes, mEdgeMeshes; |
|
| 64 |
// the quadruple ( vertex1, vertex2, face1, face2 ) defining an edge. |
|
| 65 |
// In fact the 2 vertices already define it, the faces only provide easy |
|
| 66 |
// way to get to know the colors. Order: arbitrary. Face1 arbitrarily on |
|
| 67 |
// the 'left' or right of vector vertex1 --> vertex2, according to Quat. |
|
| 68 |
private static final int[][] mEdgeMap = |
|
| 69 |
{
|
|
| 70 |
{ 0, 12, 0, 8},
|
|
| 71 |
{ 12, 4, 0, 9},
|
|
| 72 |
{ 4, 14, 0, 4},
|
|
| 73 |
{ 14, 2, 0, 11},
|
|
| 74 |
{ 2, 0, 0, 1},
|
|
| 75 |
{ 14, 9, 4, 11},
|
|
| 76 |
{ 9, 11, 3, 11},
|
|
| 77 |
{ 11, 18, 2, 11},
|
|
| 78 |
{ 18, 2, 1, 11},
|
|
| 79 |
{ 18, 6, 2, 1},
|
|
| 80 |
{ 6, 16, 7, 1},
|
|
| 81 |
{ 16, 0, 8, 1},
|
|
| 82 |
{ 16, 10, 8, 7},
|
|
| 83 |
{ 10, 8, 8, 10},
|
|
| 84 |
{ 8, 12, 8, 9},
|
|
| 85 |
{ 8, 13, 9, 10},
|
|
| 86 |
{ 13, 5, 9, 5},
|
|
| 87 |
{ 5, 4, 9, 4},
|
|
| 88 |
{ 5, 15, 4, 5},
|
|
| 89 |
{ 15, 9, 4, 3},
|
|
| 90 |
{ 11, 19, 2, 3},
|
|
| 91 |
{ 19, 7, 2, 6},
|
|
| 92 |
{ 7, 6, 2, 7},
|
|
| 93 |
{ 7, 17, 7, 6},
|
|
| 94 |
{ 17, 10, 7, 10},
|
|
| 95 |
{ 17, 1, 6, 10},
|
|
| 96 |
{ 1, 3, 6, 4},
|
|
| 97 |
{ 3, 19, 6, 3},
|
|
| 98 |
{ 1, 13, 10, 5},
|
|
| 99 |
{ 3, 15, 5, 3},
|
|
| 100 |
}; |
|
| 63 | 101 |
|
| 64 |
private static final Static4D[] mBasicV, mCurrV;
|
|
| 102 |
private static final float[][] mCenterCoords = new float[NUM_CENTERS][3];
|
|
| 65 | 103 |
|
| 66 | 104 |
static |
| 67 | 105 |
{
|
| 68 |
mBasicV = new Static4D[3]; |
|
| 69 |
mCurrV = new Static4D[3]; |
|
| 106 |
for(int center=0; center<NUM_CENTERS; center++) |
|
| 107 |
{
|
|
| 108 |
int[] map = mCenterMap[center]; |
|
| 109 |
|
|
| 110 |
float x = CORNERS[map[0]].get0() + |
|
| 111 |
CORNERS[map[1]].get0() + |
|
| 112 |
CORNERS[map[2]].get0() + |
|
| 113 |
CORNERS[map[3]].get0() + |
|
| 114 |
CORNERS[map[4]].get0() ; |
|
| 115 |
|
|
| 116 |
float y = CORNERS[map[0]].get1() + |
|
| 117 |
CORNERS[map[1]].get1() + |
|
| 118 |
CORNERS[map[2]].get1() + |
|
| 119 |
CORNERS[map[3]].get1() + |
|
| 120 |
CORNERS[map[4]].get1() ; |
|
| 121 |
|
|
| 122 |
float z = CORNERS[map[0]].get2() + |
|
| 123 |
CORNERS[map[1]].get2() + |
|
| 124 |
CORNERS[map[2]].get2() + |
|
| 125 |
CORNERS[map[3]].get2() + |
|
| 126 |
CORNERS[map[4]].get2() ; |
|
| 127 |
|
|
| 128 |
mCenterCoords[center][0] = x/5; |
|
| 129 |
mCenterCoords[center][1] = y/5; |
|
| 130 |
mCenterCoords[center][2] = z/5; |
|
| 131 |
} |
|
| 132 |
} |
|
| 133 |
|
|
| 134 |
private static MeshBase[] mCenterMeshes, mCornerMeshes; |
|
| 135 |
private static MeshBase[][] mEdgeMeshes; |
|
| 136 |
|
|
| 137 |
private static final Static4D[] mBasicCornerV, mCurrCornerV; |
|
| 70 | 138 |
|
| 71 |
mBasicV[0] = new Static4D( (SQ5+1)*0.125f, (SQ5-1)*0.125f, -0.250f, 0.0f ); |
|
| 72 |
mBasicV[1] = new Static4D(-(SQ5+1)*0.125f, (SQ5-1)*0.125f, -0.250f, 0.0f ); |
|
| 73 |
mBasicV[2] = new Static4D( 0, -0.500f, 0.0f, 0.0f ); |
|
| 139 |
static |
|
| 140 |
{
|
|
| 141 |
mBasicCornerV = new Static4D[3]; |
|
| 142 |
mCurrCornerV = new Static4D[3]; |
|
| 143 |
|
|
| 144 |
mBasicCornerV[0] = new Static4D( (SQ5+1)*0.125f, (SQ5-1)*0.125f, -0.250f, 0.0f ); |
|
| 145 |
mBasicCornerV[1] = new Static4D(-(SQ5+1)*0.125f, (SQ5-1)*0.125f, -0.250f, 0.0f ); |
|
| 146 |
mBasicCornerV[2] = new Static4D( 0, -0.500f, 0.0f, 0.0f ); |
|
| 74 | 147 |
}; |
| 75 | 148 |
|
| 76 | 149 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| ... | ... | |
| 99 | 172 |
|
| 100 | 173 |
int getNumStickerTypes(int numLayers) |
| 101 | 174 |
{
|
| 102 |
return 1; //numLayers; |
|
| 175 |
return numLayers-1; //numLayers;
|
|
| 103 | 176 |
} |
| 104 | 177 |
|
| 105 | 178 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| ... | ... | |
| 129 | 202 |
|
| 130 | 203 |
private void computeCenter(Static3D[] array, int center) |
| 131 | 204 |
{
|
| 132 |
int[] map = mFaceVertexMap[center]; |
|
| 133 |
|
|
| 134 |
float x = CORNERS[map[0]].get0() + |
|
| 135 |
CORNERS[map[1]].get0() + |
|
| 136 |
CORNERS[map[2]].get0() + |
|
| 137 |
CORNERS[map[3]].get0() + |
|
| 138 |
CORNERS[map[4]].get0() ; |
|
| 139 |
|
|
| 140 |
float y = CORNERS[map[0]].get1() + |
|
| 141 |
CORNERS[map[1]].get1() + |
|
| 142 |
CORNERS[map[2]].get1() + |
|
| 143 |
CORNERS[map[3]].get1() + |
|
| 144 |
CORNERS[map[4]].get1() ; |
|
| 145 |
|
|
| 146 |
float z = CORNERS[map[0]].get2() + |
|
| 147 |
CORNERS[map[1]].get2() + |
|
| 148 |
CORNERS[map[2]].get2() + |
|
| 149 |
CORNERS[map[3]].get2() + |
|
| 150 |
CORNERS[map[4]].get2() ; |
|
| 151 |
|
|
| 152 |
array[center].set(x/5,y/5,z/5); |
|
| 205 |
float[] coords = mCenterCoords[center]; |
|
| 206 |
array[center].set( coords[0], coords[1], coords[2]); |
|
| 153 | 207 |
} |
| 154 | 208 |
|
| 155 | 209 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 156 |
// Fill out mCurr{X,Y,Z} by applying appropriate Quat to mBasic{X,Y,Z}
|
|
| 210 |
// Fill out mCurrCorner{X,Y,Z} by applying appropriate Quat to mBasicCorner{X,Y,Z}
|
|
| 157 | 211 |
// Appropriate one: QUATS[QUAT_INDICES[corner]]. |
| 158 | 212 |
|
| 159 |
private void computeBasicVectors(int corner) |
|
| 213 |
private void computeBasicCornerVectors(int corner)
|
|
| 160 | 214 |
{
|
| 161 |
Static4D quat = QUATS[QUAT_INDICES[corner]]; |
|
| 215 |
Static4D quat = QUATS[QUAT_CORNER_INDICES[corner]];
|
|
| 162 | 216 |
|
| 163 |
mCurrV[0] = RubikSurfaceView.rotateVectorByQuat(mBasicV[0],quat);
|
|
| 164 |
mCurrV[1] = RubikSurfaceView.rotateVectorByQuat(mBasicV[1],quat);
|
|
| 165 |
mCurrV[2] = RubikSurfaceView.rotateVectorByQuat(mBasicV[2],quat);
|
|
| 217 |
mCurrCornerV[0] = RubikSurfaceView.rotateVectorByQuat(mBasicCornerV[0],quat);
|
|
| 218 |
mCurrCornerV[1] = RubikSurfaceView.rotateVectorByQuat(mBasicCornerV[1],quat);
|
|
| 219 |
mCurrCornerV[2] = RubikSurfaceView.rotateVectorByQuat(mBasicCornerV[2],quat);
|
|
| 166 | 220 |
} |
| 167 | 221 |
|
| 168 | 222 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| ... | ... | |
| 182 | 236 |
int N = (numCubitsPerCorner-1)/3; |
| 183 | 237 |
int block = (part-1) % N; |
| 184 | 238 |
int index = (part-1) / N; |
| 185 |
Static4D pri = mCurrV[index]; |
|
| 186 |
Static4D sec = mCurrV[(index+2)%3]; |
|
| 239 |
Static4D pri = mCurrCornerV[index];
|
|
| 240 |
Static4D sec = mCurrCornerV[(index+2)%3];
|
|
| 187 | 241 |
|
| 188 | 242 |
int multP = (block % ((numLayers-3)/2)) + 1; |
| 189 | 243 |
int multS = (block / ((numLayers-3)/2)); |
| ... | ... | |
| 195 | 249 |
} |
| 196 | 250 |
|
| 197 | 251 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 198 |
// TODO |
|
| 199 | 252 |
|
| 200 |
private void computeEdge(Static3D pos, int edge, int part)
|
|
| 253 |
private int computeEdgeType(int cubit, int numCubitsPerCorner, int numCubitsPerEdge)
|
|
| 201 | 254 |
{
|
| 255 |
int part = (cubit - NUM_CORNERS*numCubitsPerCorner) % numCubitsPerEdge; |
|
| 256 |
return (part+1)/2; |
|
| 257 |
} |
|
| 202 | 258 |
|
| 259 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 260 |
|
|
| 261 |
private void computeEdge(Static3D pos, int numLayers, int edge, int part) |
|
| 262 |
{
|
|
| 263 |
Static3D c1 = CORNERS[ mEdgeMap[edge][0] ]; |
|
| 264 |
Static3D c2 = CORNERS[ mEdgeMap[edge][1] ]; |
|
| 265 |
float x = (c1.get0() + c2.get0())/2; |
|
| 266 |
float y = (c1.get1() + c2.get1())/2; |
|
| 267 |
float z = (c1.get2() + c2.get2())/2; |
|
| 268 |
|
|
| 269 |
if( part==0 ) |
|
| 270 |
{
|
|
| 271 |
pos.set(x,y,z); |
|
| 272 |
} |
|
| 273 |
else |
|
| 274 |
{
|
|
| 275 |
int mult = (part+1)/2; |
|
| 276 |
int dir = (part+1)%2; |
|
| 277 |
float[] center = mCenterCoords[ mEdgeMap[edge][dir+2] ]; |
|
| 278 |
|
|
| 279 |
float vX = center[0]-x; |
|
| 280 |
float vY = center[1]-y; |
|
| 281 |
float vZ = center[2]-z; |
|
| 282 |
|
|
| 283 |
float A = mult*(0.5f-MEGA_D)/((1+SQ5/5)*(numLayers-1)); |
|
| 284 |
|
|
| 285 |
pos.set( x+A*vX, y+A*vY, z+A*vZ ); |
|
| 286 |
} |
|
| 203 | 287 |
} |
| 204 | 288 |
|
| 205 | 289 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| ... | ... | |
| 207 | 291 |
Static3D[] getCubitPositions(int numLayers) |
| 208 | 292 |
{
|
| 209 | 293 |
int numCubitsPerCorner = numCubitsPerCorner(numLayers); |
| 210 |
// int numCubitsPerEdge = numCubitsPerEdge(numLayers);
|
|
| 211 |
int numCubits = NUM_CORNERS*numCubitsPerCorner ;//+ NUM_EDGES*numCubitsPerEdge + NUM_CENTERS;
|
|
| 294 |
int numCubitsPerEdge = numCubitsPerEdge(numLayers); |
|
| 295 |
int numCubits = NUM_CORNERS*numCubitsPerCorner + NUM_EDGES*numCubitsPerEdge;// + NUM_CENTERS;
|
|
| 212 | 296 |
int index=0; |
| 213 | 297 |
|
| 214 | 298 |
final Static3D[] CENTERS = new Static3D[numCubits]; |
| 215 | 299 |
|
| 216 | 300 |
for(int corner=0; corner<NUM_CORNERS; corner++) |
| 217 | 301 |
{
|
| 218 |
computeBasicVectors(corner); |
|
| 302 |
computeBasicCornerVectors(corner);
|
|
| 219 | 303 |
|
| 220 | 304 |
for(int part=0; part<numCubitsPerCorner; part++, index++) |
| 221 | 305 |
{
|
| ... | ... | |
| 223 | 307 |
computeCorner(CENTERS[index],numCubitsPerCorner,numLayers,corner,part); |
| 224 | 308 |
} |
| 225 | 309 |
} |
| 226 |
/* |
|
| 310 |
|
|
| 227 | 311 |
for(int edge=0; edge<NUM_EDGES; edge++) |
| 228 | 312 |
{
|
| 229 | 313 |
for(int part=0; part<numCubitsPerEdge; part++, index++) |
| 230 | 314 |
{
|
| 231 |
computeEdge(CENTERS,index, edge, part ); |
|
| 315 |
CENTERS[index] = new Static3D(0,0,0); |
|
| 316 |
computeEdge(CENTERS[index], numLayers, edge, part ); |
|
| 232 | 317 |
} |
| 233 | 318 |
} |
| 234 |
|
|
| 319 |
/* |
|
| 235 | 320 |
for(int center=0; center<NUM_CENTERS; center++, index++) |
| 236 | 321 |
{
|
| 237 | 322 |
computeCenter(CENTERS,index); |
| ... | ... | |
| 249 | 334 |
if( cubit < NUM_CORNERS*numCubitsPerCorner ) |
| 250 | 335 |
{
|
| 251 | 336 |
int corner = cubit/numCubitsPerCorner; |
| 252 |
return QUAT_INDICES[corner]; |
|
| 253 |
} |
|
| 254 |
/* |
|
| 255 |
if( cubit < NUM_CENTERS + NUM_CORNERS*numCubitsPerCorner ) |
|
| 256 |
{
|
|
| 257 |
switch(cubit-NUM_CORNERS*numCubitsPerCorner) |
|
| 258 |
{
|
|
| 259 |
case 0: return 0; |
|
| 260 |
case 1: return 52; |
|
| 261 |
case 2: return 3; |
|
| 262 |
case 3: return 53; |
|
| 263 |
case 4: return 59; |
|
| 264 |
case 5: return 20; |
|
| 265 |
case 6: return 22; |
|
| 266 |
case 7: return 58; |
|
| 267 |
case 8: return 55; |
|
| 268 |
case 9: return 13; |
|
| 269 |
case 10: return 1; |
|
| 270 |
case 11: return 14; |
|
| 271 |
} |
|
| 337 |
return QUAT_CORNER_INDICES[corner]; |
|
| 272 | 338 |
} |
| 273 | 339 |
|
| 274 | 340 |
int numCubitsPerEdge = numCubitsPerEdge(numLayers); |
| 275 | 341 |
|
| 276 |
// TODO: edges |
|
| 342 |
if( cubit < NUM_CORNERS*numCubitsPerCorner + NUM_EDGES*numCubitsPerEdge ) |
|
| 343 |
{
|
|
| 344 |
int edge = (cubit-NUM_CORNERS*numCubitsPerCorner)/numCubitsPerEdge; |
|
| 345 |
return QUAT_EDGE_INDICES[edge]; |
|
| 346 |
} |
|
| 347 |
|
|
| 348 |
/* |
|
| 349 |
else |
|
| 350 |
{
|
|
| 351 |
// TODO: centers |
|
| 352 |
} |
|
| 277 | 353 |
*/ |
| 354 |
|
|
| 278 | 355 |
return 0; |
| 279 | 356 |
} |
| 280 | 357 |
|
| ... | ... | |
| 285 | 362 |
int numCubitsPerCorner = numCubitsPerCorner(numLayers); |
| 286 | 363 |
int numCubitsPerEdge = numCubitsPerEdge(numLayers); |
| 287 | 364 |
int index = (numLayers-3)/2; |
| 365 |
int variants = ObjectList.MEGA.getNumVariants(); |
|
| 288 | 366 |
MeshBase mesh; |
| 289 | 367 |
|
| 290 |
if( mCornerMeshes==null ) mCornerMeshes = new MeshBase[ObjectList.MEGA.getNumVariants()]; |
|
| 368 |
if( mCornerMeshes==null ) mCornerMeshes = new MeshBase[variants]; |
|
| 369 |
if( mEdgeMeshes ==null ) mEdgeMeshes = new MeshBase[variants][index+1]; |
|
| 291 | 370 |
|
| 292 |
// if( cubit < NUM_CORNERS*numCubitsPerCorner )
|
|
| 371 |
if( cubit < NUM_CORNERS*numCubitsPerCorner ) |
|
| 293 | 372 |
{
|
| 294 |
if( mCornerMeshes[index]==null ) mCornerMeshes[index] = FactoryCubit.getInstance().createMegaminxCornerMesh(numLayers); |
|
| 373 |
if( mCornerMeshes[index]==null ) |
|
| 374 |
{
|
|
| 375 |
mCornerMeshes[index] = FactoryCubit.getInstance().createMegaminxCornerMesh(numLayers); |
|
| 376 |
} |
|
| 295 | 377 |
mesh = mCornerMeshes[index].copy(true); |
| 296 | 378 |
} |
| 297 |
/* |
|
| 298 |
else if( cubit<NUM_CENTERS + NUM_CORNERS*numCubitsPerCorner ) |
|
| 379 |
else //if( cubit<NUM_CORNERS*numCubitsPerCorner + NUM_EDGES*numCubitsPerEdge ) |
|
| 299 | 380 |
{
|
| 300 |
if( mCornerMesh==null ) mCornerMesh = FactoryCubit.getInstance().createMegaminxCenterMesh(); |
|
| 301 |
mesh = mCornerMesh.copy(true); |
|
| 381 |
int type = computeEdgeType(cubit,numCubitsPerCorner,numCubitsPerEdge); |
|
| 382 |
|
|
| 383 |
if( mEdgeMeshes[index][type]==null ) |
|
| 384 |
{
|
|
| 385 |
mEdgeMeshes[index][type] = FactoryCubit.getInstance().createMegaminxEdgeMesh(index,type); |
|
| 386 |
} |
|
| 387 |
|
|
| 388 |
mesh = mEdgeMeshes[index][type].copy(true); |
|
| 302 | 389 |
} |
| 390 |
/* |
|
| 303 | 391 |
else |
| 304 | 392 |
{
|
| 305 |
if( mEdgeMesh==null ) mEdgeMesh = new MeshBase[(numLayers-1)/2]; |
|
| 306 |
|
|
| 307 |
// TODO |
|
| 393 |
// TODO: centers |
|
| 308 | 394 |
} |
| 309 | 395 |
*/ |
| 310 | 396 |
MatrixEffectQuaternion quat = new MatrixEffectQuaternion( QUATS[getQuat(cubit,numLayers)], new Static3D(0,0,0) ); |
| ... | ... | |
| 314 | 400 |
} |
| 315 | 401 |
|
| 316 | 402 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 317 |
// TODO |
|
| 318 | 403 |
|
| 319 |
int getFaceColor(int cubit, int cubitface, int numLayers)
|
|
| 404 |
int getCornerColor(int cubit, int cubitface, int numLayers, int numCubitsPerCorner)
|
|
| 320 | 405 |
{
|
| 321 | 406 |
if( cubitface<0 || cubitface>2 ) return NUM_TEXTURES*NUM_FACES; |
| 322 | 407 |
|
| 323 |
int numCubitsPerCorner = numCubitsPerCorner(numLayers); |
|
| 324 | 408 |
int part = cubit % numCubitsPerCorner; |
| 325 | 409 |
int corner= cubit / numCubitsPerCorner; |
| 326 | 410 |
|
| ... | ... | |
| 357 | 441 |
return NUM_TEXTURES*NUM_FACES; |
| 358 | 442 |
} |
| 359 | 443 |
|
| 444 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 445 |
|
|
| 446 |
int getEdgeColor(int cubit, int cubitface, int numLayers, int numCubitsPerCorner, int numCubitsPerEdge) |
|
| 447 |
{
|
|
| 448 |
if( cubitface<0 || cubitface>1 ) return NUM_TEXTURES*NUM_FACES; |
|
| 449 |
|
|
| 450 |
int part = (cubit - NUM_CORNERS*numCubitsPerCorner) % numCubitsPerEdge; |
|
| 451 |
int edge = (cubit - NUM_CORNERS*numCubitsPerCorner) / numCubitsPerEdge; |
|
| 452 |
|
|
| 453 |
if( part==0 ) |
|
| 454 |
{
|
|
| 455 |
return mEdgeMap[edge][cubitface+2]; |
|
| 456 |
} |
|
| 457 |
|
|
| 458 |
return cubitface==((part+1)%2) ? mEdgeMap[edge][cubitface+2] : NUM_TEXTURES*NUM_FACES; |
|
| 459 |
} |
|
| 460 |
|
|
| 461 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 462 |
// TODO |
|
| 463 |
|
|
| 464 |
int getCenterColor(int cubit, int cubitface, int numLayers) |
|
| 465 |
{
|
|
| 466 |
return 0; |
|
| 467 |
} |
|
| 468 |
|
|
| 469 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 470 |
|
|
| 471 |
int getFaceColor(int cubit, int cubitface, int numLayers) |
|
| 472 |
{
|
|
| 473 |
int numCubitsPerCorner = numCubitsPerCorner(numLayers); |
|
| 474 |
int numCubitsPerEdge = numCubitsPerEdge(numLayers); |
|
| 475 |
|
|
| 476 |
if( cubit < NUM_CORNERS*numCubitsPerCorner ) |
|
| 477 |
{
|
|
| 478 |
return getCornerColor(cubit,cubitface,numLayers,numCubitsPerCorner); |
|
| 479 |
} |
|
| 480 |
else if( cubit<NUM_CORNERS*numCubitsPerCorner + NUM_EDGES*numCubitsPerEdge ) |
|
| 481 |
{
|
|
| 482 |
return getEdgeColor(cubit,cubitface,numLayers,numCubitsPerCorner,numCubitsPerEdge); |
|
| 483 |
} |
|
| 484 |
else |
|
| 485 |
{
|
|
| 486 |
return getCenterColor(cubit,cubitface,numLayers); |
|
| 487 |
} |
|
| 488 |
} |
|
| 489 |
|
|
| 360 | 490 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 361 | 491 |
// TODO |
| 362 | 492 |
|
| 363 | 493 |
void createFaceTexture(Canvas canvas, Paint paint, int face, int left, int top) |
| 364 | 494 |
{
|
| 365 |
paint.setColor(FACE_COLORS[face]); |
|
| 495 |
paint.setColor(FACE_COLORS[face%NUM_FACES]);
|
|
| 366 | 496 |
paint.setStyle(Paint.Style.FILL); |
| 367 | 497 |
canvas.drawRect(left,top,left+TEXTURE_HEIGHT,top+TEXTURE_HEIGHT,paint); |
| 368 | 498 |
} |
Also available in: Unified diff
Progress with Megaminx.