Revision 15290f35
Added by Leszek Koltunski over 5 years ago
src/main/java/org/distorted/library/mesh/MeshCubes.java | ||
---|---|---|
58 | 58 |
private int[][] mCubes; |
59 | 59 |
private ArrayList<Edge> mEdges = new ArrayList<>(); |
60 | 60 |
|
61 |
private int remainingVert;
|
|
61 |
private int currVert;
|
|
62 | 62 |
private int numVertices; |
63 | 63 |
private int mSideBends; |
64 | 64 |
private int mEdgeNum; |
... | ... | |
197 | 197 |
|
198 | 198 |
markRegions(); |
199 | 199 |
numVertices = computeDataLength(); |
200 |
remainingVert = numVertices;
|
|
200 |
currVert = 0;
|
|
201 | 201 |
} |
202 | 202 |
} |
203 | 203 |
|
... | ... | |
221 | 221 |
|
222 | 222 |
markRegions(); |
223 | 223 |
numVertices = computeDataLength(); |
224 |
remainingVert = numVertices;
|
|
224 |
currVert = 0;
|
|
225 | 225 |
} |
226 | 226 |
} |
227 | 227 |
|
... | ... | |
392 | 392 |
|
393 | 393 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
394 | 394 |
|
395 |
private int buildFrontBackGrid(boolean front, int vertex, float[] attribs)
|
|
395 |
private void buildFrontBackGrid(boolean front, float[] attribs)
|
|
396 | 396 |
{ |
397 | 397 |
int last, current; |
398 | 398 |
boolean seenLand=false; |
... | ... | |
414 | 414 |
{ |
415 | 415 |
currentBlockIsNE = isNE(row,col); |
416 | 416 |
|
417 |
if( !seenLand && !front && ((vertex%2==1)^currentBlockIsNE) )
|
|
417 |
if( !seenLand && !front && ((currVert%2==1)^currentBlockIsNE) )
|
|
418 | 418 |
{ |
419 | 419 |
//android.util.Log.d("CUBES","repeating winding2 vertex"); |
420 | 420 |
|
421 |
vertex = repeatLast(vertex,attribs);
|
|
421 |
repeatLast(attribs);
|
|
422 | 422 |
} |
423 | 423 |
|
424 | 424 |
createNormals(front,row,col); |
... | ... | |
427 | 427 |
{ |
428 | 428 |
if( (last!=current) || !lastBlockIsNE ) |
429 | 429 |
{ |
430 |
if( seenLand && (last != current) ) vertex = repeatLast(vertex,attribs);
|
|
431 |
vertex= addFrontVertex( vertex, 0, vectZ, col, row, attribs);
|
|
432 |
if( seenLand && (last != current) ) vertex = repeatLast(vertex,attribs);
|
|
433 |
if( !lastBlockIsNE || (!front && !seenLand) ) vertex = repeatLast(vertex,attribs);
|
|
434 |
vertex= addFrontVertex( vertex, 1, vectZ, col, row+1, attribs);
|
|
430 |
if( seenLand && (last != current) ) repeatLast(attribs);
|
|
431 |
addFrontVertex( 0, vectZ, col, row, attribs);
|
|
432 |
if( seenLand && (last != current) ) repeatLast(attribs);
|
|
433 |
if( !lastBlockIsNE || (!front && !seenLand) ) repeatLast(attribs);
|
|
434 |
addFrontVertex( 1, vectZ, col, row+1, attribs);
|
|
435 | 435 |
} |
436 |
vertex= addFrontVertex( vertex, 2, vectZ, col+1, row, attribs);
|
|
437 |
vertex= addFrontVertex( vertex, 3, vectZ, col+1, row+1, attribs);
|
|
436 |
addFrontVertex( 2, vectZ, col+1, row, attribs);
|
|
437 |
addFrontVertex( 3, vectZ, col+1, row+1, attribs);
|
|
438 | 438 |
} |
439 | 439 |
else |
440 | 440 |
{ |
441 | 441 |
if( (last!=current) || lastBlockIsNE ) |
442 | 442 |
{ |
443 |
if( seenLand && (last != current) ) vertex = repeatLast(vertex,attribs);
|
|
444 |
vertex= addFrontVertex( vertex, 1, vectZ, col, row+1, attribs);
|
|
445 |
if( seenLand && (last != current) ) vertex = repeatLast(vertex,attribs);
|
|
446 |
if( lastBlockIsNE || (!front && !seenLand) ) vertex = repeatLast(vertex,attribs);
|
|
447 |
vertex= addFrontVertex( vertex, 0, vectZ, col, row, attribs);
|
|
443 |
if( seenLand && (last != current) ) repeatLast(attribs);
|
|
444 |
addFrontVertex( 1, vectZ, col, row+1, attribs);
|
|
445 |
if( seenLand && (last != current) ) repeatLast(attribs);
|
|
446 |
if( lastBlockIsNE || (!front && !seenLand) ) repeatLast(attribs);
|
|
447 |
addFrontVertex( 0, vectZ, col, row, attribs);
|
|
448 | 448 |
} |
449 |
vertex= addFrontVertex( vertex, 3, vectZ, col+1, row+1, attribs);
|
|
450 |
vertex= addFrontVertex( vertex, 2, vectZ, col+1, row , attribs);
|
|
449 |
addFrontVertex( 3, vectZ, col+1, row+1, attribs);
|
|
450 |
addFrontVertex( 2, vectZ, col+1, row , attribs);
|
|
451 | 451 |
} |
452 | 452 |
|
453 | 453 |
seenLand = true; |
... | ... | |
457 | 457 |
last = current; |
458 | 458 |
} |
459 | 459 |
} |
460 |
|
|
461 |
return vertex; |
|
462 | 460 |
} |
463 | 461 |
|
464 | 462 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
465 | 463 |
|
466 |
private int buildSideGrid(int vertex, float[] attribs)
|
|
464 |
private void buildSideGrid(float[] attribs)
|
|
467 | 465 |
{ |
468 | 466 |
//android.util.Log.d("CUBES", "buildSide"); |
469 | 467 |
|
470 | 468 |
for(int i=0; i<mEdgeNum; i++) |
471 | 469 |
{ |
472 |
vertex = buildIthSide(mEdges.get(i), vertex, attribs); |
|
473 |
} |
|
474 |
|
|
475 |
return vertex; |
|
470 |
buildIthSide(mEdges.get(i), attribs); |
|
471 |
} |
|
476 | 472 |
} |
477 | 473 |
|
478 | 474 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
479 | 475 |
|
480 |
private int buildIthSide(Edge curr, int vertex, float[] attribs)
|
|
476 |
private void buildIthSide(Edge curr, float[] attribs)
|
|
481 | 477 |
{ |
482 | 478 |
Edge prev, next; |
483 | 479 |
int col, row, side; |
... | ... | |
499 | 495 |
side= curr.side; |
500 | 496 |
next = getNextEdge(curr); |
501 | 497 |
|
502 |
addSideVertex(curr,true,i+1,prev.side,vertex++,attribs);
|
|
498 |
addSideVertex(curr,true,i+1,prev.side,attribs); |
|
503 | 499 |
|
504 | 500 |
do |
505 | 501 |
{ |
506 | 502 |
if( prev.side!=curr.side ) |
507 | 503 |
{ |
508 |
addSideVertex(curr,true,i+1,prev.side,vertex++,attribs);
|
|
509 |
addSideVertex(curr,true,i ,prev.side,vertex++,attribs);
|
|
504 |
addSideVertex(curr,true,i+1,prev.side,attribs); |
|
505 |
addSideVertex(curr,true,i ,prev.side,attribs); |
|
510 | 506 |
} |
511 | 507 |
|
512 |
addSideVertex(curr,false,i+1,next.side,vertex++,attribs);
|
|
513 |
addSideVertex(curr,false,i ,next.side,vertex++,attribs);
|
|
508 |
addSideVertex(curr,false,i+1,next.side,attribs); |
|
509 |
addSideVertex(curr,false,i ,next.side,attribs); |
|
514 | 510 |
|
515 | 511 |
prev = curr; |
516 | 512 |
curr = next; |
... | ... | |
518 | 514 |
} |
519 | 515 |
while( curr.col!=col || curr.row!=row || curr.side!=side ); |
520 | 516 |
|
521 |
vertex = repeatLast(vertex,attribs);
|
|
517 |
repeatLast(attribs);
|
|
522 | 518 |
} |
523 |
|
|
524 |
return vertex; |
|
525 | 519 |
} |
526 | 520 |
|
527 | 521 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
... | ... | |
575 | 569 |
|
576 | 570 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
577 | 571 |
|
578 |
private int addFrontVertex(int vertex, int index, float vectZ, int col, int row, float[] attribs)
|
|
572 |
private void addFrontVertex(int index, float vectZ, int col, int row, float[] attribs)
|
|
579 | 573 |
{ |
580 |
remainingVert--; |
|
581 |
|
|
582 | 574 |
float x = (float)col/mCols; |
583 | 575 |
float y = (float)row/mRows; |
584 | 576 |
|
585 |
attribs[VERT_ATTRIBS*vertex + POS_ATTRIB ] = x-0.5f;
|
|
586 |
attribs[VERT_ATTRIBS*vertex + POS_ATTRIB+1] = 0.5f-y;
|
|
587 |
attribs[VERT_ATTRIBS*vertex + POS_ATTRIB+2] = vectZ;
|
|
577 |
attribs[VERT_ATTRIBS*currVert + POS_ATTRIB ] = x-0.5f;
|
|
578 |
attribs[VERT_ATTRIBS*currVert + POS_ATTRIB+1] = 0.5f-y;
|
|
579 |
attribs[VERT_ATTRIBS*currVert + POS_ATTRIB+2] = vectZ;
|
|
588 | 580 |
|
589 |
attribs[VERT_ATTRIBS*vertex + NOR_ATTRIB ] = mNormalX[index];
|
|
590 |
attribs[VERT_ATTRIBS*vertex + NOR_ATTRIB+1] = mNormalY[index];
|
|
591 |
attribs[VERT_ATTRIBS*vertex + NOR_ATTRIB+2] = mNormalZ[index];
|
|
581 |
attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB ] = mNormalX[index];
|
|
582 |
attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB+1] = mNormalY[index];
|
|
583 |
attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB+2] = mNormalZ[index];
|
|
592 | 584 |
|
593 |
attribs[VERT_ATTRIBS*vertex + INF_ATTRIB ] = 1.0f; //
|
|
594 |
attribs[VERT_ATTRIBS*vertex + INF_ATTRIB+1] = 0.0f; // TODO
|
|
595 |
attribs[VERT_ATTRIBS*vertex + INF_ATTRIB+2] = 0.0f; //
|
|
585 |
attribs[VERT_ATTRIBS*currVert + INF_ATTRIB ] = 0.0f; // TODO
|
|
586 |
attribs[VERT_ATTRIBS*currVert + INF_ATTRIB+1] = 0.0f; // TODO
|
|
587 |
attribs[VERT_ATTRIBS*currVert + INF_ATTRIB+2] = vectZ;
|
|
596 | 588 |
|
597 |
attribs[VERT_ATTRIBS*vertex + TEX_ATTRIB ] = x;
|
|
598 |
attribs[VERT_ATTRIBS*vertex + TEX_ATTRIB+1] = 1.0f-y;
|
|
589 |
attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB ] = x;
|
|
590 |
attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB+1] = 1.0f-y;
|
|
599 | 591 |
|
600 |
return vertex+1;
|
|
592 |
currVert++;
|
|
601 | 593 |
} |
602 | 594 |
|
603 | 595 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
604 | 596 |
|
605 |
private void addSideVertex(Edge curr, boolean back, int slice,int side, int vertex, float[] attribs)
|
|
597 |
private void addSideVertex(Edge curr, boolean back, int slice, int side, float[] attribs)
|
|
606 | 598 |
{ |
607 | 599 |
//android.util.Log.e("CUBES", "adding Side vertex!"); |
608 |
|
|
609 |
remainingVert--; |
|
610 |
|
|
611 | 600 |
float x, y; |
612 | 601 |
|
613 | 602 |
switch(curr.side) |
614 | 603 |
{ |
615 | 604 |
case NORTH: x = (float)(back ? (curr.col ):(curr.col+1))/mCols; |
616 | 605 |
|
617 |
attribs[VERT_ATTRIBS*vertex + POS_ATTRIB ] = x - 0.5f;
|
|
618 |
attribs[VERT_ATTRIBS*vertex + POS_ATTRIB+1] = 0.5f - (float)curr.row/mRows;
|
|
619 |
attribs[VERT_ATTRIBS*vertex + POS_ATTRIB+2] = 0.5f - (float)slice/mSlices;
|
|
606 |
attribs[VERT_ATTRIBS*currVert + POS_ATTRIB ] = x - 0.5f;
|
|
607 |
attribs[VERT_ATTRIBS*currVert + POS_ATTRIB+1] = 0.5f - (float)curr.row/mRows;
|
|
608 |
attribs[VERT_ATTRIBS*currVert + POS_ATTRIB+2] = 0.5f - (float)slice/mSlices;
|
|
620 | 609 |
|
621 |
attribs[VERT_ATTRIBS*vertex + NOR_ATTRIB ] = side==NORTH ? 0.0f : (side==WEST?-R:R);
|
|
622 |
attribs[VERT_ATTRIBS*vertex + NOR_ATTRIB+1] = 1.0f;
|
|
623 |
attribs[VERT_ATTRIBS*vertex + NOR_ATTRIB+2] = (slice==0 ? R : (slice==mSlices ? -R:0) );
|
|
610 |
attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB ] = side==NORTH ? 0.0f : (side==WEST?-R:R);
|
|
611 |
attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB+1] = 1.0f;
|
|
612 |
attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB+2] = (slice==0 ? R : (slice==mSlices ? -R:0) );
|
|
624 | 613 |
|
625 |
attribs[VERT_ATTRIBS*vertex + INF_ATTRIB ] = 1.0f; //
|
|
626 |
attribs[VERT_ATTRIBS*vertex + INF_ATTRIB+1] = 0.0f; // TODO
|
|
627 |
attribs[VERT_ATTRIBS*vertex + INF_ATTRIB+2] = 0.0f; //
|
|
614 |
attribs[VERT_ATTRIBS*currVert + INF_ATTRIB ] = 0.0f; //
|
|
615 |
attribs[VERT_ATTRIBS*currVert + INF_ATTRIB+1] = 0.0f; // TODO
|
|
616 |
attribs[VERT_ATTRIBS*currVert + INF_ATTRIB+2] = 0.5f - (float)slice/mSlices;
|
|
628 | 617 |
|
629 |
attribs[VERT_ATTRIBS*vertex + TEX_ATTRIB ] = x;
|
|
630 |
attribs[VERT_ATTRIBS*vertex + TEX_ATTRIB+1] = 1.0f-(float)(curr.row-slice)/mRows;
|
|
618 |
attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB ] = x;
|
|
619 |
attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB+1] = 1.0f-(float)(curr.row-slice)/mRows;
|
|
631 | 620 |
break; |
632 | 621 |
case SOUTH: x = (float)(back ? (curr.col+1):(curr.col ))/mCols; |
633 | 622 |
|
634 |
attribs[VERT_ATTRIBS*vertex + POS_ATTRIB ] = x - 0.5f;
|
|
635 |
attribs[VERT_ATTRIBS*vertex + POS_ATTRIB+1] = 0.5f - (float)(curr.row+1)/mRows;
|
|
636 |
attribs[VERT_ATTRIBS*vertex + POS_ATTRIB+2] = 0.5f - (float)slice/mSlices;
|
|
623 |
attribs[VERT_ATTRIBS*currVert + POS_ATTRIB ] = x - 0.5f;
|
|
624 |
attribs[VERT_ATTRIBS*currVert + POS_ATTRIB+1] = 0.5f - (float)(curr.row+1)/mRows;
|
|
625 |
attribs[VERT_ATTRIBS*currVert + POS_ATTRIB+2] = 0.5f - (float)slice/mSlices;
|
|
637 | 626 |
|
638 |
attribs[VERT_ATTRIBS*vertex + NOR_ATTRIB ] = side==SOUTH ? 0.0f: (side==EAST?-R:R);
|
|
639 |
attribs[VERT_ATTRIBS*vertex + NOR_ATTRIB+1] =-1.0f;
|
|
640 |
attribs[VERT_ATTRIBS*vertex + NOR_ATTRIB+2] = (slice==0 ? R : (slice==mSlices ? -R:0) );
|
|
627 |
attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB ] = side==SOUTH ? 0.0f: (side==EAST?-R:R);
|
|
628 |
attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB+1] =-1.0f;
|
|
629 |
attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB+2] = (slice==0 ? R : (slice==mSlices ? -R:0) );
|
|
641 | 630 |
|
642 |
attribs[VERT_ATTRIBS*vertex + INF_ATTRIB ] = 1.0f; //
|
|
643 |
attribs[VERT_ATTRIBS*vertex + INF_ATTRIB+1] = 0.0f; // TODO
|
|
644 |
attribs[VERT_ATTRIBS*vertex + INF_ATTRIB+2] = 0.0f; //
|
|
631 |
attribs[VERT_ATTRIBS*currVert + INF_ATTRIB ] = 0.0f; //
|
|
632 |
attribs[VERT_ATTRIBS*currVert + INF_ATTRIB+1] = 0.0f; // TODO
|
|
633 |
attribs[VERT_ATTRIBS*currVert + INF_ATTRIB+2] = 0.5f - (float)slice/mSlices;
|
|
645 | 634 |
|
646 |
attribs[VERT_ATTRIBS*vertex + TEX_ATTRIB ] = x;
|
|
647 |
attribs[VERT_ATTRIBS*vertex + TEX_ATTRIB+1] = 1.0f - (float)(curr.row+1+slice)/mRows;
|
|
635 |
attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB ] = x;
|
|
636 |
attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB+1] = 1.0f - (float)(curr.row+1+slice)/mRows;
|
|
648 | 637 |
break; |
649 | 638 |
case WEST : y = (float)(back ? (curr.row+1):(curr.row))/mRows; |
650 | 639 |
|
651 |
attribs[VERT_ATTRIBS*vertex + POS_ATTRIB ] = (float)curr.col/mCols -0.5f;
|
|
652 |
attribs[VERT_ATTRIBS*vertex + POS_ATTRIB+1] = 0.5f - y;
|
|
653 |
attribs[VERT_ATTRIBS*vertex + POS_ATTRIB+2] = 0.5f - (float)slice/mSlices;
|
|
640 |
attribs[VERT_ATTRIBS*currVert + POS_ATTRIB ] = (float)curr.col/mCols -0.5f;
|
|
641 |
attribs[VERT_ATTRIBS*currVert + POS_ATTRIB+1] = 0.5f - y;
|
|
642 |
attribs[VERT_ATTRIBS*currVert + POS_ATTRIB+2] = 0.5f - (float)slice/mSlices;
|
|
654 | 643 |
|
655 |
attribs[VERT_ATTRIBS*vertex + NOR_ATTRIB ] =-1.0f;
|
|
656 |
attribs[VERT_ATTRIBS*vertex + NOR_ATTRIB+1] = side==WEST ? 0.0f : (side==NORTH?-R:R);
|
|
657 |
attribs[VERT_ATTRIBS*vertex + NOR_ATTRIB+2] = (slice==0 ? R : (slice==mSlices ? -R:0) );
|
|
644 |
attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB ] =-1.0f;
|
|
645 |
attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB+1] = side==WEST ? 0.0f : (side==NORTH?-R:R);
|
|
646 |
attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB+2] = (slice==0 ? R : (slice==mSlices ? -R:0) );
|
|
658 | 647 |
|
659 |
attribs[VERT_ATTRIBS*vertex + INF_ATTRIB ] = 1.0f; //
|
|
660 |
attribs[VERT_ATTRIBS*vertex + INF_ATTRIB+1] = 0.0f; // TODO
|
|
661 |
attribs[VERT_ATTRIBS*vertex + INF_ATTRIB+2] = 0.0f; //
|
|
648 |
attribs[VERT_ATTRIBS*currVert + INF_ATTRIB ] = 0.0f; //
|
|
649 |
attribs[VERT_ATTRIBS*currVert + INF_ATTRIB+1] = 0.0f; // TODO
|
|
650 |
attribs[VERT_ATTRIBS*currVert + INF_ATTRIB+2] = 0.5f - (float)slice/mSlices;
|
|
662 | 651 |
|
663 |
attribs[VERT_ATTRIBS*vertex + TEX_ATTRIB ] = (float)(curr.col-slice)/mCols;
|
|
664 |
attribs[VERT_ATTRIBS*vertex + TEX_ATTRIB+1] = 1.0f - y;
|
|
652 |
attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB ] = (float)(curr.col-slice)/mCols;
|
|
653 |
attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB+1] = 1.0f - y;
|
|
665 | 654 |
break; |
666 | 655 |
case EAST : y = (float)(back ? (curr.row):(curr.row+1))/mRows; |
667 | 656 |
|
668 |
attribs[VERT_ATTRIBS*vertex + POS_ATTRIB ] = (float)(curr.col+1)/mCols -0.5f;
|
|
669 |
attribs[VERT_ATTRIBS*vertex + POS_ATTRIB+1] = 0.5f - y;
|
|
670 |
attribs[VERT_ATTRIBS*vertex + POS_ATTRIB+2] = 0.5f - (float)slice/mSlices;
|
|
657 |
attribs[VERT_ATTRIBS*currVert + POS_ATTRIB ] = (float)(curr.col+1)/mCols -0.5f;
|
|
658 |
attribs[VERT_ATTRIBS*currVert + POS_ATTRIB+1] = 0.5f - y;
|
|
659 |
attribs[VERT_ATTRIBS*currVert + POS_ATTRIB+2] = 0.5f - (float)slice/mSlices;
|
|
671 | 660 |
|
672 |
attribs[VERT_ATTRIBS*vertex + NOR_ATTRIB ] = 1.0f;
|
|
673 |
attribs[VERT_ATTRIBS*vertex + NOR_ATTRIB+1] = side==EAST ? 0.0f : (side==SOUTH?-R:R);
|
|
674 |
attribs[VERT_ATTRIBS*vertex + NOR_ATTRIB+2] = (slice==0 ? R : (slice==mSlices ? -R:0) );
|
|
661 |
attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB ] = 1.0f;
|
|
662 |
attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB+1] = side==EAST ? 0.0f : (side==SOUTH?-R:R);
|
|
663 |
attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB+2] = (slice==0 ? R : (slice==mSlices ? -R:0) );
|
|
675 | 664 |
|
676 |
attribs[VERT_ATTRIBS*vertex + INF_ATTRIB ] = 1.0f; //
|
|
677 |
attribs[VERT_ATTRIBS*vertex + INF_ATTRIB+1] = 0.0f; // TODO
|
|
678 |
attribs[VERT_ATTRIBS*vertex + INF_ATTRIB+2] = 0.0f; //
|
|
665 |
attribs[VERT_ATTRIBS*currVert + INF_ATTRIB ] = 0.0f; //
|
|
666 |
attribs[VERT_ATTRIBS*currVert + INF_ATTRIB+1] = 0.0f; // TODO
|
|
667 |
attribs[VERT_ATTRIBS*currVert + INF_ATTRIB+2] = 0.5f - (float)slice/mSlices;
|
|
679 | 668 |
|
680 |
attribs[VERT_ATTRIBS*vertex + TEX_ATTRIB ] = (float)(curr.col+1+slice)/mCols;
|
|
681 |
attribs[VERT_ATTRIBS*vertex + TEX_ATTRIB+1] = 1.0f - y;
|
|
669 |
attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB ] = (float)(curr.col+1+slice)/mCols;
|
|
670 |
attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB+1] = 1.0f - y;
|
|
682 | 671 |
break; |
683 | 672 |
} |
684 | 673 |
|
685 |
float tex0 = attribs[VERT_ATTRIBS*vertex + TEX_ATTRIB ]; |
|
686 |
float tex1 = attribs[VERT_ATTRIBS*vertex + TEX_ATTRIB+1]; |
|
674 |
float tex0 = attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB ]; |
|
675 |
float tex1 = attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB+1]; |
|
676 |
|
|
677 |
if(tex0>1.0f) attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB ] = 2.0f-tex0; |
|
678 |
if(tex0<0.0f) attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB ] = -tex0; |
|
679 |
if(tex1>1.0f) attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB+1] = 2.0f-tex1; |
|
680 |
if(tex1<0.0f) attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB+1] = -tex1; |
|
687 | 681 |
|
688 |
if(tex0>1.0f) attribs[VERT_ATTRIBS*vertex + TEX_ATTRIB ] = 2.0f-tex0; |
|
689 |
if(tex0<0.0f) attribs[VERT_ATTRIBS*vertex + TEX_ATTRIB ] = -tex0; |
|
690 |
if(tex1>1.0f) attribs[VERT_ATTRIBS*vertex + TEX_ATTRIB+1] = 2.0f-tex1; |
|
691 |
if(tex1<0.0f) attribs[VERT_ATTRIBS*vertex + TEX_ATTRIB+1] = -tex1; |
|
682 |
currVert++; |
|
692 | 683 |
} |
693 | 684 |
|
694 | 685 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
695 | 686 |
|
696 |
private int repeatLast(int vertex, float[] attribs)
|
|
687 |
private void repeatLast(float[] attribs)
|
|
697 | 688 |
{ |
698 | 689 |
//android.util.Log.e("CUBES", "repeating last vertex!"); |
699 | 690 |
|
700 |
if( vertex>0 ) |
|
701 |
{ |
|
702 |
remainingVert--; |
|
703 |
|
|
704 |
attribs[VERT_ATTRIBS*vertex + POS_ATTRIB ] = attribs[VERT_ATTRIBS*(vertex-1) + POS_ATTRIB ]; |
|
705 |
attribs[VERT_ATTRIBS*vertex + POS_ATTRIB+1] = attribs[VERT_ATTRIBS*(vertex-1) + POS_ATTRIB+1]; |
|
706 |
attribs[VERT_ATTRIBS*vertex + POS_ATTRIB+2] = attribs[VERT_ATTRIBS*(vertex-1) + POS_ATTRIB+2]; |
|
691 |
attribs[VERT_ATTRIBS*currVert + POS_ATTRIB ] = attribs[VERT_ATTRIBS*(currVert-1) + POS_ATTRIB ]; |
|
692 |
attribs[VERT_ATTRIBS*currVert + POS_ATTRIB+1] = attribs[VERT_ATTRIBS*(currVert-1) + POS_ATTRIB+1]; |
|
693 |
attribs[VERT_ATTRIBS*currVert + POS_ATTRIB+2] = attribs[VERT_ATTRIBS*(currVert-1) + POS_ATTRIB+2]; |
|
707 | 694 |
|
708 |
attribs[VERT_ATTRIBS*vertex + NOR_ATTRIB ] = attribs[VERT_ATTRIBS*(vertex-1) + NOR_ATTRIB ];
|
|
709 |
attribs[VERT_ATTRIBS*vertex + NOR_ATTRIB+1] = attribs[VERT_ATTRIBS*(vertex-1) + NOR_ATTRIB+1];
|
|
710 |
attribs[VERT_ATTRIBS*vertex + NOR_ATTRIB+2] = attribs[VERT_ATTRIBS*(vertex-1) + NOR_ATTRIB+2];
|
|
695 |
attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB ] = attribs[VERT_ATTRIBS*(currVert-1) + NOR_ATTRIB ];
|
|
696 |
attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB+1] = attribs[VERT_ATTRIBS*(currVert-1) + NOR_ATTRIB+1];
|
|
697 |
attribs[VERT_ATTRIBS*currVert + NOR_ATTRIB+2] = attribs[VERT_ATTRIBS*(currVert-1) + NOR_ATTRIB+2];
|
|
711 | 698 |
|
712 |
attribs[VERT_ATTRIBS*vertex + INF_ATTRIB ] = attribs[VERT_ATTRIBS*(vertex-1) + INF_ATTRIB ];
|
|
713 |
attribs[VERT_ATTRIBS*vertex + INF_ATTRIB+1] = attribs[VERT_ATTRIBS*(vertex-1) + INF_ATTRIB+1];
|
|
714 |
attribs[VERT_ATTRIBS*vertex + INF_ATTRIB+2] = attribs[VERT_ATTRIBS*(vertex-1) + INF_ATTRIB+2];
|
|
699 |
attribs[VERT_ATTRIBS*currVert + INF_ATTRIB ] = attribs[VERT_ATTRIBS*(currVert-1) + INF_ATTRIB ];
|
|
700 |
attribs[VERT_ATTRIBS*currVert + INF_ATTRIB+1] = attribs[VERT_ATTRIBS*(currVert-1) + INF_ATTRIB+1];
|
|
701 |
attribs[VERT_ATTRIBS*currVert + INF_ATTRIB+2] = attribs[VERT_ATTRIBS*(currVert-1) + INF_ATTRIB+2];
|
|
715 | 702 |
|
716 |
attribs[VERT_ATTRIBS*vertex + TEX_ATTRIB ] = attribs[VERT_ATTRIBS*(vertex-1) + TEX_ATTRIB ];
|
|
717 |
attribs[VERT_ATTRIBS*vertex + TEX_ATTRIB+1] = attribs[VERT_ATTRIBS*(vertex-1) + TEX_ATTRIB+1];
|
|
703 |
attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB ] = attribs[VERT_ATTRIBS*(currVert-1) + TEX_ATTRIB ];
|
|
704 |
attribs[VERT_ATTRIBS*currVert + TEX_ATTRIB+1] = attribs[VERT_ATTRIBS*(currVert-1) + TEX_ATTRIB+1];
|
|
718 | 705 |
|
719 |
|
|
720 |
vertex++; |
|
721 |
} |
|
722 |
|
|
723 |
return vertex; |
|
706 |
currVert++; |
|
724 | 707 |
} |
725 | 708 |
|
726 | 709 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
727 | 710 |
|
728 | 711 |
private void build() |
729 | 712 |
{ |
730 |
int vertSoFar=0; |
|
731 | 713 |
float[] attribs= new float[VERT_ATTRIBS*numVertices]; |
732 | 714 |
|
733 |
vertSoFar = buildFrontBackGrid(true, vertSoFar,attribs);
|
|
715 |
buildFrontBackGrid(true,attribs);
|
|
734 | 716 |
|
735 | 717 |
if( mSlices>0 ) |
736 | 718 |
{ |
737 |
vertSoFar = repeatLast(vertSoFar,attribs); |
|
738 |
if( vertSoFar%2==1 ) |
|
739 |
{ |
|
740 |
vertSoFar = repeatLast(vertSoFar,attribs); |
|
741 |
} |
|
742 |
vertSoFar = buildSideGrid (vertSoFar,attribs); |
|
743 |
buildFrontBackGrid (false,vertSoFar,attribs); |
|
719 |
repeatLast(attribs); |
|
720 |
if( currVert%2==1 ) repeatLast(attribs); |
|
721 |
buildSideGrid(attribs); |
|
722 |
buildFrontBackGrid(false,attribs); |
|
744 | 723 |
} |
745 | 724 |
|
746 | 725 |
mEdges.clear(); |
747 | 726 |
mEdges = null; |
748 | 727 |
mCubes = null; |
749 | 728 |
|
750 |
if( remainingVert!=0 )
|
|
751 |
android.util.Log.e("MeshCubes", "remainingVert " +remainingVert );
|
|
729 |
if( currVert!=numVertices )
|
|
730 |
android.util.Log.e("MeshCubes", "currVert " +currVert+" numVertices="+numVertices );
|
|
752 | 731 |
|
753 | 732 |
setAttribs(attribs); |
754 | 733 |
} |
Also available in: Unified diff
Progress with the Inflate vector in MeshCubes.