Merge pull request #525 from vnen/update-clang-format
Update clang-format to version 11pull/400/head
Rémi Verschelde
GitHub
commit
55c0a2ea03
|
|
@ -13,9 +13,9 @@ AlignAfterOpenBracket: DontAlign
|
|||
AlignTrailingComments: false
|
||||
AllowAllParametersOfDeclarationOnNextLine: false
|
||||
# AllowShortBlocksOnASingleLine: false
|
||||
AllowShortCaseLabelsOnASingleLine: true
|
||||
# AllowShortCaseLabelsOnASingleLine: false
|
||||
AllowShortFunctionsOnASingleLine: Inline
|
||||
AllowShortIfStatementsOnASingleLine: true
|
||||
# AllowShortIfStatementsOnASingleLine: false
|
||||
# AllowShortLoopsOnASingleLine: false
|
||||
# AlwaysBreakAfterDefinitionReturnType: None
|
||||
# AlwaysBreakAfterReturnType: None
|
||||
|
|
@ -76,7 +76,7 @@ IndentWidth: 4
|
|||
# IndentWrappedFunctionNames: false
|
||||
# JavaScriptQuotes: Leave
|
||||
# JavaScriptWrapImports: true
|
||||
# KeepEmptyLinesAtTheStartOfBlocks: true
|
||||
KeepEmptyLinesAtTheStartOfBlocks: false
|
||||
# MacroBlockBegin: ''
|
||||
# MacroBlockEnd: ''
|
||||
# MaxEmptyLinesToKeep: 1
|
||||
|
|
@ -112,10 +112,11 @@ UseTab: Always
|
|||
---
|
||||
### C++ specific config ###
|
||||
Language: Cpp
|
||||
Standard: Cpp03
|
||||
Standard: Cpp11
|
||||
---
|
||||
### ObjC specific config ###
|
||||
Language: ObjC
|
||||
Standard: Cpp11
|
||||
ObjCBlockIndentWidth: 4
|
||||
# ObjCSpaceAfterProperty: false
|
||||
# ObjCSpaceBeforeProtocolList: true
|
||||
|
|
@ -123,4 +124,5 @@ ObjCBlockIndentWidth: 4
|
|||
### Java specific config ###
|
||||
Language: Java
|
||||
# BreakAfterJavaFieldAnnotations: false
|
||||
JavaImportGroups: ['org.godotengine', 'android', 'androidx', 'com.android', 'com.google', 'java', 'javax']
|
||||
...
|
||||
|
|
|
|||
|
|
@ -147,14 +147,22 @@ jobs:
|
|||
|
||||
static-checks:
|
||||
name: Static Checks (clang-format)
|
||||
runs-on: ubuntu-16.04
|
||||
runs-on: ubuntu-20.04
|
||||
steps:
|
||||
- name: Checkout
|
||||
uses: actions/checkout@v2.3.4
|
||||
uses: actions/checkout@v2
|
||||
|
||||
- name: Make apt sources.list use the default Ubuntu repositories
|
||||
run: |
|
||||
sudo rm -f /etc/apt/sources.list.d/*
|
||||
sudo cp -f misc/ci/sources.list /etc/apt/sources.list
|
||||
sudo apt-get update
|
||||
|
||||
- name: Install dependencies
|
||||
run: |
|
||||
sudo apt-get install clang-format-8
|
||||
sudo apt-get install -qq dos2unix recode clang-format-11
|
||||
sudo update-alternatives --remove-all clang-format
|
||||
sudo update-alternatives --install /usr/bin/clang-format clang-format /usr/bin/clang-format-11 100
|
||||
|
||||
- name: Style checks via clang-format
|
||||
run: |
|
||||
|
|
|
|||
|
|
@ -16,12 +16,10 @@ public:
|
|||
|
||||
real_t get_area() const; /// get area
|
||||
inline bool has_no_area() const {
|
||||
|
||||
return (size.x <= CMP_EPSILON || size.y <= CMP_EPSILON || size.z <= CMP_EPSILON);
|
||||
}
|
||||
|
||||
inline bool has_no_surface() const {
|
||||
|
||||
return (size.x <= CMP_EPSILON && size.y <= CMP_EPSILON && size.z <= CMP_EPSILON);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -14,7 +14,6 @@ using namespace godot;
|
|||
} // namespace
|
||||
|
||||
struct CameraMatrix {
|
||||
|
||||
enum Planes {
|
||||
PLANE_NEAR,
|
||||
PLANE_FAR,
|
||||
|
|
@ -84,7 +83,6 @@ struct CameraMatrix {
|
|||
};
|
||||
|
||||
Vector3 CameraMatrix::xform(const Vector3 &p_vec3) const {
|
||||
|
||||
Vector3 ret;
|
||||
ret.x = matrix[0][0] * p_vec3.x + matrix[1][0] * p_vec3.y + matrix[2][0] * p_vec3.z + matrix[3][0];
|
||||
ret.y = matrix[0][1] * p_vec3.x + matrix[1][1] * p_vec3.y + matrix[2][1] * p_vec3.z + matrix[3][1];
|
||||
|
|
|
|||
|
|
@ -11,12 +11,10 @@
|
|||
namespace godot {
|
||||
|
||||
struct Color {
|
||||
|
||||
private:
|
||||
// static float _parse_col(const String& p_str, int p_ofs);
|
||||
public:
|
||||
union {
|
||||
|
||||
struct {
|
||||
float r;
|
||||
float g;
|
||||
|
|
|
|||
|
|
@ -321,7 +321,6 @@ void register_method(const char *name, M method_ptr, godot_method_rpc_mode rpc_t
|
|||
template <class D, class B, class R, class... As>
|
||||
void register_method_explicit(const char *name, R (B::*method_ptr)(As...),
|
||||
godot_method_rpc_mode rpc_type = GODOT_METHOD_RPC_MODE_DISABLED) {
|
||||
|
||||
static_assert(std::is_base_of<B, D>::value, "Explicit class must derive from method class");
|
||||
register_method(name, static_cast<R (D::*)(As...)>(method_ptr), rpc_type);
|
||||
}
|
||||
|
|
@ -394,7 +393,6 @@ void register_property(const char *name, P(T::*var), P default_value,
|
|||
godot_method_rpc_mode rpc_mode = GODOT_METHOD_RPC_MODE_DISABLED,
|
||||
godot_property_usage_flags usage = GODOT_PROPERTY_USAGE_DEFAULT,
|
||||
godot_property_hint hint = GODOT_PROPERTY_HINT_NONE, String hint_string = "") {
|
||||
|
||||
static_assert(T::___CLASS_IS_SCRIPT, "This function must only be used on custom classes");
|
||||
|
||||
Variant def_val = default_value;
|
||||
|
|
@ -451,7 +449,6 @@ void register_property(const char *name, void (T::*setter)(P), P (T::*getter)(),
|
|||
godot_method_rpc_mode rpc_mode = GODOT_METHOD_RPC_MODE_DISABLED,
|
||||
godot_property_usage_flags usage = GODOT_PROPERTY_USAGE_DEFAULT,
|
||||
godot_property_hint hint = GODOT_PROPERTY_HINT_NONE, String hint_string = "") {
|
||||
|
||||
static_assert(T::___CLASS_IS_SCRIPT, "This function must only be used on custom classes");
|
||||
|
||||
Variant def_val = default_value;
|
||||
|
|
@ -495,7 +492,6 @@ void register_property(const char *name, void (T::*setter)(P), P (T::*getter)()
|
|||
godot_method_rpc_mode rpc_mode = GODOT_METHOD_RPC_MODE_DISABLED,
|
||||
godot_property_usage_flags usage = GODOT_PROPERTY_USAGE_DEFAULT,
|
||||
godot_property_hint hint = GODOT_PROPERTY_HINT_NONE, String hint_string = "") {
|
||||
|
||||
register_property(name, setter, (P(T::*)())getter, default_value, rpc_mode, usage, hint, hint_string);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -23,7 +23,6 @@ extern "C" const godot_gdnative_ext_net_3_2_api_struct *net_3_2_api;
|
|||
extern "C" const void *gdnlib;
|
||||
|
||||
class Godot {
|
||||
|
||||
public:
|
||||
static void print(const String &message);
|
||||
static void print_warning(const String &description, const String &function, const String &file, int line);
|
||||
|
|
|
|||
|
|
@ -232,7 +232,6 @@ inline double stepify(double p_value, double p_step) {
|
|||
}
|
||||
|
||||
inline unsigned int next_power_of_2(unsigned int x) {
|
||||
|
||||
if (x == 0)
|
||||
return 0;
|
||||
|
||||
|
|
|
|||
|
|
@ -26,7 +26,6 @@ class PoolByteArray {
|
|||
|
||||
public:
|
||||
class Read {
|
||||
|
||||
friend class PoolByteArray;
|
||||
godot_pool_byte_array_read_access *_read_access;
|
||||
|
||||
|
|
|
|||
|
|
@ -17,7 +17,6 @@ typedef Vector2 Point2;
|
|||
struct Transform2D;
|
||||
|
||||
struct Rect2 {
|
||||
|
||||
Point2 position;
|
||||
Size2 size;
|
||||
|
||||
|
|
@ -48,14 +47,12 @@ struct Rect2 {
|
|||
bool intersects_segment(const Point2 &p_from, const Point2 &p_to, Point2 *r_position = nullptr, Point2 *r_normal = nullptr) const;
|
||||
|
||||
inline bool encloses(const Rect2 &p_rect) const {
|
||||
|
||||
return (p_rect.position.x >= position.x) && (p_rect.position.y >= position.y) &&
|
||||
((p_rect.position.x + p_rect.size.x) < (position.x + size.x)) &&
|
||||
((p_rect.position.y + p_rect.size.y) < (position.y + size.y));
|
||||
}
|
||||
|
||||
inline bool has_no_area() const {
|
||||
|
||||
return (size.x <= 0 || size.y <= 0);
|
||||
}
|
||||
Rect2 clip(const Rect2 &p_rect) const;
|
||||
|
|
@ -82,7 +79,6 @@ struct Rect2 {
|
|||
inline bool operator!=(const Rect2 &p_rect) const { return position != p_rect.position || size != p_rect.size; }
|
||||
|
||||
inline Rect2 grow(real_t p_by) const {
|
||||
|
||||
Rect2 g = *this;
|
||||
g.position.x -= p_by;
|
||||
g.position.y -= p_by;
|
||||
|
|
@ -92,7 +88,6 @@ struct Rect2 {
|
|||
}
|
||||
|
||||
inline Rect2 expand(const Vector2 &p_vector) const {
|
||||
|
||||
Rect2 r = *this;
|
||||
r.expand_to(p_vector);
|
||||
return r;
|
||||
|
|
|
|||
|
|
@ -19,7 +19,6 @@ class Ref {
|
|||
T *reference = nullptr;
|
||||
|
||||
void ref(const Ref &p_from) {
|
||||
|
||||
if (p_from.reference == reference)
|
||||
return;
|
||||
|
||||
|
|
@ -31,7 +30,6 @@ class Ref {
|
|||
}
|
||||
|
||||
void ref_pointer(T *p_ref) {
|
||||
|
||||
ERR_FAIL_COND(p_ref == nullptr);
|
||||
|
||||
if (p_ref->init_ref())
|
||||
|
|
@ -40,44 +38,35 @@ class Ref {
|
|||
|
||||
public:
|
||||
inline bool operator<(const Ref<T> &p_r) const {
|
||||
|
||||
return reference < p_r.reference;
|
||||
}
|
||||
inline bool operator==(const Ref<T> &p_r) const {
|
||||
|
||||
return reference == p_r.reference;
|
||||
}
|
||||
inline bool operator!=(const Ref<T> &p_r) const {
|
||||
|
||||
return reference != p_r.reference;
|
||||
}
|
||||
|
||||
inline T *operator->() {
|
||||
|
||||
return reference;
|
||||
}
|
||||
|
||||
inline T *operator*() {
|
||||
|
||||
return reference;
|
||||
}
|
||||
|
||||
inline const T *operator->() const {
|
||||
|
||||
return reference;
|
||||
}
|
||||
|
||||
inline const T *ptr() const {
|
||||
|
||||
return reference;
|
||||
}
|
||||
inline T *ptr() {
|
||||
|
||||
return reference;
|
||||
}
|
||||
|
||||
inline const T *operator*() const {
|
||||
|
||||
return reference;
|
||||
}
|
||||
|
||||
|
|
@ -88,7 +77,6 @@ public:
|
|||
}
|
||||
|
||||
void operator=(const Ref &p_from) {
|
||||
|
||||
ref(p_from);
|
||||
}
|
||||
|
||||
|
|
@ -118,7 +106,6 @@ public:
|
|||
}
|
||||
|
||||
Ref(const Ref &p_from) {
|
||||
|
||||
reference = nullptr;
|
||||
ref(p_from);
|
||||
}
|
||||
|
|
@ -138,7 +125,6 @@ public:
|
|||
}
|
||||
|
||||
Ref(T *p_reference) {
|
||||
|
||||
if (p_reference)
|
||||
ref_pointer(p_reference);
|
||||
else
|
||||
|
|
@ -146,7 +132,6 @@ public:
|
|||
}
|
||||
|
||||
Ref(const Variant &p_variant) {
|
||||
|
||||
reference = nullptr;
|
||||
Object *refb = T::___get_from_variant(p_variant);
|
||||
if (refb == nullptr) {
|
||||
|
|
@ -168,7 +153,6 @@ public:
|
|||
// mutexes will avoid more crashes?
|
||||
|
||||
if (reference && reference->unreference()) {
|
||||
|
||||
//memdelete(reference);
|
||||
reference->free();
|
||||
}
|
||||
|
|
@ -181,12 +165,10 @@ public:
|
|||
}
|
||||
|
||||
Ref() {
|
||||
|
||||
reference = nullptr;
|
||||
}
|
||||
|
||||
~Ref() {
|
||||
|
||||
unref();
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -14,7 +14,6 @@ class PoolStringArray;
|
|||
class String;
|
||||
|
||||
class CharString {
|
||||
|
||||
friend class String;
|
||||
|
||||
godot_char_string _char_string;
|
||||
|
|
|
|||
|
|
@ -14,7 +14,6 @@ namespace godot {
|
|||
class Basis;
|
||||
|
||||
struct Vector3 {
|
||||
|
||||
enum Axis {
|
||||
AXIS_X,
|
||||
AXIS_Y,
|
||||
|
|
@ -305,7 +304,6 @@ inline Vector3 operator*(real_t p_scalar, const Vector3 &p_vec) {
|
|||
}
|
||||
|
||||
inline Vector3 vec3_cross(const Vector3 &p_a, const Vector3 &p_b) {
|
||||
|
||||
return p_a.cross(p_b);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,4 @@
|
|||
deb http://archive.ubuntu.com/ubuntu/ focal main restricted universe multiverse
|
||||
deb http://archive.ubuntu.com/ubuntu/ focal-updates main restricted universe multiverse
|
||||
deb http://archive.ubuntu.com/ubuntu/ focal-security main restricted universe multiverse
|
||||
deb http://archive.ubuntu.com/ubuntu/ focal-backports main restricted universe multiverse
|
||||
|
|
@ -7,7 +7,6 @@
|
|||
namespace godot {
|
||||
|
||||
bool AABB::intersects(const AABB &p_aabb) const {
|
||||
|
||||
if (position.x >= (p_aabb.position.x + p_aabb.size.x))
|
||||
return false;
|
||||
if ((position.x + size.x) <= p_aabb.position.x)
|
||||
|
|
@ -25,7 +24,6 @@ bool AABB::intersects(const AABB &p_aabb) const {
|
|||
}
|
||||
|
||||
bool AABB::intersects_inclusive(const AABB &p_aabb) const {
|
||||
|
||||
if (position.x > (p_aabb.position.x + p_aabb.size.x))
|
||||
return false;
|
||||
if ((position.x + size.x) < p_aabb.position.x)
|
||||
|
|
@ -43,7 +41,6 @@ bool AABB::intersects_inclusive(const AABB &p_aabb) const {
|
|||
}
|
||||
|
||||
bool AABB::encloses(const AABB &p_aabb) const {
|
||||
|
||||
Vector3 src_min = position;
|
||||
Vector3 src_max = position + size;
|
||||
Vector3 dst_min = p_aabb.position;
|
||||
|
|
@ -59,7 +56,6 @@ bool AABB::encloses(const AABB &p_aabb) const {
|
|||
}
|
||||
|
||||
Vector3 AABB::get_support(const Vector3 &p_normal) const {
|
||||
|
||||
Vector3 half_extents = size * 0.5;
|
||||
Vector3 ofs = position + half_extents;
|
||||
|
||||
|
|
@ -71,23 +67,29 @@ Vector3 AABB::get_support(const Vector3 &p_normal) const {
|
|||
}
|
||||
|
||||
Vector3 AABB::get_endpoint(int p_point) const {
|
||||
|
||||
switch (p_point) {
|
||||
case 0: return Vector3(position.x, position.y, position.z);
|
||||
case 1: return Vector3(position.x, position.y, position.z + size.z);
|
||||
case 2: return Vector3(position.x, position.y + size.y, position.z);
|
||||
case 3: return Vector3(position.x, position.y + size.y, position.z + size.z);
|
||||
case 4: return Vector3(position.x + size.x, position.y, position.z);
|
||||
case 5: return Vector3(position.x + size.x, position.y, position.z + size.z);
|
||||
case 6: return Vector3(position.x + size.x, position.y + size.y, position.z);
|
||||
case 7: return Vector3(position.x + size.x, position.y + size.y, position.z + size.z);
|
||||
case 0:
|
||||
return Vector3(position.x, position.y, position.z);
|
||||
case 1:
|
||||
return Vector3(position.x, position.y, position.z + size.z);
|
||||
case 2:
|
||||
return Vector3(position.x, position.y + size.y, position.z);
|
||||
case 3:
|
||||
return Vector3(position.x, position.y + size.y, position.z + size.z);
|
||||
case 4:
|
||||
return Vector3(position.x + size.x, position.y, position.z);
|
||||
case 5:
|
||||
return Vector3(position.x + size.x, position.y, position.z + size.z);
|
||||
case 6:
|
||||
return Vector3(position.x + size.x, position.y + size.y, position.z);
|
||||
case 7:
|
||||
return Vector3(position.x + size.x, position.y + size.y, position.z + size.z);
|
||||
};
|
||||
|
||||
ERR_FAIL_V(Vector3());
|
||||
}
|
||||
|
||||
bool AABB::intersects_convex_shape(const Plane *p_planes, int p_plane_count) const {
|
||||
|
||||
Vector3 half_extents = size * 0.5;
|
||||
Vector3 ofs = position + half_extents;
|
||||
|
||||
|
|
@ -106,7 +108,6 @@ bool AABB::intersects_convex_shape(const Plane *p_planes, int p_plane_count) con
|
|||
}
|
||||
|
||||
bool AABB::has_point(const Vector3 &p_point) const {
|
||||
|
||||
if (p_point.x < position.x)
|
||||
return false;
|
||||
if (p_point.y < position.y)
|
||||
|
|
@ -124,7 +125,6 @@ bool AABB::has_point(const Vector3 &p_point) const {
|
|||
}
|
||||
|
||||
void AABB::expand_to(const Vector3 &p_vector) {
|
||||
|
||||
Vector3 begin = position;
|
||||
Vector3 end = position + size;
|
||||
|
||||
|
|
@ -147,7 +147,6 @@ void AABB::expand_to(const Vector3 &p_vector) {
|
|||
}
|
||||
|
||||
void AABB::project_range_in_plane(const Plane &p_plane, real_t &r_min, real_t &r_max) const {
|
||||
|
||||
Vector3 half_extents(size.x * 0.5, size.y * 0.5, size.z * 0.5);
|
||||
Vector3 center(position.x + half_extents.x, position.y + half_extents.y, position.z + half_extents.z);
|
||||
|
||||
|
|
@ -158,7 +157,6 @@ void AABB::project_range_in_plane(const Plane &p_plane, real_t &r_min, real_t &r
|
|||
}
|
||||
|
||||
real_t AABB::get_longest_axis_size() const {
|
||||
|
||||
real_t max_size = size.x;
|
||||
|
||||
if (size.y > max_size) {
|
||||
|
|
@ -173,7 +171,6 @@ real_t AABB::get_longest_axis_size() const {
|
|||
}
|
||||
|
||||
real_t AABB::get_shortest_axis_size() const {
|
||||
|
||||
real_t max_size = size.x;
|
||||
|
||||
if (size.y < max_size) {
|
||||
|
|
@ -188,7 +185,6 @@ real_t AABB::get_shortest_axis_size() const {
|
|||
}
|
||||
|
||||
bool AABB::smits_intersect_ray(const Vector3 &from, const Vector3 &dir, real_t t0, real_t t1) const {
|
||||
|
||||
real_t divx = 1.0 / dir.x;
|
||||
real_t divy = 1.0 / dir.y;
|
||||
real_t divz = 1.0 / dir.z;
|
||||
|
|
@ -232,7 +228,6 @@ bool AABB::smits_intersect_ray(const Vector3 &from, const Vector3 &dir, real_t t
|
|||
}
|
||||
|
||||
void AABB::grow_by(real_t p_amount) {
|
||||
|
||||
position.x -= p_amount;
|
||||
position.y -= p_amount;
|
||||
position.z -= p_amount;
|
||||
|
|
@ -242,21 +237,17 @@ void AABB::grow_by(real_t p_amount) {
|
|||
}
|
||||
|
||||
real_t AABB::get_area() const {
|
||||
|
||||
return size.x * size.y * size.z;
|
||||
}
|
||||
|
||||
bool AABB::operator==(const AABB &p_rval) const {
|
||||
|
||||
return ((position == p_rval.position) && (size == p_rval.size));
|
||||
}
|
||||
bool AABB::operator!=(const AABB &p_rval) const {
|
||||
|
||||
return ((position != p_rval.position) || (size != p_rval.size));
|
||||
}
|
||||
|
||||
void AABB::merge_with(const AABB &p_aabb) {
|
||||
|
||||
Vector3 beg_1, beg_2;
|
||||
Vector3 end_1, end_2;
|
||||
Vector3 min, max;
|
||||
|
|
@ -279,7 +270,6 @@ void AABB::merge_with(const AABB &p_aabb) {
|
|||
}
|
||||
|
||||
AABB AABB::intersection(const AABB &p_aabb) const {
|
||||
|
||||
Vector3 src_min = position;
|
||||
Vector3 src_max = position + size;
|
||||
Vector3 dst_min = p_aabb.position;
|
||||
|
|
@ -290,7 +280,6 @@ AABB AABB::intersection(const AABB &p_aabb) const {
|
|||
if (src_min.x > dst_max.x || src_max.x < dst_min.x)
|
||||
return AABB();
|
||||
else {
|
||||
|
||||
min.x = (src_min.x > dst_min.x) ? src_min.x : dst_min.x;
|
||||
max.x = (src_max.x < dst_max.x) ? src_max.x : dst_max.x;
|
||||
}
|
||||
|
|
@ -298,7 +287,6 @@ AABB AABB::intersection(const AABB &p_aabb) const {
|
|||
if (src_min.y > dst_max.y || src_max.y < dst_min.y)
|
||||
return AABB();
|
||||
else {
|
||||
|
||||
min.y = (src_min.y > dst_min.y) ? src_min.y : dst_min.y;
|
||||
max.y = (src_max.y < dst_max.y) ? src_max.y : dst_max.y;
|
||||
}
|
||||
|
|
@ -306,7 +294,6 @@ AABB AABB::intersection(const AABB &p_aabb) const {
|
|||
if (src_min.z > dst_max.z || src_max.z < dst_min.z)
|
||||
return AABB();
|
||||
else {
|
||||
|
||||
min.z = (src_min.z > dst_min.z) ? src_min.z : dst_min.z;
|
||||
max.z = (src_max.z < dst_max.z) ? src_max.z : dst_max.z;
|
||||
}
|
||||
|
|
@ -315,7 +302,6 @@ AABB AABB::intersection(const AABB &p_aabb) const {
|
|||
}
|
||||
|
||||
bool AABB::intersects_ray(const Vector3 &p_from, const Vector3 &p_dir, Vector3 *r_clip, Vector3 *r_normal) const {
|
||||
|
||||
Vector3 c1, c2;
|
||||
Vector3 end = position + size;
|
||||
real_t near = -1e20;
|
||||
|
|
@ -358,7 +344,6 @@ bool AABB::intersects_ray(const Vector3 &p_from, const Vector3 &p_dir, Vector3 *
|
|||
}
|
||||
|
||||
bool AABB::intersects_segment(const Vector3 &p_from, const Vector3 &p_to, Vector3 *r_clip, Vector3 *r_normal) const {
|
||||
|
||||
real_t min = 0, max = 1;
|
||||
int axis = 0;
|
||||
real_t sign = 0;
|
||||
|
|
@ -372,7 +357,6 @@ bool AABB::intersects_segment(const Vector3 &p_from, const Vector3 &p_to, Vector
|
|||
real_t csign;
|
||||
|
||||
if (seg_from < seg_to) {
|
||||
|
||||
if (seg_from > box_end || seg_to < box_begin)
|
||||
return false;
|
||||
real_t length = seg_to - seg_from;
|
||||
|
|
@ -381,7 +365,6 @@ bool AABB::intersects_segment(const Vector3 &p_from, const Vector3 &p_to, Vector
|
|||
csign = -1.0;
|
||||
|
||||
} else {
|
||||
|
||||
if (seg_to > box_end || seg_from < box_begin)
|
||||
return false;
|
||||
real_t length = seg_to - seg_from;
|
||||
|
|
@ -416,7 +399,6 @@ bool AABB::intersects_segment(const Vector3 &p_from, const Vector3 &p_to, Vector
|
|||
}
|
||||
|
||||
bool AABB::intersects_plane(const Plane &p_plane) const {
|
||||
|
||||
Vector3 points[8] = {
|
||||
Vector3(position.x, position.y, position.z),
|
||||
Vector3(position.x, position.y, position.z + size.z),
|
||||
|
|
@ -432,7 +414,6 @@ bool AABB::intersects_plane(const Plane &p_plane) const {
|
|||
bool under = false;
|
||||
|
||||
for (int i = 0; i < 8; i++) {
|
||||
|
||||
if (p_plane.distance_to(points[i]) > 0)
|
||||
over = true;
|
||||
else
|
||||
|
|
@ -443,7 +424,6 @@ bool AABB::intersects_plane(const Plane &p_plane) const {
|
|||
}
|
||||
|
||||
Vector3 AABB::get_longest_axis() const {
|
||||
|
||||
Vector3 axis(1, 0, 0);
|
||||
real_t max_size = size.x;
|
||||
|
||||
|
|
@ -460,7 +440,6 @@ Vector3 AABB::get_longest_axis() const {
|
|||
return axis;
|
||||
}
|
||||
int AABB::get_longest_axis_index() const {
|
||||
|
||||
int axis = 0;
|
||||
real_t max_size = size.x;
|
||||
|
||||
|
|
@ -478,7 +457,6 @@ int AABB::get_longest_axis_index() const {
|
|||
}
|
||||
|
||||
Vector3 AABB::get_shortest_axis() const {
|
||||
|
||||
Vector3 axis(1, 0, 0);
|
||||
real_t max_size = size.x;
|
||||
|
||||
|
|
@ -495,7 +473,6 @@ Vector3 AABB::get_shortest_axis() const {
|
|||
return axis;
|
||||
}
|
||||
int AABB::get_shortest_axis_index() const {
|
||||
|
||||
int axis = 0;
|
||||
real_t max_size = size.x;
|
||||
|
||||
|
|
@ -513,7 +490,6 @@ int AABB::get_shortest_axis_index() const {
|
|||
}
|
||||
|
||||
AABB AABB::merge(const AABB &p_with) const {
|
||||
|
||||
AABB aabb = *this;
|
||||
aabb.merge_with(p_with);
|
||||
return aabb;
|
||||
|
|
@ -524,24 +500,19 @@ AABB AABB::expand(const Vector3 &p_vector) const {
|
|||
return aabb;
|
||||
}
|
||||
AABB AABB::grow(real_t p_by) const {
|
||||
|
||||
AABB aabb = *this;
|
||||
aabb.grow_by(p_by);
|
||||
return aabb;
|
||||
}
|
||||
|
||||
void AABB::get_edge(int p_edge, Vector3 &r_from, Vector3 &r_to) const {
|
||||
|
||||
ERR_FAIL_INDEX(p_edge, 12);
|
||||
switch (p_edge) {
|
||||
|
||||
case 0: {
|
||||
|
||||
r_from = Vector3(position.x + size.x, position.y, position.z);
|
||||
r_to = Vector3(position.x, position.y, position.z);
|
||||
} break;
|
||||
case 1: {
|
||||
|
||||
r_from = Vector3(position.x + size.x, position.y, position.z + size.z);
|
||||
r_to = Vector3(position.x + size.x, position.y, position.z);
|
||||
} break;
|
||||
|
|
@ -551,18 +522,15 @@ void AABB::get_edge(int p_edge, Vector3 &r_from, Vector3 &r_to) const {
|
|||
|
||||
} break;
|
||||
case 3: {
|
||||
|
||||
r_from = Vector3(position.x, position.y, position.z);
|
||||
r_to = Vector3(position.x, position.y, position.z + size.z);
|
||||
|
||||
} break;
|
||||
case 4: {
|
||||
|
||||
r_from = Vector3(position.x, position.y + size.y, position.z);
|
||||
r_to = Vector3(position.x + size.x, position.y + size.y, position.z);
|
||||
} break;
|
||||
case 5: {
|
||||
|
||||
r_from = Vector3(position.x + size.x, position.y + size.y, position.z);
|
||||
r_to = Vector3(position.x + size.x, position.y + size.y, position.z + size.z);
|
||||
} break;
|
||||
|
|
@ -572,31 +540,26 @@ void AABB::get_edge(int p_edge, Vector3 &r_from, Vector3 &r_to) const {
|
|||
|
||||
} break;
|
||||
case 7: {
|
||||
|
||||
r_from = Vector3(position.x, position.y + size.y, position.z + size.z);
|
||||
r_to = Vector3(position.x, position.y + size.y, position.z);
|
||||
|
||||
} break;
|
||||
case 8: {
|
||||
|
||||
r_from = Vector3(position.x, position.y, position.z + size.z);
|
||||
r_to = Vector3(position.x, position.y + size.y, position.z + size.z);
|
||||
|
||||
} break;
|
||||
case 9: {
|
||||
|
||||
r_from = Vector3(position.x, position.y, position.z);
|
||||
r_to = Vector3(position.x, position.y + size.y, position.z);
|
||||
|
||||
} break;
|
||||
case 10: {
|
||||
|
||||
r_from = Vector3(position.x + size.x, position.y, position.z);
|
||||
r_to = Vector3(position.x + size.x, position.y + size.y, position.z);
|
||||
|
||||
} break;
|
||||
case 11: {
|
||||
|
||||
r_from = Vector3(position.x + size.x, position.y, position.z + size.z);
|
||||
r_to = Vector3(position.x + size.x, position.y + size.y, position.z + size.z);
|
||||
|
||||
|
|
@ -605,7 +568,6 @@ void AABB::get_edge(int p_edge, Vector3 &r_from, Vector3 &r_to) const {
|
|||
}
|
||||
|
||||
AABB::operator String() const {
|
||||
|
||||
return String() + position + " - " + size;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -19,12 +19,10 @@ Basis::Basis(const Vector3 &row0, const Vector3 &row1, const Vector3 &row2) {
|
|||
}
|
||||
|
||||
Basis::Basis(real_t xx, real_t xy, real_t xz, real_t yx, real_t yy, real_t yz, real_t zx, real_t zy, real_t zz) {
|
||||
|
||||
set(xx, xy, xz, yx, yy, yz, zx, zy, zz);
|
||||
}
|
||||
|
||||
Basis::Basis() {
|
||||
|
||||
elements[0][0] = 1;
|
||||
elements[0][1] = 0;
|
||||
elements[0][2] = 0;
|
||||
|
|
@ -58,7 +56,6 @@ void Basis::invert() {
|
|||
#undef cofac
|
||||
|
||||
bool Basis::isequal_approx(const Basis &a, const Basis &b) const {
|
||||
|
||||
for (int i = 0; i < 3; i++) {
|
||||
for (int j = 0; j < 3; j++) {
|
||||
if ((::fabs(a.elements[i][j] - b.elements[i][j]) < CMP_EPSILON) == false)
|
||||
|
|
@ -174,7 +171,6 @@ Basis Basis::slerp(Basis b, float t) const {
|
|||
// the angles in the decomposition R = X(a1).Y(a2).Z(a3) where Z(a) rotates
|
||||
// around the z-axis by a and so on.
|
||||
Vector3 Basis::get_euler_xyz() const {
|
||||
|
||||
// Euler angles in XYZ convention.
|
||||
// See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix
|
||||
//
|
||||
|
|
@ -218,7 +214,6 @@ Vector3 Basis::get_euler_xyz() const {
|
|||
// and similar for other axes.
|
||||
// The current implementation uses XYZ convention (Z is the first rotation).
|
||||
void Basis::set_euler_xyz(const Vector3 &p_euler) {
|
||||
|
||||
real_t c, s;
|
||||
|
||||
c = ::cos(p_euler.x);
|
||||
|
|
@ -241,7 +236,6 @@ void Basis::set_euler_xyz(const Vector3 &p_euler) {
|
|||
// as in first-Z, then-X, last-Y. The angles for X, Y, and Z rotations are returned
|
||||
// as the x, y, and z components of a Vector3 respectively.
|
||||
Vector3 Basis::get_euler_yxz() const {
|
||||
|
||||
// Euler angles in YXZ convention.
|
||||
// See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix
|
||||
//
|
||||
|
|
@ -287,7 +281,6 @@ Vector3 Basis::get_euler_yxz() const {
|
|||
// and similar for other axes.
|
||||
// The current implementation uses YXZ convention (Z is the first rotation).
|
||||
void Basis::set_euler_yxz(const Vector3 &p_euler) {
|
||||
|
||||
real_t c, s;
|
||||
|
||||
c = ::cos(p_euler.x);
|
||||
|
|
@ -333,7 +326,6 @@ bool Basis::operator!=(const Basis &p_matrix) const {
|
|||
}
|
||||
|
||||
Vector3 Basis::xform(const Vector3 &p_vector) const {
|
||||
|
||||
return Vector3(
|
||||
elements[0].dot(p_vector),
|
||||
elements[1].dot(p_vector),
|
||||
|
|
@ -341,7 +333,6 @@ Vector3 Basis::xform(const Vector3 &p_vector) const {
|
|||
}
|
||||
|
||||
Vector3 Basis::xform_inv(const Vector3 &p_vector) const {
|
||||
|
||||
return Vector3(
|
||||
(elements[0][0] * p_vector.x) + (elements[1][0] * p_vector.y) + (elements[2][0] * p_vector.z),
|
||||
(elements[0][1] * p_vector.x) + (elements[1][1] * p_vector.y) + (elements[2][1] * p_vector.z),
|
||||
|
|
@ -362,42 +353,36 @@ Basis Basis::operator*(const Basis &p_matrix) const {
|
|||
}
|
||||
|
||||
void Basis::operator+=(const Basis &p_matrix) {
|
||||
|
||||
elements[0] += p_matrix.elements[0];
|
||||
elements[1] += p_matrix.elements[1];
|
||||
elements[2] += p_matrix.elements[2];
|
||||
}
|
||||
|
||||
Basis Basis::operator+(const Basis &p_matrix) const {
|
||||
|
||||
Basis ret(*this);
|
||||
ret += p_matrix;
|
||||
return ret;
|
||||
}
|
||||
|
||||
void Basis::operator-=(const Basis &p_matrix) {
|
||||
|
||||
elements[0] -= p_matrix.elements[0];
|
||||
elements[1] -= p_matrix.elements[1];
|
||||
elements[2] -= p_matrix.elements[2];
|
||||
}
|
||||
|
||||
Basis Basis::operator-(const Basis &p_matrix) const {
|
||||
|
||||
Basis ret(*this);
|
||||
ret -= p_matrix;
|
||||
return ret;
|
||||
}
|
||||
|
||||
void Basis::operator*=(real_t p_val) {
|
||||
|
||||
elements[0] *= p_val;
|
||||
elements[1] *= p_val;
|
||||
elements[2] *= p_val;
|
||||
}
|
||||
|
||||
Basis Basis::operator*(real_t p_val) const {
|
||||
|
||||
Basis ret(*this);
|
||||
ret *= p_val;
|
||||
return ret;
|
||||
|
|
@ -406,9 +391,7 @@ Basis Basis::operator*(real_t p_val) const {
|
|||
Basis::operator String() const {
|
||||
String s;
|
||||
for (int i = 0; i < 3; i++) {
|
||||
|
||||
for (int j = 0; j < 3; j++) {
|
||||
|
||||
if (i != 0 || j != 0)
|
||||
s += ", ";
|
||||
|
||||
|
|
@ -421,7 +404,6 @@ Basis::operator String() const {
|
|||
/* create / set */
|
||||
|
||||
void Basis::set(real_t xx, real_t xy, real_t xz, real_t yx, real_t yy, real_t yz, real_t zx, real_t zy, real_t zz) {
|
||||
|
||||
elements[0][0] = xx;
|
||||
elements[0][1] = xy;
|
||||
elements[0][2] = xz;
|
||||
|
|
@ -433,12 +415,10 @@ void Basis::set(real_t xx, real_t xy, real_t xz, real_t yx, real_t yy, real_t yz
|
|||
elements[2][2] = zz;
|
||||
}
|
||||
Vector3 Basis::get_column(int i) const {
|
||||
|
||||
return Vector3(elements[0][i], elements[1][i], elements[2][i]);
|
||||
}
|
||||
|
||||
Vector3 Basis::get_row(int i) const {
|
||||
|
||||
return Vector3(elements[i][0], elements[i][1], elements[i][2]);
|
||||
}
|
||||
Vector3 Basis::get_main_diagonal() const {
|
||||
|
|
@ -593,7 +573,6 @@ int Basis::get_orthogonal_index() const {
|
|||
Basis orth = *this;
|
||||
for (int i = 0; i < 3; i++) {
|
||||
for (int j = 0; j < 3; j++) {
|
||||
|
||||
real_t v = orth[i][j];
|
||||
if (v > 0.5)
|
||||
v = 1.0;
|
||||
|
|
@ -607,7 +586,6 @@ int Basis::get_orthogonal_index() const {
|
|||
}
|
||||
|
||||
for (int i = 0; i < 24; i++) {
|
||||
|
||||
if (_ortho_bases[i] == orth)
|
||||
return i;
|
||||
}
|
||||
|
|
@ -616,7 +594,6 @@ int Basis::get_orthogonal_index() const {
|
|||
}
|
||||
|
||||
void Basis::set_orthogonal_index(int p_index) {
|
||||
|
||||
//there only exist 24 orthogonal bases in r3
|
||||
ERR_FAIL_COND(p_index >= 24);
|
||||
|
||||
|
|
@ -624,7 +601,6 @@ void Basis::set_orthogonal_index(int p_index) {
|
|||
}
|
||||
|
||||
Basis::Basis(const Vector3 &p_euler) {
|
||||
|
||||
set_euler(p_euler);
|
||||
}
|
||||
|
||||
|
|
@ -635,7 +611,6 @@ Basis::Basis(const Vector3 &p_euler) {
|
|||
namespace godot {
|
||||
|
||||
Basis::Basis(const Quat &p_quat) {
|
||||
|
||||
real_t d = p_quat.length_squared();
|
||||
real_t s = 2.0 / d;
|
||||
real_t xs = p_quat.x * s, ys = p_quat.y * s, zs = p_quat.z * s;
|
||||
|
|
|
|||
|
|
@ -31,29 +31,22 @@
|
|||
#include "CameraMatrix.hpp"
|
||||
|
||||
void CameraMatrix::set_identity() {
|
||||
|
||||
for (int i = 0; i < 4; i++) {
|
||||
|
||||
for (int j = 0; j < 4; j++) {
|
||||
|
||||
matrix[i][j] = (i == j) ? 1 : 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void CameraMatrix::set_zero() {
|
||||
|
||||
for (int i = 0; i < 4; i++) {
|
||||
|
||||
for (int j = 0; j < 4; j++) {
|
||||
|
||||
matrix[i][j] = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Plane CameraMatrix::xform4(const Plane &p_vec4) const {
|
||||
|
||||
Plane ret;
|
||||
|
||||
ret.normal.x = matrix[0][0] * p_vec4.normal.x + matrix[1][0] * p_vec4.normal.y + matrix[2][0] * p_vec4.normal.z + matrix[3][0] * p_vec4.d;
|
||||
|
|
@ -64,7 +57,6 @@ Plane CameraMatrix::xform4(const Plane &p_vec4) const {
|
|||
}
|
||||
|
||||
void CameraMatrix::set_perspective(real_t p_fovy_degrees, real_t p_aspect, real_t p_z_near, real_t p_z_far, bool p_flip_fov) {
|
||||
|
||||
if (p_flip_fov) {
|
||||
p_fovy_degrees = get_fovy(p_fovy_degrees, 1.0 / p_aspect);
|
||||
}
|
||||
|
|
@ -157,7 +149,6 @@ void CameraMatrix::set_for_hmd(int p_eye, real_t p_aspect, real_t p_intraocular_
|
|||
};
|
||||
|
||||
void CameraMatrix::set_orthogonal(real_t p_left, real_t p_right, real_t p_bottom, real_t p_top, real_t p_znear, real_t p_zfar) {
|
||||
|
||||
set_identity();
|
||||
|
||||
matrix[0][0] = 2.0 / (p_right - p_left);
|
||||
|
|
@ -170,7 +161,6 @@ void CameraMatrix::set_orthogonal(real_t p_left, real_t p_right, real_t p_bottom
|
|||
}
|
||||
|
||||
void CameraMatrix::set_orthogonal(real_t p_size, real_t p_aspect, real_t p_znear, real_t p_zfar, bool p_flip_fov) {
|
||||
|
||||
if (!p_flip_fov) {
|
||||
p_size *= p_aspect;
|
||||
}
|
||||
|
|
@ -179,7 +169,6 @@ void CameraMatrix::set_orthogonal(real_t p_size, real_t p_aspect, real_t p_znear
|
|||
}
|
||||
|
||||
void CameraMatrix::set_frustum(real_t p_left, real_t p_right, real_t p_bottom, real_t p_top, real_t p_near, real_t p_far) {
|
||||
|
||||
ERR_FAIL_COND(p_right <= p_left);
|
||||
ERR_FAIL_COND(p_top <= p_bottom);
|
||||
ERR_FAIL_COND(p_far <= p_near);
|
||||
|
|
@ -220,7 +209,6 @@ void CameraMatrix::set_frustum(real_t p_size, real_t p_aspect, Vector2 p_offset,
|
|||
}
|
||||
|
||||
real_t CameraMatrix::get_z_far() const {
|
||||
|
||||
const real_t *matrix = (const real_t *)this->matrix;
|
||||
Plane new_plane = Plane(matrix[3] - matrix[2],
|
||||
matrix[7] - matrix[6],
|
||||
|
|
@ -233,7 +221,6 @@ real_t CameraMatrix::get_z_far() const {
|
|||
return new_plane.d;
|
||||
}
|
||||
real_t CameraMatrix::get_z_near() const {
|
||||
|
||||
const real_t *matrix = (const real_t *)this->matrix;
|
||||
Plane new_plane = Plane(matrix[3] + matrix[2],
|
||||
matrix[7] + matrix[6],
|
||||
|
|
@ -245,7 +232,6 @@ real_t CameraMatrix::get_z_near() const {
|
|||
}
|
||||
|
||||
Vector2 CameraMatrix::get_viewport_half_extents() const {
|
||||
|
||||
const real_t *matrix = (const real_t *)this->matrix;
|
||||
///////--- Near Plane ---///////
|
||||
Plane near_plane = Plane(matrix[3] + matrix[2],
|
||||
|
|
@ -274,7 +260,6 @@ Vector2 CameraMatrix::get_viewport_half_extents() const {
|
|||
}
|
||||
|
||||
bool CameraMatrix::get_endpoints(const Transform &p_transform, Vector3 *p_8points) const {
|
||||
|
||||
std::vector<Plane> planes = get_projection_planes(Transform());
|
||||
const Planes intersections[8][3] = {
|
||||
{ PLANE_FAR, PLANE_LEFT, PLANE_TOP },
|
||||
|
|
@ -288,7 +273,6 @@ bool CameraMatrix::get_endpoints(const Transform &p_transform, Vector3 *p_8point
|
|||
};
|
||||
|
||||
for (int i = 0; i < 8; i++) {
|
||||
|
||||
Vector3 point;
|
||||
bool res = planes[intersections[i][0]].intersect_3(planes[intersections[i][1]], planes[intersections[i][2]], &point);
|
||||
ERR_FAIL_COND_V(!res, false);
|
||||
|
|
@ -299,7 +283,6 @@ bool CameraMatrix::get_endpoints(const Transform &p_transform, Vector3 *p_8point
|
|||
}
|
||||
|
||||
std::vector<Plane> CameraMatrix::get_projection_planes(const Transform &p_transform) const {
|
||||
|
||||
/** Fast Plane Extraction from combined modelview/projection matrices.
|
||||
* References:
|
||||
* https://web.archive.org/web/20011221205252/http://www.markmorley.com/opengl/frustumculling.html
|
||||
|
|
@ -382,14 +365,12 @@ std::vector<Plane> CameraMatrix::get_projection_planes(const Transform &p_transf
|
|||
}
|
||||
|
||||
CameraMatrix CameraMatrix::inverse() const {
|
||||
|
||||
CameraMatrix cm = *this;
|
||||
cm.invert();
|
||||
return cm;
|
||||
}
|
||||
|
||||
void CameraMatrix::invert() {
|
||||
|
||||
int i, j, k;
|
||||
int pvt_i[4], pvt_j[4]; /* Locations of pivot matrix */
|
||||
real_t pvt_val; /* Value of current pivot element */
|
||||
|
|
@ -440,20 +421,23 @@ void CameraMatrix::invert() {
|
|||
|
||||
/** Divide column by minus pivot value **/
|
||||
for (i = 0; i < 4; i++) {
|
||||
if (i != k) matrix[i][k] /= (-pvt_val);
|
||||
if (i != k)
|
||||
matrix[i][k] /= (-pvt_val);
|
||||
}
|
||||
|
||||
/** Reduce the matrix **/
|
||||
for (i = 0; i < 4; i++) {
|
||||
hold = matrix[i][k];
|
||||
for (j = 0; j < 4; j++) {
|
||||
if (i != k && j != k) matrix[i][j] += hold * matrix[k][j];
|
||||
if (i != k && j != k)
|
||||
matrix[i][j] += hold * matrix[k][j];
|
||||
}
|
||||
}
|
||||
|
||||
/** Divide row by pivot **/
|
||||
for (j = 0; j < 4; j++) {
|
||||
if (j != k) matrix[k][j] /= pvt_val;
|
||||
if (j != k)
|
||||
matrix[k][j] /= pvt_val;
|
||||
}
|
||||
|
||||
/** Replace pivot by reciprocal (at last we can touch it). **/
|
||||
|
|
@ -483,12 +467,10 @@ void CameraMatrix::invert() {
|
|||
}
|
||||
|
||||
CameraMatrix::CameraMatrix() {
|
||||
|
||||
set_identity();
|
||||
}
|
||||
|
||||
CameraMatrix CameraMatrix::operator*(const CameraMatrix &p_matrix) const {
|
||||
|
||||
CameraMatrix new_matrix;
|
||||
|
||||
for (int j = 0; j < 4; j++) {
|
||||
|
|
@ -504,7 +486,6 @@ CameraMatrix CameraMatrix::operator*(const CameraMatrix &p_matrix) const {
|
|||
}
|
||||
|
||||
void CameraMatrix::set_light_bias() {
|
||||
|
||||
real_t *m = &matrix[0][0];
|
||||
|
||||
m[0] = 0.5;
|
||||
|
|
@ -526,7 +507,6 @@ void CameraMatrix::set_light_bias() {
|
|||
}
|
||||
|
||||
void CameraMatrix::set_light_atlas_rect(const Rect2 &p_rect) {
|
||||
|
||||
real_t *m = &matrix[0][0];
|
||||
|
||||
m[0] = p_rect.size.width;
|
||||
|
|
@ -548,7 +528,6 @@ void CameraMatrix::set_light_atlas_rect(const Rect2 &p_rect) {
|
|||
}
|
||||
|
||||
CameraMatrix::operator String() const {
|
||||
|
||||
String str;
|
||||
for (int i = 0; i < 4; i++)
|
||||
for (int j = 0; j < 4; j++)
|
||||
|
|
@ -558,20 +537,17 @@ CameraMatrix::operator String() const {
|
|||
}
|
||||
|
||||
real_t CameraMatrix::get_aspect() const {
|
||||
|
||||
Vector2 vp_he = get_viewport_half_extents();
|
||||
return vp_he.x / vp_he.y;
|
||||
}
|
||||
|
||||
int CameraMatrix::get_pixels_per_meter(int p_for_pixel_width) const {
|
||||
|
||||
Vector3 result = xform(Vector3(1, 0, -1));
|
||||
|
||||
return int((result.x * 0.5 + 0.5) * p_for_pixel_width);
|
||||
}
|
||||
|
||||
bool CameraMatrix::is_orthogonal() const {
|
||||
|
||||
return matrix[3][3] == 1.0;
|
||||
}
|
||||
|
||||
|
|
@ -599,7 +575,6 @@ real_t CameraMatrix::get_fov() const {
|
|||
}
|
||||
|
||||
void CameraMatrix::make_scale(const Vector3 &p_scale) {
|
||||
|
||||
set_identity();
|
||||
matrix[0][0] = p_scale.x;
|
||||
matrix[1][1] = p_scale.y;
|
||||
|
|
@ -607,7 +582,6 @@ void CameraMatrix::make_scale(const Vector3 &p_scale) {
|
|||
}
|
||||
|
||||
void CameraMatrix::scale_translate_to_fit(const AABB &p_aabb) {
|
||||
|
||||
Vector3 min = p_aabb.position;
|
||||
Vector3 max = p_aabb.position + p_aabb.size;
|
||||
|
||||
|
|
@ -633,7 +607,6 @@ void CameraMatrix::scale_translate_to_fit(const AABB &p_aabb) {
|
|||
}
|
||||
|
||||
CameraMatrix::operator Transform() const {
|
||||
|
||||
Transform tr;
|
||||
const real_t *m = &matrix[0][0];
|
||||
|
||||
|
|
@ -657,7 +630,6 @@ CameraMatrix::operator Transform() const {
|
|||
}
|
||||
|
||||
CameraMatrix::CameraMatrix(const Transform &p_transform) {
|
||||
|
||||
const Transform &tr = p_transform;
|
||||
real_t *m = &matrix[0][0];
|
||||
|
||||
|
|
|
|||
|
|
@ -13,11 +13,9 @@ namespace godot {
|
|||
static String _to_hex(float p_val);
|
||||
|
||||
static float _parse_col(const String &p_str, int p_ofs) {
|
||||
|
||||
int ig = 0;
|
||||
|
||||
for (int i = 0; i < 2; i++) {
|
||||
|
||||
int c = (int)(wchar_t)p_str[i + p_ofs];
|
||||
int v = 0;
|
||||
|
||||
|
|
@ -43,7 +41,6 @@ static float _parse_col(const String &p_str, int p_ofs) {
|
|||
}
|
||||
|
||||
uint32_t Color::to_32() const {
|
||||
|
||||
uint32_t c = (uint8_t)(a * 255);
|
||||
c <<= 8;
|
||||
c |= (uint8_t)(r * 255);
|
||||
|
|
@ -148,7 +145,6 @@ uint8_t Color::get_a8() const {
|
|||
}
|
||||
|
||||
float Color::get_h() const {
|
||||
|
||||
float min = MIN(r, g);
|
||||
min = MIN(min, b);
|
||||
float max = MAX(r, g);
|
||||
|
|
@ -334,7 +330,6 @@ Color Color::contrasted() const {
|
|||
}
|
||||
|
||||
Color Color::linear_interpolate(const Color &p_b, float p_t) const {
|
||||
|
||||
Color res = *this;
|
||||
|
||||
res.r += (p_t * (p_b.r - r));
|
||||
|
|
@ -346,7 +341,6 @@ Color Color::linear_interpolate(const Color &p_b, float p_t) const {
|
|||
}
|
||||
|
||||
Color Color::blend(const Color &p_over) const {
|
||||
|
||||
Color res;
|
||||
float sa = 1.0 - p_over.a;
|
||||
res.a = a * sa + p_over.a;
|
||||
|
|
@ -361,7 +355,6 @@ Color Color::blend(const Color &p_over) const {
|
|||
}
|
||||
|
||||
Color Color::to_linear() const {
|
||||
|
||||
return Color(
|
||||
r < 0.04045 ? r * (1.0 / 12.92) : ::pow((r + 0.055) * (1.0 / (1 + 0.055)), 2.4),
|
||||
g < 0.04045 ? g * (1.0 / 12.92) : ::pow((g + 0.055) * (1.0 / (1 + 0.055)), 2.4),
|
||||
|
|
@ -477,13 +470,11 @@ bool Color::html_is_valid(const String &p_color) {
|
|||
#define CLAMP(m_a, m_min, m_max) (((m_a) < (m_min)) ? (m_min) : (((m_a) > (m_max)) ? m_max : m_a))
|
||||
#endif
|
||||
static String _to_hex(float p_val) {
|
||||
|
||||
int v = p_val * 255;
|
||||
v = CLAMP(v, 0, 255);
|
||||
String ret;
|
||||
|
||||
for (int i = 0; i < 2; i++) {
|
||||
|
||||
wchar_t c[2] = { 0, 0 };
|
||||
int lv = v & 0xF;
|
||||
if (lv < 10)
|
||||
|
|
@ -514,7 +505,6 @@ Color::operator String() const {
|
|||
}
|
||||
|
||||
bool Color::operator<(const Color &p_color) const {
|
||||
|
||||
if (r == p_color.r) {
|
||||
if (g == p_color.g) {
|
||||
if (b == p_color.b) {
|
||||
|
|
@ -528,7 +518,6 @@ bool Color::operator<(const Color &p_color) const {
|
|||
}
|
||||
|
||||
Color Color::operator+(const Color &p_color) const {
|
||||
|
||||
return Color(
|
||||
r + p_color.r,
|
||||
g + p_color.g,
|
||||
|
|
@ -537,7 +526,6 @@ Color Color::operator+(const Color &p_color) const {
|
|||
}
|
||||
|
||||
void Color::operator+=(const Color &p_color) {
|
||||
|
||||
r = r + p_color.r;
|
||||
g = g + p_color.g;
|
||||
b = b + p_color.b;
|
||||
|
|
@ -545,7 +533,6 @@ void Color::operator+=(const Color &p_color) {
|
|||
}
|
||||
|
||||
Color Color::operator-(const Color &p_color) const {
|
||||
|
||||
return Color(
|
||||
r - p_color.r,
|
||||
g - p_color.g,
|
||||
|
|
@ -554,7 +541,6 @@ Color Color::operator-(const Color &p_color) const {
|
|||
}
|
||||
|
||||
void Color::operator-=(const Color &p_color) {
|
||||
|
||||
r = r - p_color.r;
|
||||
g = g - p_color.g;
|
||||
b = b - p_color.b;
|
||||
|
|
@ -562,7 +548,6 @@ void Color::operator-=(const Color &p_color) {
|
|||
}
|
||||
|
||||
Color Color::operator*(const Color &p_color) const {
|
||||
|
||||
return Color(
|
||||
r * p_color.r,
|
||||
g * p_color.g,
|
||||
|
|
@ -571,7 +556,6 @@ Color Color::operator*(const Color &p_color) const {
|
|||
}
|
||||
|
||||
Color Color::operator*(const real_t &rvalue) const {
|
||||
|
||||
return Color(
|
||||
r * rvalue,
|
||||
g * rvalue,
|
||||
|
|
@ -580,7 +564,6 @@ Color Color::operator*(const real_t &rvalue) const {
|
|||
}
|
||||
|
||||
void Color::operator*=(const Color &p_color) {
|
||||
|
||||
r = r * p_color.r;
|
||||
g = g * p_color.g;
|
||||
b = b * p_color.b;
|
||||
|
|
@ -588,7 +571,6 @@ void Color::operator*=(const Color &p_color) {
|
|||
}
|
||||
|
||||
void Color::operator*=(const real_t &rvalue) {
|
||||
|
||||
r = r * rvalue;
|
||||
g = g * rvalue;
|
||||
b = b * rvalue;
|
||||
|
|
@ -596,7 +578,6 @@ void Color::operator*=(const real_t &rvalue) {
|
|||
}
|
||||
|
||||
Color Color::operator/(const Color &p_color) const {
|
||||
|
||||
return Color(
|
||||
r / p_color.r,
|
||||
g / p_color.g,
|
||||
|
|
@ -605,7 +586,6 @@ Color Color::operator/(const Color &p_color) const {
|
|||
}
|
||||
|
||||
Color Color::operator/(const real_t &rvalue) const {
|
||||
|
||||
return Color(
|
||||
r / rvalue,
|
||||
g / rvalue,
|
||||
|
|
@ -614,7 +594,6 @@ Color Color::operator/(const real_t &rvalue) const {
|
|||
}
|
||||
|
||||
void Color::operator/=(const Color &p_color) {
|
||||
|
||||
r = r / p_color.r;
|
||||
g = g / p_color.g;
|
||||
b = b / p_color.b;
|
||||
|
|
@ -622,7 +601,6 @@ void Color::operator/=(const Color &p_color) {
|
|||
}
|
||||
|
||||
void Color::operator/=(const real_t &rvalue) {
|
||||
|
||||
if (rvalue == 0) {
|
||||
r = 1.0;
|
||||
g = 1.0;
|
||||
|
|
@ -637,7 +615,6 @@ void Color::operator/=(const real_t &rvalue) {
|
|||
}
|
||||
|
||||
Color Color::operator-() const {
|
||||
|
||||
return Color(
|
||||
1.0 - r,
|
||||
1.0 - g,
|
||||
|
|
|
|||
|
|
@ -55,9 +55,12 @@ void Godot::print_warning(const String &description, const String &function, con
|
|||
godot::api->godot_print_warning(c_desc, c_func, c_file, line);
|
||||
};
|
||||
|
||||
if (c_desc != nullptr) godot::api->godot_free(c_desc);
|
||||
if (c_func != nullptr) godot::api->godot_free(c_func);
|
||||
if (c_file != nullptr) godot::api->godot_free(c_file);
|
||||
if (c_desc != nullptr)
|
||||
godot::api->godot_free(c_desc);
|
||||
if (c_func != nullptr)
|
||||
godot::api->godot_free(c_func);
|
||||
if (c_file != nullptr)
|
||||
godot::api->godot_free(c_file);
|
||||
}
|
||||
|
||||
void Godot::print_error(const String &description, const String &function, const String &file, int line) {
|
||||
|
|
@ -71,9 +74,12 @@ void Godot::print_error(const String &description, const String &function, const
|
|||
godot::api->godot_print_error(c_desc, c_func, c_file, line);
|
||||
};
|
||||
|
||||
if (c_desc != nullptr) godot::api->godot_free(c_desc);
|
||||
if (c_func != nullptr) godot::api->godot_free(c_func);
|
||||
if (c_file != nullptr) godot::api->godot_free(c_file);
|
||||
if (c_desc != nullptr)
|
||||
godot::api->godot_free(c_desc);
|
||||
if (c_func != nullptr)
|
||||
godot::api->godot_free(c_func);
|
||||
if (c_file != nullptr)
|
||||
godot::api->godot_free(c_file);
|
||||
}
|
||||
|
||||
void ___register_types();
|
||||
|
|
@ -136,7 +142,8 @@ void Godot::gdnative_init(godot_gdnative_init_options *options) {
|
|||
}
|
||||
} break;
|
||||
|
||||
default: break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -10,12 +10,10 @@ void Plane::set_normal(const Vector3 &p_normal) {
|
|||
}
|
||||
|
||||
Vector3 Plane::project(const Vector3 &p_point) const {
|
||||
|
||||
return p_point - normal * distance_to(p_point);
|
||||
}
|
||||
|
||||
void Plane::normalize() {
|
||||
|
||||
real_t l = normal.length();
|
||||
if (l == 0) {
|
||||
*this = Plane(0, 0, 0, 0);
|
||||
|
|
@ -26,19 +24,16 @@ void Plane::normalize() {
|
|||
}
|
||||
|
||||
Plane Plane::normalized() const {
|
||||
|
||||
Plane p = *this;
|
||||
p.normalize();
|
||||
return p;
|
||||
}
|
||||
|
||||
Vector3 Plane::get_any_point() const {
|
||||
|
||||
return get_normal() * d;
|
||||
}
|
||||
|
||||
Vector3 Plane::get_any_perpendicular_normal() const {
|
||||
|
||||
static const Vector3 p1 = Vector3(1, 0, 0);
|
||||
static const Vector3 p2 = Vector3(0, 1, 0);
|
||||
Vector3 p;
|
||||
|
|
@ -57,7 +52,6 @@ Vector3 Plane::get_any_perpendicular_normal() const {
|
|||
/* intersections */
|
||||
|
||||
bool Plane::intersect_3(const Plane &p_plane1, const Plane &p_plane2, Vector3 *r_result) const {
|
||||
|
||||
const Plane &p_plane0 = *this;
|
||||
Vector3 normal0 = p_plane0.normal;
|
||||
Vector3 normal1 = p_plane1.normal;
|
||||
|
|
@ -79,13 +73,11 @@ bool Plane::intersect_3(const Plane &p_plane1, const Plane &p_plane2, Vector3 *r
|
|||
}
|
||||
|
||||
bool Plane::intersects_ray(Vector3 p_from, Vector3 p_dir, Vector3 *p_intersection) const {
|
||||
|
||||
Vector3 segment = p_dir;
|
||||
real_t den = normal.dot(segment);
|
||||
|
||||
//printf("den is %i\n",den);
|
||||
if (::fabs(den) <= CMP_EPSILON) {
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -104,13 +96,11 @@ bool Plane::intersects_ray(Vector3 p_from, Vector3 p_dir, Vector3 *p_intersectio
|
|||
}
|
||||
|
||||
bool Plane::intersects_segment(Vector3 p_begin, Vector3 p_end, Vector3 *p_intersection) const {
|
||||
|
||||
Vector3 segment = p_begin - p_end;
|
||||
real_t den = normal.dot(segment);
|
||||
|
||||
//printf("den is %i\n",den);
|
||||
if (::fabs(den) <= CMP_EPSILON) {
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -118,7 +108,6 @@ bool Plane::intersects_segment(Vector3 p_begin, Vector3 p_end, Vector3 *p_inters
|
|||
//printf("dist is %i\n",dist);
|
||||
|
||||
if (dist < -CMP_EPSILON || dist > (1.0 + CMP_EPSILON)) {
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -131,47 +120,39 @@ bool Plane::intersects_segment(Vector3 p_begin, Vector3 p_end, Vector3 *p_inters
|
|||
/* misc */
|
||||
|
||||
bool Plane::is_almost_like(const Plane &p_plane) const {
|
||||
|
||||
return (normal.dot(p_plane.normal) > _PLANE_EQ_DOT_EPSILON && ::fabs(d - p_plane.d) < _PLANE_EQ_D_EPSILON);
|
||||
}
|
||||
|
||||
Plane::operator String() const {
|
||||
|
||||
// return normal.operator String() + ", " + rtos(d);
|
||||
return String(); // @Todo
|
||||
}
|
||||
|
||||
bool Plane::is_point_over(const Vector3 &p_point) const {
|
||||
|
||||
return (normal.dot(p_point) > d);
|
||||
}
|
||||
|
||||
real_t Plane::distance_to(const Vector3 &p_point) const {
|
||||
|
||||
return (normal.dot(p_point) - d);
|
||||
}
|
||||
|
||||
bool Plane::has_point(const Vector3 &p_point, real_t _epsilon) const {
|
||||
|
||||
real_t dist = normal.dot(p_point) - d;
|
||||
dist = ::fabs(dist);
|
||||
return (dist <= _epsilon);
|
||||
}
|
||||
|
||||
Plane::Plane(const Vector3 &p_normal, real_t p_d) {
|
||||
|
||||
normal = p_normal;
|
||||
d = p_d;
|
||||
}
|
||||
|
||||
Plane::Plane(const Vector3 &p_point, const Vector3 &p_normal) {
|
||||
|
||||
normal = p_normal;
|
||||
d = p_normal.dot(p_point);
|
||||
}
|
||||
|
||||
Plane::Plane(const Vector3 &p_point1, const Vector3 &p_point2, const Vector3 &p_point3, ClockDirection p_dir) {
|
||||
|
||||
if (p_dir == CLOCKWISE)
|
||||
normal = (p_point1 - p_point3).cross(p_point1 - p_point2);
|
||||
else
|
||||
|
|
@ -182,12 +163,10 @@ Plane::Plane(const Vector3 &p_point1, const Vector3 &p_point2, const Vector3 &p_
|
|||
}
|
||||
|
||||
bool Plane::operator==(const Plane &p_plane) const {
|
||||
|
||||
return normal == p_plane.normal && d == p_plane.d;
|
||||
}
|
||||
|
||||
bool Plane::operator!=(const Plane &p_plane) const {
|
||||
|
||||
return normal != p_plane.normal || d != p_plane.d;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -100,7 +100,6 @@ Quat Quat::inverse() const {
|
|||
}
|
||||
|
||||
Quat Quat::slerp(const Quat &q, const real_t &t) const {
|
||||
|
||||
Quat to1;
|
||||
real_t omega, cosom, sinom, scale0, scale1;
|
||||
|
||||
|
|
@ -144,12 +143,12 @@ Quat Quat::slerp(const Quat &q, const real_t &t) const {
|
|||
}
|
||||
|
||||
Quat Quat::slerpni(const Quat &q, const real_t &t) const {
|
||||
|
||||
const Quat &from = *this;
|
||||
|
||||
real_t dot = from.dot(q);
|
||||
|
||||
if (::fabs(dot) > 0.9999) return from;
|
||||
if (::fabs(dot) > 0.9999)
|
||||
return from;
|
||||
|
||||
real_t theta = ::acos(dot),
|
||||
sinT = 1.0 / ::sin(theta),
|
||||
|
|
@ -200,7 +199,6 @@ Quat Quat::operator*(const Vector3 &v) const {
|
|||
}
|
||||
|
||||
Vector3 Quat::xform(const Vector3 &v) const {
|
||||
|
||||
Quat q = *this * v;
|
||||
q *= this->inverse();
|
||||
return Vector3(q.x, q.y, q.z);
|
||||
|
|
@ -234,7 +232,6 @@ Quat::Quat(const Vector3 &v0, const Vector3 &v1) // shortest arc
|
|||
z = 0;
|
||||
w = 0;
|
||||
} else {
|
||||
|
||||
real_t s = ::sqrt((1.0 + d) * 2.0);
|
||||
real_t rs = 1.0 / s;
|
||||
|
||||
|
|
@ -282,7 +279,6 @@ void Quat::operator*=(const real_t &s) {
|
|||
}
|
||||
|
||||
void Quat::operator/=(const real_t &s) {
|
||||
|
||||
*this *= 1.0 / s;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -16,7 +16,6 @@ namespace godot {
|
|||
#endif
|
||||
|
||||
real_t Rect2::distance_to(const Vector2 &p_point) const {
|
||||
|
||||
real_t dist = 1e20;
|
||||
|
||||
if (p_point.x < position.x) {
|
||||
|
|
@ -77,7 +76,6 @@ Rect2::operator String() const {
|
|||
}
|
||||
|
||||
bool Rect2::intersects_segment(const Point2 &p_from, const Point2 &p_to, Point2 *r_position, Point2 *r_normal) const {
|
||||
|
||||
real_t min = 0, max = 1;
|
||||
int axis = 0;
|
||||
real_t sign = 0;
|
||||
|
|
@ -91,7 +89,6 @@ bool Rect2::intersects_segment(const Point2 &p_from, const Point2 &p_to, Point2
|
|||
real_t csign;
|
||||
|
||||
if (seg_from < seg_to) {
|
||||
|
||||
if (seg_from > box_end || seg_to < box_begin)
|
||||
return false;
|
||||
real_t length = seg_to - seg_from;
|
||||
|
|
@ -100,7 +97,6 @@ bool Rect2::intersects_segment(const Point2 &p_from, const Point2 &p_to, Point2
|
|||
csign = -1.0;
|
||||
|
||||
} else {
|
||||
|
||||
if (seg_to > box_end || seg_from < box_begin)
|
||||
return false;
|
||||
real_t length = seg_to - seg_from;
|
||||
|
|
@ -135,7 +131,6 @@ bool Rect2::intersects_segment(const Point2 &p_from, const Point2 &p_to, Point2
|
|||
}
|
||||
|
||||
bool Rect2::intersects_transformed(const Transform2D &p_xform, const Rect2 &p_rect) const {
|
||||
|
||||
//SAT intersection between local and transformed rect2
|
||||
|
||||
Vector2 xf_points[4] = {
|
||||
|
|
|
|||
|
|
@ -141,7 +141,6 @@ const wchar_t *String::unicode_str() const {
|
|||
}
|
||||
|
||||
char *String::alloc_c_string() const {
|
||||
|
||||
godot_char_string contents = godot::api->godot_string_utf8(&_godot_string);
|
||||
|
||||
int length = godot::api->godot_char_string_length(&contents);
|
||||
|
|
@ -166,7 +165,6 @@ CharString String::utf8() const {
|
|||
}
|
||||
|
||||
CharString String::ascii(bool p_extended) const {
|
||||
|
||||
CharString ret;
|
||||
|
||||
if (p_extended)
|
||||
|
|
|
|||
|
|
@ -22,14 +22,12 @@ bool is_type_known(size_t type_tag) {
|
|||
}
|
||||
|
||||
void register_global_type(const char *name, size_t type_tag, size_t base_type_tag) {
|
||||
|
||||
godot::nativescript_1_1_api->godot_nativescript_set_global_type_tag(godot::_RegisterState::language_index, name, (const void *)type_tag);
|
||||
|
||||
register_type(type_tag, base_type_tag);
|
||||
}
|
||||
|
||||
bool is_type_compatible(size_t ask_tag, size_t have_tag) {
|
||||
|
||||
if (have_tag == 0)
|
||||
return false;
|
||||
|
||||
|
|
|
|||
|
|
@ -15,14 +15,12 @@ const Transform Transform::FLIP_Y = Transform(1, 0, 0, 0, -1, 0, 0, 0, 1, 0, 0,
|
|||
const Transform Transform::FLIP_Z = Transform(1, 0, 0, 0, 1, 0, 0, 0, -1, 0, 0, 0);
|
||||
|
||||
Transform Transform::inverse_xform(const Transform &t) const {
|
||||
|
||||
Vector3 v = t.origin - origin;
|
||||
return Transform(basis.transpose_xform(t.basis),
|
||||
basis.xform(v));
|
||||
}
|
||||
|
||||
void Transform::set(real_t xx, real_t xy, real_t xz, real_t yx, real_t yy, real_t yz, real_t zx, real_t zy, real_t zz, real_t tx, real_t ty, real_t tz) {
|
||||
|
||||
basis.elements[0][0] = xx;
|
||||
basis.elements[0][1] = xy;
|
||||
basis.elements[0][2] = xz;
|
||||
|
|
@ -38,14 +36,12 @@ void Transform::set(real_t xx, real_t xy, real_t xz, real_t yx, real_t yy, real_
|
|||
}
|
||||
|
||||
Vector3 Transform::xform(const Vector3 &p_vector) const {
|
||||
|
||||
return Vector3(
|
||||
basis.elements[0].dot(p_vector) + origin.x,
|
||||
basis.elements[1].dot(p_vector) + origin.y,
|
||||
basis.elements[2].dot(p_vector) + origin.z);
|
||||
}
|
||||
Vector3 Transform::xform_inv(const Vector3 &p_vector) const {
|
||||
|
||||
Vector3 v = p_vector - origin;
|
||||
|
||||
return Vector3(
|
||||
|
|
@ -55,7 +51,6 @@ Vector3 Transform::xform_inv(const Vector3 &p_vector) const {
|
|||
}
|
||||
|
||||
Plane Transform::xform(const Plane &p_plane) const {
|
||||
|
||||
Vector3 point = p_plane.normal * p_plane.d;
|
||||
Vector3 point_dir = point + p_plane.normal;
|
||||
point = xform(point);
|
||||
|
|
@ -68,7 +63,6 @@ Plane Transform::xform(const Plane &p_plane) const {
|
|||
return Plane(normal, d);
|
||||
}
|
||||
Plane Transform::xform_inv(const Plane &p_plane) const {
|
||||
|
||||
Vector3 point = p_plane.normal * p_plane.d;
|
||||
Vector3 point_dir = point + p_plane.normal;
|
||||
point = xform_inv(point);
|
||||
|
|
@ -100,7 +94,6 @@ AABB Transform::xform(const AABB &p_aabb) const {
|
|||
return new_aabb;
|
||||
}
|
||||
AABB Transform::xform_inv(const AABB &p_aabb) const {
|
||||
|
||||
/* define vertices */
|
||||
Vector3 vertices[8] = {
|
||||
Vector3(p_aabb.position.x + p_aabb.size.x, p_aabb.position.y + p_aabb.size.y, p_aabb.position.z + p_aabb.size.z),
|
||||
|
|
@ -118,7 +111,6 @@ AABB Transform::xform_inv(const AABB &p_aabb) const {
|
|||
ret.position = xform_inv(vertices[0]);
|
||||
|
||||
for (int i = 1; i < 8; i++) {
|
||||
|
||||
ret.expand_to(xform_inv(vertices[i]));
|
||||
}
|
||||
|
||||
|
|
@ -126,20 +118,17 @@ AABB Transform::xform_inv(const AABB &p_aabb) const {
|
|||
}
|
||||
|
||||
void Transform::affine_invert() {
|
||||
|
||||
basis.invert();
|
||||
origin = basis.xform(-origin);
|
||||
}
|
||||
|
||||
Transform Transform::affine_inverse() const {
|
||||
|
||||
Transform ret = *this;
|
||||
ret.affine_invert();
|
||||
return ret;
|
||||
}
|
||||
|
||||
void Transform::invert() {
|
||||
|
||||
basis.transpose();
|
||||
origin = basis.xform(-origin);
|
||||
}
|
||||
|
|
@ -153,29 +142,24 @@ Transform Transform::inverse() const {
|
|||
}
|
||||
|
||||
void Transform::rotate(const Vector3 &p_axis, real_t p_phi) {
|
||||
|
||||
*this = rotated(p_axis, p_phi);
|
||||
}
|
||||
|
||||
Transform Transform::rotated(const Vector3 &p_axis, real_t p_phi) const {
|
||||
|
||||
return Transform(Basis(p_axis, p_phi), Vector3()) * (*this);
|
||||
}
|
||||
|
||||
void Transform::rotate_basis(const Vector3 &p_axis, real_t p_phi) {
|
||||
|
||||
basis.rotate(p_axis, p_phi);
|
||||
}
|
||||
|
||||
Transform Transform::looking_at(const Vector3 &p_target, const Vector3 &p_up) const {
|
||||
|
||||
Transform t = *this;
|
||||
t.set_look_at(origin, p_target, p_up);
|
||||
return t;
|
||||
}
|
||||
|
||||
void Transform::set_look_at(const Vector3 &p_eye, const Vector3 &p_target, const Vector3 &p_up) {
|
||||
|
||||
// Reference: MESA source code
|
||||
Vector3 v_x, v_y, v_z;
|
||||
|
||||
|
|
@ -203,7 +187,6 @@ void Transform::set_look_at(const Vector3 &p_eye, const Vector3 &p_target, const
|
|||
}
|
||||
|
||||
Transform Transform::interpolate_with(const Transform &p_transform, real_t p_c) const {
|
||||
|
||||
/* not sure if very "efficient" but good enough? */
|
||||
|
||||
Vector3 src_scale = basis.get_scale();
|
||||
|
|
@ -223,20 +206,17 @@ Transform Transform::interpolate_with(const Transform &p_transform, real_t p_c)
|
|||
}
|
||||
|
||||
void Transform::scale(const Vector3 &p_scale) {
|
||||
|
||||
basis.scale(p_scale);
|
||||
origin *= p_scale;
|
||||
}
|
||||
|
||||
Transform Transform::scaled(const Vector3 &p_scale) const {
|
||||
|
||||
Transform t = *this;
|
||||
t.scale(p_scale);
|
||||
return t;
|
||||
}
|
||||
|
||||
void Transform::scale_basis(const Vector3 &p_scale) {
|
||||
|
||||
basis.scale(p_scale);
|
||||
}
|
||||
|
||||
|
|
@ -244,60 +224,50 @@ void Transform::translate(real_t p_tx, real_t p_ty, real_t p_tz) {
|
|||
translate(Vector3(p_tx, p_ty, p_tz));
|
||||
}
|
||||
void Transform::translate(const Vector3 &p_translation) {
|
||||
|
||||
for (int i = 0; i < 3; i++) {
|
||||
origin[i] += basis.elements[i].dot(p_translation);
|
||||
}
|
||||
}
|
||||
|
||||
Transform Transform::translated(const Vector3 &p_translation) const {
|
||||
|
||||
Transform t = *this;
|
||||
t.translate(p_translation);
|
||||
return t;
|
||||
}
|
||||
|
||||
void Transform::orthonormalize() {
|
||||
|
||||
basis.orthonormalize();
|
||||
}
|
||||
|
||||
Transform Transform::orthonormalized() const {
|
||||
|
||||
Transform _copy = *this;
|
||||
_copy.orthonormalize();
|
||||
return _copy;
|
||||
}
|
||||
|
||||
bool Transform::operator==(const Transform &p_transform) const {
|
||||
|
||||
return (basis == p_transform.basis && origin == p_transform.origin);
|
||||
}
|
||||
bool Transform::operator!=(const Transform &p_transform) const {
|
||||
|
||||
return (basis != p_transform.basis || origin != p_transform.origin);
|
||||
}
|
||||
|
||||
void Transform::operator*=(const Transform &p_transform) {
|
||||
|
||||
origin = xform(p_transform.origin);
|
||||
basis *= p_transform.basis;
|
||||
}
|
||||
|
||||
Transform Transform::operator*(const Transform &p_transform) const {
|
||||
|
||||
Transform t = *this;
|
||||
t *= p_transform;
|
||||
return t;
|
||||
}
|
||||
|
||||
Transform::operator String() const {
|
||||
|
||||
return basis.operator String() + " - " + origin.operator String();
|
||||
}
|
||||
|
||||
Transform::Transform(const Basis &p_basis, const Vector3 &p_origin) {
|
||||
|
||||
basis = p_basis;
|
||||
origin = p_origin;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -12,7 +12,6 @@ const Transform2D Transform2D::FLIP_X = Transform2D(-1, 0, 0, 1, 0, 0);
|
|||
const Transform2D Transform2D::FLIP_Y = Transform2D(1, 0, 0, -1, 0, 0);
|
||||
|
||||
Transform2D::Transform2D(real_t xx, real_t xy, real_t yx, real_t yy, real_t ox, real_t oy) {
|
||||
|
||||
elements[0][0] = xx;
|
||||
elements[0][1] = xy;
|
||||
elements[1][0] = yx;
|
||||
|
|
@ -22,28 +21,24 @@ Transform2D::Transform2D(real_t xx, real_t xy, real_t yx, real_t yy, real_t ox,
|
|||
}
|
||||
|
||||
Vector2 Transform2D::basis_xform(const Vector2 &v) const {
|
||||
|
||||
return Vector2(
|
||||
tdotx(v),
|
||||
tdoty(v));
|
||||
}
|
||||
|
||||
Vector2 Transform2D::basis_xform_inv(const Vector2 &v) const {
|
||||
|
||||
return Vector2(
|
||||
elements[0].dot(v),
|
||||
elements[1].dot(v));
|
||||
}
|
||||
|
||||
Vector2 Transform2D::xform(const Vector2 &v) const {
|
||||
|
||||
return Vector2(
|
||||
tdotx(v),
|
||||
tdoty(v)) +
|
||||
elements[2];
|
||||
}
|
||||
Vector2 Transform2D::xform_inv(const Vector2 &p_vec) const {
|
||||
|
||||
Vector2 v = p_vec - elements[2];
|
||||
|
||||
return Vector2(
|
||||
|
|
@ -51,7 +46,6 @@ Vector2 Transform2D::xform_inv(const Vector2 &p_vec) const {
|
|||
elements[1].dot(v));
|
||||
}
|
||||
Rect2 Transform2D::xform(const Rect2 &p_rect) const {
|
||||
|
||||
Vector2 x = elements[0] * p_rect.size.x;
|
||||
Vector2 y = elements[1] * p_rect.size.y;
|
||||
Vector2 position = xform(p_rect.position);
|
||||
|
|
@ -65,7 +59,6 @@ Rect2 Transform2D::xform(const Rect2 &p_rect) const {
|
|||
}
|
||||
|
||||
void Transform2D::set_rotation_and_scale(real_t p_rot, const Size2 &p_scale) {
|
||||
|
||||
elements[0][0] = ::cos(p_rot) * p_scale.x;
|
||||
elements[1][1] = ::cos(p_rot) * p_scale.y;
|
||||
elements[1][0] = -::sin(p_rot) * p_scale.y;
|
||||
|
|
@ -73,7 +66,6 @@ void Transform2D::set_rotation_and_scale(real_t p_rot, const Size2 &p_scale) {
|
|||
}
|
||||
|
||||
Rect2 Transform2D::xform_inv(const Rect2 &p_rect) const {
|
||||
|
||||
Vector2 ends[4] = {
|
||||
xform_inv(p_rect.position),
|
||||
xform_inv(Vector2(p_rect.position.x, p_rect.position.y + p_rect.size.y)),
|
||||
|
|
@ -98,14 +90,12 @@ void Transform2D::invert() {
|
|||
}
|
||||
|
||||
Transform2D Transform2D::inverse() const {
|
||||
|
||||
Transform2D inv = *this;
|
||||
inv.invert();
|
||||
return inv;
|
||||
}
|
||||
|
||||
void Transform2D::affine_invert() {
|
||||
|
||||
real_t det = basis_determinant();
|
||||
ERR_FAIL_COND(det == 0);
|
||||
real_t idet = 1.0 / det;
|
||||
|
|
@ -118,7 +108,6 @@ void Transform2D::affine_invert() {
|
|||
}
|
||||
|
||||
Transform2D Transform2D::affine_inverse() const {
|
||||
|
||||
Transform2D inv = *this;
|
||||
inv.affine_invert();
|
||||
return inv;
|
||||
|
|
@ -138,7 +127,6 @@ real_t Transform2D::get_rotation() const {
|
|||
}
|
||||
|
||||
void Transform2D::set_rotation(real_t p_rot) {
|
||||
|
||||
real_t cr = ::cos(p_rot);
|
||||
real_t sr = ::sin(p_rot);
|
||||
elements[0][0] = cr;
|
||||
|
|
@ -148,7 +136,6 @@ void Transform2D::set_rotation(real_t p_rot) {
|
|||
}
|
||||
|
||||
Transform2D::Transform2D(real_t p_rot, const Vector2 &p_position) {
|
||||
|
||||
real_t cr = ::cos(p_rot);
|
||||
real_t sr = ::sin(p_rot);
|
||||
elements[0][0] = cr;
|
||||
|
|
@ -168,23 +155,19 @@ void Transform2D::scale(const Size2 &p_scale) {
|
|||
elements[2] *= p_scale;
|
||||
}
|
||||
void Transform2D::scale_basis(const Size2 &p_scale) {
|
||||
|
||||
elements[0][0] *= p_scale.x;
|
||||
elements[0][1] *= p_scale.y;
|
||||
elements[1][0] *= p_scale.x;
|
||||
elements[1][1] *= p_scale.y;
|
||||
}
|
||||
void Transform2D::translate(real_t p_tx, real_t p_ty) {
|
||||
|
||||
translate(Vector2(p_tx, p_ty));
|
||||
}
|
||||
void Transform2D::translate(const Vector2 &p_translation) {
|
||||
|
||||
elements[2] += basis_xform(p_translation);
|
||||
}
|
||||
|
||||
void Transform2D::orthonormalize() {
|
||||
|
||||
// Gram-Schmidt Process
|
||||
|
||||
Vector2 x = elements[0];
|
||||
|
|
@ -198,14 +181,12 @@ void Transform2D::orthonormalize() {
|
|||
elements[1] = y;
|
||||
}
|
||||
Transform2D Transform2D::orthonormalized() const {
|
||||
|
||||
Transform2D on = *this;
|
||||
on.orthonormalize();
|
||||
return on;
|
||||
}
|
||||
|
||||
bool Transform2D::operator==(const Transform2D &p_transform) const {
|
||||
|
||||
for (int i = 0; i < 3; i++) {
|
||||
if (elements[i] != p_transform.elements[i])
|
||||
return false;
|
||||
|
|
@ -215,7 +196,6 @@ bool Transform2D::operator==(const Transform2D &p_transform) const {
|
|||
}
|
||||
|
||||
bool Transform2D::operator!=(const Transform2D &p_transform) const {
|
||||
|
||||
for (int i = 0; i < 3; i++) {
|
||||
if (elements[i] != p_transform.elements[i])
|
||||
return true;
|
||||
|
|
@ -225,7 +205,6 @@ bool Transform2D::operator!=(const Transform2D &p_transform) const {
|
|||
}
|
||||
|
||||
void Transform2D::operator*=(const Transform2D &p_transform) {
|
||||
|
||||
elements[2] = xform(p_transform.elements[2]);
|
||||
|
||||
real_t x0, x1, y0, y1;
|
||||
|
|
@ -242,54 +221,46 @@ void Transform2D::operator*=(const Transform2D &p_transform) {
|
|||
}
|
||||
|
||||
Transform2D Transform2D::operator*(const Transform2D &p_transform) const {
|
||||
|
||||
Transform2D t = *this;
|
||||
t *= p_transform;
|
||||
return t;
|
||||
}
|
||||
|
||||
Transform2D Transform2D::scaled(const Size2 &p_scale) const {
|
||||
|
||||
Transform2D copy = *this;
|
||||
copy.scale(p_scale);
|
||||
return copy;
|
||||
}
|
||||
|
||||
Transform2D Transform2D::basis_scaled(const Size2 &p_scale) const {
|
||||
|
||||
Transform2D copy = *this;
|
||||
copy.scale_basis(p_scale);
|
||||
return copy;
|
||||
}
|
||||
|
||||
Transform2D Transform2D::untranslated() const {
|
||||
|
||||
Transform2D copy = *this;
|
||||
copy.elements[2] = Vector2();
|
||||
return copy;
|
||||
}
|
||||
|
||||
Transform2D Transform2D::translated(const Vector2 &p_offset) const {
|
||||
|
||||
Transform2D copy = *this;
|
||||
copy.translate(p_offset);
|
||||
return copy;
|
||||
}
|
||||
|
||||
Transform2D Transform2D::rotated(real_t p_phi) const {
|
||||
|
||||
Transform2D copy = *this;
|
||||
copy.rotate(p_phi);
|
||||
return copy;
|
||||
}
|
||||
|
||||
real_t Transform2D::basis_determinant() const {
|
||||
|
||||
return elements[0].x * elements[1].y - elements[0].y * elements[1].x;
|
||||
}
|
||||
|
||||
Transform2D Transform2D::interpolate_with(const Transform2D &p_transform, real_t p_c) const {
|
||||
|
||||
//extract parameters
|
||||
Vector2 p1 = get_origin();
|
||||
Vector2 p2 = p_transform.get_origin();
|
||||
|
|
@ -325,7 +296,6 @@ Transform2D Transform2D::interpolate_with(const Transform2D &p_transform, real_t
|
|||
}
|
||||
|
||||
Transform2D::operator String() const {
|
||||
|
||||
return String(String() + elements[0] + ", " + elements[1] + ", " + elements[2]);
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue