|
|
@@ -1,4 +1,4 @@
|
|
|
-module BABYLON {
|
|
|
+module BABYLON {
|
|
|
export interface IGetSetVerticesData {
|
|
|
isVerticesDataPresent(kind: string): boolean;
|
|
|
getVerticesData(kind: string): number[];
|
|
|
@@ -287,23 +287,27 @@
|
|
|
offset = offset || defaultOffset;
|
|
|
offset = offset > defaultOffset ? defaultOffset : Math.floor(offset); // offset max allowed : defaultOffset
|
|
|
|
|
|
- var positions = [];
|
|
|
- var indices = [];
|
|
|
- var normals = [];
|
|
|
- var uvs = [];
|
|
|
-
|
|
|
- var us = []; // us[path_id] = [uDist1, uDist2, uDist3 ... ] distances between points on path path_id
|
|
|
- var vs = []; // vs[i] = [vDist1, vDist2, vDist3, ... ] distances between points i of consecutives paths from pathArray
|
|
|
- var uTotalDistance = []; // uTotalDistance[p] : total distance of path p
|
|
|
- var vTotalDistance = []; // vTotalDistance[i] : total distance between points i of first and last path from pathArray
|
|
|
- var minlg; // minimal length among all paths from pathArray
|
|
|
- var lg = []; // array of path lengths : nb of vertex per path
|
|
|
- var idx = []; // array of path indexes : index of each path (first vertex) in positions array
|
|
|
+ var positions: number[] = [];
|
|
|
+ var indices: number[] = [];
|
|
|
+ var normals: number[] = [];
|
|
|
+ var uvs: number[] = [];
|
|
|
+
|
|
|
+ var us: number[][] = []; // us[path_id] = [uDist1, uDist2, uDist3 ... ] distances between points on path path_id
|
|
|
+ var vs: number[][] = []; // vs[i] = [vDist1, vDist2, vDist3, ... ] distances between points i of consecutives paths from pathArray
|
|
|
+ var uTotalDistance: number[] = []; // uTotalDistance[p] : total distance of path p
|
|
|
+ var vTotalDistance: number[] = []; // vTotalDistance[i] : total distance between points i of first and last path from pathArray
|
|
|
+ var minlg: number; // minimal length among all paths from pathArray
|
|
|
+ var lg: number[] = []; // array of path lengths : nb of vertex per path
|
|
|
+ var idx: number[] = []; // array of path indexes : index of each path (first vertex) in positions array
|
|
|
+
|
|
|
+ var p: number; // path iterator
|
|
|
+ var i: number; // point iterator
|
|
|
+ var j: number; // point iterator
|
|
|
|
|
|
// if single path in pathArray
|
|
|
if (pathArray.length < 2) {
|
|
|
- var ar1 = [];
|
|
|
- var ar2 = [];
|
|
|
+ var ar1: Vector3[] = [];
|
|
|
+ var ar2: Vector3[] = [];
|
|
|
for (var i = 0; i < pathArray[0].length - offset; i++) {
|
|
|
ar1.push(pathArray[0][i]);
|
|
|
ar2.push(pathArray[0][i + offset]);
|
|
|
@@ -312,22 +316,22 @@
|
|
|
}
|
|
|
|
|
|
// positions and horizontal distances (u)
|
|
|
- var idc = 0;
|
|
|
+ var idc: number = 0;
|
|
|
minlg = pathArray[0].length;
|
|
|
for (p = 0; p < pathArray.length; p++) {
|
|
|
uTotalDistance[p] = 0;
|
|
|
us[p] = [0];
|
|
|
- var path = pathArray[p];
|
|
|
- var l = path.length;
|
|
|
+ var path: Vector3[] = pathArray[p];
|
|
|
+ var l: number = path.length;
|
|
|
minlg = (minlg < l) ? minlg : l;
|
|
|
lg[p] = l;
|
|
|
idx[p] = idc;
|
|
|
- var j = 0;
|
|
|
+ j = 0;
|
|
|
while (j < l) {
|
|
|
positions.push(path[j].x, path[j].y, path[j].z);
|
|
|
if (j > 0) {
|
|
|
- var vectlg = path[j].subtract(path[j - 1]).length();
|
|
|
- var dist = vectlg + uTotalDistance[p];
|
|
|
+ var vectlg: number = path[j].subtract(path[j - 1]).length();
|
|
|
+ var dist: number = vectlg + uTotalDistance[p];
|
|
|
us[p].push(dist);
|
|
|
uTotalDistance[p] = dist;
|
|
|
}
|
|
|
@@ -345,9 +349,11 @@
|
|
|
for (i = 0; i < minlg; i++) {
|
|
|
vTotalDistance[i] = 0;
|
|
|
vs[i] = [0];
|
|
|
+ var path1: Vector3[];
|
|
|
+ var path2: Vector3[];
|
|
|
for (p = 0; p < pathArray.length - 1; p++) {
|
|
|
- var path1 = pathArray[p];
|
|
|
- var path2 = pathArray[p + 1];
|
|
|
+ path1 = pathArray[p];
|
|
|
+ path2 = pathArray[p + 1];
|
|
|
vectlg = path2[i].subtract(path1[i]).length();
|
|
|
dist = vectlg + vTotalDistance[i];
|
|
|
vs[i].push(dist);
|
|
|
@@ -364,38 +370,43 @@
|
|
|
|
|
|
|
|
|
// uvs
|
|
|
+ var u: number;
|
|
|
+ var v: number;
|
|
|
for (p = 0; p < pathArray.length; p++) {
|
|
|
- for (i = 0; i < minlg; i++) {
|
|
|
- var u = us[p][i] / uTotalDistance[p];
|
|
|
- var v = vs[i][p] / vTotalDistance[i];
|
|
|
+ for (var i = 0; i < minlg; i++) {
|
|
|
+ u = us[p][i] / uTotalDistance[p];
|
|
|
+ v = vs[i][p] / vTotalDistance[i];
|
|
|
uvs.push(u, v);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// indices
|
|
|
- var p = 0; // path index
|
|
|
- var i = 0; // positions array index
|
|
|
- var l1 = lg[p] - 1; // path1 length
|
|
|
- var l2 = lg[p + 1] - 1; // path2 length
|
|
|
- var min = (l1 < l2) ? l1 : l2; // current path stop index
|
|
|
- var shft = idx[1] - idx[0]; // shift
|
|
|
- var path1nb = closeArray ? lg.length : lg.length - 1; // number of path1 to iterate
|
|
|
-
|
|
|
-
|
|
|
- while (i <= min && p < path1nb) { // stay under min and don't go over next to last path
|
|
|
- // draw two triangles between path1 (p1) and path2 (p2) : (p1.i, p2.i, p1.i+1) and (p2.i+1, p1.i+1, p2.i) clockwise
|
|
|
- var t1 = i;
|
|
|
- var t2 = i + shft;
|
|
|
- var t3 = i + 1;
|
|
|
- var t4 = i + shft + 1;
|
|
|
-
|
|
|
- indices.push(i, i + shft, i + 1);
|
|
|
- indices.push(i + shft + 1, i + 1, i + shft);
|
|
|
- i += 1;
|
|
|
- if (i === min) { // if end of one of two consecutive paths reached, go next existing path
|
|
|
+ p = 0; // path index
|
|
|
+ var pi: number = 0; // positions array index
|
|
|
+ var l1: number = lg[p] - 1; // path1 length
|
|
|
+ var l2: number = lg[p + 1] - 1; // path2 length
|
|
|
+ var min: number = (l1 < l2) ? l1 : l2; // current path stop index
|
|
|
+ var shft: number = idx[1] - idx[0]; // shift
|
|
|
+ var path1nb: number = closeArray ? lg.length : lg.length - 1; // number of path1 to iterate
|
|
|
+ var t1: number; // two consecutive triangles, so 4 points : point1
|
|
|
+ var t2: number; // point2
|
|
|
+ var t3: number; // point3
|
|
|
+ var t4: number; // point4
|
|
|
+
|
|
|
+ while (pi <= min && p < path1nb) { // stay under min and don't go over next to last path
|
|
|
+ // draw two triangles between path1 (p1) and path2 (p2) : (p1.pi, p2.pi, p1.pi+1) and (p2.pi+1, p1.pi+1, p2.pi) clockwise
|
|
|
+ t1 = pi;
|
|
|
+ t2 = pi + shft;
|
|
|
+ t3 = pi + 1;
|
|
|
+ t4 = pi + shft + 1;
|
|
|
+
|
|
|
+ indices.push(pi, pi + shft, pi + 1);
|
|
|
+ indices.push(pi + shft + 1, pi + 1, pi + shft);
|
|
|
+ pi += 1;
|
|
|
+ if (pi === min) { // if end of one of two consecutive paths reached, go next existing path
|
|
|
if (closePath) { // if closePath, add last triangles between start and end of the paths
|
|
|
- indices.push(i, i + shft, idx[p]);
|
|
|
- indices.push(idx[p] + shft, idx[p], i + shft);
|
|
|
+ indices.push(pi, pi + shft, idx[p]);
|
|
|
+ indices.push(idx[p] + shft, idx[p], pi + shft);
|
|
|
t3 = idx[p];
|
|
|
t4 = idx[p] + shft;
|
|
|
}
|
|
|
@@ -411,8 +422,8 @@
|
|
|
l2 = lg[p + 1] - 1;
|
|
|
}
|
|
|
|
|
|
- i = idx[p];
|
|
|
- min = (l1 < l2) ? l1 + i : l2 + i;
|
|
|
+ pi = idx[p];
|
|
|
+ min = (l1 < l2) ? l1 + pi : l2 + pi;
|
|
|
}
|
|
|
}
|
|
|
|
jbousquie