Revision 0919eba7
Added by Leszek Koltunski about 3 years ago
| src/main/java/org/distorted/objects/TwistyHelicopter.java | ||
|---|---|---|
| 33 | 33 |
import org.distorted.library.type.Static3D; |
| 34 | 34 |
import org.distorted.library.type.Static4D; |
| 35 | 35 |
import org.distorted.main.R; |
| 36 |
import org.distorted.main.RubikSurfaceView; |
|
| 37 | 36 |
|
| 38 | 37 |
import java.util.Random; |
| 39 | 38 |
|
| ... | ... | |
| 185 | 184 |
private static final int[] QUAT_INDICES = |
| 186 | 185 |
{ 0,13,14,1,12,2,3,7,20,6,13,17,7,23,18,12,22,10,8,16,11,21,19,9,3,15,14,0,5,2,1,4 };
|
| 187 | 186 |
|
| 188 |
private final double[][] VERTICES_CORNER = new double[][] |
|
| 187 |
private static final double[][] VERTICES_CORNER = new double[][]
|
|
| 189 | 188 |
{
|
| 190 |
// TODO |
|
| 189 |
{-0.50f, 0.00f, 0.00f},
|
|
| 190 |
{ 0.00f,-0.50f, 0.00f},
|
|
| 191 |
{ 0.00f, 0.00f,-0.50f},
|
|
| 192 |
{-0.25f,-0.25f,-0.25f},
|
|
| 193 |
{ 0.00f, 0.00f, 0.00f}
|
|
| 191 | 194 |
}; |
| 192 | 195 |
|
| 193 |
private final int[][] VERT_INDEXES_CORNER = new int[][] |
|
| 196 |
private static final int[][] VERT_INDEXES_CORNER = new int[][]
|
|
| 194 | 197 |
{
|
| 195 |
// TODO |
|
| 198 |
{0,1,4},
|
|
| 199 |
{2,0,4},
|
|
| 200 |
{1,2,4},
|
|
| 201 |
{3,1,0},
|
|
| 202 |
{3,2,1},
|
|
| 203 |
{3,0,2}
|
|
| 196 | 204 |
}; |
| 197 | 205 |
|
| 198 |
private final double[][] VERTICES_FACE = new double[][] |
|
| 206 |
private static final float E = 0.1666666f; |
|
| 207 |
|
|
| 208 |
private static final double[][] VERTICES_FACE = new double[][] |
|
| 209 |
{
|
|
| 210 |
{ 0.00f +E, 0.00f +E, 0.00f },
|
|
| 211 |
{ 0.50f +E, 0.00f +E, 0.00f },
|
|
| 212 |
{ 0.00f +E, 0.50f +E, 0.00f },
|
|
| 213 |
{ 0.25f +E, 0.25f +E,-0.25f },
|
|
| 214 |
}; |
|
| 215 |
|
|
| 216 |
private static final int[][] VERT_INDEXES_FACE = new int[][] |
|
| 199 | 217 |
{
|
| 200 |
// TODO |
|
| 218 |
{ 0,1,2 },
|
|
| 219 |
{ 2,1,3 },
|
|
| 220 |
{ 0,1,3 },
|
|
| 221 |
{ 2,0,3 }
|
|
| 201 | 222 |
}; |
| 202 | 223 |
|
| 203 |
private final int[][] VERT_INDEXES_FACE = new int[][]
|
|
| 224 |
private static final float[][] STICKERS = new float[][]
|
|
| 204 | 225 |
{
|
| 205 |
// TODO
|
|
| 226 |
{ -0.5f, 0.25f, 0.25f, -0.5f, 0.25f, 0.25f }
|
|
| 206 | 227 |
}; |
| 207 | 228 |
|
| 208 |
private static MeshBase mCornerMesh, mFaceMesh;
|
|
| 229 |
private static MeshBase[] mMeshes;
|
|
| 209 | 230 |
|
| 210 | 231 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 211 | 232 |
|
| ... | ... | |
| 219 | 240 |
|
| 220 | 241 |
double[][] getVertices(int cubitType) |
| 221 | 242 |
{
|
| 222 |
if( cubitType==0 ) // Corner |
|
| 223 |
{
|
|
| 224 |
return VERTICES_CORNER; |
|
| 225 |
} |
|
| 226 |
if( cubitType==1 ) // Face |
|
| 227 |
{
|
|
| 228 |
return VERTICES_FACE; |
|
| 229 |
} |
|
| 230 |
|
|
| 243 |
if( cubitType==0 ) return VERTICES_CORNER; |
|
| 244 |
if( cubitType==1 ) return VERTICES_FACE; |
|
| 231 | 245 |
return null; |
| 232 | 246 |
} |
| 233 | 247 |
|
| ... | ... | |
| 235 | 249 |
|
| 236 | 250 |
int[][] getVertIndexes(int cubitType) |
| 237 | 251 |
{
|
| 238 |
if( cubitType==0 ) // Corner |
|
| 239 |
{
|
|
| 240 |
return VERT_INDEXES_CORNER; |
|
| 241 |
} |
|
| 242 |
if( cubitType==1 ) // Face |
|
| 243 |
{
|
|
| 244 |
return VERT_INDEXES_FACE; |
|
| 245 |
} |
|
| 246 |
|
|
| 252 |
if( cubitType==0 ) return VERT_INDEXES_CORNER; |
|
| 253 |
if( cubitType==1 ) return VERT_INDEXES_FACE; |
|
| 247 | 254 |
return null; |
| 248 | 255 |
} |
| 249 | 256 |
|
| ... | ... | |
| 251 | 258 |
|
| 252 | 259 |
int getNumCubitTypes(int numLayers) |
| 253 | 260 |
{
|
| 254 |
return 1;
|
|
| 261 |
return 2;
|
|
| 255 | 262 |
} |
| 256 | 263 |
|
| 257 | 264 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| ... | ... | |
| 319 | 326 |
|
| 320 | 327 |
MeshBase createCubitMesh(int cubit, int numLayers) |
| 321 | 328 |
{
|
| 329 |
if( mMeshes==null ) |
|
| 330 |
{
|
|
| 331 |
FactoryCubit factory = FactoryCubit.getInstance(); |
|
| 332 |
factory.clear(); |
|
| 333 |
mMeshes = new MeshBase[2]; |
|
| 334 |
} |
|
| 335 |
|
|
| 322 | 336 |
MeshBase mesh; |
| 323 | 337 |
|
| 324 | 338 |
if( cubit<8 ) |
| 325 | 339 |
{
|
| 326 |
if( mCornerMesh==null ) mCornerMesh = FactoryCubit.getInstance().createHelicopterCornerMesh(); |
|
| 327 |
mesh = mCornerMesh.copy(true); |
|
| 340 |
if( mMeshes[0]==null ) |
|
| 341 |
{
|
|
| 342 |
float[][] bands= new float[][] |
|
| 343 |
{
|
|
| 344 |
{0.028f,35,0.16f,0.7f,7,3,3},
|
|
| 345 |
{0.000f, 0,1.00f,0.0f,3,1,5}
|
|
| 346 |
}; |
|
| 347 |
int[] bandIndexes = new int[] { 0,0,0,1,1,1 };
|
|
| 348 |
float[][] corners = new float[][] { {0.08f,0.15f}, {0.08f,0.20f} };
|
|
| 349 |
int[] cornerIndexes = new int[] { 1,1,1,0,0 };
|
|
| 350 |
float[][] centers = new float[][] { {-0.25f, -0.25f, -0.25f} };
|
|
| 351 |
int[] centerIndexes = new int[] { 0,0,0,-1,0 };
|
|
| 352 |
|
|
| 353 |
FactoryCubit factory = FactoryCubit.getInstance(); |
|
| 354 |
factory.createNewFaceTransform(VERTICES_CORNER,VERT_INDEXES_CORNER); |
|
| 355 |
mMeshes[0] = factory.createRoundedSolid(VERTICES_CORNER, VERT_INDEXES_CORNER, |
|
| 356 |
bands, bandIndexes, |
|
| 357 |
corners, cornerIndexes, |
|
| 358 |
centers, centerIndexes, |
|
| 359 |
getNumCubitFaces() ); |
|
| 360 |
} |
|
| 361 |
mesh = mMeshes[0].copy(true); |
|
| 328 | 362 |
} |
| 329 | 363 |
else |
| 330 | 364 |
{
|
| 331 |
if( mFaceMesh==null ) mFaceMesh = FactoryCubit.getInstance().createHelicopterFaceMesh(); |
|
| 332 |
mesh = mFaceMesh.copy(true); |
|
| 365 |
if( mMeshes[1]==null ) mMeshes[1] = FactoryCubit.getInstance().createHelicopterFaceMesh(); |
|
| 366 |
/* |
|
| 367 |
{
|
|
| 368 |
float[][] bands= new float[][] |
|
| 369 |
{
|
|
| 370 |
{0.028f,35,0.16f,0.7f,7,3,3},
|
|
| 371 |
{0.000f, 0,1.00f,0.0f,3,1,3}
|
|
| 372 |
}; |
|
| 373 |
int[] bandIndexes = new int[] { 0,1,1,1 };
|
|
| 374 |
float[][] corners = new float[][] { {0.06f,0.15f}, {0.06f,0.20f} };
|
|
| 375 |
int[] cornerIndexes = new int[] { 0,1,1,-1 };
|
|
| 376 |
float[][] centers = new float[][] { {-1.0f/12, -1.0f/12, -1.0f/4} };
|
|
| 377 |
int[] centerIndexes = new int[] { 0,0,0,-1 };
|
|
| 378 |
|
|
| 379 |
FactoryCubit factory = FactoryCubit.getInstance(); |
|
| 380 |
factory.createNewFaceTransform(VERTICES_FACE,VERT_INDEXES_FACE); |
|
| 381 |
mMeshes[1] = factory.createRoundedSolid(VERTICES_FACE, VERT_INDEXES_FACE, |
|
| 382 |
bands, bandIndexes, |
|
| 383 |
corners, cornerIndexes, |
|
| 384 |
centers, centerIndexes, |
|
| 385 |
getNumCubitFaces() ); |
|
| 386 |
} |
|
| 387 |
|
|
| 388 |
*/ |
|
| 389 |
mesh = mMeshes[1].copy(true); |
|
| 333 | 390 |
} |
| 334 | 391 |
|
| 335 | 392 |
int index = QUAT_INDICES[cubit]; |
Also available in: Unified diff
Correct still one bug with collapsing stickers in teh new Cubit engine.
Convert the Helicopter corner cubits to the new engine.