Revision 7b925f23
Added by Leszek Koltunski 1 day ago
src/main/java/org/distorted/library/mesh/MeshMultigon.kt | ||
---|---|---|
86 | 86 |
} |
87 | 87 |
|
88 | 88 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
89 |
private fun computeEdgeVectors(vertices: Array<Array<FloatArray>>, edgesUp: Array<IntArray?>)
|
|
89 |
private fun computeEdgeVectors(vertices: Array<Array<FloatArray>>, edgesUp: Array<IntArray>) |
|
90 | 90 |
{ |
91 | 91 |
val numPoly = vertices.size |
92 | 92 |
mEdgeVectors = arrayOfNulls(numPoly) |
... | ... | |
99 | 99 |
|
100 | 100 |
for (v in 0 until numV) |
101 | 101 |
{ |
102 |
val edgeUp = edgesUp[c]!![v]
|
|
102 |
val edgeUp = edgesUp[c][v] |
|
103 | 103 |
val xs = polygon[v][0] |
104 | 104 |
val ys = polygon[v][1] |
105 | 105 |
val n = if (v==numV-1) 0 else v+1 |
... | ... | |
201 | 201 |
|
202 | 202 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
203 | 203 |
private fun computeMode(vL: FloatArray, vR: FloatArray, vT: FloatArray, normL: FloatArray, normR: FloatArray, |
204 |
edgesUp: Array<IntArray?>, vertsUp: Array<BooleanArray?>, vertices: Array<Array<FloatArray>>, centers: Array<FloatArray?>, component: Int, curr: Int): Int |
|
204 |
edgesUp: Array<IntArray>, vertsUp: Array<BooleanArray?>, vertices: Array<Array<FloatArray>>, |
|
205 |
centers: Array<FloatArray?>, component: Int, curr: Int): Int |
|
205 | 206 |
{ |
206 | 207 |
val v = vertices[component] |
207 | 208 |
val edges = edgesUp[component] |
208 | 209 |
val numPoly = v.size |
209 | 210 |
val next = if (curr==numPoly-1) 0 else curr+1 |
210 | 211 |
val prev = if (curr==0) numPoly-1 else curr-1 |
211 |
val eupc = edges!![curr]
|
|
212 |
val eupc = edges[curr] |
|
212 | 213 |
|
213 | 214 |
if (eupc<0) |
214 | 215 |
{ |
... | ... | |
496 | 497 |
} |
497 | 498 |
|
498 | 499 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
499 |
private fun detectNextOuterVertex(vertices: Array<Array<FloatArray>>, curr: FloatArray, vect: FloatArray, edgesUp: Array<IntArray?>): FloatArray
|
|
500 |
private fun detectNextOuterVertex(vertices: Array<Array<FloatArray>>, curr: FloatArray, vect: FloatArray, edgesUp: Array<IntArray>): FloatArray |
|
500 | 501 |
{ |
501 | 502 |
var maxAngle = 0.0 |
502 | 503 |
var x = 0f |
... | ... | |
513 | 514 |
val xc = vert[v][0] |
514 | 515 |
val yc = vert[v][1] |
515 | 516 |
|
516 |
if (edgesUp[c]!![v]<0&&isSame(xc-curr[0], yc-curr[1]))
|
|
517 |
if (edgesUp[c][v]<0&&isSame(xc-curr[0], yc-curr[1])) |
|
517 | 518 |
{ |
518 | 519 |
val n = (if (v==numV-1) 0 else v+1) |
519 | 520 |
val xn = vert[n][0] |
... | ... | |
573 | 574 |
} |
574 | 575 |
|
575 | 576 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
576 |
private fun generateHole(vertices: Array<Array<FloatArray>>, unclaimedEdges: Array<IntArray?>, output: Array<FloatArray>, edgesUp: Array<IntArray?>, holeNumber: Int, numHoleVerts: Int): Int
|
|
577 |
private fun generateHole(vertices: Array<Array<FloatArray>>, unclaimedEdges: Array<IntArray?>, output: Array<FloatArray>, edgesUp: Array<IntArray>, holeNumber: Int, numHoleVerts: Int): Int |
|
577 | 578 |
{ |
578 | 579 |
var firstIndex = -1 |
579 | 580 |
|
... | ... | |
593 | 594 |
|
594 | 595 |
val p = unclaimedEdges[nextIndex]!![0] |
595 | 596 |
val v = unclaimedEdges[nextIndex]!![1] |
596 |
edgesUp[p]!![v] = -holeNumber-2
|
|
597 |
edgesUp[p][v] = -holeNumber-2 |
|
597 | 598 |
currIndex = nextIndex |
598 | 599 |
val e = unclaimedEdges[nextIndex] |
599 | 600 |
val ve = vertices[e!![0]][e[1]] |
... | ... | |
614 | 615 |
} |
615 | 616 |
|
616 | 617 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
617 |
private fun computeHoles(vertices: Array<Array<FloatArray>>, edgesUp: Array<IntArray?>, outer: Array<FloatArray>, numHoleVerts: Int): Array<Array<FloatArray?>>
|
|
618 |
private fun computeHoles(vertices: Array<Array<FloatArray>>, edgesUp: Array<IntArray>, outer: Array<FloatArray>, numHoleVerts: Int): Array<Array<FloatArray?>> |
|
618 | 619 |
{ |
619 | 620 |
val unclaimedEdges = arrayOfNulls<IntArray>(numHoleVerts) |
620 | 621 |
var index = 0 |
... | ... | |
625 | 626 |
val ve = vertices[p] |
626 | 627 |
val numEdges = ve.size |
627 | 628 |
|
628 |
for (e in 0 until numEdges) if (edgesUp[p]!![e]<0)
|
|
629 |
for (e in 0 until numEdges) if (edgesUp[p][e]<0) |
|
629 | 630 |
{ |
630 | 631 |
val x1 = ve[e][0] |
631 | 632 |
val y1 = ve[e][1] |
... | ... | |
639 | 640 |
// x x x |
640 | 641 |
// x o x |
641 | 642 |
// o x x |
642 |
if (doesNotBelongToOuter(x1, y1, outer)||doesNotBelongToOuter(x2, y2, outer))
|
|
643 |
if ( doesNotBelongToOuter(x1,y1,outer) || doesNotBelongToOuter(x2,y2,outer) )
|
|
643 | 644 |
{ |
644 | 645 |
unclaimedEdges[index] = intArrayOf(p, e, 1) |
645 | 646 |
index++ |
... | ... | |
668 | 669 |
holes.add(hole) |
669 | 670 |
} |
670 | 671 |
|
671 |
val ret: Array<Array<FloatArray?>> = arrayOfNulls(numHoles) |
|
672 |
for (h in 0 until numHoles) ret[h] = holes.removeAt(0) |
|
672 |
|
|
673 |
val ret = holes.toTypedArray() |
|
674 |
holes.clear() |
|
673 | 675 |
|
674 | 676 |
return ret |
675 | 677 |
} |
... | ... | |
687 | 689 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
688 | 690 |
// PUBLIC API |
689 | 691 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
690 |
fun computeEdgesUp(vertices: Array<Array<FloatArray>>): Array<IntArray?>
|
|
692 |
fun computeEdgesUp(vertices: Array<Array<FloatArray>>): Array<IntArray> |
|
691 | 693 |
{ |
692 | 694 |
val numPoly = vertices.size |
693 | 695 |
val up = arrayOfNulls<IntArray>(numPoly) |
... | ... | |
699 | 701 |
for (e in 0 until numEdges) up[p]!![e] = isUp(vertices, p, e) |
700 | 702 |
} |
701 | 703 |
|
702 |
return up |
|
704 |
return up.requireNoNulls()
|
|
703 | 705 |
} |
704 | 706 |
|
705 | 707 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
706 |
fun computeOuterAndHoleVertices(vertices: Array<Array<FloatArray>>, edgesUp: Array<IntArray?>): Array<Array<FloatArray>>
|
|
708 |
fun computeOuterAndHoleVertices(vertices: Array<Array<FloatArray>>, edgesUp: Array<IntArray>): Array<Array<FloatArray>> |
|
707 | 709 |
{ |
708 | 710 |
val tmp = ArrayList<FloatArray>() |
709 | 711 |
|
... | ... | |
722 | 724 |
while (!isSame(next[0]-first[0], next[1]-first[1])) |
723 | 725 |
|
724 | 726 |
val numOuterVerts = tmp.size |
725 |
val outerVertices = arrayOfNulls<FloatArray>(numOuterVerts)
|
|
726 |
for (i in 0 until numOuterVerts) outerVertices[i] = tmp.removeAt(0)
|
|
727 |
val outerVertices = tmp.toTypedArray()
|
|
728 |
tmp.clear()
|
|
727 | 729 |
|
728 | 730 |
val numEdgesDown = countEdgesDown(edgesUp) |
729 | 731 |
val numHoleVerts = numEdgesDown-numOuterVerts |
730 | 732 |
var holeVertices: Array<Array<FloatArray?>>? = null |
731 | 733 |
if (numHoleVerts>0) holeVertices = computeHoles(vertices, edgesUp, outerVertices, numHoleVerts) |
732 | 734 |
val numHoles = holeVertices?.size ?: 0 |
733 |
val ret: Array<Array<FloatArray?>> = arrayOfNulls(1+numHoles)
|
|
735 |
val ret: Array<Array<FloatArray>> = arrayOfNulls(1+numHoles) |
|
734 | 736 |
ret[0] = outerVertices |
735 | 737 |
for (i in 0 until numHoles) ret[i+1] = holeVertices!![i] |
736 | 738 |
|
Also available in: Unified diff
transition the 'mesh' package.