/src/main/java/org/distorted/objectlib/objects/TwistyCoinTetrahedron.java - Annotate - TwistyPuzzleLib - Distorted Android

distorted-objectlib / src / main / java / org / distorted / objectlib / objects / TwistyCoinTetrahedron.java @ 8f5116ec

1	4f629c09	Leszek Koltunski	///////////////////////////////////////////////////////////////////////////////////////////////////
2	03410dc1	Leszek Koltunski	// Copyright 2023 Leszek Koltunski //
3	4f629c09	Leszek Koltunski	// //
4			// This file is part of Magic Cube. //
5			// //
6			// Magic Cube is proprietary software licensed under an EULA which you should have received //
7			// along with the code. If not, check https://distorted.org/magic/License-Magic-Cube.html //
8			///////////////////////////////////////////////////////////////////////////////////////////////////
9
10			package org.distorted.objectlib.objects;
11
12			import static org.distorted.objectlib.touchcontrol.TouchControl.TC_TETRAHEDRON;
13			import static org.distorted.objectlib.touchcontrol.TouchControl.TYPE_SPLIT_EDGE_COIN;
14
15	aacf5e27	Leszek Koltunski	import org.distorted.library.helpers.QuatHelper;
16	4f629c09	Leszek Koltunski	import org.distorted.library.type.Static3D;
17			import org.distorted.library.type.Static4D;
18			import org.distorted.objectlib.helpers.FactoryCubit;
19			import org.distorted.objectlib.helpers.ObjectFaceShape;
20			import org.distorted.objectlib.helpers.ObjectShape;
21	ae9d9227	leszek	import org.distorted.objectlib.metadata.Metadata;
22	4f629c09	Leszek Koltunski	import org.distorted.objectlib.helpers.ObjectVertexEffects;
23			import org.distorted.objectlib.main.InitAssets;
24	361fd0de	leszek	import org.distorted.objectlib.metadata.ListObjects;
25	4f629c09	Leszek Koltunski	import org.distorted.objectlib.scrambling.ScrambleEdgeGenerator;
26	768149e8	Leszek Koltunski	import org.distorted.objectlib.shape.ShapeTetrahedron;
27	4f629c09	Leszek Koltunski	import org.distorted.objectlib.touchcontrol.TouchControlTetrahedron;
28
29			///////////////////////////////////////////////////////////////////////////////////////////////////
30
31	768149e8	Leszek Koltunski	public class TwistyCoinTetrahedron extends ShapeTetrahedron
32	4f629c09	Leszek Koltunski	{
33			static final Static3D[] ROT_AXIS = new Static3D[]
34			{
35			new Static3D( 0,-SQ3/3,-SQ6/3),
36			new Static3D( 0,-SQ3/3, SQ6/3),
37			new Static3D( SQ6/3, SQ3/3, 0),
38			new Static3D(-SQ6/3, SQ3/3, 0),
39			};
40
41	b480f4dd	Leszek Koltunski	private static final int N = 5;
42
43	4f629c09	Leszek Koltunski	private int[][] mEdges;
44			private int[][] mBasicAngle;
45			private float[][] mCuts;
46			private float[][] mPosition;
47	b480f4dd	Leszek Koltunski	private int[] mQuatIndex;
48	acf2a9e1	Leszek Koltunski	private boolean[][] mRotatable;
49	b480f4dd	Leszek Koltunski
50			private float[][] V,M,L;
51	4f629c09	Leszek Koltunski
52			///////////////////////////////////////////////////////////////////////////////////////////////////
53
54	ae9d9227	leszek	public TwistyCoinTetrahedron(int iconMode, Static4D quat, Static3D move, float scale, Metadata meta, InitAssets asset)
55	4f629c09	Leszek Koltunski	{
56	ae9d9227	leszek	super(iconMode, meta.getNumLayers()[0], quat, move, scale, meta, asset);
57	4f629c09	Leszek Koltunski	}
58
59	a70b1e96	Leszek Koltunski	///////////////////////////////////////////////////////////////////////////////////////////////////
60
61			@Override
62			public float[][] returnRotationFactor()
63			{
64			float C1 = 1.0f;
65			float C2 = 1.7f;
66			float[] f = new float[] { C1,C1,C2 };
67			return new float[][] { f,f,f,f };
68			}
69
70	731a57a6	leszek	///////////////////////////////////////////////////////////////////////////////////////////////////
71
72			@Override
73			protected float[][][] getStickerStrokes()
74			{
75			boolean icon = isInIconMode();
76
77			float S1 = icon ? 0.15f : 0.13f;
78			float S2 = icon ? 0.15f : 0.20f;
79			float S3 = icon ? 0.15f : 0.20f;
80
81			return new float[][][] { {{ S1,S1,S1,S1,S1 }} , {{S2,S2,S2}} , {{S3,S3}} };
82			}
83
84			///////////////////////////////////////////////////////////////////////////////////////////////////
85
86			@Override
87			protected float[][][] getStickerRadii()
88			{
89			float R = 0.12f;
90			return new float[][][] { {{ 0,R,0,0,0 }} , {{0,0,0}} , {{0,0}} };
91			}
92
93			///////////////////////////////////////////////////////////////////////////////////////////////////
94
95			@Override
96			public int[][] getScrambleAlgorithms()
97			{
98			setUpRotatable();
99			return ScrambleEdgeGenerator.getScramblingAlgorithms(mBasicAngle, mRotatable);
100			}
101
102	4f629c09	Leszek Koltunski	///////////////////////////////////////////////////////////////////////////////////////////////////
103
104			public int[][] getScrambleEdges()
105			{
106	acf2a9e1	Leszek Koltunski	if( mEdges==null )
107			{
108	91bb7d90	Leszek Koltunski	mEdges = new int[][]
109			{
110			{ 2,1,3,1, 6,1,7,1, 10,1,11,1, 14,1,15,1}, // tips
111			{ 0,0,1,0, 4,0,5,0, 8,0, 9,0, 12,0,13,0}, // centers
112			};
113	acf2a9e1	Leszek Koltunski	}
114
115	4f629c09	Leszek Koltunski	return mEdges;
116			}
117
118			///////////////////////////////////////////////////////////////////////////////////////////////////
119
120			public float[][] getCuts(int[] numLayers)
121			{
122			if( mCuts==null )
123			{
124	a1b74688	leszek	float[] cut = new float[] { -0.620f,0.600f };
125	4f629c09	Leszek Koltunski	mCuts = new float[][] { cut,cut,cut,cut };
126			}
127
128			return mCuts;
129			}
130
131	acf2a9e1	Leszek Koltunski	///////////////////////////////////////////////////////////////////////////////////////////////////
132
133			private void setUpRotatable()
134			{
135			if( mRotatable==null )
136			{
137			boolean[] tmp = new boolean[] {true,false,true};
138			mRotatable = new boolean[][] { tmp,tmp,tmp,tmp };
139			}
140			}
141
142	4f629c09	Leszek Koltunski	///////////////////////////////////////////////////////////////////////////////////////////////////
143
144			public boolean[][] getLayerRotatable(int[] numLayers)
145			{
146	acf2a9e1	Leszek Koltunski	setUpRotatable();
147			return mRotatable;
148	4f629c09	Leszek Koltunski	}
149
150			///////////////////////////////////////////////////////////////////////////////////////////////////
151
152			public int getTouchControlType()
153			{
154			return TC_TETRAHEDRON;
155			}
156
157			///////////////////////////////////////////////////////////////////////////////////////////////////
158
159			public int getTouchControlSplit()
160			{
161			return TYPE_SPLIT_EDGE_COIN;
162			}
163
164			///////////////////////////////////////////////////////////////////////////////////////////////////
165
166			public int[][][] getEnabled()
167			{
168			return new int[][][]
169			{
170	720b26cd	Leszek Koltunski	{{0},{0},{0},{1},{2},{3}},
171			{{1},{1},{1},{0},{3},{2}},
172	4f629c09	Leszek Koltunski	{{2},{2},{2},{3},{1},{0}},
173			{{3},{3},{3},{2},{0},{1}}
174			};
175			}
176
177			///////////////////////////////////////////////////////////////////////////////////////////////////
178
179			public float[] getDist3D(int[] numLayers)
180			{
181			return TouchControlTetrahedron.D3D;
182			}
183
184			///////////////////////////////////////////////////////////////////////////////////////////////////
185
186			public Static3D[] getFaceAxis()
187			{
188			return TouchControlTetrahedron.FACE_AXIS;
189			}
190
191	b480f4dd	Leszek Koltunski	///////////////////////////////////////////////////////////////////////////////////////////////////
192
193			private void initVertices()
194			{
195			V = new float[][]
196			{
197			{ 0.0f,-0.75f*SQ2,-1.5f},
198			{ 0.0f,-0.75f*SQ2, 1.5f},
199			{ 1.5f, 0.75f*SQ2, 0.0f},
200			{-1.5f, 0.75f*SQ2, 0.0f},
201			};
202
203			M = new float[4][3];
204
205			for(int i=0; i<4; i++)
206			for(int j=0; j<3; j++)
207	a1b74688	leszek	M[i][j] = (V[0][j]+V[1][j]+V[2][j]+V[3][j]-V[i][j])/3;
208	b480f4dd	Leszek Koltunski
209	a1b74688	leszek	final float B = 0.492f;
210	b480f4dd	Leszek Koltunski	L = new float[12][3];
211
212			for(int i=0; i<3; i++)
213			{
214	a1b74688	leszek	L[ 0][i] = BV[1][i] + (1-B)(V[2][i] + V[3][i])/2;
215			L[ 1][i] = BV[3][i] + (1-B)(V[1][i] + V[2][i])/2;
216			L[ 2][i] = BV[2][i] + (1-B)(V[1][i] + V[3][i])/2;
217			L[ 3][i] = BV[0][i] + (1-B)(V[2][i] + V[3][i])/2;
218			L[ 4][i] = BV[2][i] + (1-B)(V[0][i] + V[3][i])/2;
219			L[ 5][i] = BV[3][i] + (1-B)(V[0][i] + V[2][i])/2;
220			L[ 6][i] = BV[3][i] + (1-B)(V[1][i] + V[0][i])/2;
221			L[ 7][i] = BV[0][i] + (1-B)(V[1][i] + V[3][i])/2;
222			L[ 8][i] = BV[1][i] + (1-B)(V[0][i] + V[3][i])/2;
223			L[ 9][i] = BV[2][i] + (1-B)(V[1][i] + V[0][i])/2;
224			L[10][i] = BV[0][i] + (1-B)(V[1][i] + V[2][i])/2;
225			L[11][i] = BV[1][i] + (1-B)(V[0][i] + V[2][i])/2;
226	b480f4dd	Leszek Koltunski	}
227			}
228
229	4f629c09	Leszek Koltunski	///////////////////////////////////////////////////////////////////////////////////////////////////
230
231			public float[][] getCubitPositions(int[] numLayers)
232			{
233			if( mPosition==null )
234			{
235	b480f4dd	Leszek Koltunski	if( V==null ) initVertices();
236
237	768149e8	Leszek Koltunski	float A = -0.016f;
238	a1b74688	leszek	float B = 1.06f;
239	166e4113	Leszek Koltunski	float[] r0 = new float[] { A(V[0][0]-M[0][0]), A(V[0][1]-M[0][1]), A*(V[0][2]-M[0][2]) };
240			float[] r1 = new float[] { A(V[1][0]-M[1][0]), A(V[1][1]-M[1][1]), A*(V[1][2]-M[1][2]) };
241			float[] r2 = new float[] { A(V[2][0]-M[2][0]), A(V[2][1]-M[2][1]), A*(V[2][2]-M[2][2]) };
242			float[] r3 = new float[] { A(V[3][0]-M[3][0]), A(V[3][1]-M[3][1]), A*(V[3][2]-M[3][2]) };
243
244	4f629c09	Leszek Koltunski	mPosition = new float[][]
245			{
246	b480f4dd	Leszek Koltunski	{V[1][0],V[1][1],V[1][2]},
247			{V[0][0],V[0][1],V[0][2]},
248			{V[2][0],V[2][1],V[2][2]},
249			{V[3][0],V[3][1],V[3][2]},
250
251	a1b74688	leszek	{BM[0][0],BM[0][1],B*M[0][2]},
252			{BM[1][0],BM[1][1],B*M[1][2]},
253			{BM[2][0],BM[2][1],B*M[2][2]},
254			{BM[3][0],BM[3][1],B*M[3][2]},
255	b480f4dd	Leszek Koltunski
256	166e4113	Leszek Koltunski	{L[ 0][0] +r0[0],L[ 0][1] +r0[1],L[ 0][2] +r0[2]},
257			{L[ 1][0] +r0[0],L[ 1][1] +r0[1],L[ 1][2] +r0[2]},
258			{L[ 2][0] +r0[0],L[ 2][1] +r0[1],L[ 2][2] +r0[2]},
259			{L[ 3][0] +r1[0],L[ 3][1] +r1[1],L[ 3][2] +r1[2]},
260			{L[ 4][0] +r1[0],L[ 4][1] +r1[1],L[ 4][2] +r1[2]},
261			{L[ 5][0] +r1[0],L[ 5][1] +r1[1],L[ 5][2] +r1[2]},
262			{L[ 6][0] +r2[0],L[ 6][1] +r2[1],L[ 6][2] +r2[2]},
263			{L[ 7][0] +r2[0],L[ 7][1] +r2[1],L[ 7][2] +r2[2]},
264			{L[ 8][0] +r2[0],L[ 8][1] +r2[1],L[ 8][2] +r2[2]},
265			{L[ 9][0] +r3[0],L[ 9][1] +r3[1],L[ 9][2] +r3[2]},
266			{L[10][0] +r3[0],L[10][1] +r3[1],L[10][2] +r3[2]},
267			{L[11][0] +r3[0],L[11][1] +r3[1],L[11][2] +r3[2]},
268	4f629c09	Leszek Koltunski	};
269			}
270
271			return mPosition;
272			}
273
274			///////////////////////////////////////////////////////////////////////////////////////////////////
275
276			public Static4D getCubitQuats(int cubit, int[] numLayers)
277			{
278	b480f4dd	Leszek Koltunski	if( mQuatIndex==null ) mQuatIndex = new int[] {0,6,1,2,
279			0,5,4,3,
280			0,2,1,10,8,5,11,7,4,9,6,3 };
281			return mObjectQuats[mQuatIndex[cubit]];
282			}
283
284			///////////////////////////////////////////////////////////////////////////////////////////////////
285
286			private float[] rotateVertices(float angle, float[] vector, float[] center, float[] rotAxis)
287			{
288			float[] ret = new float[4];
289			float sin = (float)Math.sin(angle/2);
290			float cos = (float)Math.cos(angle/2);
291			float[] quat= new float[] { sinrotAxis[0], sinrotAxis[1], sin*rotAxis[2], cos};
292			QuatHelper.rotateVectorByQuat(ret,vector,quat);
293
294			ret[0] += center[0];
295			ret[1] += center[1];
296			ret[2] += center[2];
297
298			return ret;
299			}
300
301			///////////////////////////////////////////////////////////////////////////////////////////////////
302
303			private void normalize(float[] v)
304			{
305			float len = (float)Math.sqrt(v[0]v[0] + v[1]v[1] + v[2]*v[2]);
306			v[0] /= len;
307			v[1] /= len;
308			v[2] /= len;
309			}
310
311			///////////////////////////////////////////////////////////////////////////////////////////////////
312
313			private float[][] produceCorner()
314			{
315	166e4113	Leszek Koltunski	float[][] ret = new float[5 + 3*(N+1) +3][];
316	b480f4dd	Leszek Koltunski
317	a1b74688	leszek	float C = 0.50f;
318	720b26cd	Leszek Koltunski	ret[0] = new float[] { 0.00f, 0.0f , 0.00f };
319			ret[1] = new float[] { 0.00f, 0.0f , -1.50f };
320			ret[2] = new float[] { 0.75f, 0.75f*SQ2, -0.75f };
321			ret[3] = new float[] {-0.75f, 0.75f*SQ2, -0.75f };
322			ret[4] = new float[] { 0.00f, C0.75fSQ2,C*-1.50f };
323	b480f4dd	Leszek Koltunski
324			float[] vect1 = new float[4];
325			float[] vect2 = new float[4];
326			float[] vect3 = new float[4];
327
328	a1b74688	leszek	float G = 0.94f;
329
330	b480f4dd	Leszek Koltunski	for(int i=0; i<3; i++)
331			{
332	a1b74688	leszek	vect1[i] = -GM[0][i] + G(V[1][i]+V[3][i])/2;
333			vect2[i] = -GM[3][i] + G(V[1][i]+V[2][i])/2;
334			vect3[i] = -GM[2][i] + G(V[0][i]+V[1][i])/2;
335	b480f4dd	Leszek Koltunski	}
336
337			float[] rot1 = new float[] { V[0][0]-M[0][0], V[0][1]-M[0][1], V[0][2]-M[0][2] };
338			float[] rot2 = new float[] { V[3][0]-M[3][0], V[3][1]-M[3][1], V[3][2]-M[3][2] };
339			float[] rot3 = new float[] { V[2][0]-M[2][0], V[2][1]-M[2][1], V[2][2]-M[2][2] };
340
341			normalize(rot1);
342			normalize(rot2);
343			normalize(rot3);
344
345			float[] center1 = { M[0][0]-V[1][0], M[0][1]-V[1][1], M[0][2]-V[1][2] };
346			float[] center2 = { M[3][0]-V[1][0], M[3][1]-V[1][1], M[3][2]-V[1][2] };
347			float[] center3 = { M[2][0]-V[1][0], M[2][1]-V[1][1], M[2][2]-V[1][2] };
348
349			for(int i=0; i<N+1; i++)
350			{
351			float angle = (float)(2Math.PI/3)i/N;
352
353			ret[5 +i] = rotateVertices(angle,vect1,center1,rot1);
354			ret[5+ N+1 +i] = rotateVertices(angle,vect2,center2,rot2);
355			ret[5+2*(N+1)+i] = rotateVertices(angle,vect3,center3,rot3);
356			}
357
358	166e4113	Leszek Koltunski	float B = 0.85f;
359			ret[ 5 + 3(N+1) ] = new float[] { ret[0][0]B + ret[1][0](1-B), ret[0][1]B + ret[1][1](1-B), ret[0][2]B + ret[1][2]*(1-B) };
360			ret[ 5 + 3(N+1)+1] = new float[] { ret[0][0]B + ret[2][0](1-B), ret[0][1]B + ret[2][1](1-B), ret[0][2]B + ret[2][2]*(1-B) };
361			ret[ 5 + 3(N+1)+2] = new float[] { ret[0][0]B + ret[3][0](1-B), ret[0][1]B + ret[3][1](1-B), ret[0][2]B + ret[3][2]*(1-B) };
362
363	b480f4dd	Leszek Koltunski	return ret;
364			}
365
366			///////////////////////////////////////////////////////////////////////////////////////////////////
367
368			private float[][] produceCenter()
369			{
370	5be5c5db	leszek	final float D = 0.96f;
371	b480f4dd	Leszek Koltunski	float[][] ret = new float[3*N+1][];
372
373			float[] rot = new float[] { V[0][0]-M[0][0], V[0][1]-M[0][1], V[0][2]-M[0][2] };
374			normalize(rot);
375
376			float[] center1 = { 0.0f,-D*SQ2 , D };
377			float[] center2 = { D1.5f, DSQ2/2,-D/2};
378			float[] center3 = {-D1.5f, DSQ2/2,-D/2};
379
380			float[] vect1 = { D0.75f, D0.75fSQ2, -D0.75f, 0.0f };
381			float[] vect2 = { -D*1.50f, 0.00f , 0.00f, 0.0f };
382			float[] vect3 = { D0.75f,-D0.75fSQ2, D0.75f, 0.0f };
383
384			for(int i=0; i<N; i++)
385			{
386			float angle = (float)(Math.PI/3)*i/N;
387
388			ret[ N-1-i] = rotateVertices(angle, vect1, center1, rot);
389			ret[2*N-1-i] = rotateVertices(angle, vect2, center2, rot);
390			ret[3*N-1-i] = rotateVertices(angle, vect3, center3, rot);
391			}
392
393			ret[3*N] = new float[] { 0.0f, -SQ2/4, -0.5f };
394
395			return ret;
396			}
397
398			///////////////////////////////////////////////////////////////////////////////////////////////////
399
400			private float[][] produceLeaf()
401			{
402			float[][] ret = new float[2*N+1][];
403
404			float[] rot = new float[] { V[0][0]-M[0][0], V[0][1]-M[0][1], V[0][2]-M[0][2] };
405			normalize(rot);
406
407	a1b74688	leszek	float[] center1 = { 0.0f, -0.75f*SQ2, 0.75f };
408			float[] center2 = { 0.0f, 0.25f*SQ2,-0.25f };
409	b480f4dd	Leszek Koltunski
410	a1b74688	leszek	float[] vect1 = { 0.75f, 0.75f*SQ2, -0.75f, 0.0f };
411	b480f4dd	Leszek Koltunski	float[] vect2 = new float[4];
412	a1b74688	leszek	for(int i=0; i<3; i++) vect2[i] = -M[0][i] + (V[1][i]+V[3][i])/2;
413
414			final float G = 0.95f;
415	b480f4dd	Leszek Koltunski
416			for(int i=0; i<N; i++)
417	4f629c09	Leszek Koltunski	{
418	b480f4dd	Leszek Koltunski	float angle1 = (float)( Math.PI/3)*i/N;
419			float angle2 = (float)(2Math.PI/3)i/N;
420
421			ret[ N-1-i] = rotateVertices(angle1, vect1, center1, rot);
422			ret[2*N-1-i] = rotateVertices(angle2, vect2, center2, rot);
423	a1b74688	leszek
424			float[] tmp = ret[N-1-i];
425			tmp[0]*=G;
426			tmp[1]*=G;
427			tmp[2]*=G;
428			tmp = ret[2*N-1-i];
429			tmp[0]*=G;
430			tmp[1]*=G;
431			tmp[2]*=G;
432	4f629c09	Leszek Koltunski	}
433
434	b480f4dd	Leszek Koltunski	ret[2N] = new float[] { 0.0f, -0.75fSQ2/10, -1.5f/10 };
435
436			return ret;
437	4f629c09	Leszek Koltunski	}
438
439			///////////////////////////////////////////////////////////////////////////////////////////////////
440
441			private float[][] getVertices(int variant)
442			{
443	b480f4dd	Leszek Koltunski	if( variant==0 ) return produceCorner();
444			else if( variant==1 ) return produceCenter();
445			else return produceLeaf();
446			}
447
448			///////////////////////////////////////////////////////////////////////////////////////////////////
449
450			private int[][] produceCornerShape()
451			{
452	166e4113	Leszek Koltunski	int[][] ret = new int[9+3*N+3][];
453	b480f4dd	Leszek Koltunski
454			ret[0] = new int[N+4];
455			ret[0][0] = 3;
456			ret[0][1] = 0;
457			ret[0][2] = 2;
458			for(int i=0; i<N+1; i++) ret[0][3+i] = 5+N-i;
459
460			ret[1] = new int[N+4];
461			ret[1][0] = 2;
462			ret[1][1] = 0;
463			ret[1][2] = 1;
464			for(int i=0; i<N+1; i++) ret[1][3+i] = 6+2*N-i;
465
466			ret[2] = new int[N+4];
467			ret[2][0] = 1;
468			ret[2][1] = 0;
469			ret[2][2] = 3;
470			for(int i=0; i<N+1; i++) ret[2][3+i] = 7+3*N-i;
471
472			ret[3] = new int[] {5+ N,2 , 4 };
473			ret[4] = new int[] {2 ,6+ N, 4 };
474			ret[5] = new int[] {6+2*N,1 , 4 };
475			ret[6] = new int[] {1 ,7+2*N, 4 };
476			ret[7] = new int[] {7+3*N,3 , 4 };
477			ret[8] = new int[] {3 ,5 , 4 };
478
479			for(int i=0; i<N; i++)
480	4f629c09	Leszek Koltunski	{
481	b480f4dd	Leszek Koltunski	ret[9+ i] = new int[] {5 +i, 6 +i, 4};
482			ret[9+ N+i] = new int[] {6+ N+i, 7+ N+i, 4};
483			ret[9+2N+i] = new int[] {7+2N+i, 8+2*N+i, 4};
484	4f629c09	Leszek Koltunski	}
485	b480f4dd	Leszek Koltunski
486	166e4113	Leszek Koltunski	ret[3N+ 9] = new int[] { 3N+8, 3*N+ 9, 3 };
487			ret[3N+10] = new int[] { 3N+9, 3*N+10, 1 };
488			ret[3N+11] = new int[] { 3N+8, 3*N+10, 2 };
489
490	b480f4dd	Leszek Koltunski	return ret;
491			}
492
493			///////////////////////////////////////////////////////////////////////////////////////////////////
494
495			private int[][] produceCenterShape()
496			{
497			int[][] ret = new int[3+3*(N-1)+1][];
498
499			ret[0] = new int[3*N];
500	b2e19fa7	Leszek Koltunski	for(int i=0; i<3*N; i++) ret[0][i] = i;
501	b480f4dd	Leszek Koltunski
502			for(int i=1; i<=N-1; i++)
503	4f629c09	Leszek Koltunski	{
504	b480f4dd	Leszek Koltunski	ret[i] = new int[3];
505	5be5c5db	leszek	ret[i][0] = 3*N;
506	b2e19fa7	Leszek Koltunski	ret[i][1] = i;
507	5be5c5db	leszek	ret[i][2] = i-1;
508	b480f4dd	Leszek Koltunski
509			ret[N-1+i] = new int[3];
510	5be5c5db	leszek	ret[N-1+i][0] = 3*N;
511	b2e19fa7	Leszek Koltunski	ret[N-1+i][1] = N+i;
512	5be5c5db	leszek	ret[N-1+i][2] = N+i-1;
513	b480f4dd	Leszek Koltunski
514			ret[2*N-2+i] = new int[3];
515	5be5c5db	leszek	ret[2N-2+i][0] = 3N;
516	b2e19fa7	Leszek Koltunski	ret[2N-2+i][1] = 2N+i;
517	5be5c5db	leszek	ret[2N-2+i][2] = 2N+i-1;
518	4f629c09	Leszek Koltunski	}
519	b480f4dd	Leszek Koltunski
520			ret[3N-2] = new int[] { N-1, N, 3N };
521			ret[3N-1] = new int[] { 2N-1, 2N, 3N };
522			ret[3N ] = new int[] { 3N-1, 0, 3*N };
523
524			return ret;
525			}
526
527			///////////////////////////////////////////////////////////////////////////////////////////////////
528
529			private int[][] produceLeafShape()
530			{
531			int[][] ret = new int[2+2*(N-1)+1][];
532
533			ret[0] = new int[2*N];
534			for(int i=0; i<2N; i++) ret[0][i] = 2N-1-i;
535
536			for(int i=1; i<=N-1; i++)
537	4f629c09	Leszek Koltunski	{
538	b480f4dd	Leszek Koltunski	ret[i] = new int[3];
539			ret[i][0] = i;
540			ret[i][1] = i-1;
541			ret[i][2] = 2*N;
542
543			ret[N-1+i] = new int[3];
544			ret[N-1+i][0] = N+i;
545			ret[N-1+i][1] = N+i-1;
546			ret[N-1+i][2] = 2*N;
547	4f629c09	Leszek Koltunski	}
548	b480f4dd	Leszek Koltunski
549			ret[2N-1] = new int[] { N, N-1, 2N };
550			ret[2N ] = new int[] { 0,2N-1, 2*N };
551
552			return ret;
553	4f629c09	Leszek Koltunski	}
554
555			///////////////////////////////////////////////////////////////////////////////////////////////////
556
557			public ObjectShape getObjectShape(int variant)
558			{
559			if( variant==0 )
560			{
561	b480f4dd	Leszek Koltunski	int[][] indices = produceCornerShape();
562	4f629c09	Leszek Koltunski	return new ObjectShape(getVertices(variant), indices);
563			}
564			else if( variant==1 )
565			{
566	b480f4dd	Leszek Koltunski	int[][] indices = produceCenterShape();
567	4f629c09	Leszek Koltunski	return new ObjectShape(getVertices(variant), indices);
568			}
569			else
570			{
571	b480f4dd	Leszek Koltunski	int[][] indices = produceLeafShape();
572	4f629c09	Leszek Koltunski	return new ObjectShape(getVertices(variant), indices);
573			}
574			}
575
576			///////////////////////////////////////////////////////////////////////////////////////////////////
577
578			public ObjectFaceShape getObjectFaceShape(int variant)
579			{
580			if( variant==0 )
581			{
582	b2e19fa7	Leszek Koltunski	float h1 = isInIconMode() ? 0.0001f : 0.03f;
583			float h2 = isInIconMode() ? 0.0001f : 0.01f;
584	c741467f	Leszek Koltunski	float[][] bands = { {h1,35,0.2f,0.4f,5,2,1}, {h2,35,0.2f,0.4f,2,0,0} };
585	166e4113	Leszek Koltunski	int num = 9+3*N+3;
586			int[] indices = new int[num];
587			for(int i=3; i<num; i++) indices[i] = 1;
588	b480f4dd	Leszek Koltunski	float A = 0.5f;
589			float[] convexCenter = { 0.0fA, 0.75fSQ2A, -1.50fA};
590			return new ObjectFaceShape(bands,indices,convexCenter);
591	4f629c09	Leszek Koltunski	}
592			else if( variant==1 )
593			{
594	5be5c5db	leszek	float h = isInIconMode() ? 0.0001f : 0.001f;
595	b2e19fa7	Leszek Koltunski	float[][] bands = { {h,15,0.05f,0.1f,5,0,0}, {h,15,0.05f,0.1f,2,0,0} };
596	b480f4dd	Leszek Koltunski	int num = 3+3*(N-1)+1;
597			int[] indices = new int[num];
598			for(int i=1; i<num; i++) indices[i] = 1;
599	4f629c09	Leszek Koltunski	return new ObjectFaceShape(bands,indices,null);
600			}
601			else
602			{
603	a1b74688	leszek	float h1 = isInIconMode() ? 0.0001f : 0.001f;
604	b2e19fa7	Leszek Koltunski	float h2 = isInIconMode() ? 0.0001f : 0.001f;
605	a1b74688	leszek	float[][] bands = { {h1,35,0.30f,0.5f,5,0,0}, {h2,25,0.125f,0.2f,2,0,0} };
606	b480f4dd	Leszek Koltunski	int num = 2+2*(N-1)+1;
607			int[] indices = new int[num];
608			for(int i=1; i<num; i++) indices[i] = 1;
609	4f629c09	Leszek Koltunski	return new ObjectFaceShape(bands,indices,null);
610			}
611			}
612
613			///////////////////////////////////////////////////////////////////////////////////////////////////
614
615			public ObjectVertexEffects getVertexEffects(int variant)
616			{
617			if( variant==0 )
618			{
619	c741467f	Leszek Koltunski	float[][] corners = { {0.05f,0.20f} };
620	166e4113	Leszek Koltunski	int num = 5 + 3*(N+1) + 3;
621			int[] indices = new int[num];
622	a1b74688	leszek	for(int i=1; i<num; i++) indices[i] = -1;
623	b480f4dd	Leszek Koltunski	float[][] centers = { { 0.00f, 0.75f*SQ2,-1.50f} };
624	4f629c09	Leszek Koltunski	return FactoryCubit.generateVertexEffect(getVertices(variant),corners,indices,centers,indices);
625			}
626			else if( variant==1 )
627			{
628	5be5c5db	leszek	float[][] corners = { {0.02f,0.20f} };
629			int[] indices = new int[3*N+1];
630			for(int i=0; i<3*N+1; i++) indices[i] = -1;
631			indices[ N-1] = 0;
632			indices[2*N-1] = 0;
633			indices[3*N-1] = 0;
634
635			float[][] centers = { { 0.0f, -SQ2/4, -0.5f } };
636			return FactoryCubit.generateVertexEffect(getVertices(variant),corners,indices,centers,indices);
637	4f629c09	Leszek Koltunski	}
638			else
639			{
640	a1b74688	leszek	float[][] corners = { {0.017f,0.10f} };
641	b480f4dd	Leszek Koltunski	int[] indices = new int[2*N+1];
642			for(int i=0; i<2*N+1; i++) indices[i] = -1;
643	a1b74688	leszek	indices[ N-1] = 0;
644			indices[2*N-1] = 0;
645
646			float A = 10;
647			float[][] centers = { { 0.0f, A-0.75fSQ2/10, A*-1.5f/10 } };
648	4f629c09	Leszek Koltunski	return FactoryCubit.generateVertexEffect(getVertices(variant),corners,indices,centers,indices);
649			}
650			}
651
652			///////////////////////////////////////////////////////////////////////////////////////////////////
653
654			public int getNumCubitVariants(int[] numLayers)
655			{
656			return 3;
657			}
658
659			///////////////////////////////////////////////////////////////////////////////////////////////////
660
661			public int getCubitVariant(int cubit, int[] numLayers)
662			{
663	b480f4dd	Leszek Koltunski	return cubit<4 ? 0 : (cubit<8 ? 1:2);
664	4f629c09	Leszek Koltunski	}
665
666			///////////////////////////////////////////////////////////////////////////////////////////////////
667	731a57a6	leszek	// doesn't matter, we're overriding getStickerRadii() anyway
668	4f629c09	Leszek Koltunski
669			public float getStickerRadius()
670			{
671	731a57a6	leszek	return 0.0f;
672	4f629c09	Leszek Koltunski	}
673
674			///////////////////////////////////////////////////////////////////////////////////////////////////
675	731a57a6	leszek	// doesn't matter, we're overriding getStickerStrokes() anyway
676	4f629c09	Leszek Koltunski
677			public float getStickerStroke()
678			{
679	731a57a6	leszek	return 0.0f;
680	166e4113	Leszek Koltunski	}
681
682			///////////////////////////////////////////////////////////////////////////////////////////////////
683
684			@Override
685			public void adjustStickerCoords()
686			{
687	a1b74688	leszek	float Y = 0.02f;
688			float Z = 0.06422593f - 0.25f*Y;
689			float X = 0.5f - Y;
690	720b26cd	Leszek Koltunski
691	b2e19fa7	Leszek Koltunski	float K = 1.45f;
692	720b26cd	Leszek Koltunski	float A = K*0.50f;
693			float B = K*0.25f;
694			float C = K*0.43301257f;
695
696	166e4113	Leszek Koltunski	float D = 0.3580885f;
697			float E = 0.12022744f;
698			float F = 0.32227963f - 0.015f;
699			float G = 0.14090173f + 0.01f;
700
701	7e9a35eb	leszek	float H = 0.5f;
702			float I = 0.0f;
703
704	ebe8c08e	leszek	mStickerCoords = new float[][][][]
705	166e4113	Leszek Koltunski	{
706	ebe8c08e	leszek	{ { {-D, E}, { I,-H}, {D, E}, {F, G}, {-F, G} } },
707			{ { {-C, B}, { C, B}, {I,-A} } },
708			{ { {-X, Z}, { X, Z} } }
709	166e4113	Leszek Koltunski	};
710	4f629c09	Leszek Koltunski	}
711
712			///////////////////////////////////////////////////////////////////////////////////////////////////
713
714	ebe8c08e	leszek	public float[][][] getStickerAngles()
715	4f629c09	Leszek Koltunski	{
716	8f5116ec	leszek	float D1 = (float)(2*Math.PI/3);
717			float D2 = (float)(Math.PI/3);
718			return new float[][][] { {{ 0,0,0,-D1,0 }} , {{D2,D2,D2}} , {{D1,D2}} };
719	4f629c09	Leszek Koltunski	}
720
721			///////////////////////////////////////////////////////////////////////////////////////////////////
722			// PUBLIC API
723
724			public Static3D[] getRotationAxis()
725			{
726			return ROT_AXIS;
727			}
728
729			///////////////////////////////////////////////////////////////////////////////////////////////////
730
731			public int[][] getBasicAngles()
732			{
733			if( mBasicAngle ==null )
734			{
735			int[] tmp = {3,3,3};
736			mBasicAngle = new int[][] { tmp,tmp,tmp,tmp };
737			}
738
739			return mBasicAngle;
740			}
741
742			///////////////////////////////////////////////////////////////////////////////////////////////////
743
744			public String getShortName()
745			{
746	361fd0de	leszek	return ListObjects.COIN_3.name();
747	4f629c09	Leszek Koltunski	}
748
749			///////////////////////////////////////////////////////////////////////////////////////////////////
750
751			public String[][] getTutorials()
752			{
753			return new String[][] {
754			{"gb","2WrDNfcfpAg","Coin Pyraminx Tutorial","Brent Richter"},
755			{"es","5pTfSCsHPWs","Tutorial Coin Pyraminx","Kubekings"},
756			{"ru","qUMQsn8kg1A","Как собрать Коин Пираминкс","Алексей Ярыгин"},
757			{"vn","TOaiOcEE0lk","Hướng Dẫn Giải Pyraminx Coin","Rubik Cube"},
758	2318a72a	leszek	{"tw","ofVag-kYgQ4","圓盤金字塔 ","1hrBLD"},
759	4f629c09	Leszek Koltunski	};
760			}
761			}

Project

General

Profile

TwistyPuzzleLib

distorted-objectlib / src / main / java / org / distorted / objectlib / objects / TwistyCoinTetrahedron.java @ 8f5116ec