Revision 716f5517
Added by Leszek Koltunski about 1 year ago
src/main/java/org/distorted/objectlib/objects/TwistyIcosamate.java | ||
---|---|---|
47 | 47 |
private static final float X1 = D/3; |
48 | 48 |
private static final float X2 = (D+F)/3; |
49 | 49 |
private static final float X3 = (2*D+F)/3; |
50 |
private static final float X4 = (D+F)/2;
|
|
50 |
private static final float X4 = (D+F)/3;
|
|
51 | 51 |
private static final float Y1 = (A+2*B)/3; |
52 | 52 |
private static final float Y2 = B/3; |
53 | 53 |
private static final float Z1 = (C+E)/3; |
... | ... | |
71 | 71 |
private int[][] mBasicAngle; |
72 | 72 |
private float[][] mCuts; |
73 | 73 |
private float[][] mPosition; |
74 |
private int[] mQuatIndex; |
|
74 | 75 |
|
75 | 76 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
76 | 77 |
|
... | ... | |
160 | 161 |
{ |
161 | 162 |
if( mPosition==null ) |
162 | 163 |
{ |
164 |
float N = numLayers[0]; |
|
165 |
float AN = N*A; |
|
166 |
float BN = N*B; |
|
167 |
float CN = N*C; |
|
168 |
float DN = N*D; |
|
169 |
float EN = N*E; |
|
170 |
float FN = N*F; |
|
171 |
float HN = N*H; |
|
172 |
|
|
163 | 173 |
mPosition = new float[][] |
164 | 174 |
{ |
165 |
{ 0, A, 0}, |
|
166 |
|
|
167 |
{ 0, B, C},
|
|
168 |
{ D, B, E},
|
|
169 |
{ F, B, H},
|
|
170 |
{-F, B, H},
|
|
171 |
{-D, B, E},
|
|
172 |
|
|
173 |
{ D,-B,-E},
|
|
174 |
{ F,-B,-H},
|
|
175 |
{-F,-B,-H},
|
|
176 |
{-D,-B,-E},
|
|
177 |
{ 0,-B,-C},
|
|
178 |
|
|
179 |
{ 0,-A, 0},
|
|
180 |
|
|
181 |
{ X1, Y1, Z1 },
|
|
182 |
{ X2, Y1, Z2 },
|
|
183 |
{ 0, Y1, Z3 },
|
|
184 |
{ -X2, Y1, Z2 },
|
|
185 |
{ -X1, Y1, Z1 },
|
|
186 |
|
|
187 |
{ 0,-Y2, Z4 },
|
|
188 |
{ X3,-Y2, Z5 },
|
|
189 |
{ X4,-Y2, Z6 },
|
|
190 |
{ -X4,-Y2, Z6 },
|
|
191 |
{ -X3,-Y2, Z5 },
|
|
192 |
|
|
193 |
{ 0, Y2,-Z4 },
|
|
194 |
{ -X3, Y2,-Z5 },
|
|
195 |
{ -X4, Y2,-Z6 },
|
|
196 |
{ X4, Y2,-Z6 },
|
|
197 |
{ X3, Y2,-Z5 },
|
|
198 |
|
|
199 |
{ -X1,-Y1,-Z1 },
|
|
200 |
{ -X2,-Y1,-Z2 },
|
|
201 |
{ 0,-Y1,-Z3 },
|
|
202 |
{ X2,-Y1,-Z2 },
|
|
203 |
{ X1,-Y1,-Z1 },
|
|
175 |
{ 0, AN, 0},
|
|
176 |
|
|
177 |
{ 0, BN, CN},
|
|
178 |
{ DN, BN, EN},
|
|
179 |
{ FN, BN, HN},
|
|
180 |
{-FN, BN, HN},
|
|
181 |
{-DN, BN, EN},
|
|
182 |
|
|
183 |
{ DN,-BN,-EN},
|
|
184 |
{ FN,-BN,-HN},
|
|
185 |
{-FN,-BN,-HN},
|
|
186 |
{-DN,-BN,-EN},
|
|
187 |
{ 0,-BN,-CN},
|
|
188 |
|
|
189 |
{ 0,-AN, 0},
|
|
190 |
|
|
191 |
{ X1*N, Y1*N, Z1*N },
|
|
192 |
{ X2*N, Y1*N, Z2*N },
|
|
193 |
{ 0, Y1*N, Z3*N },
|
|
194 |
{ -X2*N, Y1*N, Z2*N },
|
|
195 |
{ -X1*N, Y1*N, Z1*N },
|
|
196 |
|
|
197 |
{ 0,-Y2*N, Z4*N },
|
|
198 |
{ X3*N,-Y2*N, Z5*N },
|
|
199 |
{ X4*N,-Y2*N, Z6*N },
|
|
200 |
{ -X4*N,-Y2*N, Z6*N },
|
|
201 |
{ -X3*N,-Y2*N, Z5*N },
|
|
202 |
|
|
203 |
{ 0, Y2*N,-Z4*N },
|
|
204 |
{ -X3*N, Y2*N,-Z5*N },
|
|
205 |
{ -X4*N, Y2*N,-Z6*N },
|
|
206 |
{ X4*N, Y2*N,-Z6*N },
|
|
207 |
{ X3*N, Y2*N,-Z5*N },
|
|
208 |
|
|
209 |
{ -X1*N,-Y1*N,-Z1*N },
|
|
210 |
{ -X2*N,-Y1*N,-Z2*N },
|
|
211 |
{ 0,-Y1*N,-Z3*N },
|
|
212 |
{ X2*N,-Y1*N,-Z2*N },
|
|
213 |
{ X1*N,-Y1*N,-Z1*N },
|
|
204 | 214 |
}; |
205 | 215 |
} |
206 | 216 |
|
... | ... | |
211 | 221 |
|
212 | 222 |
public Static4D getCubitQuats(int cubit, int[] numLayers) |
213 | 223 |
{ |
214 |
return mObjectQuats[0]; // TODO |
|
224 |
if( mQuatIndex==null ) |
|
225 |
{ |
|
226 |
mQuatIndex = new int[] |
|
227 |
{ |
|
228 |
0,12,5,9,13,8,10,6,7,18,14,55, |
|
229 |
0,4,3,2,1, 6,11,32,14,26, 41,27,7,5,10, 35,18,45,33,15 |
|
230 |
}; |
|
231 |
} |
|
232 |
|
|
233 |
return mObjectQuats[mQuatIndex[cubit]]; |
|
215 | 234 |
} |
216 | 235 |
|
217 | 236 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
... | ... | |
220 | 239 |
{ |
221 | 240 |
if( variant==0 ) |
222 | 241 |
{ |
223 |
float H1 = (B-A)/2; |
|
224 |
return new float[][] { {0,0,0},{0,H1,C/2},{D/2,H1,E/2},{F/2,H1,H/2},{-F/2,H1,H/2},{-D/2,H1,E/2},{0,-A,0} }; |
|
242 |
float N = getNumLayers()[0]; |
|
243 |
float X = B-A; |
|
244 |
return new float[][] { {0,0,0},{0,X,C},{D,X,E},{F,X,H},{-F,X,H},{-D,X,E},{0,-A*N,0} }; |
|
225 | 245 |
} |
226 | 246 |
else |
227 | 247 |
{ |
228 |
return new float[][] { {F/2,Y2,(C-H)/2-Z4},{0,-B+Y2,-H-Z4},{-F/2,Y2,(C-H)/2-Z4},{0,Y2,-Z4} }; |
|
248 |
float N = getNumLayers()[0]; |
|
249 |
float CX = X1*N; |
|
250 |
float CY = Y1*N; |
|
251 |
float CZ = Z1*N; |
|
252 |
|
|
253 |
return new float[][] { { D-CX, A*(N-1)+ B-CY, E-CZ }, |
|
254 |
{ D-CX, A*(N-2)+2*B-CY, C+E-CZ }, |
|
255 |
{ -CX, A*(N-1)+ B-CY, C -CZ }, |
|
256 |
{ -CX, -CY, -CZ } |
|
257 |
}; |
|
229 | 258 |
} |
230 | 259 |
} |
231 | 260 |
|
Also available in: Unified diff
Progress with Icosamate