55 |
55 |
private float dX, dY, dZ;
|
56 |
56 |
private int[][] mWall;
|
57 |
57 |
private int[][] mPoints;
|
58 |
|
private boolean[][][] mTmp;
|
|
58 |
private float[][] mCuts;
|
|
59 |
private float[][] mNormal;
|
|
60 |
private BandagedElementCuboid[] mElements;
|
|
61 |
private int mNumElements;
|
59 |
62 |
|
60 |
63 |
///////////////////////////////////////////////////////////////////////////////////////////////////
|
61 |
64 |
|
... | ... | |
64 |
67 |
|
65 |
68 |
}
|
66 |
69 |
|
|
70 |
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
71 |
|
|
72 |
public float[][] getCuts(int[] numLayers)
|
|
73 |
{
|
|
74 |
int numFaces = 6;
|
|
75 |
float[][] cuts = new float[numFaces][];
|
|
76 |
|
|
77 |
for(int axis=0; axis<numFaces; axis++)
|
|
78 |
{
|
|
79 |
int len = numLayers[axis/2];
|
|
80 |
float start = 1-len*0.5f;
|
|
81 |
|
|
82 |
if( len>=2 )
|
|
83 |
{
|
|
84 |
cuts[axis] = new float[len-1];
|
|
85 |
for(int i=0; i<len-1; i++) cuts[axis][i] = start+i;
|
|
86 |
}
|
|
87 |
}
|
|
88 |
|
|
89 |
return cuts;
|
|
90 |
}
|
|
91 |
|
|
92 |
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
93 |
|
|
94 |
private void createNormal()
|
|
95 |
{
|
|
96 |
if( mNormal==null )
|
|
97 |
{
|
|
98 |
mNormal = new float[][]
|
|
99 |
{
|
|
100 |
{ 1, 0, 0 },
|
|
101 |
{-1, 0, 0 },
|
|
102 |
{ 0, 1, 0 },
|
|
103 |
{ 0,-1, 0 },
|
|
104 |
{ 0, 0, 1 },
|
|
105 |
{ 0, 0,-1 }
|
|
106 |
};
|
|
107 |
}
|
|
108 |
}
|
|
109 |
|
67 |
110 |
///////////////////////////////////////////////////////////////////////////////////////////////////
|
68 |
111 |
|
69 |
112 |
private float[][] getVertices(ArrayList<float[]> list, float[] move, int variant)
|
... | ... | |
213 |
256 |
|
214 |
257 |
///////////////////////////////////////////////////////////////////////////////////////////////////
|
215 |
258 |
|
216 |
|
private boolean cubitExists(float[] pos, float x, float y, float z)
|
|
259 |
private boolean elementExists(int x, int y, int z)
|
217 |
260 |
{
|
218 |
|
int len = pos.length/3;
|
219 |
|
|
220 |
|
for(int i=0; i<len; i++)
|
221 |
|
if( pos[3*i]==x && pos[3*i+1]==y && pos[3*i+2]==z ) return true;
|
|
261 |
for(int i=0; i<mNumElements; i++)
|
|
262 |
{
|
|
263 |
int[] row = mElements[i].getRotRow();
|
|
264 |
if( row[0]==x && row[2]==y && row[4]==z ) return true;
|
|
265 |
}
|
222 |
266 |
|
223 |
267 |
return false;
|
224 |
268 |
}
|
225 |
269 |
|
226 |
270 |
///////////////////////////////////////////////////////////////////////////////////////////////////
|
227 |
271 |
|
228 |
|
private void createRight(int x, ArrayList<float[]> list)
|
|
272 |
private void displayWall(String tmp)
|
229 |
273 |
{
|
230 |
|
for(int y=0; y<mMax; y++)
|
231 |
|
for(int z=0; z<mMax; z++)
|
|
274 |
StringBuilder sb = new StringBuilder();
|
|
275 |
|
|
276 |
for(int i=0; i<mMax; i++)
|
|
277 |
{
|
|
278 |
for(int j=0; j<mMax; j++)
|
232 |
279 |
{
|
233 |
|
boolean b = (y<mY && z<mZ) && ( mTmp[x][mY-1-y][mZ-1-z] && (x+1>=mX || !mTmp[x+1][mY-1-y][mZ-1-z]) );
|
234 |
|
mWall[z][y] = b ? WALL_MARKED : WALL_EMPTY;
|
|
280 |
sb.append(mWall[i][j]);
|
|
281 |
sb.append(' ');
|
235 |
282 |
}
|
|
283 |
sb.append(" - ");
|
|
284 |
}
|
|
285 |
|
|
286 |
android.util.Log.e("D", tmp+" : "+sb);
|
|
287 |
}
|
|
288 |
|
|
289 |
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
290 |
|
|
291 |
private void createRight(int x, ArrayList<float[]> list)
|
|
292 |
{
|
|
293 |
for(int i=0; i<mMax; i++)
|
|
294 |
for(int j=0; j<mMax; j++) mWall[i][j] = WALL_EMPTY;
|
|
295 |
|
|
296 |
for(int i=0; i<mNumElements; i++)
|
|
297 |
{
|
|
298 |
int[] row = mElements[i].getRotRow();
|
|
299 |
int y = mY-1-row[2];
|
|
300 |
int z = mZ-1-row[4];
|
|
301 |
if( row[0]==x ) mWall[z][y] = elementExists(x+1,y,z) ? WALL_EMPTY : WALL_MARKED;
|
|
302 |
}
|
236 |
303 |
|
237 |
304 |
createVertices(list,mWall,AXIS_XP,x);
|
238 |
305 |
}
|
... | ... | |
241 |
308 |
|
242 |
309 |
private void createLeft(int x, ArrayList<float[]> list)
|
243 |
310 |
{
|
244 |
|
for(int y=0; y<mMax; y++)
|
245 |
|
for(int z=0; z<mMax; z++)
|
246 |
|
{
|
247 |
|
boolean b = (y<mY && z<mZ) && ( mTmp[x][mY-1-y][z] && (x<1 || !mTmp[x-1][mY-1-y][z]) );
|
248 |
|
mWall[z][y] = b ? WALL_MARKED : WALL_EMPTY;
|
249 |
|
}
|
|
311 |
for(int i=0; i<mMax; i++)
|
|
312 |
for(int j=0; j<mMax; j++) mWall[i][j] = WALL_EMPTY;
|
|
313 |
|
|
314 |
for(int i=0; i<mNumElements; i++)
|
|
315 |
{
|
|
316 |
int[] row = mElements[i].getRotRow();
|
|
317 |
int y = mY-1-row[2];
|
|
318 |
int z = row[4];
|
|
319 |
if( row[0]==x ) mWall[z][y] = elementExists(x-1,y,z) ? WALL_EMPTY : WALL_MARKED;
|
|
320 |
}
|
250 |
321 |
|
251 |
322 |
createVertices(list,mWall,AXIS_XM,x);
|
252 |
323 |
}
|
... | ... | |
255 |
326 |
|
256 |
327 |
private void createTop(int y, ArrayList<float[]> list)
|
257 |
328 |
{
|
258 |
|
for(int z=0; z<mMax; z++)
|
259 |
|
for(int x=0; x<mMax; x++)
|
260 |
|
{
|
261 |
|
boolean b = (x<mX && z<mZ) && ( mTmp[x][y][z] && (y+1>=mY || !mTmp[x][y+1][z]) );
|
262 |
|
mWall[x][z] = b ? WALL_MARKED : WALL_EMPTY;
|
263 |
|
}
|
|
329 |
for(int i=0; i<mMax; i++)
|
|
330 |
for(int j=0; j<mMax; j++) mWall[i][j] = WALL_EMPTY;
|
|
331 |
|
|
332 |
for(int i=0; i< mNumElements; i++)
|
|
333 |
{
|
|
334 |
int[] row = mElements[i].getRotRow();
|
|
335 |
int x = row[0];
|
|
336 |
int z = row[4];
|
|
337 |
if( row[2]==y ) mWall[x][z] = elementExists(x,y+1,z) ? WALL_EMPTY : WALL_MARKED;
|
|
338 |
}
|
264 |
339 |
|
265 |
340 |
createVertices(list,mWall,AXIS_YP,y);
|
266 |
341 |
}
|
... | ... | |
269 |
344 |
|
270 |
345 |
private void createBottom(int y, ArrayList<float[]> list)
|
271 |
346 |
{
|
272 |
|
for(int z=0; z<mMax; z++)
|
273 |
|
for(int x=0; x<mMax; x++)
|
274 |
|
{
|
275 |
|
boolean b = (x<mX && z<mZ) && ( mTmp[x][y][mZ-1-z] && (y<1 || !mTmp[x][y-1][mZ-1-z]) );
|
276 |
|
mWall[x][z] = b ? WALL_MARKED : WALL_EMPTY;
|
277 |
|
}
|
|
347 |
for(int i=0; i<mMax; i++)
|
|
348 |
for(int j=0; j<mMax; j++) mWall[i][j] = WALL_EMPTY;
|
|
349 |
|
|
350 |
for(int i=0; i<mNumElements; i++)
|
|
351 |
{
|
|
352 |
int[] row = mElements[i].getRotRow();
|
|
353 |
int x = row[0];
|
|
354 |
int z = mZ-1-row[4];
|
|
355 |
if( row[2]==y ) mWall[x][z] = elementExists(x,y-1,z) ? WALL_EMPTY : WALL_MARKED;
|
|
356 |
}
|
278 |
357 |
|
279 |
358 |
createVertices(list,mWall,AXIS_YM,y);
|
280 |
359 |
}
|
... | ... | |
283 |
362 |
|
284 |
363 |
private void createFront(int z, ArrayList<float[]> list)
|
285 |
364 |
{
|
286 |
|
for(int y=0; y<mMax; y++)
|
287 |
|
for(int x=0; x<mMax; x++)
|
288 |
|
{
|
289 |
|
boolean b = (x<mX && y<mY) && ( mTmp[x][mY-1-y][z] && (z+1>=mZ || !mTmp[x][mY-1-y][z+1]) );
|
290 |
|
mWall[x][y] = b ? WALL_MARKED : WALL_EMPTY;
|
291 |
|
}
|
|
365 |
for(int i=0; i<mMax; i++)
|
|
366 |
for(int j=0; j<mMax; j++) mWall[i][j] = WALL_EMPTY;
|
|
367 |
|
|
368 |
for(int i=0; i<mNumElements; i++)
|
|
369 |
{
|
|
370 |
int[] row = mElements[i].getRotRow();
|
|
371 |
int x = row[0];
|
|
372 |
int y = mY-1-row[2];
|
|
373 |
if( row[4]==z ) mWall[x][y] = elementExists(x,y,z+1) ? WALL_EMPTY : WALL_MARKED;
|
|
374 |
}
|
292 |
375 |
|
293 |
376 |
createVertices(list,mWall,AXIS_ZP,z);
|
294 |
377 |
}
|
... | ... | |
297 |
380 |
|
298 |
381 |
private void createBack(int z, ArrayList<float[]> list)
|
299 |
382 |
{
|
300 |
|
for(int y=0; y<mMax; y++)
|
301 |
|
for(int x=0; x<mMax; x++)
|
302 |
|
{
|
303 |
|
boolean b = (x<mX && y<mY) && ( mTmp[mX-1-x][mY-1-y][z] && (z<1 || !mTmp[mX-1-x][mY-1-y][z-1]) );
|
304 |
|
mWall[x][y] = b ? WALL_MARKED : WALL_EMPTY;
|
305 |
|
}
|
|
383 |
for(int i=0; i<mMax; i++)
|
|
384 |
for(int j=0; j<mMax; j++) mWall[i][j] = WALL_EMPTY;
|
|
385 |
|
|
386 |
for(int i=0; i<mNumElements; i++)
|
|
387 |
{
|
|
388 |
int[] row = mElements[i].getRotRow();
|
|
389 |
int x = mX-1-row[0];
|
|
390 |
int y = mY-1-row[2];
|
|
391 |
if( row[4]==z ) mWall[x][y] = elementExists(x,y,z-1) ? WALL_EMPTY : WALL_MARKED;
|
|
392 |
}
|
306 |
393 |
|
307 |
394 |
createVertices(list,mWall,AXIS_ZM,z);
|
308 |
395 |
}
|
... | ... | |
798 |
885 |
|
799 |
886 |
///////////////////////////////////////////////////////////////////////////////////////////////////
|
800 |
887 |
|
801 |
|
public void prepare(int numVariants, int x, int y, int z)
|
|
888 |
public void prepare(int numVariants, int[] numLayers)
|
802 |
889 |
{
|
803 |
890 |
if( mVertexArray==null ) mVertexArray = new ArrayList<>();
|
804 |
891 |
mVertices= new float[numVariants][][];
|
... | ... | |
806 |
893 |
mMove = new float[numVariants][3];
|
807 |
894 |
mBandIndices = new int[numVariants][];
|
808 |
895 |
|
809 |
|
mX = x;
|
810 |
|
mY = y;
|
811 |
|
mZ = z;
|
|
896 |
mX = numLayers[0];
|
|
897 |
mY = numLayers[1];
|
|
898 |
mZ = numLayers[2];
|
812 |
899 |
|
813 |
900 |
dX = mX/2.0f;
|
814 |
901 |
dY = mY/2.0f;
|
... | ... | |
818 |
905 |
|
819 |
906 |
mWall = new int[mMax][mMax];
|
820 |
907 |
mPoints = new int[mMax+1][mMax+1];
|
821 |
|
mTmp = new boolean[mX][mY][mZ];
|
|
908 |
mCuts = getCuts(numLayers);
|
|
909 |
|
|
910 |
createNormal();
|
822 |
911 |
}
|
823 |
912 |
|
824 |
913 |
///////////////////////////////////////////////////////////////////////////////////////////////////
|
... | ... | |
827 |
916 |
{
|
828 |
917 |
mVertexArray.clear();
|
829 |
918 |
|
830 |
|
float begX = 0.5f*(1-mX);
|
831 |
|
float begY = 0.5f*(1-mY);
|
832 |
|
float begZ = 0.5f*(1-mZ);
|
833 |
|
|
834 |
|
for(int x=0; x<mX; x++)
|
835 |
|
for(int y=0; y<mY; y++)
|
836 |
|
for(int z=0; z<mZ; z++) mTmp[x][y][z] = cubitExists(pos,begX+x,begY+y,begZ+z);
|
|
919 |
mNumElements = pos.length/3;
|
|
920 |
mElements = new BandagedElementCuboid[mNumElements];
|
|
921 |
for(int i=0; i<mNumElements; i++) mElements[i] = new BandagedElementCuboid(pos, 3*i, mNormal, mCuts);
|
837 |
922 |
|
838 |
923 |
for(int x=0; x<mX; x++) createRight (x,mVertexArray);
|
839 |
924 |
for(int x=0; x<mX; x++) createLeft (x,mVertexArray);
|
... | ... | |
888 |
973 |
int angle = 60;
|
889 |
974 |
float R = 0.2f;
|
890 |
975 |
float S = 0.5f;
|
891 |
|
int numVerts= 5;
|
|
976 |
int numVerts= (mX+mY+mZ)>= 16 ? 4:5;
|
892 |
977 |
int extraI = 0;
|
893 |
978 |
int extraV = 0;
|
894 |
979 |
|
... | ... | |
904 |
989 |
|
905 |
990 |
///////////////////////////////////////////////////////////////////////////////////////////////////
|
906 |
991 |
|
907 |
|
public MeshBase createMesh(float[] pos, int x, int y, int z, boolean iconMode, boolean roundCorners)
|
|
992 |
public MeshBase createMesh(float[] pos, int[] numLayers, boolean iconMode, boolean roundCorners)
|
908 |
993 |
{
|
909 |
|
prepare(1,x,y,z);
|
|
994 |
prepare(1,numLayers);
|
910 |
995 |
ObjectShape shape = createIrregularShape(0,pos);
|
911 |
996 |
ObjectFaceShape face = createIrregularFaceShape(0,iconMode);
|
912 |
997 |
ObjectVertexEffects effects = createVertexEffects(0,roundCorners);
|
generalize FactoryBandagedCuboid: start removing 'cuboidal' assumptions from it.