Revision 7764a67a
Added by Leszek Koltunski about 3 years ago
src/main/java/org/distorted/objects/TwistyKilominx.java | ||
---|---|---|
35 | 35 |
|
36 | 36 |
import static org.distorted.objects.FactoryCubit.COS18; |
37 | 37 |
import static org.distorted.objects.FactoryCubit.COS54; |
38 |
import static org.distorted.objects.FactoryCubit.SIN18; |
|
38 | 39 |
|
39 | 40 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
40 | 41 |
|
41 | 42 |
public class TwistyKilominx extends TwistyMinx |
42 | 43 |
{ |
43 |
private static MeshBase mMesh; |
|
44 |
private static MeshBase[] mCenterMeshes, mCornerMeshes; |
|
45 |
private static MeshBase[][] mEdgeMeshes; |
|
46 |
|
|
47 |
private static final int mNumCornerEdgeVariants; |
|
48 |
|
|
49 |
static |
|
50 |
{ |
|
51 |
int[] sizes = ObjectList.KILO.getSizes(); |
|
52 |
int variants = sizes.length; |
|
53 |
mNumCornerEdgeVariants = sizes[0]==3 ? variants-1 : variants; |
|
54 |
} |
|
44 | 55 |
|
45 | 56 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
46 | 57 |
|
... | ... | |
169 | 180 |
private int computeEdgeType(int cubit, int numCubitsPerCorner, int numCubitsPerEdge) |
170 | 181 |
{ |
171 | 182 |
int part = (cubit - NUM_CORNERS*numCubitsPerCorner) % numCubitsPerEdge; |
172 |
return (part+1)/2;
|
|
183 |
return part - 2*(part/4);
|
|
173 | 184 |
} |
174 | 185 |
|
175 | 186 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
... | ... | |
251 | 262 |
} |
252 | 263 |
|
253 | 264 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
254 |
// TODO |
|
255 | 265 |
|
256 |
private int getQuat(int cubit) |
|
266 |
private int getQuat(int cubit, int numCubitsPerCorner, int numCubitsPerEdge)
|
|
257 | 267 |
{ |
258 |
return ( cubit>=0 && cubit<20 ) ? QUAT_CORNER_INDICES[cubit] : 0; |
|
268 |
if( cubit < NUM_CORNERS*numCubitsPerCorner ) |
|
269 |
{ |
|
270 |
int corner = cubit/numCubitsPerCorner; |
|
271 |
return QUAT_CORNER_INDICES[corner]; |
|
272 |
} |
|
273 |
|
|
274 |
if( cubit < NUM_CORNERS*numCubitsPerCorner + NUM_EDGES*numCubitsPerEdge ) |
|
275 |
{ |
|
276 |
int edge = (cubit-NUM_CORNERS*numCubitsPerCorner)/numCubitsPerEdge; |
|
277 |
return QUAT_EDGE_INDICES[edge]; |
|
278 |
} |
|
279 |
|
|
280 |
if( numCubitsPerCorner==0 ) |
|
281 |
{ |
|
282 |
return QUAT_CORNER_INDICES[cubit]; |
|
283 |
} |
|
284 |
else |
|
285 |
{ |
|
286 |
cubit -= (NUM_CORNERS*numCubitsPerCorner + NUM_EDGES*numCubitsPerEdge); |
|
287 |
int numCubitsPerCenter = 5; |
|
288 |
int face = cubit/numCubitsPerCenter; |
|
289 |
int index= cubit%numCubitsPerCenter; |
|
290 |
int corner=mCenterMap[face][index]; |
|
291 |
|
|
292 |
return QUAT_CORNER_INDICES[corner]; |
|
293 |
} |
|
259 | 294 |
} |
260 | 295 |
|
261 | 296 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
262 |
// TODO |
|
263 | 297 |
|
264 | 298 |
MeshBase createCubitMesh(int cubit, int numLayers) |
265 | 299 |
{ |
266 |
if( mMesh==null ) mMesh = FactoryCubit.getInstance().createKilominxCornerMesh(); |
|
267 |
MeshBase mesh = mMesh.copy(true); |
|
300 |
int numCubitsPerCorner = numCubitsPerCorner(numLayers); |
|
301 |
int numCubitsPerEdge = numCubitsPerEdge(numLayers); |
|
302 |
int[] sizes = ObjectList.KILO.getSizes(); |
|
303 |
int variants = sizes.length; |
|
304 |
int highestSize = sizes[variants-1]; |
|
305 |
int lowestSize = sizes[0]; |
|
306 |
int indexCornerEdge = (numLayers-lowestSize)/2 - (lowestSize==3 ? 1:0); |
|
307 |
MeshBase mesh; |
|
308 |
|
|
309 |
if( mNumCornerEdgeVariants>0 ) |
|
310 |
{ |
|
311 |
if( mCornerMeshes==null ) mCornerMeshes = new MeshBase[mNumCornerEdgeVariants]; |
|
312 |
if( mEdgeMeshes ==null ) mEdgeMeshes = new MeshBase[mNumCornerEdgeVariants][(highestSize-3)/2]; |
|
313 |
} |
|
314 |
|
|
315 |
if( mCenterMeshes==null ) mCenterMeshes = new MeshBase[variants]; |
|
316 |
|
|
317 |
if( cubit < NUM_CORNERS*numCubitsPerCorner ) |
|
318 |
{ |
|
319 |
if( mCornerMeshes[indexCornerEdge]==null ) |
|
320 |
{ |
|
321 |
mCornerMeshes[indexCornerEdge] = FactoryCubit.getInstance().createMinxCornerMesh(ObjectList.KILO,numLayers); |
|
322 |
} |
|
323 |
mesh = mCornerMeshes[indexCornerEdge].copy(true); |
|
324 |
} |
|
325 |
else if( cubit<NUM_CORNERS*numCubitsPerCorner + NUM_EDGES*numCubitsPerEdge ) |
|
326 |
{ |
|
327 |
int type = computeEdgeType(cubit,numCubitsPerCorner,numCubitsPerEdge); // left-top, right-top, left-second, right-second, left-third... |
|
328 |
|
|
329 |
if( mEdgeMeshes[indexCornerEdge][type]==null ) |
|
330 |
{ |
|
331 |
float tmp = (numLayers/3.0f)/(numLayers-1); |
|
332 |
float height= tmp*COS18; |
|
333 |
float width = tmp + type*height*SIN18/COS18; |
|
334 |
|
|
335 |
mEdgeMeshes[indexCornerEdge][type] = FactoryCubit.getInstance().createKilominxEdgeMesh(numLayers,width,height); |
|
336 |
} |
|
337 |
|
|
338 |
mesh = mEdgeMeshes[indexCornerEdge][type].copy(true); |
|
339 |
} |
|
340 |
else |
|
341 |
{ |
|
342 |
int indexCenter = (numLayers-3)/2; |
|
343 |
|
|
344 |
if( mCenterMeshes[indexCenter]==null ) |
|
345 |
{ |
|
346 |
float width = (1+0.5f*(numLayers-3)*SIN18)*(numLayers/3.0f)/(numLayers-1); |
|
347 |
mCenterMeshes[indexCenter] = FactoryCubit.getInstance().createKilominxCenterMesh(width); |
|
348 |
} |
|
349 |
|
|
350 |
mesh = mCenterMeshes[indexCenter].copy(true); |
|
351 |
} |
|
268 | 352 |
|
269 |
MatrixEffectQuaternion quat = new MatrixEffectQuaternion( QUATS[getQuat(cubit)], new Static3D(0,0,0) ); |
|
353 |
Static4D q = QUATS[getQuat(cubit,numCubitsPerCorner,numCubitsPerEdge)]; |
|
354 |
MatrixEffectQuaternion quat = new MatrixEffectQuaternion( q, new Static3D(0,0,0) ); |
|
270 | 355 |
mesh.apply(quat,0xffffffff,0); |
271 | 356 |
|
272 | 357 |
return mesh; |
Also available in: Unified diff
Progress with any size Kilominx.