BlueGit

timfa frameworkv3

commit

timfa wsadhelios · pushed by timfa

Authored 2022-10-20 · 4 years ago

Hash
b7687e2ff7c38c78c8f0b6444319b5e2f415e87b
Parent
24db7846
1 file changed +38 −32
framework/util/ray.js +38 −32
@@ -1,49 +1,55 @@
1 1 class Ray
2 2 {
3 static Cast(scene, origin, direction, maxLength = -1)
3 static Cast (scene, origin, direction, maxLength = -1)
4 4 {
5 5 direction = direction.normalize();
6 let hits = [] // {hitObj, hitPoint}
7 for(var i = 0; i < scene.activeObjects.length; i++)
6 let hits = []; // {hitObj, hitPoint}
7 for (var i = 0; i < scene.activeObjects.length; i++)
8 8 {
9 9 let castAngle = direction.toAngle();
10 10
11 if(scene.activeObjects[i] != this && scene.activeObjects[i].collider.enabled)
11 if (scene.activeObjects[i] != this && scene.activeObjects[i].collider.enabled)
12 12 {
13 13 var hw = scene.activeObjects[i].transform.size.x / 2;
14 14 var hh = scene.activeObjects[i].transform.size.y / 2;
15
16 let points =
17 [
18 new vector(scene.activeObjects[i].transform.position.x - hw, scene.activeObjects[i].transform.position.y - hh),
19 new vector(scene.activeObjects[i].transform.position.x + hw, scene.activeObjects[i].transform.position.y - hh),
20 new vector(scene.activeObjects[i].transform.position.x - hw, scene.activeObjects[i].transform.position.y + hh),
21 new vector(scene.activeObjects[i].transform.position.x + hw, scene.activeObjects[i].transform.position.y + hh)
22 ]
23
24 points.sort((p1,p2) => p1.subtract(origin).length - p2.subtract(origin).length).pop();
25
26 for(let p = 0; p < points.length; p++)
15
16 let points =
17 [
18 new vector(scene.activeObjects[i].transform.position.x - hw, scene.activeObjects[i].transform.position.y - hh),
19 new vector(scene.activeObjects[i].transform.position.x + hw, scene.activeObjects[i].transform.position.y - hh),
20 new vector(scene.activeObjects[i].transform.position.x - hw, scene.activeObjects[i].transform.position.y + hh),
21 new vector(scene.activeObjects[i].transform.position.x + hw, scene.activeObjects[i].transform.position.y + hh)
22 ];
23
24 points.sort((p1, p2) => p1.subtract(origin).length - p2.subtract(origin).length).pop();
25
26 for (let p = 0; p < points.length; p++)
27 27 {
28 28 let point = points[p];
29 29 let deltaDistance = point.subtract(origin).length;
30 30
31 let stretched = direction.stretch(Math.min(deltaDistance, maxLength > 0? maxLength : deltaDistance))
31 if (deltaDistance > maxLength && maxLength > 0)
32 {
33 continue;
34 }
35
36 let stretched = direction.stretch(Math.min(deltaDistance, maxLength > 0 ? maxLength : deltaDistance));
32 37
33 38 let calcPoint = origin.add(stretched);
34 39
35 if(scene.activeObjects[i].collider.isInBounds(calcPoint))
40 if (scene.activeObjects[i].collider.isInBounds(calcPoint))
36 41 {
37 42 //determine in between which vector angles ray is
38 var angles = points.map(p => Ray.mapPointToPointAndAngle(p, origin))
43 var angles = points.map(p => Ray.mapPointToPointAndAngle(p, origin));
39 44
40 45 pointLoop:
41 for(let pa = 0; pa < angles.length; pa++)
46 for (let pa = 0; pa < angles.length; pa++)
42 47 {
43 for(let pb = 0; pb < angles.length; pb++)
48 for (let pb = 0; pb < angles.length; pb++)
44 49 {
45 if(angles[pa].angle - angles[pb].angle > 270 || angles[pb].angle - angles[pa].angle > 270) {
46
50 if (angles[pa].angle - angles[pb].angle > 270 || angles[pb].angle - angles[pa].angle > 270)
51 {
52
47 53 castAngle = (castAngle + 180) % 360;
48 54 angles.forEach(pIn => pIn.angle = (pIn.angle + 180) % 360);
49 55 break pointLoop;
@@ -51,9 +57,9 @@ class Ray
51 57 }
52 58 }
53 59
54 angles = angles.sort((a,b) => b.angle - a.angle);
55
56 if(angles[1].length > angles[0].length && angles[1].length > angles[2].length)
60 angles = angles.sort((a, b) => b.angle - a.angle);
61
62 if (angles[1].length > angles[0].length && angles[1].length > angles[2].length)
57 63 {
58 64 //only one face can be hit at this time, which is between angles[0] and angles[2]
59 65 angles.removeAt(1); //remove the center, connecting to the un-hittable face
@@ -63,12 +69,12 @@ class Ray
63 69 //one of two faces can be hit at this time, either angles[0]-angles[1] or angles[1]-angles[2]
64 70 (castAngle > angles[1].angle) ? angles.pop() : angles.shift(); //figure out on which side we are, and remove the furthest
65 71 }
66
72
67 73 //calc % of angle in relation to the angles it is between
68 74 let smallAngle = Math.min(angles[1].angle, angles[0].angle);
69 75 let percent = (castAngle - smallAngle) / (Math.max(angles[1].angle, angles[0].angle) - smallAngle);
70
71 hits.push({hitObj: scene.activeObjects[i], hitPoint: angles[1].point.lerpTo(angles[0].point, percent)})
76
77 hits.push({ hitObj: scene.activeObjects[i], hitPoint: angles[1].point.lerpTo(angles[0].point, percent) });
72 78 break;
73 79 }
74 80 }
@@ -77,9 +83,9 @@ class Ray
77 83
78 84 let shortest = hits[0];
79 85
80 for(let i = 0; i < hits.length; i++)
86 for (let i = 0; i < hits.length; i++)
81 87 {
82 if(hits[i].length < shortest.length)
88 if (hits[i].length < shortest.length)
83 89 {
84 90 shortest = hits[i];
85 91 }
@@ -88,7 +94,7 @@ class Ray
88 94 return shortest;
89 95 }
90 96
91 static mapPointToPointAndAngle(point, origin)
97 static mapPointToPointAndAngle (point, origin)
92 98 {
93 99 let delta = point.subtract(origin);
94 100
@@ -1,49 +1,55 @@
1class Ray
1class Ray
2{
2{
3 static Cast(scene, origin, direction, maxLength = -1)
3 static Cast (scene, origin, direction, maxLength = -1)
4 {
4 {
5 direction = direction.normalize();
5 direction = direction.normalize();
6 let hits = [] // {hitObj, hitPoint}
6 let hits = []; // {hitObj, hitPoint}
7 for(var i = 0; i < scene.activeObjects.length; i++)
7 for (var i = 0; i < scene.activeObjects.length; i++)
8 {
8 {
9 let castAngle = direction.toAngle();
9 let castAngle = direction.toAngle();
10
10
11 if(scene.activeObjects[i] != this && scene.activeObjects[i].collider.enabled)
11 if (scene.activeObjects[i] != this && scene.activeObjects[i].collider.enabled)
12 {
12 {
13 var hw = scene.activeObjects[i].transform.size.x / 2;
13 var hw = scene.activeObjects[i].transform.size.x / 2;
14 var hh = scene.activeObjects[i].transform.size.y / 2;
14 var hh = scene.activeObjects[i].transform.size.y / 2;
15
15
16 let points =
16 let points =
17 [
17 [
18 new vector(scene.activeObjects[i].transform.position.x - hw, scene.activeObjects[i].transform.position.y - hh),
18 new vector(scene.activeObjects[i].transform.position.x - hw, scene.activeObjects[i].transform.position.y - hh),
19 new vector(scene.activeObjects[i].transform.position.x + hw, scene.activeObjects[i].transform.position.y - hh),
19 new vector(scene.activeObjects[i].transform.position.x + hw, scene.activeObjects[i].transform.position.y - hh),
20 new vector(scene.activeObjects[i].transform.position.x - hw, scene.activeObjects[i].transform.position.y + hh),
20 new vector(scene.activeObjects[i].transform.position.x - hw, scene.activeObjects[i].transform.position.y + hh),
21 new vector(scene.activeObjects[i].transform.position.x + hw, scene.activeObjects[i].transform.position.y + hh)
21 new vector(scene.activeObjects[i].transform.position.x + hw, scene.activeObjects[i].transform.position.y + hh)
22 ]
22 ];
23
23
24 points.sort((p1,p2) => p1.subtract(origin).length - p2.subtract(origin).length).pop();
24 points.sort((p1, p2) => p1.subtract(origin).length - p2.subtract(origin).length).pop();
25
25
26 for(let p = 0; p < points.length; p++)
26 for (let p = 0; p < points.length; p++)
27 {
27 {
28 let point = points[p];
28 let point = points[p];
29 let deltaDistance = point.subtract(origin).length;
29 let deltaDistance = point.subtract(origin).length;
30
30
31 let stretched = direction.stretch(Math.min(deltaDistance, maxLength > 0? maxLength : deltaDistance))
31 if (deltaDistance > maxLength && maxLength > 0)
32 {
33 continue;
34 }
35
36 let stretched = direction.stretch(Math.min(deltaDistance, maxLength > 0 ? maxLength : deltaDistance));
32
37
33 let calcPoint = origin.add(stretched);
38 let calcPoint = origin.add(stretched);
34
39
35 if(scene.activeObjects[i].collider.isInBounds(calcPoint))
40 if (scene.activeObjects[i].collider.isInBounds(calcPoint))
36 {
41 {
37 //determine in between which vector angles ray is
42 //determine in between which vector angles ray is
38 var angles = points.map(p => Ray.mapPointToPointAndAngle(p, origin))
43 var angles = points.map(p => Ray.mapPointToPointAndAngle(p, origin));
39
44
40 pointLoop:
45 pointLoop:
41 for(let pa = 0; pa < angles.length; pa++)
46 for (let pa = 0; pa < angles.length; pa++)
42 {
47 {
43 for(let pb = 0; pb < angles.length; pb++)
48 for (let pb = 0; pb < angles.length; pb++)
44 {
49 {
45 if(angles[pa].angle - angles[pb].angle > 270 || angles[pb].angle - angles[pa].angle > 270) {
50 if (angles[pa].angle - angles[pb].angle > 270 || angles[pb].angle - angles[pa].angle > 270)
46
51 {
52
47 castAngle = (castAngle + 180) % 360;
53 castAngle = (castAngle + 180) % 360;
48 angles.forEach(pIn => pIn.angle = (pIn.angle + 180) % 360);
54 angles.forEach(pIn => pIn.angle = (pIn.angle + 180) % 360);
49 break pointLoop;
55 break pointLoop;
@@ -51,9 +57,9 @@ class Ray
51 }
57 }
52 }
58 }
53
59
54 angles = angles.sort((a,b) => b.angle - a.angle);
60 angles = angles.sort((a, b) => b.angle - a.angle);
55
61
56 if(angles[1].length > angles[0].length && angles[1].length > angles[2].length)
62 if (angles[1].length > angles[0].length && angles[1].length > angles[2].length)
57 {
63 {
58 //only one face can be hit at this time, which is between angles[0] and angles[2]
64 //only one face can be hit at this time, which is between angles[0] and angles[2]
59 angles.removeAt(1); //remove the center, connecting to the un-hittable face
65 angles.removeAt(1); //remove the center, connecting to the un-hittable face
@@ -63,12 +69,12 @@ class Ray
63 //one of two faces can be hit at this time, either angles[0]-angles[1] or angles[1]-angles[2]
69 //one of two faces can be hit at this time, either angles[0]-angles[1] or angles[1]-angles[2]
64 (castAngle > angles[1].angle) ? angles.pop() : angles.shift(); //figure out on which side we are, and remove the furthest
70 (castAngle > angles[1].angle) ? angles.pop() : angles.shift(); //figure out on which side we are, and remove the furthest
65 }
71 }
66
72
67 //calc % of angle in relation to the angles it is between
73 //calc % of angle in relation to the angles it is between
68 let smallAngle = Math.min(angles[1].angle, angles[0].angle);
74 let smallAngle = Math.min(angles[1].angle, angles[0].angle);
69 let percent = (castAngle - smallAngle) / (Math.max(angles[1].angle, angles[0].angle) - smallAngle);
75 let percent = (castAngle - smallAngle) / (Math.max(angles[1].angle, angles[0].angle) - smallAngle);
70
76
71 hits.push({hitObj: scene.activeObjects[i], hitPoint: angles[1].point.lerpTo(angles[0].point, percent)})
77 hits.push({ hitObj: scene.activeObjects[i], hitPoint: angles[1].point.lerpTo(angles[0].point, percent) });
72 break;
78 break;
73 }
79 }
74 }
80 }
@@ -77,9 +83,9 @@ class Ray
77
83
78 let shortest = hits[0];
84 let shortest = hits[0];
79
85
80 for(let i = 0; i < hits.length; i++)
86 for (let i = 0; i < hits.length; i++)
81 {
87 {
82 if(hits[i].length < shortest.length)
88 if (hits[i].length < shortest.length)
83 {
89 {
84 shortest = hits[i];
90 shortest = hits[i];
85 }
91 }
@@ -88,7 +94,7 @@ class Ray
88 return shortest;
94 return shortest;
89 }
95 }
90
96
91 static mapPointToPointAndAngle(point, origin)
97 static mapPointToPointAndAngle (point, origin)
92 {
98 {
93 let delta = point.subtract(origin);
99 let delta = point.subtract(origin);
94
100