151 lines
4.1 KiB
C++
151 lines
4.1 KiB
C++
#include "precompile.h"
|
|
|
|
#include <algorithm>
|
|
#include <cfloat>
|
|
#include <glm/gtx/intersect.hpp>
|
|
#include <glm/vec3.hpp>
|
|
|
|
void TestGlm()
|
|
{
|
|
glm::vec3 orig(0.0, 0.0, 0.0);
|
|
glm::vec3 dir(1.0, 1.0, 0);
|
|
glm::vec3 v0(0.0, 1.0, 0);
|
|
glm::vec3 v1(1.3, 1.0, 0);
|
|
glm::vec3 v2(0.0, 2.0, 0);
|
|
glm::vec3 baryPosition;
|
|
bool ret = glm::intersectRayTriangle(orig, dir, v0, v1, v2, baryPosition);
|
|
int i = 0;
|
|
}
|
|
|
|
bool IntersectSegmentCircle(Vector2D p0, Vector2D p1, Vector2D pos, float rad)
|
|
{
|
|
Vector2D t = p1 - p0;
|
|
float d = std::max(t.Norm(), 0.0001f);
|
|
Vector2D n = p0 - pos;
|
|
float v = n.Dot(t);
|
|
float z = n.Dot(n) - rad*rad;
|
|
if (z > 0 && v > 0) {
|
|
return false;
|
|
}
|
|
float u = v*v - z;
|
|
if (u < 0) {
|
|
return false;
|
|
}
|
|
float i = sqrt(u);
|
|
float x = -v - i;
|
|
if (x < 0 && (x = -v + i), x <= d) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool IntersectSegmentAabb(Vector2D p0, Vector2D p1, Vector2D _min, Vector2D _max)
|
|
{
|
|
float t = 0.0f;
|
|
float d = FLT_MAX;
|
|
Vector2D n = p0;
|
|
Vector2D v = p1 - p0;
|
|
float z = v.Norm();
|
|
v = z > (float)1e-5 ? v / z : Vector2D(1, 0);
|
|
if (std::abs(v.x) < (float)1e-5) {
|
|
v.x = float(2e-5);
|
|
}
|
|
if (std::abs(v.y) < (float)1e-5) {
|
|
v.y = (float)2e-5;
|
|
}
|
|
if (std::abs(v.x) > (float)1e-5) {
|
|
float u = (_min.x - n.x) / v.x;
|
|
float i = (_max.x - n.x) / v.x;
|
|
t = std::max(t, std::min(u, i));
|
|
d = std::min(d, std::max(u, i));
|
|
if (t > d) {
|
|
return false;
|
|
}
|
|
}
|
|
if (std::abs(v.y) > (float)1e-5) {
|
|
float x = (_min.y - n.y) / v.y;
|
|
float l = (_max.y - n.y) / v.y;
|
|
t = std::max(t, std::min(x, l));
|
|
d = std::min(d, std::max(x, l));
|
|
if (t > d) {
|
|
return false;
|
|
}
|
|
}
|
|
if (t > z) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool IntersectAabbCircle(Vector2D a_min, Vector2D a_max, Vector2D b_pos, float b_rad)
|
|
{
|
|
if (b_pos.x >= a_min.x && b_pos.x <= a_max.x &&
|
|
b_pos.y >= a_min.y && b_pos.y <= a_max.y) {
|
|
return true;
|
|
}
|
|
Vector2D nearest_point(a8::Clamp(b_pos.x, a_min.x, a_max.x),
|
|
a8::Clamp(b_pos.y, a_min.y, a_max.y));
|
|
Vector2D i = b_pos - nearest_point;
|
|
float n = a8::LengthSqr(i);
|
|
return n < b_rad*b_rad;
|
|
}
|
|
|
|
bool IntersectAabbAabb(Vector2D a_min, Vector2D a_max, Vector2D b_min, Vector2D b_max)
|
|
{
|
|
Vector2D a_v = (a_max - a_min) * 0.5f;
|
|
Vector2D a_center = a_min + a_v;
|
|
Vector2D b_v = (b_max - b_min) * 0.5f;
|
|
Vector2D b_center = b_min + b_v;
|
|
Vector2D z = b_center - a_center;
|
|
float u = a_v.x + b_v.x - std::abs(z.x);
|
|
return u > 0;
|
|
}
|
|
|
|
bool IntersectCircleCircle(Vector2D a_pos, float a_rad, Vector2D b_pos, float b_rad)
|
|
{
|
|
float t = a_rad + b_rad;
|
|
Vector2D d = b_pos - a_pos;
|
|
float n = a8::LengthSqr(d);
|
|
return n < t*t;
|
|
}
|
|
|
|
bool CircleContainCircle(Vector2D a_pos, float a_rad, Vector2D b_pos, float b_rad)
|
|
{
|
|
float distance = (a_pos - b_pos).Norm();
|
|
return distance < a_rad - b_rad;
|
|
}
|
|
|
|
bool CalcCircleAabbSafePoint(Vector2D a_min, Vector2D a_max, Vector2D b_pos, float b_rad,
|
|
Vector2D& new_pos)
|
|
{
|
|
new_pos = b_pos;
|
|
bool at_left = std::abs(b_pos.x - a_min.x) < std::abs(b_pos.x - a_max.x);
|
|
bool at_down = std::abs(b_pos.y - a_min.y) < std::abs(b_pos.y - a_max.y);
|
|
float x_len = at_left ? std::abs(b_pos.x - a_min.x) : std::abs(b_pos.x - a_max.x);
|
|
float y_len = at_down ? std::abs(b_pos.y - a_min.y) : std::abs(b_pos.y - a_max.y);
|
|
if (at_left) {
|
|
if (x_len < y_len) {
|
|
//左
|
|
new_pos.x = a_min.x - b_rad - 1;
|
|
} else {
|
|
if (at_down) {
|
|
new_pos.y = a_min.y - b_rad - 1;
|
|
} else {
|
|
new_pos.y = a_max.y + b_rad + 1;
|
|
}
|
|
}
|
|
} else {
|
|
if (x_len < y_len) {
|
|
//右
|
|
new_pos.x = a_max.x + b_rad + 1;
|
|
} else {
|
|
if (at_down) {
|
|
new_pos.y = a_min.y - b_rad - 1;
|
|
} else {
|
|
new_pos.y = a_max.y + b_rad + 1;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|