Merge pull request #31667 from YeldhamDev/geometry_point_circle_cleanup
Add 'is_point_in_circle()' to Geometry class, and general file cleanup
This commit is contained in:
Rémi Verschelde
GitHub
commit
69de1eca01
|
|
@ -1432,6 +1432,11 @@ PoolVector<Plane> _Geometry::build_capsule_planes(float p_radius, float p_height
|
|||
return Geometry::build_capsule_planes(p_radius, p_height, p_sides, p_lats, p_axis);
|
||||
}
|
||||
|
||||
bool _Geometry::is_point_in_circle(const Vector2 &p_point, const Vector2 &p_circle_pos, real_t p_circle_radius) {
|
||||
|
||||
return Geometry::is_point_in_circle(p_point, p_circle_pos, p_circle_radius);
|
||||
}
|
||||
|
||||
real_t _Geometry::segment_intersects_circle(const Vector2 &p_from, const Vector2 &p_to, const Vector2 &p_circle_pos, real_t p_circle_radius) {
|
||||
|
||||
return Geometry::segment_intersects_circle(p_from, p_to, p_circle_pos, p_circle_radius);
|
||||
|
|
@ -1727,6 +1732,7 @@ void _Geometry::_bind_methods() {
|
|||
ClassDB::bind_method(D_METHOD("build_box_planes", "extents"), &_Geometry::build_box_planes);
|
||||
ClassDB::bind_method(D_METHOD("build_cylinder_planes", "radius", "height", "sides", "axis"), &_Geometry::build_cylinder_planes, DEFVAL(Vector3::AXIS_Z));
|
||||
ClassDB::bind_method(D_METHOD("build_capsule_planes", "radius", "height", "sides", "lats", "axis"), &_Geometry::build_capsule_planes, DEFVAL(Vector3::AXIS_Z));
|
||||
ClassDB::bind_method(D_METHOD("is_point_in_circle", "point", "circle_position", "circle_radius"), &_Geometry::is_point_in_circle);
|
||||
ClassDB::bind_method(D_METHOD("segment_intersects_circle", "segment_from", "segment_to", "circle_position", "circle_radius"), &_Geometry::segment_intersects_circle);
|
||||
ClassDB::bind_method(D_METHOD("segment_intersects_segment_2d", "from_a", "to_a", "from_b", "to_b"), &_Geometry::segment_intersects_segment_2d);
|
||||
ClassDB::bind_method(D_METHOD("line_intersects_line_2d", "from_a", "dir_a", "from_b", "dir_b"), &_Geometry::line_intersects_line_2d);
|
||||
|
|
|
|||
|
|
@ -109,11 +109,11 @@ public:
|
|||
};
|
||||
|
||||
enum PowerState {
|
||||
POWERSTATE_UNKNOWN, /**< cannot determine power status */
|
||||
POWERSTATE_ON_BATTERY, /**< Not plugged in, running on the battery */
|
||||
POWERSTATE_NO_BATTERY, /**< Plugged in, no battery available */
|
||||
POWERSTATE_CHARGING, /**< Plugged in, charging battery */
|
||||
POWERSTATE_CHARGED /**< Plugged in, battery charged */
|
||||
POWERSTATE_UNKNOWN, // Cannot determine power status.
|
||||
POWERSTATE_ON_BATTERY, // Not plugged in, running on the battery.
|
||||
POWERSTATE_NO_BATTERY, // Plugged in, no battery available.
|
||||
POWERSTATE_CHARGING, // Plugged in, charging battery.
|
||||
POWERSTATE_CHARGED // Plugged in, battery charged.
|
||||
};
|
||||
|
||||
enum Weekday {
|
||||
|
|
@ -127,8 +127,8 @@ public:
|
|||
};
|
||||
|
||||
enum Month {
|
||||
/// Start at 1 to follow Windows SYSTEMTIME structure
|
||||
/// https://msdn.microsoft.com/en-us/library/windows/desktop/ms724950(v=vs.85).aspx
|
||||
// Start at 1 to follow Windows SYSTEMTIME structure
|
||||
// https://msdn.microsoft.com/en-us/library/windows/desktop/ms724950(v=vs.85).aspx
|
||||
MONTH_JANUARY = 1,
|
||||
MONTH_FEBRUARY,
|
||||
MONTH_MARCH,
|
||||
|
|
@ -264,24 +264,6 @@ public:
|
|||
bool is_scancode_unicode(uint32_t p_unicode) const;
|
||||
int find_scancode_from_string(const String &p_code) const;
|
||||
|
||||
/*
|
||||
struct Date {
|
||||
|
||||
int year;
|
||||
Month month;
|
||||
int day;
|
||||
Weekday weekday;
|
||||
bool dst;
|
||||
};
|
||||
|
||||
struct Time {
|
||||
|
||||
int hour;
|
||||
int min;
|
||||
int sec;
|
||||
};
|
||||
*/
|
||||
|
||||
void set_use_file_access_save_and_swap(bool p_enable);
|
||||
|
||||
void set_native_icon(const String &p_filename);
|
||||
|
|
@ -409,6 +391,7 @@ public:
|
|||
PoolVector<Vector3> segment_intersects_sphere(const Vector3 &p_from, const Vector3 &p_to, const Vector3 &p_sphere_pos, real_t p_sphere_radius);
|
||||
PoolVector<Vector3> segment_intersects_cylinder(const Vector3 &p_from, const Vector3 &p_to, float p_height, float p_radius);
|
||||
PoolVector<Vector3> segment_intersects_convex(const Vector3 &p_from, const Vector3 &p_to, const Vector<Plane> &p_planes);
|
||||
bool is_point_in_circle(const Vector2 &p_point, const Vector2 &p_circle_pos, real_t p_circle_radius);
|
||||
real_t segment_intersects_circle(const Vector2 &p_from, const Vector2 &p_to, const Vector2 &p_circle_pos, real_t p_circle_radius);
|
||||
int get_uv84_normal_bit(const Vector3 &p_vector);
|
||||
|
||||
|
|
@ -425,17 +408,17 @@ public:
|
|||
OPERATION_INTERSECTION,
|
||||
OPERATION_XOR
|
||||
};
|
||||
// 2D polygon boolean operations
|
||||
Array merge_polygons_2d(const Vector<Vector2> &p_polygon_a, const Vector<Vector2> &p_polygon_b); // union (add)
|
||||
Array clip_polygons_2d(const Vector<Vector2> &p_polygon_a, const Vector<Vector2> &p_polygon_b); // difference (subtract)
|
||||
Array intersect_polygons_2d(const Vector<Vector2> &p_polygon_a, const Vector<Vector2> &p_polygon_b); // common area (multiply)
|
||||
Array exclude_polygons_2d(const Vector<Vector2> &p_polygon_a, const Vector<Vector2> &p_polygon_b); // all but common area (xor)
|
||||
// 2D polygon boolean operations.
|
||||
Array merge_polygons_2d(const Vector<Vector2> &p_polygon_a, const Vector<Vector2> &p_polygon_b); // Union (add).
|
||||
Array clip_polygons_2d(const Vector<Vector2> &p_polygon_a, const Vector<Vector2> &p_polygon_b); // Difference (subtract).
|
||||
Array intersect_polygons_2d(const Vector<Vector2> &p_polygon_a, const Vector<Vector2> &p_polygon_b); // Common area (multiply).
|
||||
Array exclude_polygons_2d(const Vector<Vector2> &p_polygon_a, const Vector<Vector2> &p_polygon_b); // All but common area (xor).
|
||||
|
||||
// 2D polyline vs polygon operations
|
||||
Array clip_polyline_with_polygon_2d(const Vector<Vector2> &p_polyline, const Vector<Vector2> &p_polygon); // cut
|
||||
Array intersect_polyline_with_polygon_2d(const Vector<Vector2> &p_polyline, const Vector<Vector2> &p_polygon); // chop
|
||||
// 2D polyline vs polygon operations.
|
||||
Array clip_polyline_with_polygon_2d(const Vector<Vector2> &p_polyline, const Vector<Vector2> &p_polygon); // Cut.
|
||||
Array intersect_polyline_with_polygon_2d(const Vector<Vector2> &p_polyline, const Vector<Vector2> &p_polygon); // Chop.
|
||||
|
||||
// 2D offset polygons/polylines
|
||||
// 2D offset polygons/polylines.
|
||||
enum PolyJoinType {
|
||||
JOIN_SQUARE,
|
||||
JOIN_ROUND,
|
||||
|
|
@ -491,24 +474,24 @@ public:
|
|||
Error open_encrypted_pass(const String &p_path, ModeFlags p_mode_flags, const String &p_pass);
|
||||
Error open_compressed(const String &p_path, ModeFlags p_mode_flags, CompressionMode p_compress_mode = COMPRESSION_FASTLZ);
|
||||
|
||||
Error open(const String &p_path, ModeFlags p_mode_flags); ///< open a file
|
||||
void close(); ///< close a file
|
||||
bool is_open() const; ///< true when file is open
|
||||
Error open(const String &p_path, ModeFlags p_mode_flags); // open a file.
|
||||
void close(); // Close a file.
|
||||
bool is_open() const; // True when file is open.
|
||||
|
||||
String get_path() const; /// returns the path for the current open file
|
||||
String get_path_absolute() const; /// returns the absolute path for the current open file
|
||||
String get_path() const; // Returns the path for the current open file.
|
||||
String get_path_absolute() const; // Returns the absolute path for the current open file.
|
||||
|
||||
void seek(int64_t p_position); ///< seek to a given position
|
||||
void seek_end(int64_t p_position = 0); ///< seek from the end of file
|
||||
int64_t get_position() const; ///< get position in the file
|
||||
int64_t get_len() const; ///< get size of the file
|
||||
void seek(int64_t p_position); // Seek to a given position.
|
||||
void seek_end(int64_t p_position = 0); // Seek from the end of file.
|
||||
int64_t get_position() const; // Get position in the file.
|
||||
int64_t get_len() const; // Get size of the file.
|
||||
|
||||
bool eof_reached() const; ///< reading passed EOF
|
||||
bool eof_reached() const; // Reading passed EOF.
|
||||
|
||||
uint8_t get_8() const; ///< get a byte
|
||||
uint16_t get_16() const; ///< get 16 bits uint
|
||||
uint32_t get_32() const; ///< get 32 bits uint
|
||||
uint64_t get_64() const; ///< get 64 bits uint
|
||||
uint8_t get_8() const; // Get a byte.
|
||||
uint16_t get_16() const; // Get 16 bits uint.
|
||||
uint32_t get_32() const; // Get 32 bits uint.
|
||||
uint64_t get_64() const; // Get 64 bits uint.
|
||||
|
||||
float get_float() const;
|
||||
double get_double() const;
|
||||
|
|
@ -516,27 +499,27 @@ public:
|
|||
|
||||
Variant get_var(bool p_allow_objects = false) const;
|
||||
|
||||
PoolVector<uint8_t> get_buffer(int p_length) const; ///< get an array of bytes
|
||||
PoolVector<uint8_t> get_buffer(int p_length) const; // Get an array of bytes.
|
||||
String get_line() const;
|
||||
Vector<String> get_csv_line(const String &p_delim = ",") const;
|
||||
String get_as_text() const;
|
||||
String get_md5(const String &p_path) const;
|
||||
String get_sha256(const String &p_path) const;
|
||||
|
||||
/**< use this for files WRITTEN in _big_ endian machines (ie, amiga/mac)
|
||||
/* Use this for files WRITTEN in _big_ endian machines (ie, amiga/mac).
|
||||
* It's not about the current CPU type but file formats.
|
||||
* this flags get reset to false (little endian) on each open
|
||||
* This flags get reset to false (little endian) on each open.
|
||||
*/
|
||||
|
||||
void set_endian_swap(bool p_swap);
|
||||
bool get_endian_swap();
|
||||
|
||||
Error get_error() const; ///< get last error
|
||||
Error get_error() const; // Get last error.
|
||||
|
||||
void store_8(uint8_t p_dest); ///< store a byte
|
||||
void store_16(uint16_t p_dest); ///< store 16 bits uint
|
||||
void store_32(uint32_t p_dest); ///< store 32 bits uint
|
||||
void store_64(uint64_t p_dest); ///< store 64 bits uint
|
||||
void store_8(uint8_t p_dest); // Store a byte.
|
||||
void store_16(uint16_t p_dest); // Store 16 bits uint.
|
||||
void store_32(uint32_t p_dest); // Store 32 bits uint.
|
||||
void store_64(uint64_t p_dest); // Store 64 bits uint.
|
||||
|
||||
void store_float(float p_dest);
|
||||
void store_double(double p_dest);
|
||||
|
|
@ -549,11 +532,11 @@ public:
|
|||
virtual void store_pascal_string(const String &p_string);
|
||||
virtual String get_pascal_string();
|
||||
|
||||
void store_buffer(const PoolVector<uint8_t> &p_buffer); ///< store an array of bytes
|
||||
void store_buffer(const PoolVector<uint8_t> &p_buffer); // Store an array of bytes.
|
||||
|
||||
void store_var(const Variant &p_var, bool p_full_objects = false);
|
||||
|
||||
bool file_exists(const String &p_name) const; ///< return true if a file exists
|
||||
bool file_exists(const String &p_name) const; // Return true if a file exists.
|
||||
|
||||
uint64_t get_modified_time(const String &p_file) const;
|
||||
|
||||
|
|
@ -575,18 +558,18 @@ protected:
|
|||
public:
|
||||
Error open(const String &p_path);
|
||||
|
||||
Error list_dir_begin(bool p_skip_navigational = false, bool p_skip_hidden = false); ///< This starts dir listing
|
||||
Error list_dir_begin(bool p_skip_navigational = false, bool p_skip_hidden = false); // This starts dir listing.
|
||||
String get_next();
|
||||
bool current_is_dir() const;
|
||||
|
||||
void list_dir_end(); ///<
|
||||
void list_dir_end();
|
||||
|
||||
int get_drive_count();
|
||||
String get_drive(int p_drive);
|
||||
int get_current_drive();
|
||||
|
||||
Error change_dir(String p_dir); ///< can be relative or absolute, return false on success
|
||||
String get_current_dir(); ///< return current dir location
|
||||
Error change_dir(String p_dir); // Can be relative or absolute, return false on success.
|
||||
String get_current_dir(); // Return current dir location.
|
||||
|
||||
Error make_dir(String p_dir);
|
||||
Error make_dir_recursive(String p_dir);
|
||||
|
|
|
|||
|
|
@ -34,9 +34,10 @@
|
|||
#include "thirdparty/misc/clipper.hpp"
|
||||
#include "thirdparty/misc/triangulator.h"
|
||||
|
||||
#define SCALE_FACTOR 100000.0 // based on CMP_EPSILON
|
||||
#define SCALE_FACTOR 100000.0 // Based on CMP_EPSILON.
|
||||
|
||||
/* this implementation is very inefficient, commenting unless bugs happen. See the other one.
|
||||
// This implementation is very inefficient, commenting unless bugs happen. See the other one.
|
||||
/*
|
||||
bool Geometry::is_point_in_polygon(const Vector2 &p_point, const Vector<Vector2> &p_polygon) {
|
||||
|
||||
Vector<int> indices = Geometry::triangulate_polygon(p_polygon);
|
||||
|
|
@ -124,8 +125,8 @@ struct _FaceClassify {
|
|||
};
|
||||
|
||||
static bool _connect_faces(_FaceClassify *p_faces, int len, int p_group) {
|
||||
/* connect faces, error will occur if an edge is shared between more than 2 faces */
|
||||
/* clear connections */
|
||||
// Connect faces, error will occur if an edge is shared between more than 2 faces.
|
||||
// Clear connections.
|
||||
|
||||
bool error = false;
|
||||
|
||||
|
|
@ -195,13 +196,6 @@ static bool _connect_faces(_FaceClassify *p_faces, int len, int p_group) {
|
|||
if (p_faces[i].links[j].face == -1)
|
||||
p_faces[i].valid = false;
|
||||
}
|
||||
/*printf("face %i is valid: %i, group %i. connected to %i:%i,%i:%i,%i:%i\n",i,p_faces[i].valid,p_faces[i].group,
|
||||
p_faces[i].links[0].face,
|
||||
p_faces[i].links[0].edge,
|
||||
p_faces[i].links[1].face,
|
||||
p_faces[i].links[1].edge,
|
||||
p_faces[i].links[2].face,
|
||||
p_faces[i].links[2].edge);*/
|
||||
}
|
||||
return error;
|
||||
}
|
||||
|
|
@ -249,10 +243,10 @@ PoolVector<PoolVector<Face3> > Geometry::separate_objects(PoolVector<Face3> p_ar
|
|||
|
||||
if (error) {
|
||||
|
||||
ERR_FAIL_COND_V(error, PoolVector<PoolVector<Face3> >()); // invalid geometry
|
||||
ERR_FAIL_COND_V(error, PoolVector<PoolVector<Face3> >()); // Invalid geometry.
|
||||
}
|
||||
|
||||
/* group connected faces in separate objects */
|
||||
// Group connected faces in separate objects.
|
||||
|
||||
int group = 0;
|
||||
for (int i = 0; i < len; i++) {
|
||||
|
|
@ -264,7 +258,7 @@ PoolVector<PoolVector<Face3> > Geometry::separate_objects(PoolVector<Face3> p_ar
|
|||
}
|
||||
}
|
||||
|
||||
/* group connected faces in separate objects */
|
||||
// Group connected faces in separate objects.
|
||||
|
||||
for (int i = 0; i < len; i++) {
|
||||
|
||||
|
|
@ -376,7 +370,7 @@ static inline void _plot_face(uint8_t ***p_cell_status, int x, int y, int z, int
|
|||
static inline void _mark_outside(uint8_t ***p_cell_status, int x, int y, int z, int len_x, int len_y, int len_z) {
|
||||
|
||||
if (p_cell_status[x][y][z] & 3)
|
||||
return; // nothing to do, already used and/or visited
|
||||
return; // Nothing to do, already used and/or visited.
|
||||
|
||||
p_cell_status[x][y][z] = _CELL_PREV_FIRST;
|
||||
|
||||
|
|
@ -384,29 +378,20 @@ static inline void _mark_outside(uint8_t ***p_cell_status, int x, int y, int z,
|
|||
|
||||
uint8_t &c = p_cell_status[x][y][z];
|
||||
|
||||
//printf("at %i,%i,%i\n",x,y,z);
|
||||
|
||||
if ((c & _CELL_STEP_MASK) == _CELL_STEP_NONE) {
|
||||
/* Haven't been in here, mark as outside */
|
||||
// Haven't been in here, mark as outside.
|
||||
p_cell_status[x][y][z] |= _CELL_EXTERIOR;
|
||||
//printf("not marked as anything, marking exterior\n");
|
||||
}
|
||||
|
||||
//printf("cell step is %i\n",(c&_CELL_STEP_MASK));
|
||||
|
||||
if ((c & _CELL_STEP_MASK) != _CELL_STEP_DONE) {
|
||||
/* if not done, increase step */
|
||||
// If not done, increase step.
|
||||
c += 1 << 2;
|
||||
//printf("incrementing cell step\n");
|
||||
}
|
||||
|
||||
if ((c & _CELL_STEP_MASK) == _CELL_STEP_DONE) {
|
||||
/* Go back */
|
||||
//printf("done, going back a cell\n");
|
||||
|
||||
// Go back.
|
||||
switch (c & _CELL_PREV_MASK) {
|
||||
case _CELL_PREV_FIRST: {
|
||||
//printf("at end, finished marking\n");
|
||||
return;
|
||||
} break;
|
||||
case _CELL_PREV_Y_POS: {
|
||||
|
|
@ -440,8 +425,6 @@ static inline void _mark_outside(uint8_t ***p_cell_status, int x, int y, int z,
|
|||
continue;
|
||||
}
|
||||
|
||||
//printf("attempting new cell!\n");
|
||||
|
||||
int next_x = x, next_y = y, next_z = z;
|
||||
uint8_t prev = 0;
|
||||
|
||||
|
|
@ -475,8 +458,6 @@ static inline void _mark_outside(uint8_t ***p_cell_status, int x, int y, int z,
|
|||
default: ERR_FAIL();
|
||||
}
|
||||
|
||||
//printf("testing if new cell will be ok...!\n");
|
||||
|
||||
if (next_x < 0 || next_x >= len_x)
|
||||
continue;
|
||||
if (next_y < 0 || next_y >= len_y)
|
||||
|
|
@ -484,13 +465,9 @@ static inline void _mark_outside(uint8_t ***p_cell_status, int x, int y, int z,
|
|||
if (next_z < 0 || next_z >= len_z)
|
||||
continue;
|
||||
|
||||
//printf("testing if new cell is traversable\n");
|
||||
|
||||
if (p_cell_status[next_x][next_y][next_z] & 3)
|
||||
continue;
|
||||
|
||||
//printf("move to it\n");
|
||||
|
||||
x = next_x;
|
||||
y = next_y;
|
||||
z = next_z;
|
||||
|
|
@ -507,17 +484,6 @@ static inline void _build_faces(uint8_t ***p_cell_status, int x, int y, int z, i
|
|||
if (p_cell_status[x][y][z] & _CELL_EXTERIOR)
|
||||
return;
|
||||
|
||||
/* static const Vector3 vertices[8]={
|
||||
Vector3(0,0,0),
|
||||
Vector3(0,0,1),
|
||||
Vector3(0,1,0),
|
||||
Vector3(0,1,1),
|
||||
Vector3(1,0,0),
|
||||
Vector3(1,0,1),
|
||||
Vector3(1,1,0),
|
||||
Vector3(1,1,1),
|
||||
};
|
||||
*/
|
||||
#define vert(m_idx) Vector3(((m_idx)&4) >> 2, ((m_idx)&2) >> 1, (m_idx)&1)
|
||||
|
||||
static const uint8_t indices[6][4] = {
|
||||
|
|
@ -529,22 +495,6 @@ static inline void _build_faces(uint8_t ***p_cell_status, int x, int y, int z, i
|
|||
{ 0, 4, 6, 2 },
|
||||
|
||||
};
|
||||
/*
|
||||
|
||||
{0,1,2,3},
|
||||
{0,1,4,5},
|
||||
{0,2,4,6},
|
||||
{4,5,6,7},
|
||||
{2,3,7,6},
|
||||
{1,3,5,7},
|
||||
|
||||
{0,2,3,1},
|
||||
{0,1,5,4},
|
||||
{0,4,6,2},
|
||||
{7,6,4,5},
|
||||
{7,3,2,6},
|
||||
{7,5,1,3},
|
||||
*/
|
||||
|
||||
for (int i = 0; i < 6; i++) {
|
||||
|
||||
|
|
@ -607,9 +557,9 @@ PoolVector<Face3> Geometry::wrap_geometry(PoolVector<Face3> p_array, real_t *p_e
|
|||
}
|
||||
}
|
||||
|
||||
global_aabb.grow_by(0.01); // avoid numerical error
|
||||
global_aabb.grow_by(0.01); // Avoid numerical error.
|
||||
|
||||
// determine amount of cells in grid axis
|
||||
// Determine amount of cells in grid axis.
|
||||
int div_x, div_y, div_z;
|
||||
|
||||
if (global_aabb.size.x / _MIN_SIZE < _MAX_LENGTH)
|
||||
|
|
@ -632,7 +582,7 @@ PoolVector<Face3> Geometry::wrap_geometry(PoolVector<Face3> p_array, real_t *p_e
|
|||
voxelsize.y /= div_y;
|
||||
voxelsize.z /= div_z;
|
||||
|
||||
// create and initialize cells to zero
|
||||
// Create and initialize cells to zero.
|
||||
|
||||
uint8_t ***cell_status = memnew_arr(uint8_t **, div_x);
|
||||
for (int i = 0; i < div_x; i++) {
|
||||
|
|
@ -650,7 +600,7 @@ PoolVector<Face3> Geometry::wrap_geometry(PoolVector<Face3> p_array, real_t *p_e
|
|||
}
|
||||
}
|
||||
|
||||
// plot faces into cells
|
||||
// Plot faces into cells.
|
||||
|
||||
for (int i = 0; i < face_count; i++) {
|
||||
|
||||
|
|
@ -662,7 +612,7 @@ PoolVector<Face3> Geometry::wrap_geometry(PoolVector<Face3> p_array, real_t *p_e
|
|||
_plot_face(cell_status, 0, 0, 0, div_x, div_y, div_z, voxelsize, f);
|
||||
}
|
||||
|
||||
// determine which cells connect to the outside by traversing the outside and recursively flood-fill marking
|
||||
// Determine which cells connect to the outside by traversing the outside and recursively flood-fill marking.
|
||||
|
||||
for (int i = 0; i < div_x; i++) {
|
||||
|
||||
|
|
@ -691,7 +641,7 @@ PoolVector<Face3> Geometry::wrap_geometry(PoolVector<Face3> p_array, real_t *p_e
|
|||
}
|
||||
}
|
||||
|
||||
// build faces for the inside-outside cell divisors
|
||||
// Build faces for the inside-outside cell divisors.
|
||||
|
||||
PoolVector<Face3> wrapped_faces;
|
||||
|
||||
|
|
@ -706,7 +656,7 @@ PoolVector<Face3> Geometry::wrap_geometry(PoolVector<Face3> p_array, real_t *p_e
|
|||
}
|
||||
}
|
||||
|
||||
// transform face vertices to global coords
|
||||
// Transform face vertices to global coords.
|
||||
|
||||
int wrapped_faces_count = wrapped_faces.size();
|
||||
PoolVector<Face3>::Write wrapped_facesw = wrapped_faces.write();
|
||||
|
|
@ -753,7 +703,7 @@ Vector<Vector<Vector2> > Geometry::decompose_polygon_in_convex(Vector<Point2> po
|
|||
inp.SetOrientation(TRIANGULATOR_CCW);
|
||||
in_poly.push_back(inp);
|
||||
TriangulatorPartition tpart;
|
||||
if (tpart.ConvexPartition_HM(&in_poly, &out_poly) == 0) { //failed!
|
||||
if (tpart.ConvexPartition_HM(&in_poly, &out_poly) == 0) { // Failed.
|
||||
ERR_PRINT("Convex decomposing failed!");
|
||||
return decomp;
|
||||
}
|
||||
|
|
@ -781,7 +731,7 @@ Geometry::MeshData Geometry::build_convex_mesh(const PoolVector<Plane> &p_planes
|
|||
|
||||
#define SUBPLANE_SIZE 1024.0
|
||||
|
||||
real_t subplane_size = 1024.0; // should compute this from the actual plane
|
||||
real_t subplane_size = 1024.0; // Should compute this from the actual plane.
|
||||
for (int i = 0; i < p_planes.size(); i++) {
|
||||
|
||||
Plane p = p_planes[i];
|
||||
|
|
@ -789,7 +739,7 @@ Geometry::MeshData Geometry::build_convex_mesh(const PoolVector<Plane> &p_planes
|
|||
Vector3 ref = Vector3(0.0, 1.0, 0.0);
|
||||
|
||||
if (ABS(p.normal.dot(ref)) > 0.95)
|
||||
ref = Vector3(0.0, 0.0, 1.0); // change axis
|
||||
ref = Vector3(0.0, 0.0, 1.0); // Change axis.
|
||||
|
||||
Vector3 right = p.normal.cross(ref).normalized();
|
||||
Vector3 up = p.normal.cross(right).normalized();
|
||||
|
|
@ -827,20 +777,20 @@ Geometry::MeshData Geometry::build_convex_mesh(const PoolVector<Plane> &p_planes
|
|||
real_t dist0 = clip.distance_to(edge0_A);
|
||||
real_t dist1 = clip.distance_to(edge1_A);
|
||||
|
||||
if (dist0 <= 0) { // behind plane
|
||||
if (dist0 <= 0) { // Behind plane.
|
||||
|
||||
new_vertices.push_back(vertices[k]);
|
||||
}
|
||||
|
||||
// check for different sides and non coplanar
|
||||
// Check for different sides and non coplanar.
|
||||
if ((dist0 * dist1) < 0) {
|
||||
|
||||
// calculate intersection
|
||||
// Calculate intersection.
|
||||
Vector3 rel = edge1_A - edge0_A;
|
||||
|
||||
real_t den = clip.normal.dot(rel);
|
||||
if (Math::is_zero_approx(den))
|
||||
continue; // point too short
|
||||
continue; // Point too short.
|
||||
|
||||
real_t dist = -(clip.normal.dot(edge0_A) - clip.d) / den;
|
||||
Vector3 inters = edge0_A + rel * dist;
|
||||
|
|
@ -854,11 +804,11 @@ Geometry::MeshData Geometry::build_convex_mesh(const PoolVector<Plane> &p_planes
|
|||
if (vertices.size() < 3)
|
||||
continue;
|
||||
|
||||
//result is a clockwise face
|
||||
// Result is a clockwise face.
|
||||
|
||||
MeshData::Face face;
|
||||
|
||||
// add face indices
|
||||
// Add face indices.
|
||||
for (int j = 0; j < vertices.size(); j++) {
|
||||
|
||||
int idx = -1;
|
||||
|
|
@ -882,7 +832,7 @@ Geometry::MeshData Geometry::build_convex_mesh(const PoolVector<Plane> &p_planes
|
|||
face.plane = p;
|
||||
mesh.faces.push_back(face);
|
||||
|
||||
//add edge
|
||||
// Add edge.
|
||||
|
||||
for (int j = 0; j < face.indices.size(); j++) {
|
||||
|
||||
|
|
@ -972,7 +922,7 @@ PoolVector<Plane> Geometry::build_sphere_planes(real_t p_radius, int p_lats, int
|
|||
|
||||
for (int j = 1; j <= p_lats; j++) {
|
||||
|
||||
//todo this is stupid, fix
|
||||
// FIXME: This is stupid.
|
||||
Vector3 angle = normal.linear_interpolate(axis, j / (real_t)p_lats).normalized();
|
||||
Vector3 pos = angle * p_radius;
|
||||
planes.push_back(Plane(pos, angle));
|
||||
|
|
@ -1032,12 +982,12 @@ struct _AtlasWorkRectResult {
|
|||
|
||||
void Geometry::make_atlas(const Vector<Size2i> &p_rects, Vector<Point2i> &r_result, Size2i &r_size) {
|
||||
|
||||
//super simple, almost brute force scanline stacking fitter
|
||||
//it's pretty basic for now, but it tries to make sure that the aspect ratio of the
|
||||
//resulting atlas is somehow square. This is necessary because video cards have limits
|
||||
//on texture size (usually 2048 or 4096), so the more square a texture, the more chances
|
||||
//it will work in every hardware.
|
||||
// for example, it will prioritize a 1024x1024 atlas (works everywhere) instead of a
|
||||
// Super simple, almost brute force scanline stacking fitter.
|
||||
// It's pretty basic for now, but it tries to make sure that the aspect ratio of the
|
||||
// resulting atlas is somehow square. This is necessary because video cards have limits.
|
||||
// On texture size (usually 2048 or 4096), so the more square a texture, the more chances.
|
||||
// It will work in every hardware.
|
||||
// For example, it will prioritize a 1024x1024 atlas (works everywhere) instead of a
|
||||
// 256x8192 atlas (won't work anywhere).
|
||||
|
||||
ERR_FAIL_COND(p_rects.size() == 0);
|
||||
|
|
@ -1066,7 +1016,7 @@ void Geometry::make_atlas(const Vector<Size2i> &p_rects, Vector<Point2i> &r_resu
|
|||
for (int j = 0; j < w; j++)
|
||||
hmax.write[j] = 0;
|
||||
|
||||
//place them
|
||||
// Place them.
|
||||
int ofs = 0;
|
||||
int limit_h = 0;
|
||||
for (int j = 0; j < wrects.size(); j++) {
|
||||
|
|
@ -1101,7 +1051,7 @@ void Geometry::make_atlas(const Vector<Size2i> &p_rects, Vector<Point2i> &r_resu
|
|||
if (end_w > max_w)
|
||||
max_w = end_w;
|
||||
|
||||
if (ofs == 0 || end_h > limit_h) //while h limit not reached, keep stacking
|
||||
if (ofs == 0 || end_h > limit_h) // While h limit not reached, keep stacking.
|
||||
ofs += wrects[j].s.width;
|
||||
}
|
||||
|
||||
|
|
@ -1112,7 +1062,7 @@ void Geometry::make_atlas(const Vector<Size2i> &p_rects, Vector<Point2i> &r_resu
|
|||
results.push_back(result);
|
||||
}
|
||||
|
||||
//find the result with the best aspect ratio
|
||||
// Find the result with the best aspect ratio.
|
||||
|
||||
int best = -1;
|
||||
real_t best_aspect = 1e20;
|
||||
|
|
@ -1152,7 +1102,7 @@ Vector<Vector<Point2> > Geometry::_polypaths_do_operation(PolyBooleanOperation p
|
|||
}
|
||||
Path path_a, path_b;
|
||||
|
||||
// Need to scale points (Clipper's requirement for robust computation)
|
||||
// Need to scale points (Clipper's requirement for robust computation).
|
||||
for (int i = 0; i != p_polypath_a.size(); ++i) {
|
||||
path_a << IntPoint(p_polypath_a[i].x * SCALE_FACTOR, p_polypath_a[i].y * SCALE_FACTOR);
|
||||
}
|
||||
|
|
@ -1160,19 +1110,19 @@ Vector<Vector<Point2> > Geometry::_polypaths_do_operation(PolyBooleanOperation p
|
|||
path_b << IntPoint(p_polypath_b[i].x * SCALE_FACTOR, p_polypath_b[i].y * SCALE_FACTOR);
|
||||
}
|
||||
Clipper clp;
|
||||
clp.AddPath(path_a, ptSubject, !is_a_open); // forward compatible with Clipper 10.0.0
|
||||
clp.AddPath(path_b, ptClip, true); // polylines cannot be set as clip
|
||||
clp.AddPath(path_a, ptSubject, !is_a_open); // Forward compatible with Clipper 10.0.0.
|
||||
clp.AddPath(path_b, ptClip, true); // Polylines cannot be set as clip.
|
||||
|
||||
Paths paths;
|
||||
|
||||
if (is_a_open) {
|
||||
PolyTree tree; // needed to populate polylines
|
||||
PolyTree tree; // Needed to populate polylines.
|
||||
clp.Execute(op, tree);
|
||||
OpenPathsFromPolyTree(tree, paths);
|
||||
} else {
|
||||
clp.Execute(op, paths); // works on closed polygons only
|
||||
clp.Execute(op, paths); // Works on closed polygons only.
|
||||
}
|
||||
// Have to scale points down now
|
||||
// Have to scale points down now.
|
||||
Vector<Vector<Point2> > polypaths;
|
||||
|
||||
for (Paths::size_type i = 0; i < paths.size(); ++i) {
|
||||
|
|
@ -1214,16 +1164,16 @@ Vector<Vector<Point2> > Geometry::_polypath_offset(const Vector<Point2> &p_polyp
|
|||
ClipperOffset co;
|
||||
Path path;
|
||||
|
||||
// Need to scale points (Clipper's requirement for robust computation)
|
||||
// Need to scale points (Clipper's requirement for robust computation).
|
||||
for (int i = 0; i != p_polypath.size(); ++i) {
|
||||
path << IntPoint(p_polypath[i].x * SCALE_FACTOR, p_polypath[i].y * SCALE_FACTOR);
|
||||
}
|
||||
co.AddPath(path, jt, et);
|
||||
|
||||
Paths paths;
|
||||
co.Execute(paths, p_delta * SCALE_FACTOR); // inflate/deflate
|
||||
co.Execute(paths, p_delta * SCALE_FACTOR); // Inflate/deflate.
|
||||
|
||||
// Have to scale points down now
|
||||
// Have to scale points down now.
|
||||
Vector<Vector<Point2> > polypaths;
|
||||
|
||||
for (Paths::size_type i = 0; i < paths.size(); ++i) {
|
||||
|
|
|
|||
|
|
@ -47,37 +47,37 @@ class Geometry {
|
|||
public:
|
||||
static real_t get_closest_points_between_segments(const Vector2 &p1, const Vector2 &q1, const Vector2 &p2, const Vector2 &q2, Vector2 &c1, Vector2 &c2) {
|
||||
|
||||
Vector2 d1 = q1 - p1; // Direction vector of segment S1
|
||||
Vector2 d2 = q2 - p2; // Direction vector of segment S2
|
||||
Vector2 d1 = q1 - p1; // Direction vector of segment S1.
|
||||
Vector2 d2 = q2 - p2; // Direction vector of segment S2.
|
||||
Vector2 r = p1 - p2;
|
||||
real_t a = d1.dot(d1); // Squared length of segment S1, always nonnegative
|
||||
real_t e = d2.dot(d2); // Squared length of segment S2, always nonnegative
|
||||
real_t a = d1.dot(d1); // Squared length of segment S1, always nonnegative.
|
||||
real_t e = d2.dot(d2); // Squared length of segment S2, always nonnegative.
|
||||
real_t f = d2.dot(r);
|
||||
real_t s, t;
|
||||
// Check if either or both segments degenerate into points
|
||||
// Check if either or both segments degenerate into points.
|
||||
if (a <= CMP_EPSILON && e <= CMP_EPSILON) {
|
||||
// Both segments degenerate into points
|
||||
// Both segments degenerate into points.
|
||||
c1 = p1;
|
||||
c2 = p2;
|
||||
return Math::sqrt((c1 - c2).dot(c1 - c2));
|
||||
}
|
||||
if (a <= CMP_EPSILON) {
|
||||
// First segment degenerates into a point
|
||||
// First segment degenerates into a point.
|
||||
s = 0.0;
|
||||
t = f / e; // s = 0 => t = (b*s + f) / e = f / e
|
||||
t = CLAMP(t, 0.0, 1.0);
|
||||
} else {
|
||||
real_t c = d1.dot(r);
|
||||
if (e <= CMP_EPSILON) {
|
||||
// Second segment degenerates into a point
|
||||
// Second segment degenerates into a point.
|
||||
t = 0.0;
|
||||
s = CLAMP(-c / a, 0.0, 1.0); // t = 0 => s = (b*t - c) / a = -c / a
|
||||
} else {
|
||||
// The general nondegenerate case starts here
|
||||
// The general nondegenerate case starts here.
|
||||
real_t b = d1.dot(d2);
|
||||
real_t denom = a * e - b * b; // Always nonnegative
|
||||
real_t denom = a * e - b * b; // Always nonnegative.
|
||||
// If segments not parallel, compute closest point on L1 to L2 and
|
||||
// clamp to segment S1. Else pick arbitrary s (here 0)
|
||||
// clamp to segment S1. Else pick arbitrary s (here 0).
|
||||
if (denom != 0.0) {
|
||||
s = CLAMP((b * f - c * e) / denom, 0.0, 1.0);
|
||||
} else
|
||||
|
|
@ -88,7 +88,7 @@ public:
|
|||
|
||||
//If t in [0,1] done. Else clamp t, recompute s for the new value
|
||||
// of t using s = Dot((P2 + D2*t) - P1,D1) / Dot(D1,D1)= (t*b - c) / a
|
||||
// and clamp s to [0, 1]
|
||||
// and clamp s to [0, 1].
|
||||
if (t < 0.0) {
|
||||
t = 0.0;
|
||||
s = CLAMP(-c / a, 0.0, 1.0);
|
||||
|
|
@ -105,14 +105,14 @@ public:
|
|||
|
||||
static void get_closest_points_between_segments(const Vector3 &p1, const Vector3 &p2, const Vector3 &q1, const Vector3 &q2, Vector3 &c1, Vector3 &c2) {
|
||||
|
||||
//do the function 'd' as defined by pb. I think is is dot product of some sort
|
||||
// Do the function 'd' as defined by pb. I think is is dot product of some sort.
|
||||
#define d_of(m, n, o, p) ((m.x - n.x) * (o.x - p.x) + (m.y - n.y) * (o.y - p.y) + (m.z - n.z) * (o.z - p.z))
|
||||
|
||||
//calculate the parametric position on the 2 curves, mua and mub
|
||||
// Calculate the parametric position on the 2 curves, mua and mub.
|
||||
real_t mua = (d_of(p1, q1, q2, q1) * d_of(q2, q1, p2, p1) - d_of(p1, q1, p2, p1) * d_of(q2, q1, q2, q1)) / (d_of(p2, p1, p2, p1) * d_of(q2, q1, q2, q1) - d_of(q2, q1, p2, p1) * d_of(q2, q1, p2, p1));
|
||||
real_t mub = (d_of(p1, q1, q2, q1) + mua * d_of(q2, q1, p2, p1)) / d_of(q2, q1, q2, q1);
|
||||
|
||||
//clip the value between [0..1] constraining the solution to lie on the original curves
|
||||
// Clip the value between [0..1] constraining the solution to lie on the original curves.
|
||||
if (mua < 0) mua = 0;
|
||||
if (mub < 0) mub = 0;
|
||||
if (mua > 1) mua = 1;
|
||||
|
|
@ -125,38 +125,38 @@ public:
|
|||
Vector3 u = p_to_a - p_from_a;
|
||||
Vector3 v = p_to_b - p_from_b;
|
||||
Vector3 w = p_from_a - p_to_a;
|
||||
real_t a = u.dot(u); // always >= 0
|
||||
real_t a = u.dot(u); // Always >= 0
|
||||
real_t b = u.dot(v);
|
||||
real_t c = v.dot(v); // always >= 0
|
||||
real_t c = v.dot(v); // Always >= 0
|
||||
real_t d = u.dot(w);
|
||||
real_t e = v.dot(w);
|
||||
real_t D = a * c - b * b; // always >= 0
|
||||
real_t D = a * c - b * b; // Always >= 0
|
||||
real_t sc, sN, sD = D; // sc = sN / sD, default sD = D >= 0
|
||||
real_t tc, tN, tD = D; // tc = tN / tD, default tD = D >= 0
|
||||
|
||||
// compute the line parameters of the two closest points
|
||||
if (D < CMP_EPSILON) { // the lines are almost parallel
|
||||
sN = 0.0; // force using point P0 on segment S1
|
||||
sD = 1.0; // to prevent possible division by 0.0 later
|
||||
// Compute the line parameters of the two closest points.
|
||||
if (D < CMP_EPSILON) { // The lines are almost parallel.
|
||||
sN = 0.0; // Force using point P0 on segment S1
|
||||
sD = 1.0; // to prevent possible division by 0.0 later.
|
||||
tN = e;
|
||||
tD = c;
|
||||
} else { // get the closest points on the infinite lines
|
||||
} else { // Get the closest points on the infinite lines
|
||||
sN = (b * e - c * d);
|
||||
tN = (a * e - b * d);
|
||||
if (sN < 0.0) { // sc < 0 => the s=0 edge is visible
|
||||
if (sN < 0.0) { // sc < 0 => the s=0 edge is visible.
|
||||
sN = 0.0;
|
||||
tN = e;
|
||||
tD = c;
|
||||
} else if (sN > sD) { // sc > 1 => the s=1 edge is visible
|
||||
} else if (sN > sD) { // sc > 1 => the s=1 edge is visible.
|
||||
sN = sD;
|
||||
tN = e + b;
|
||||
tD = c;
|
||||
}
|
||||
}
|
||||
|
||||
if (tN < 0.0) { // tc < 0 => the t=0 edge is visible
|
||||
if (tN < 0.0) { // tc < 0 => the t=0 edge is visible.
|
||||
tN = 0.0;
|
||||
// recompute sc for this edge
|
||||
// Recompute sc for this edge.
|
||||
if (-d < 0.0)
|
||||
sN = 0.0;
|
||||
else if (-d > a)
|
||||
|
|
@ -165,9 +165,9 @@ public:
|
|||
sN = -d;
|
||||
sD = a;
|
||||
}
|
||||
} else if (tN > tD) { // tc > 1 => the t=1 edge is visible
|
||||
} else if (tN > tD) { // tc > 1 => the t=1 edge is visible.
|
||||
tN = tD;
|
||||
// recompute sc for this edge
|
||||
// Recompute sc for this edge.
|
||||
if ((-d + b) < 0.0)
|
||||
sN = 0;
|
||||
else if ((-d + b) > a)
|
||||
|
|
@ -177,14 +177,14 @@ public:
|
|||
sD = a;
|
||||
}
|
||||
}
|
||||
// finally do the division to get sc and tc
|
||||
// Finally do the division to get sc and tc.
|
||||
sc = (Math::is_zero_approx(sN) ? 0.0 : sN / sD);
|
||||
tc = (Math::is_zero_approx(tN) ? 0.0 : tN / tD);
|
||||
|
||||
// get the difference of the two closest points
|
||||
// Get the difference of the two closest points.
|
||||
Vector3 dP = w + (sc * u) - (tc * v); // = S1(sc) - S2(tc)
|
||||
|
||||
return dP.length(); // return the closest distance
|
||||
return dP.length(); // Return the closest distance.
|
||||
}
|
||||
|
||||
static inline bool ray_intersects_triangle(const Vector3 &p_from, const Vector3 &p_dir, const Vector3 &p_v0, const Vector3 &p_v1, const Vector3 &p_v2, Vector3 *r_res = 0) {
|
||||
|
|
@ -192,7 +192,7 @@ public:
|
|||
Vector3 e2 = p_v2 - p_v0;
|
||||
Vector3 h = p_dir.cross(e2);
|
||||
real_t a = e1.dot(h);
|
||||
if (Math::is_zero_approx(a)) // parallel test
|
||||
if (Math::is_zero_approx(a)) // Parallel test.
|
||||
return false;
|
||||
|
||||
real_t f = 1.0 / a;
|
||||
|
|
@ -210,16 +210,15 @@ public:
|
|||
if (v < 0.0 || u + v > 1.0)
|
||||
return false;
|
||||
|
||||
// at this stage we can compute t to find out where
|
||||
// the intersection point is on the line
|
||||
// At this stage we can compute t to find out where
|
||||
// the intersection point is on the line.
|
||||
real_t t = f * e2.dot(q);
|
||||
|
||||
if (t > 0.00001) { // ray intersection
|
||||
if (r_res)
|
||||
*r_res = p_from + p_dir * t;
|
||||
return true;
|
||||
} else // this means that there is a line intersection
|
||||
// but not a ray intersection
|
||||
} else // This means that there is a line intersection but not a ray intersection.
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -230,7 +229,7 @@ public:
|
|||
Vector3 e2 = p_v2 - p_v0;
|
||||
Vector3 h = rel.cross(e2);
|
||||
real_t a = e1.dot(h);
|
||||
if (Math::is_zero_approx(a)) // parallel test
|
||||
if (Math::is_zero_approx(a)) // Parallel test.
|
||||
return false;
|
||||
|
||||
real_t f = 1.0 / a;
|
||||
|
|
@ -248,16 +247,15 @@ public:
|
|||
if (v < 0.0 || u + v > 1.0)
|
||||
return false;
|
||||
|
||||
// at this stage we can compute t to find out where
|
||||
// the intersection point is on the line
|
||||
// At this stage we can compute t to find out where
|
||||
// the intersection point is on the line.
|
||||
real_t t = f * e2.dot(q);
|
||||
|
||||
if (t > CMP_EPSILON && t <= 1.0) { // ray intersection
|
||||
if (t > CMP_EPSILON && t <= 1.0) { // Ray intersection.
|
||||
if (r_res)
|
||||
*r_res = p_from + rel * t;
|
||||
return true;
|
||||
} else // this means that there is a line intersection
|
||||
// but not a ray intersection
|
||||
} else // This means that there is a line intersection but not a ray intersection.
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -267,13 +265,11 @@ public:
|
|||
Vector3 rel = (p_to - p_from);
|
||||
real_t rel_l = rel.length();
|
||||
if (rel_l < CMP_EPSILON)
|
||||
return false; // both points are the same
|
||||
return false; // Both points are the same.
|
||||
Vector3 normal = rel / rel_l;
|
||||
|
||||
real_t sphere_d = normal.dot(sphere_pos);
|
||||
|
||||
//Vector3 ray_closest=normal*sphere_d;
|
||||
|
||||
real_t ray_distance = sphere_pos.distance_to(normal * sphere_d);
|
||||
|
||||
if (ray_distance >= p_sphere_radius)
|
||||
|
|
@ -285,7 +281,7 @@ public:
|
|||
if (inters_d2 >= CMP_EPSILON)
|
||||
inters_d -= Math::sqrt(inters_d2);
|
||||
|
||||
// check in segment
|
||||
// Check in segment.
|
||||
if (inters_d < 0 || inters_d > rel_l)
|
||||
return false;
|
||||
|
||||
|
|
@ -304,9 +300,9 @@ public:
|
|||
Vector3 rel = (p_to - p_from);
|
||||
real_t rel_l = rel.length();
|
||||
if (rel_l < CMP_EPSILON)
|
||||
return false; // both points are the same
|
||||
return false; // Both points are the same.
|
||||
|
||||
// first check if they are parallel
|
||||
// First check if they are parallel.
|
||||
Vector3 normal = (rel / rel_l);
|
||||
Vector3 crs = normal.cross(Vector3(0, 0, 1));
|
||||
real_t crs_l = crs.length();
|
||||
|
|
@ -314,8 +310,7 @@ public:
|
|||
Vector3 z_dir;
|
||||
|
||||
if (crs_l < CMP_EPSILON) {
|
||||
//blahblah parallel
|
||||
z_dir = Vector3(1, 0, 0); //any x/y vector ok
|
||||
z_dir = Vector3(1, 0, 0); // Any x/y vector OK.
|
||||
} else {
|
||||
z_dir = crs / crs_l;
|
||||
}
|
||||
|
|
@ -323,12 +318,12 @@ public:
|
|||
real_t dist = z_dir.dot(p_from);
|
||||
|
||||
if (dist >= p_radius)
|
||||
return false; // too far away
|
||||
return false; // Too far away.
|
||||
|
||||
// convert to 2D
|
||||
// Convert to 2D.
|
||||
real_t w2 = p_radius * p_radius - dist * dist;
|
||||
if (w2 < CMP_EPSILON)
|
||||
return false; //avoid numerical error
|
||||
return false; // Avoid numerical error.
|
||||
Size2 size(Math::sqrt(w2), p_height * 0.5);
|
||||
|
||||
Vector3 x_dir = z_dir.cross(Vector3(0, 0, 1)).normalized();
|
||||
|
|
@ -375,7 +370,7 @@ public:
|
|||
return false;
|
||||
}
|
||||
|
||||
// convert to 3D again
|
||||
// Convert to 3D again.
|
||||
Vector3 result = p_from + (rel * min);
|
||||
Vector3 res_normal = result;
|
||||
|
||||
|
|
@ -416,19 +411,18 @@ public:
|
|||
|
||||
real_t den = p.normal.dot(dir);
|
||||
|
||||
//printf("den is %i\n",den);
|
||||
if (Math::abs(den) <= CMP_EPSILON)
|
||||
continue; // ignore parallel plane
|
||||
continue; // Ignore parallel plane.
|
||||
|
||||
real_t dist = -p.distance_to(p_from) / den;
|
||||
|
||||
if (den > 0) {
|
||||
//backwards facing plane
|
||||
// Backwards facing plane.
|
||||
if (dist < max)
|
||||
max = dist;
|
||||
} else {
|
||||
|
||||
//front facing plane
|
||||
// Front facing plane.
|
||||
if (dist > min) {
|
||||
min = dist;
|
||||
min_index = i;
|
||||
|
|
@ -436,8 +430,8 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
if (max <= min || min < 0 || min > rel_l || min_index == -1) // exit conditions
|
||||
return false; // no intersection
|
||||
if (max <= min || min < 0 || min > rel_l || min_index == -1) // Exit conditions.
|
||||
return false; // No intersection.
|
||||
|
||||
if (p_res)
|
||||
*p_res = p_from + dir * min;
|
||||
|
|
@ -453,16 +447,16 @@ public:
|
|||
Vector3 n = p_segment[1] - p_segment[0];
|
||||
real_t l2 = n.length_squared();
|
||||
if (l2 < 1e-20)
|
||||
return p_segment[0]; // both points are the same, just give any
|
||||
return p_segment[0]; // Both points are the same, just give any.
|
||||
|
||||
real_t d = n.dot(p) / l2;
|
||||
|
||||
if (d <= 0.0)
|
||||
return p_segment[0]; // before first point
|
||||
return p_segment[0]; // Before first point.
|
||||
else if (d >= 1.0)
|
||||
return p_segment[1]; // after first point
|
||||
return p_segment[1]; // After first point.
|
||||
else
|
||||
return p_segment[0] + n * d; // inside
|
||||
return p_segment[0] + n * d; // Inside.
|
||||
}
|
||||
|
||||
static Vector3 get_closest_point_to_segment_uncapped(const Vector3 &p_point, const Vector3 *p_segment) {
|
||||
|
|
@ -471,11 +465,11 @@ public:
|
|||
Vector3 n = p_segment[1] - p_segment[0];
|
||||
real_t l2 = n.length_squared();
|
||||
if (l2 < 1e-20)
|
||||
return p_segment[0]; // both points are the same, just give any
|
||||
return p_segment[0]; // Both points are the same, just give any.
|
||||
|
||||
real_t d = n.dot(p) / l2;
|
||||
|
||||
return p_segment[0] + n * d; // inside
|
||||
return p_segment[0] + n * d; // Inside.
|
||||
}
|
||||
|
||||
static Vector2 get_closest_point_to_segment_2d(const Vector2 &p_point, const Vector2 *p_segment) {
|
||||
|
|
@ -484,16 +478,16 @@ public:
|
|||
Vector2 n = p_segment[1] - p_segment[0];
|
||||
real_t l2 = n.length_squared();
|
||||
if (l2 < 1e-20)
|
||||
return p_segment[0]; // both points are the same, just give any
|
||||
return p_segment[0]; // Both points are the same, just give any.
|
||||
|
||||
real_t d = n.dot(p) / l2;
|
||||
|
||||
if (d <= 0.0)
|
||||
return p_segment[0]; // before first point
|
||||
return p_segment[0]; // Before first point.
|
||||
else if (d >= 1.0)
|
||||
return p_segment[1]; // after first point
|
||||
return p_segment[1]; // After first point.
|
||||
else
|
||||
return p_segment[0] + n * d; // inside
|
||||
return p_segment[0] + n * d; // Inside.
|
||||
}
|
||||
|
||||
static bool is_point_in_triangle(const Vector2 &s, const Vector2 &a, const Vector2 &b, const Vector2 &c) {
|
||||
|
|
@ -508,27 +502,25 @@ public:
|
|||
return (cn.cross(an) > 0) == orientation;
|
||||
}
|
||||
|
||||
//static bool is_point_in_polygon(const Vector2 &p_point, const Vector<Vector2> &p_polygon);
|
||||
|
||||
static Vector2 get_closest_point_to_segment_uncapped_2d(const Vector2 &p_point, const Vector2 *p_segment) {
|
||||
|
||||
Vector2 p = p_point - p_segment[0];
|
||||
Vector2 n = p_segment[1] - p_segment[0];
|
||||
real_t l2 = n.length_squared();
|
||||
if (l2 < 1e-20)
|
||||
return p_segment[0]; // both points are the same, just give any
|
||||
return p_segment[0]; // Both points are the same, just give any.
|
||||
|
||||
real_t d = n.dot(p) / l2;
|
||||
|
||||
return p_segment[0] + n * d; // inside
|
||||
return p_segment[0] + n * d; // Inside.
|
||||
}
|
||||
|
||||
static bool line_intersects_line_2d(const Vector2 &p_from_a, const Vector2 &p_dir_a, const Vector2 &p_from_b, const Vector2 &p_dir_b, Vector2 &r_result) {
|
||||
|
||||
// see http://paulbourke.net/geometry/pointlineplane/
|
||||
// See http://paulbourke.net/geometry/pointlineplane/
|
||||
|
||||
const real_t denom = p_dir_b.y * p_dir_a.x - p_dir_b.x * p_dir_a.y;
|
||||
if (Math::is_zero_approx(denom)) { // parallel?
|
||||
if (Math::is_zero_approx(denom)) { // Parallel?
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -556,11 +548,11 @@ public:
|
|||
|
||||
real_t ABpos = D.x + (C.x - D.x) * D.y / (D.y - C.y);
|
||||
|
||||
// Fail if segment C-D crosses line A-B outside of segment A-B.
|
||||
// Fail if segment C-D crosses line A-B outside of segment A-B.
|
||||
if (ABpos < 0 || ABpos > 1.0)
|
||||
return false;
|
||||
|
||||
// (4) Apply the discovered position to line A-B in the original coordinate system.
|
||||
// (4) Apply the discovered position to line A-B in the original coordinate system.
|
||||
if (r_result)
|
||||
*r_result = p_from_a + B * ABpos;
|
||||
|
||||
|
|
@ -593,7 +585,7 @@ public:
|
|||
|
||||
real_t d = p_normal.dot(p_sphere_pos) - p_normal.dot(p_triangle[0]);
|
||||
|
||||
if (d > p_sphere_radius || d < -p_sphere_radius) // not touching the plane of the face, return
|
||||
if (d > p_sphere_radius || d < -p_sphere_radius) // Not touching the plane of the face, return.
|
||||
return false;
|
||||
|
||||
Vector3 contact = p_sphere_pos - (p_normal * d);
|
||||
|
|
@ -613,25 +605,25 @@ public:
|
|||
|
||||
for (int i = 0; i < 3; i++) {
|
||||
|
||||
// check edge cylinder
|
||||
// Check edge cylinder.
|
||||
|
||||
Vector3 n1 = verts[i] - verts[i + 1];
|
||||
Vector3 n2 = p_sphere_pos - verts[i + 1];
|
||||
|
||||
///@TODO i could discard by range here to make the algorithm quicker? dunno..
|
||||
///@TODO Maybe discard by range here to make the algorithm quicker.
|
||||
|
||||
// check point within cylinder radius
|
||||
// Check point within cylinder radius.
|
||||
Vector3 axis = n1.cross(n2).cross(n1);
|
||||
axis.normalize(); // ugh
|
||||
axis.normalize();
|
||||
|
||||
real_t ad = axis.dot(n2);
|
||||
|
||||
if (ABS(ad) > p_sphere_radius) {
|
||||
// no chance with this edge, too far away
|
||||
// No chance with this edge, too far away.
|
||||
continue;
|
||||
}
|
||||
|
||||
// check point within edge capsule cylinder
|
||||
// Check point within edge capsule cylinder.
|
||||
/** 4th TEST INSIDE EDGE POINTS **/
|
||||
|
||||
real_t sphere_at = n1.dot(n2);
|
||||
|
|
@ -640,8 +632,7 @@ public:
|
|||
|
||||
r_triangle_contact = p_sphere_pos - axis * (axis.dot(n2));
|
||||
r_sphere_contact = p_sphere_pos - axis * p_sphere_radius;
|
||||
// point inside here
|
||||
//printf("solved inside edge\n");
|
||||
// Point inside here.
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -651,48 +642,51 @@ public:
|
|||
|
||||
Vector3 n = (p_sphere_pos - verts[i + 1]).normalized();
|
||||
|
||||
//r_triangle_contact=verts[i+1]+n*p_sphere_radius;p_sphere_pos+axis*(p_sphere_radius-axis.dot(n2));
|
||||
r_triangle_contact = verts[i + 1];
|
||||
r_sphere_contact = p_sphere_pos - n * p_sphere_radius;
|
||||
//printf("solved inside point segment 1\n");
|
||||
return true;
|
||||
}
|
||||
|
||||
if (n2.distance_squared_to(n1) < r2) {
|
||||
Vector3 n = (p_sphere_pos - verts[i]).normalized();
|
||||
|
||||
//r_triangle_contact=verts[i]+n*p_sphere_radius;p_sphere_pos+axis*(p_sphere_radius-axis.dot(n2));
|
||||
r_triangle_contact = verts[i];
|
||||
r_sphere_contact = p_sphere_pos - n * p_sphere_radius;
|
||||
//printf("solved inside point segment 1\n");
|
||||
return true;
|
||||
}
|
||||
|
||||
break; // It's pointless to continue at this point, so save some cpu cycles
|
||||
break; // It's pointless to continue at this point, so save some CPU cycles.
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
static inline bool is_point_in_circle(const Vector2 &p_point, const Vector2 &p_circle_pos, real_t p_circle_radius) {
|
||||
|
||||
return p_point.distance_squared_to(p_circle_pos) <= p_circle_radius * p_circle_radius;
|
||||
}
|
||||
|
||||
static real_t segment_intersects_circle(const Vector2 &p_from, const Vector2 &p_to, const Vector2 &p_circle_pos, real_t p_circle_radius) {
|
||||
|
||||
Vector2 line_vec = p_to - p_from;
|
||||
Vector2 vec_to_line = p_from - p_circle_pos;
|
||||
|
||||
/* create a quadratic formula of the form ax^2 + bx + c = 0 */
|
||||
// Create a quadratic formula of the form ax^2 + bx + c = 0
|
||||
real_t a, b, c;
|
||||
|
||||
a = line_vec.dot(line_vec);
|
||||
b = 2 * vec_to_line.dot(line_vec);
|
||||
c = vec_to_line.dot(vec_to_line) - p_circle_radius * p_circle_radius;
|
||||
|
||||
/* solve for t */
|
||||
// Solve for t.
|
||||
real_t sqrtterm = b * b - 4 * a * c;
|
||||
|
||||
/* if the term we intend to square root is less than 0 then the answer won't be real, so it definitely won't be t in the range 0 to 1 */
|
||||
// If the term we intend to square root is less than 0 then the answer won't be real,
|
||||
// so it definitely won't be t in the range 0 to 1.
|
||||
if (sqrtterm < 0) return -1;
|
||||
|
||||
/* if we can assume that the line segment starts outside the circle (e.g. for continuous time collision detection) then the following can be skipped and we can just return the equivalent of res1 */
|
||||
// If we can assume that the line segment starts outside the circle (e.g. for continuous time collision detection)
|
||||
// then the following can be skipped and we can just return the equivalent of res1.
|
||||
sqrtterm = Math::sqrt(sqrtterm);
|
||||
real_t res1 = (-b - sqrtterm) / (2 * a);
|
||||
real_t res2 = (-b + sqrtterm) / (2 * a);
|
||||
|
|
@ -718,7 +712,6 @@ public:
|
|||
int outside_count = 0;
|
||||
|
||||
for (int a = 0; a < polygon.size(); a++) {
|
||||
//real_t p_plane.d = (*this) * polygon[a];
|
||||
real_t dist = p_plane.distance_to(polygon[a]);
|
||||
if (dist < -CMP_POINT_IN_PLANE_EPSILON) {
|
||||
location_cache[a] = LOC_INSIDE;
|
||||
|
|
@ -735,11 +728,11 @@ public:
|
|||
|
||||
if (outside_count == 0) {
|
||||
|
||||
return polygon; // no changes
|
||||
return polygon; // No changes.
|
||||
|
||||
} else if (inside_count == 0) {
|
||||
|
||||
return Vector<Vector3>(); //empty
|
||||
return Vector<Vector3>(); // Empty.
|
||||
}
|
||||
|
||||
long previous = polygon.size() - 1;
|
||||
|
|
@ -894,7 +887,7 @@ public:
|
|||
return sum > 0.0f;
|
||||
}
|
||||
|
||||
/* alternate implementation that should be faster */
|
||||
// Alternate implementation that should be faster.
|
||||
static bool is_point_in_polygon(const Vector2 &p_point, const Vector<Vector2> &p_polygon) {
|
||||
int c = p_polygon.size();
|
||||
if (c < 3)
|
||||
|
|
@ -910,7 +903,8 @@ public:
|
|||
further_away_opposite.y = MIN(p[i].y, further_away_opposite.y);
|
||||
}
|
||||
|
||||
further_away += (further_away - further_away_opposite) * Vector2(1.221313, 1.512312); // make point outside that won't intersect with points in segment from p_point
|
||||
// Make point outside that won't intersect with points in segment from p_point.
|
||||
further_away += (further_away - further_away_opposite) * Vector2(1.221313, 1.512312);
|
||||
|
||||
int intersections = 0;
|
||||
for (int i = 0; i < c; i++) {
|
||||
|
|
@ -926,7 +920,8 @@ public:
|
|||
|
||||
static PoolVector<PoolVector<Face3> > separate_objects(PoolVector<Face3> p_array);
|
||||
|
||||
static PoolVector<Face3> wrap_geometry(PoolVector<Face3> p_array, real_t *p_error = NULL); ///< create a "wrap" that encloses the given geometry
|
||||
// Create a "wrap" that encloses the given geometry.
|
||||
static PoolVector<Face3> wrap_geometry(PoolVector<Face3> p_array, real_t *p_error = NULL);
|
||||
|
||||
struct MeshData {
|
||||
|
||||
|
|
@ -1008,17 +1003,17 @@ public:
|
|||
Vector<Point2> H;
|
||||
H.resize(2 * n);
|
||||
|
||||
// Sort points lexicographically
|
||||
// Sort points lexicographically.
|
||||
P.sort();
|
||||
|
||||
// Build lower hull
|
||||
// Build lower hull.
|
||||
for (int i = 0; i < n; ++i) {
|
||||
while (k >= 2 && vec2_cross(H[k - 2], H[k - 1], P[i]) <= 0)
|
||||
k--;
|
||||
H.write[k++] = P[i];
|
||||
}
|
||||
|
||||
// Build upper hull
|
||||
// Build upper hull.
|
||||
for (int i = n - 2, t = k + 1; i >= 0; i--) {
|
||||
while (k >= t && vec2_cross(H[k - 2], H[k - 1], P[i]) <= 0)
|
||||
k--;
|
||||
|
|
|
|||
|
|
@ -216,6 +216,19 @@
|
|||
Intersects [code]polyline[/code] with [code]polygon[/code] and returns an array of intersected polylines. This performs [constant OPERATION_INTERSECTION] between the polyline and the polygon. This operation can be thought of as chopping a line with a closed shape.
|
||||
</description>
|
||||
</method>
|
||||
<method name="is_point_in_circle">
|
||||
<return type="bool">
|
||||
</return>
|
||||
<argument index="0" name="point" type="Vector2">
|
||||
</argument>
|
||||
<argument index="1" name="circle_position" type="Vector2">
|
||||
</argument>
|
||||
<argument index="2" name="circle_radius" type="float">
|
||||
</argument>
|
||||
<description>
|
||||
Returns [code]true[/code] if [code]point[/code] is inside the circle or if it's located exactly [i]on[/i] the circle's boundary, otherwise returns [code]false[/code].
|
||||
</description>
|
||||
</method>
|
||||
<method name="is_point_in_polygon">
|
||||
<return type="bool">
|
||||
</return>
|
||||
|
|
|
|||
Loading…
Reference in New Issue