Revision b1f2ccf5
Added by Leszek Koltunski about 3 years ago
| src/main/java/org/distorted/objects/TwistyCube.java | ||
|---|---|---|
| 91 | 91 |
new Static4D( -0.5f, 0.5f, 0.5f, 0.5f) |
| 92 | 92 |
}; |
| 93 | 93 |
|
| 94 |
private static final double[][] VERTICES = new double[][] |
|
| 95 |
{
|
|
| 96 |
{ 0.5, 0.5, 0.5 },
|
|
| 97 |
{ 0.5, 0.5,-0.5 },
|
|
| 98 |
{ 0.5,-0.5, 0.5 },
|
|
| 99 |
{ 0.5,-0.5,-0.5 },
|
|
| 100 |
{-0.5, 0.5, 0.5 },
|
|
| 101 |
{-0.5, 0.5,-0.5 },
|
|
| 102 |
{-0.5,-0.5, 0.5 },
|
|
| 103 |
{-0.5,-0.5,-0.5 },
|
|
| 104 |
}; |
|
| 105 |
|
|
| 106 |
private static final int[][] VERT_INDEXES = new int[][] |
|
| 107 |
{
|
|
| 108 |
{2,3,1,0}, // counterclockwise!
|
|
| 109 |
{7,6,4,5},
|
|
| 110 |
{4,0,1,5},
|
|
| 111 |
{7,3,2,6},
|
|
| 112 |
{6,2,0,4},
|
|
| 113 |
{3,7,5,1}
|
|
| 114 |
}; |
|
| 115 |
|
|
| 116 |
private static final float[][] STICKERS = new float[][] |
|
| 117 |
{
|
|
| 118 |
{ -0.5f, -0.5f, 0.5f, -0.5f, 0.5f, 0.5f, -0.5f, 0.5f }
|
|
| 119 |
}; |
|
| 120 |
|
|
| 94 | 121 |
private static MeshBase[] mMeshes; |
| 95 | 122 |
|
| 96 | 123 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| ... | ... | |
| 101 | 128 |
super(size, size, quat, texture, mesh, effects, moves, ObjectList.CUBE, res, scrWidth); |
| 102 | 129 |
} |
| 103 | 130 |
|
| 131 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 132 |
|
|
| 133 |
double[][] getVertices(int cubitType) |
|
| 134 |
{
|
|
| 135 |
return VERTICES; |
|
| 136 |
} |
|
| 137 |
|
|
| 138 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 139 |
|
|
| 140 |
int[][] getVertIndexes(int cubitType) |
|
| 141 |
{
|
|
| 142 |
return VERT_INDEXES; |
|
| 143 |
} |
|
| 144 |
|
|
| 145 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 146 |
// in the sense of shape, there's always only 1 cubit type. |
|
| 147 |
|
|
| 148 |
int getNumCubitTypes(int numLayers) |
|
| 149 |
{
|
|
| 150 |
return 1; |
|
| 151 |
} |
|
| 152 |
|
|
| 104 | 153 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 105 | 154 |
|
| 106 | 155 |
MeshBase createCubitMesh(int cubit, int numLayers) |
| 107 | 156 |
{
|
| 108 | 157 |
if( mMeshes==null ) |
| 109 | 158 |
{
|
| 159 |
FactoryCubit factory = FactoryCubit.getInstance(); |
|
| 160 |
factory.clear(); |
|
| 110 | 161 |
mMeshes = new MeshBase[ObjectList.CUBE.getNumVariants()]; |
| 111 | 162 |
} |
| 112 | 163 |
|
| ... | ... | |
| 115 | 166 |
|
| 116 | 167 |
if( mMeshes[index]==null ) |
| 117 | 168 |
{
|
| 118 |
mMeshes[index] = FactoryCubit.getInstance().createCubeMesh(index); |
|
| 169 |
int extraI, extraV, num; |
|
| 170 |
|
|
| 171 |
switch(numLayers) |
|
| 172 |
{
|
|
| 173 |
case 2 : num = 6; extraI = 2; extraV = 2; break; |
|
| 174 |
case 3 : num = 5; extraI = 2; extraV = 2; break; |
|
| 175 |
case 4 : num = 5; extraI = 1; extraV = 2; break; |
|
| 176 |
default: num = 5; extraI = 1; extraV = 0; break; |
|
| 177 |
} |
|
| 178 |
|
|
| 179 |
float[][] bands = new float[][] { {0.038f,35,0.5f,0.7f,num,extraI,extraV} };
|
|
| 180 |
int[] bandIndexes = new int[] { 0,0,0,0,0,0};
|
|
| 181 |
float[][] corners = new float[][] { {0.036f,0.12f} };
|
|
| 182 |
int[] cornerIndexes = new int[] { 0,0,0,0,0,0,0,0 };
|
|
| 183 |
|
|
| 184 |
FactoryCubit factory = FactoryCubit.getInstance(); |
|
| 185 |
|
|
| 186 |
factory.createNewFaceTransform(VERTICES,VERT_INDEXES); |
|
| 187 |
mMeshes[index] = factory.createRoundedSolid(VERTICES, VERT_INDEXES, |
|
| 188 |
bands, bandIndexes, |
|
| 189 |
corners, cornerIndexes, |
|
| 190 |
getNumCubitFaces() ); |
|
| 119 | 191 |
} |
| 120 | 192 |
|
| 121 | 193 |
return mMeshes[index].copy(true); |
| ... | ... | |
| 125 | 197 |
|
| 126 | 198 |
void createFaceTexture(Canvas canvas, Paint paint, int face, int left, int top) |
| 127 | 199 |
{
|
| 128 |
float F = 0.5f; |
|
| 129 | 200 |
float R = 0.10f; |
| 130 | 201 |
float S = 0.08f; |
| 131 |
float[] vertices = { -F,-F, +F,-F, +F,+F, -F,+F};
|
|
| 132 | 202 |
|
| 133 | 203 |
FactorySticker factory = FactorySticker.getInstance(); |
| 134 |
factory.drawRoundedPolygon(canvas, paint, left, top, vertices, S, FACE_COLORS[face], R);
|
|
| 204 |
factory.drawRoundedPolygon(canvas, paint, left, top, STICKERS[0], S, FACE_COLORS[face], R);
|
|
| 135 | 205 |
} |
| 136 | 206 |
|
| 137 | 207 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 138 | 208 |
|
| 139 |
float[][] getCubitPositions(int size)
|
|
| 209 |
float[][] getCubitPositions(int numLayers)
|
|
| 140 | 210 |
{
|
| 141 |
int numCubits = size>1 ? 6*size*size - 12*size + 8 : 1;
|
|
| 211 |
int numCubits = numLayers>1 ? 6*numLayers*numLayers - 12*numLayers + 8 : 1;
|
|
| 142 | 212 |
float[][] tmp = new float[numCubits][]; |
| 143 | 213 |
|
| 144 |
float diff = 0.5f*(size-1);
|
|
| 214 |
float diff = 0.5f*(numLayers-1);
|
|
| 145 | 215 |
int currentPosition = 0; |
| 146 | 216 |
|
| 147 |
for(int x = 0; x<size; x++)
|
|
| 148 |
for(int y = 0; y<size; y++)
|
|
| 149 |
for(int z = 0; z<size; z++)
|
|
| 150 |
if( x==0 || x==size-1 || y==0 || y==size-1 || z==0 || z==size-1 )
|
|
| 217 |
for(int x = 0; x<numLayers; x++)
|
|
| 218 |
for(int y = 0; y<numLayers; y++)
|
|
| 219 |
for(int z = 0; z<numLayers; z++)
|
|
| 220 |
if( x==0 || x==numLayers-1 || y==0 || y==numLayers-1 || z==0 || z==numLayers-1 )
|
|
| 151 | 221 |
{
|
| 152 | 222 |
tmp[currentPosition++] = new float[] {x-diff,y-diff,z-diff};
|
| 153 | 223 |
} |
| ... | ... | |
| 194 | 264 |
|
| 195 | 265 |
int getNumStickerTypes(int numLayers) |
| 196 | 266 |
{
|
| 197 |
return 1;
|
|
| 267 |
return STICKERS.length;
|
|
| 198 | 268 |
} |
| 199 | 269 |
|
| 200 | 270 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
Also available in: Unified diff
Convert the first object, the Cube, to the new Cubit-creating engine.