Revision 82e62580
Added by Leszek Koltunski over 2 years ago
src/main/java/org/distorted/objectlib/objects/TwistyHelicopter.java | ||
---|---|---|
212 | 212 |
|
213 | 213 |
public Static4D getCubitQuats(int cubit, int[] numLayers) |
214 | 214 |
{ |
215 |
if( mQuatIndices==null ) mQuatIndices = new int[] { 0,19,21,7,18,16,17,3,12,4,19,8,3,9,13,18,11,2,22,10,1,15,14,23,17,20,21,0,5,16,7,6 }; |
|
215 |
if( mQuatIndices==null ) mQuatIndices = new int[] { 0,19,21, 7,18,16,17, 3, |
|
216 |
12, 4,19, 8, 3, 9,13,18,11,2,22,10,1,15,14,23,17,20,21,0,5,16,7,6 }; |
|
216 | 217 |
return mObjectQuats[mQuatIndices[cubit]]; |
217 | 218 |
} |
218 | 219 |
|
src/main/java/org/distorted/objectlib/objects/TwistyMorphix.java | ||
---|---|---|
160 | 160 |
|
161 | 161 |
public Static4D getCubitQuats(int cubit, int[] numLayers) |
162 | 162 |
{ |
163 |
int I=5; int J=2; int K=8; |
|
164 |
if( mQuatIndex==null ) mQuatIndex = new int[] { 0,I,J,K,0,I,J,K }; |
|
163 |
if( mQuatIndex==null ) mQuatIndex = new int[] { 0,5,2,8,0,5,2,8 }; |
|
165 | 164 |
return mObjectQuats[mQuatIndex[cubit]]; |
166 | 165 |
} |
167 | 166 |
|
src/main/java/org/distorted/objectlib/objects/TwistyPentultimate.java | ||
---|---|---|
145 | 145 |
{ |
146 | 146 |
0, 29, 59, 48, 18, 53, 22, 49, 11, 54, |
147 | 147 |
10, 52, 17, 27, 19, 26, 9, 28, 23, 45, |
148 |
|
|
149 | 148 |
0, 59, 15, 6, 4, 3, 29, 10, 35, 8, 2, 5 |
150 | 149 |
}; |
151 | 150 |
} |
src/main/java/org/distorted/objectlib/objects/TwistySkewb.java | ||
---|---|---|
49 | 49 |
private ScrambleState[] mStates; |
50 | 50 |
private int[] mBasicAngle; |
51 | 51 |
private float[][] mCuts; |
52 |
private float[][] mPositions; |
|
52 | 53 |
|
53 | 54 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
54 | 55 |
|
... | ... | |
166 | 167 |
|
167 | 168 |
public float[][] getCubitPositions(int[] numLayers) |
168 | 169 |
{ |
169 |
int numL = numLayers[0]; |
|
170 |
final float DIST_CORNER = numL-1; |
|
171 |
final float DIST_EDGE = numL-1; |
|
172 |
final float DIST_CENTER = numL-1; |
|
173 |
|
|
174 |
final int numCorners = getNumCorners(); |
|
175 |
final int numEdges = getNumEdges(numL); |
|
176 |
final int numCenters = 6*getNumCentersPerFace(numL); |
|
170 |
if( mPositions==null ) |
|
171 |
{ |
|
172 |
int numL = numLayers[0]; |
|
173 |
final float DIST_CORNER = numL-1; |
|
174 |
final float DIST_EDGE = numL-1; |
|
175 |
final float DIST_CENTER = numL-1; |
|
177 | 176 |
|
178 |
final float[][] CENTERS = new float[numCorners+numEdges+numCenters][]; |
|
177 |
final int numCorners = getNumCorners(); |
|
178 |
final int numEdges = getNumEdges(numL); |
|
179 |
final int numCenters = 6*getNumCentersPerFace(numL); |
|
179 | 180 |
|
180 |
/// CORNERS //////////////////////////////////////////////
|
|
181 |
mPositions = new float[numCorners+numEdges+numCenters][];
|
|
181 | 182 |
|
182 |
CENTERS[0] = new float[] { DIST_CORNER, DIST_CORNER, DIST_CORNER }; |
|
183 |
CENTERS[1] = new float[] { DIST_CORNER, DIST_CORNER,-DIST_CORNER }; |
|
184 |
CENTERS[2] = new float[] { DIST_CORNER,-DIST_CORNER, DIST_CORNER }; |
|
185 |
CENTERS[3] = new float[] { DIST_CORNER,-DIST_CORNER,-DIST_CORNER }; |
|
186 |
CENTERS[4] = new float[] {-DIST_CORNER, DIST_CORNER, DIST_CORNER }; |
|
187 |
CENTERS[5] = new float[] {-DIST_CORNER, DIST_CORNER,-DIST_CORNER }; |
|
188 |
CENTERS[6] = new float[] {-DIST_CORNER,-DIST_CORNER, DIST_CORNER }; |
|
189 |
CENTERS[7] = new float[] {-DIST_CORNER,-DIST_CORNER,-DIST_CORNER }; |
|
183 |
/// CORNERS ////////////////////////////////////////////// |
|
190 | 184 |
|
191 |
/// CENTERS ////////////////////////////////////////////// |
|
185 |
mPositions[0] = new float[] { DIST_CORNER, DIST_CORNER, DIST_CORNER }; |
|
186 |
mPositions[1] = new float[] { DIST_CORNER, DIST_CORNER,-DIST_CORNER }; |
|
187 |
mPositions[2] = new float[] { DIST_CORNER,-DIST_CORNER, DIST_CORNER }; |
|
188 |
mPositions[3] = new float[] { DIST_CORNER,-DIST_CORNER,-DIST_CORNER }; |
|
189 |
mPositions[4] = new float[] {-DIST_CORNER, DIST_CORNER, DIST_CORNER }; |
|
190 |
mPositions[5] = new float[] {-DIST_CORNER, DIST_CORNER,-DIST_CORNER }; |
|
191 |
mPositions[6] = new float[] {-DIST_CORNER,-DIST_CORNER, DIST_CORNER }; |
|
192 |
mPositions[7] = new float[] {-DIST_CORNER,-DIST_CORNER,-DIST_CORNER }; |
|
192 | 193 |
|
193 |
int index=8;
|
|
194 |
/// CENTERS //////////////////////////////////////////////
|
|
194 | 195 |
|
195 |
final float X= -1000.0f; |
|
196 |
final float Y= -1001.0f; |
|
196 |
int index=8; |
|
197 |
final float X= -1000.0f; |
|
198 |
final float Y= -1001.0f; |
|
197 | 199 |
|
198 |
final float[][] centerTable = |
|
200 |
final float[][] centerTable =
|
|
199 | 201 |
{ |
200 | 202 |
{+DIST_CENTER,X,Y}, |
201 | 203 |
{-DIST_CENTER,X,Y}, |
... | ... | |
205 | 207 |
{X,Y,-DIST_CENTER} |
206 | 208 |
}; |
207 | 209 |
|
208 |
float x,y, cen0, cen1, cen2; |
|
210 |
float x,y, cen0, cen1, cen2;
|
|
209 | 211 |
|
210 |
for( float[] centers : centerTable ) |
|
211 |
{ |
|
212 |
x = 2-numL; |
|
213 |
|
|
214 |
for(int i=0; i<numL-1; i++, x+=2) |
|
212 |
for( float[] centers : centerTable ) |
|
215 | 213 |
{ |
216 |
y = 2-numL;
|
|
214 |
x = 2-numL;
|
|
217 | 215 |
|
218 |
for(int j=0; j<numL-1; j++, y+=2, index++)
|
|
216 |
for(int i=0; i<numL-1; i++, x+=2)
|
|
219 | 217 |
{ |
220 |
if( centers[0]==Y ) cen0 = y; |
|
221 |
else if( centers[0]==X ) cen0 = x; |
|
222 |
else cen0 = centers[0]; |
|
218 |
y = 2-numL; |
|
219 |
|
|
220 |
for(int j=0; j<numL-1; j++, y+=2, index++) |
|
221 |
{ |
|
222 |
if( centers[0]==Y ) cen0 = y; |
|
223 |
else if( centers[0]==X ) cen0 = x; |
|
224 |
else cen0 = centers[0]; |
|
223 | 225 |
|
224 |
if( centers[1]==Y ) cen1 = y; |
|
225 |
else if( centers[1]==X ) cen1 = x; |
|
226 |
else cen1 = centers[1]; |
|
226 |
if( centers[1]==Y ) cen1 = y;
|
|
227 |
else if( centers[1]==X ) cen1 = x;
|
|
228 |
else cen1 = centers[1];
|
|
227 | 229 |
|
228 |
if( centers[2]==Y ) cen2 = y; |
|
229 |
else if( centers[2]==X ) cen2 = x; |
|
230 |
else cen2 = centers[2]; |
|
230 |
if( centers[2]==Y ) cen2 = y;
|
|
231 |
else if( centers[2]==X ) cen2 = x;
|
|
232 |
else cen2 = centers[2];
|
|
231 | 233 |
|
232 |
CENTERS[index] = new float[] {cen0,cen1,cen2}; |
|
234 |
mPositions[index] = new float[] {cen0,cen1,cen2}; |
|
235 |
} |
|
233 | 236 |
} |
234 |
} |
|
235 | 237 |
|
236 |
x = 3-numL; |
|
238 |
x = 3-numL;
|
|
237 | 239 |
|
238 |
for(int i=0; i<numL-2; i++, x+=2) |
|
239 |
{ |
|
240 |
y = 3-numL; |
|
241 |
|
|
242 |
for(int j=0; j<numL-2; j++, y+=2, index++) |
|
240 |
for(int i=0; i<numL-2; i++, x+=2) |
|
243 | 241 |
{ |
244 |
if( centers[0]==Y ) cen0 = y; |
|
245 |
else if( centers[0]==X ) cen0 = x; |
|
246 |
else cen0 = centers[0]; |
|
242 |
y = 3-numL; |
|
243 |
|
|
244 |
for(int j=0; j<numL-2; j++, y+=2, index++) |
|
245 |
{ |
|
246 |
if( centers[0]==Y ) cen0 = y; |
|
247 |
else if( centers[0]==X ) cen0 = x; |
|
248 |
else cen0 = centers[0]; |
|
247 | 249 |
|
248 |
if( centers[1]==Y ) cen1 = y; |
|
249 |
else if( centers[1]==X ) cen1 = x; |
|
250 |
else cen1 = centers[1]; |
|
250 |
if( centers[1]==Y ) cen1 = y;
|
|
251 |
else if( centers[1]==X ) cen1 = x;
|
|
252 |
else cen1 = centers[1];
|
|
251 | 253 |
|
252 |
if( centers[2]==Y ) cen2 = y; |
|
253 |
else if( centers[2]==X ) cen2 = x; |
|
254 |
else cen2 = centers[2]; |
|
254 |
if( centers[2]==Y ) cen2 = y;
|
|
255 |
else if( centers[2]==X ) cen2 = x;
|
|
256 |
else cen2 = centers[2];
|
|
255 | 257 |
|
256 |
CENTERS[index] = new float[] {cen0,cen1,cen2}; |
|
258 |
mPositions[index] = new float[] {cen0,cen1,cen2}; |
|
259 |
} |
|
257 | 260 |
} |
258 | 261 |
} |
259 |
} |
|
260 | 262 |
|
261 |
/// EDGES /////////////////////////////////////////////// |
|
263 |
/// EDGES ///////////////////////////////////////////////
|
|
262 | 264 |
|
263 |
final float[][] edgeTable = |
|
265 |
final float[][] edgeTable =
|
|
264 | 266 |
{ |
265 | 267 |
{0,+DIST_EDGE,+DIST_EDGE}, |
266 | 268 |
{+DIST_EDGE,0,+DIST_EDGE}, |
... | ... | |
276 | 278 |
{-DIST_EDGE,0,-DIST_EDGE} |
277 | 279 |
}; |
278 | 280 |
|
279 |
for (float[] edges : edgeTable) |
|
280 |
{ |
|
281 |
float c = 3-numL; |
|
282 |
|
|
283 |
for (int j=0; j<numL-2; j++, c+=2, index++) |
|
281 |
for (float[] edges : edgeTable) |
|
284 | 282 |
{ |
285 |
CENTERS[index] = new float[] { edges[0]==0 ? c : edges[0] , |
|
286 |
edges[1]==0 ? c : edges[1] , |
|
287 |
edges[2]==0 ? c : edges[2] }; |
|
283 |
float c = 3-numL; |
|
284 |
|
|
285 |
for (int j=0; j<numL-2; j++, c+=2, index++) |
|
286 |
{ |
|
287 |
mPositions[index] = new float[] { edges[0]==0 ? c : edges[0] , |
|
288 |
edges[1]==0 ? c : edges[1] , |
|
289 |
edges[2]==0 ? c : edges[2] }; |
|
290 |
} |
|
288 | 291 |
} |
289 | 292 |
} |
290 | 293 |
|
291 |
return CENTERS;
|
|
294 |
return mPositions;
|
|
292 | 295 |
} |
293 | 296 |
|
294 | 297 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
... | ... | |
310 | 313 |
case 3: return mObjectQuats[9]; // 180 along X |
311 | 314 |
case 4: return new Static4D(0, SQ2/2,0,SQ2/2); // 90 along Y |
312 | 315 |
case 5: return mObjectQuats[11]; // 180 along Y |
313 |
case 6: return mObjectQuats[10]; // 180 along Z
|
|
316 |
case 6: return mObjectQuats[10]; // 180 along Z |
|
314 | 317 |
case 7: return new Static4D(SQ2/2,0,-SQ2/2,0); // 180 along (SQ2/2,0,-SQ2/2) |
315 | 318 |
} |
316 | 319 |
} |
src/main/java/org/distorted/objectlib/objects/TwistySquare1.java | ||
---|---|---|
33 | 33 |
|
34 | 34 |
public class TwistySquare1 extends TwistySquare |
35 | 35 |
{ |
36 |
private int[] mQuatNumber;
|
|
36 |
private int[] mQuatIndex;
|
|
37 | 37 |
private float[][] mCenters; |
38 | 38 |
|
39 | 39 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
... | ... | |
96 | 96 |
|
97 | 97 |
public Static4D getCubitQuats(int cubit, int[] numLayers) |
98 | 98 |
{ |
99 |
if( mQuatNumber ==null )
|
|
99 |
if( mQuatIndex ==null )
|
|
100 | 100 |
{ |
101 |
mQuatNumber = new int[]
|
|
101 |
mQuatIndex = new int[]
|
|
102 | 102 |
{ |
103 | 103 |
0, 6, |
104 | 104 |
0, 9, 6, 3, 17, 14, 23, 20, |
... | ... | |
106 | 106 |
}; |
107 | 107 |
} |
108 | 108 |
|
109 |
return mObjectQuats[mQuatNumber[cubit]];
|
|
109 |
return mObjectQuats[mQuatIndex[cubit]];
|
|
110 | 110 |
} |
111 | 111 |
|
112 | 112 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
src/main/java/org/distorted/objectlib/objects/TwistySquare2.java | ||
---|---|---|
34 | 34 |
public class TwistySquare2 extends TwistySquare |
35 | 35 |
{ |
36 | 36 |
private ScrambleState[] mStates; |
37 |
private int[] mQuatNumber;
|
|
37 |
private int[] mQuatIndex;
|
|
38 | 38 |
private float[][] mCenters; |
39 | 39 |
|
40 | 40 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
... | ... | |
131 | 131 |
|
132 | 132 |
public Static4D getCubitQuats(int cubit, int[] numLayers) |
133 | 133 |
{ |
134 |
if( mQuatNumber ==null )
|
|
134 |
if( mQuatIndex==null )
|
|
135 | 135 |
{ |
136 |
mQuatNumber = new int[]
|
|
136 |
mQuatIndex = new int[]
|
|
137 | 137 |
{ |
138 | 138 |
0, 6, |
139 |
0, 9, 6, 3, 17, 14, 23, 20, |
|
140 |
0, 9, 6, 3, 0, 9, 6, 3, |
|
141 |
14, 23, 20, 17, 14, 23, 20, 17 |
|
139 |
0, 9, 6, 3,17,14,23,20, |
|
140 |
0, 9, 6, 3, 0, 9, 6, 3,14, 23, 20, 17, 14, 23, 20, 17 |
|
142 | 141 |
}; |
143 | 142 |
} |
144 | 143 |
|
145 |
return mObjectQuats[mQuatNumber[cubit]];
|
|
144 |
return mObjectQuats[mQuatIndex[cubit]];
|
|
146 | 145 |
} |
147 | 146 |
|
148 | 147 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
src/main/java/org/distorted/objectlib/objects/TwistyTrajber.java | ||
---|---|---|
52 | 52 |
private ScrambleState[] mStates; |
53 | 53 |
private int[] mBasicAngle; |
54 | 54 |
private float[][] mCuts; |
55 |
private float[][] mCenters;
|
|
55 |
private float[][] mPositions;
|
|
56 | 56 |
private int[] mQuatIndex; |
57 | 57 |
|
58 | 58 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
... | ... | |
206 | 206 |
|
207 | 207 |
public float[][] getCubitPositions(int[] numLayers) |
208 | 208 |
{ |
209 |
if( mCenters==null )
|
|
209 |
if( mPositions==null )
|
|
210 | 210 |
{ |
211 | 211 |
int numL = numLayers[0]; |
212 | 212 |
float LEN = numL*0.5f; |
213 | 213 |
|
214 | 214 |
if( numL==3 ) |
215 | 215 |
{ |
216 |
mCenters = new float[][]
|
|
216 |
mPositions = new float[][]
|
|
217 | 217 |
{ |
218 | 218 |
{ LEN, 0, LEN}, |
219 | 219 |
{ -LEN, 0, -LEN}, |
... | ... | |
258 | 258 |
final float I = LEN-0.5f*B; |
259 | 259 |
final float J = SQ2*(LEN-B); |
260 | 260 |
|
261 |
mCenters = new float[][]
|
|
261 |
mPositions = new float[][]
|
|
262 | 262 |
{ |
263 | 263 |
{ I , A, I-B }, |
264 | 264 |
{ I , -A, I-B }, |
... | ... | |
324 | 324 |
} |
325 | 325 |
} |
326 | 326 |
|
327 |
return mCenters;
|
|
327 |
return mPositions;
|
|
328 | 328 |
} |
329 | 329 |
|
330 | 330 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
src/main/java/org/distorted/objectlib/objects/TwistyUltimate.java | ||
---|---|---|
56 | 56 |
private ScrambleState[] mStates; |
57 | 57 |
private int[] mBasicAngle; |
58 | 58 |
private float[][] mCuts; |
59 |
private float[][] mCenters;
|
|
59 |
private float[][] mPositions;
|
|
60 | 60 |
private int[] mQuatIndex; |
61 | 61 |
|
62 | 62 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
... | ... | |
87 | 87 |
|
88 | 88 |
public float[][] getCubitPositions(int[] numLayers) |
89 | 89 |
{ |
90 |
if( mCenters==null )
|
|
90 |
if( mPositions==null )
|
|
91 | 91 |
{ |
92 |
mCenters = new float[][]
|
|
92 |
mPositions = new float[][]
|
|
93 | 93 |
{ |
94 | 94 |
{ 0, -1, 2*G }, |
95 | 95 |
{ 2*E,-2*E,-2*E }, |
... | ... | |
110 | 110 |
}; |
111 | 111 |
} |
112 | 112 |
|
113 |
return mCenters;
|
|
113 |
return mPositions;
|
|
114 | 114 |
} |
115 | 115 |
|
116 | 116 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
src/main/java/org/distorted/objectlib/objects/TwistyVoid.java | ||
---|---|---|
47 | 47 |
private ScrambleState[] mStates; |
48 | 48 |
private int[] mBasicAngle; |
49 | 49 |
private float[][] mCuts; |
50 |
private float[][] mCenters;
|
|
50 |
private float[][] mPositions;
|
|
51 | 51 |
private int[] mQuatIndex; |
52 | 52 |
|
53 | 53 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
... | ... | |
181 | 181 |
|
182 | 182 |
public float[][] getCubitPositions(int[] numLayers) |
183 | 183 |
{ |
184 |
if( mCenters==null )
|
|
184 |
if( mPositions==null )
|
|
185 | 185 |
{ |
186 |
mCenters = new float[][]
|
|
186 |
mPositions = new float[][]
|
|
187 | 187 |
{ |
188 | 188 |
{ 1.0f, 1.0f, 1.0f}, |
189 | 189 |
{ 1.0f, 1.0f,-1.0f}, |
... | ... | |
209 | 209 |
}; |
210 | 210 |
} |
211 | 211 |
|
212 |
return mCenters;
|
|
212 |
return mPositions;
|
|
213 | 213 |
} |
214 | 214 |
|
215 | 215 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
src/main/java/org/distorted/objectlib/objects/TwistyWindmill.java | ||
---|---|---|
51 | 51 |
private ScrambleState[] mStates; |
52 | 52 |
private int[] mBasicAngle; |
53 | 53 |
private float[][] mCuts; |
54 |
private float[][] mCenters;
|
|
54 |
private float[][] mPositions;
|
|
55 | 55 |
private int[] mQuatIndex; |
56 | 56 |
|
57 | 57 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
... | ... | |
165 | 165 |
|
166 | 166 |
public float[][] getCubitPositions(int[] numLayers) |
167 | 167 |
{ |
168 |
if( mCenters==null )
|
|
168 |
if( mPositions==null )
|
|
169 | 169 |
{ |
170 | 170 |
final float DIS1 = -X/2 + 1.5f; |
171 | 171 |
final float DIS2 = -X/2; |
172 | 172 |
|
173 |
mCenters = new float[][]
|
|
173 |
mPositions = new float[][]
|
|
174 | 174 |
{ |
175 | 175 |
{ DIS1, 1.0f, 1.5f }, |
176 | 176 |
{ 1.5f, 1.0f,-DIS1 }, |
... | ... | |
203 | 203 |
}; |
204 | 204 |
} |
205 | 205 |
|
206 |
return mCenters;
|
|
206 |
return mPositions;
|
|
207 | 207 |
} |
208 | 208 |
|
209 | 209 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
210 | 210 |
|
211 | 211 |
public Static4D getCubitQuats(int cubit, int[] numLayers) |
212 | 212 |
{ |
213 |
int I0 =0; int I1 =6; int I2 =5; int I3 =4; |
|
214 |
if( mQuatIndex==null ) mQuatIndex = new int[] {I0,I1,I2,I3,I0,I1,I2,I3,I0,I1,I2,I3, I0,I1,I2,I3,I0,I1,I2,I3,I0,I1,I2,I3, 0,0 }; |
|
213 |
if( mQuatIndex==null ) mQuatIndex = new int[] { 0,6,5,4,0,6,5,4,0,6,5,4, |
|
214 |
0,6,5,4,0,6,5,4,0,6,5,4, |
|
215 |
0,0 }; |
|
215 | 216 |
return mObjectQuats[mQuatIndex[cubit]]; |
216 | 217 |
} |
217 | 218 |
|
Also available in: Unified diff
Progress with cubit quaternions.