summaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/core/AABB.cpp561
-rw-r--r--src/core/Array.cpp162
-rw-r--r--src/core/Basis.cpp451
-rw-r--r--src/core/Color.cpp364
-rw-r--r--src/core/Dictionary.cpp69
-rw-r--r--src/core/GodotGlobal.cpp60
-rw-r--r--src/core/NodePath.cpp67
-rw-r--r--src/core/Plane.cpp127
-rw-r--r--src/core/PoolArrays.cpp436
-rw-r--r--src/core/Quat.cpp206
-rw-r--r--src/core/RID.cpp32
-rw-r--r--src/core/Rect2.cpp268
-rw-r--r--src/core/String.cpp7
-rw-r--r--src/core/TagDB.cpp19
-rw-r--r--src/core/Transform.cpp241
-rw-r--r--src/core/Transform2D.cpp220
-rw-r--r--src/core/Variant.cpp349
-rw-r--r--src/core/Vector2.cpp164
-rw-r--r--src/core/Vector3.cpp251
19 files changed, 1729 insertions, 2325 deletions
diff --git a/src/core/AABB.cpp b/src/core/AABB.cpp
index cb50583..a67d459 100644
--- a/src/core/AABB.cpp
+++ b/src/core/AABB.cpp
@@ -1,88 +1,86 @@
#include "AABB.hpp"
-#include "Vector3.hpp"
#include "Plane.hpp"
+#include "Vector3.hpp"
#include <algorithm>
namespace godot {
-bool AABB::intersects(const AABB& p_aabb) const {
+bool AABB::intersects(const AABB &p_aabb) const {
- if ( position.x >= (p_aabb.position.x + p_aabb.size.x) )
+ if (position.x >= (p_aabb.position.x + p_aabb.size.x))
return false;
- if ( (position.x+size.x) <= p_aabb.position.x )
+ if ((position.x + size.x) <= p_aabb.position.x)
return false;
- if ( position.y >= (p_aabb.position.y + p_aabb.size.y) )
+ if (position.y >= (p_aabb.position.y + p_aabb.size.y))
return false;
- if ( (position.y+size.y) <= p_aabb.position.y )
+ if ((position.y + size.y) <= p_aabb.position.y)
return false;
- if ( position.z >= (p_aabb.position.z + p_aabb.size.z) )
+ if (position.z >= (p_aabb.position.z + p_aabb.size.z))
return false;
- if ( (position.z+size.z) <= p_aabb.position.z )
+ if ((position.z + size.z) <= p_aabb.position.z)
return false;
return true;
}
-bool AABB::intersects_inclusive(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) )
+ if (position.x > (p_aabb.position.x + p_aabb.size.x))
return false;
- if ( (position.x+size.x) < p_aabb.position.x )
+ if ((position.x + size.x) < p_aabb.position.x)
return false;
- if ( position.y > (p_aabb.position.y + p_aabb.size.y) )
+ if (position.y > (p_aabb.position.y + p_aabb.size.y))
return false;
- if ( (position.y+size.y) < p_aabb.position.y )
+ if ((position.y + size.y) < p_aabb.position.y)
return false;
- if ( position.z > (p_aabb.position.z + p_aabb.size.z) )
+ if (position.z > (p_aabb.position.z + p_aabb.size.z))
return false;
- if ( (position.z+size.z) < p_aabb.position.z )
+ if ((position.z + size.z) < p_aabb.position.z)
return false;
return true;
}
-bool AABB::encloses(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;
- Vector3 dst_max=p_aabb.position+p_aabb.size;
+ Vector3 src_min = position;
+ Vector3 src_max = position + size;
+ Vector3 dst_min = p_aabb.position;
+ Vector3 dst_max = p_aabb.position + p_aabb.size;
- return (
- (src_min.x <= dst_min.x) &&
+ return (
+ (src_min.x <= dst_min.x) &&
(src_max.x > dst_max.x) &&
(src_min.y <= dst_min.y) &&
(src_max.y > dst_max.y) &&
(src_min.z <= dst_min.z) &&
- (src_max.z > dst_max.z) );
-
+ (src_max.z > dst_max.z));
}
-Vector3 AABB::get_support(const Vector3& p_normal) const {
+Vector3 AABB::get_support(const Vector3 &p_normal) const {
Vector3 half_extents = size * 0.5;
Vector3 ofs = position + half_extents;
return Vector3(
- (p_normal.x>0) ? -half_extents.x : half_extents.x,
- (p_normal.y>0) ? -half_extents.y : half_extents.y,
- (p_normal.z>0) ? -half_extents.z : half_extents.z
- )+ofs;
+ (p_normal.x > 0) ? -half_extents.x : half_extents.x,
+ (p_normal.y > 0) ? -half_extents.y : half_extents.y,
+ (p_normal.z > 0) ? -half_extents.z : half_extents.z) +
+ ofs;
}
-
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 );
+ 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);
};
ERR_FAIL_V(Vector3());
@@ -93,14 +91,13 @@ bool AABB::intersects_convex_shape(const Plane *p_planes, int p_plane_count) con
Vector3 half_extents = size * 0.5;
Vector3 ofs = position + half_extents;
- for(int i=0;i<p_plane_count;i++) {
- const Plane &p=p_planes[i];
+ for (int i = 0; i < p_plane_count; i++) {
+ const Plane &p = p_planes[i];
Vector3 point(
- (p.normal.x>0) ? -half_extents.x : half_extents.x,
- (p.normal.y>0) ? -half_extents.y : half_extents.y,
- (p.normal.z>0) ? -half_extents.z : half_extents.z
- );
- point+=ofs;
+ (p.normal.x > 0) ? -half_extents.x : half_extents.x,
+ (p.normal.y > 0) ? -half_extents.y : half_extents.y,
+ (p.normal.z > 0) ? -half_extents.z : half_extents.z);
+ point += ofs;
if (p.is_point_over(point))
return false;
}
@@ -108,69 +105,68 @@ bool AABB::intersects_convex_shape(const Plane *p_planes, int p_plane_count) con
return true;
}
-bool AABB::has_point(const Vector3& p_point) const {
+bool AABB::has_point(const Vector3 &p_point) const {
- if (p_point.x<position.x)
+ if (p_point.x < position.x)
return false;
- if (p_point.y<position.y)
+ if (p_point.y < position.y)
return false;
- if (p_point.z<position.z)
+ if (p_point.z < position.z)
return false;
- if (p_point.x>position.x+size.x)
+ if (p_point.x > position.x + size.x)
return false;
- if (p_point.y>position.y+size.y)
+ if (p_point.y > position.y + size.y)
return false;
- if (p_point.z>position.z+size.z)
+ if (p_point.z > position.z + size.z)
return false;
return true;
}
+void AABB::expand_to(const Vector3 &p_vector) {
-void AABB::expand_to(const Vector3& p_vector) {
+ Vector3 begin = position;
+ Vector3 end = position + size;
- Vector3 begin=position;
- Vector3 end=position+size;
+ if (p_vector.x < begin.x)
+ begin.x = p_vector.x;
+ if (p_vector.y < begin.y)
+ begin.y = p_vector.y;
+ if (p_vector.z < begin.z)
+ begin.z = p_vector.z;
- if (p_vector.x<begin.x)
- begin.x=p_vector.x;
- if (p_vector.y<begin.y)
- begin.y=p_vector.y;
- if (p_vector.z<begin.z)
- begin.z=p_vector.z;
+ if (p_vector.x > end.x)
+ end.x = p_vector.x;
+ if (p_vector.y > end.y)
+ end.y = p_vector.y;
+ if (p_vector.z > end.z)
+ end.z = p_vector.z;
- if (p_vector.x>end.x)
- end.x=p_vector.x;
- if (p_vector.y>end.y)
- end.y=p_vector.y;
- if (p_vector.z>end.z)
- end.z=p_vector.z;
-
- position=begin;
- size=end-begin;
+ position = begin;
+ size = end - begin;
}
-void AABB::project_range_in_plane(const Plane& p_plane,real_t &r_min,real_t& r_max) const {
+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 );
+ 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);
real_t length = p_plane.normal.abs().dot(half_extents);
- real_t distance = p_plane.distance_to( center );
+ real_t distance = p_plane.distance_to(center);
r_min = distance - length;
r_max = distance + length;
}
real_t AABB::get_longest_axis_size() const {
- real_t max_size=size.x;
+ real_t max_size = size.x;
- if (size.y > max_size ) {
- max_size=size.y;
+ if (size.y > max_size) {
+ max_size = size.y;
}
- if (size.z > max_size ) {
- max_size=size.z;
+ if (size.z > max_size) {
+ max_size = size.z;
}
return max_size;
@@ -178,167 +174,156 @@ real_t AABB::get_longest_axis_size() const {
real_t AABB::get_shortest_axis_size() const {
- real_t max_size=size.x;
+ real_t max_size = size.x;
- if (size.y < max_size ) {
- max_size=size.y;
+ if (size.y < max_size) {
+ max_size = size.y;
}
- if (size.z < max_size ) {
- max_size=size.z;
+ if (size.z < max_size) {
+ max_size = size.z;
}
return max_size;
}
-bool AABB::smits_intersect_ray(const Vector3 &from,const Vector3& dir, real_t t0, real_t t1) 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;
+ real_t divx = 1.0 / dir.x;
+ real_t divy = 1.0 / dir.y;
+ real_t divz = 1.0 / dir.z;
- Vector3 upbound=position+size;
+ Vector3 upbound = position + size;
real_t tmin, tmax, tymin, tymax, tzmin, tzmax;
if (dir.x >= 0) {
tmin = (position.x - from.x) * divx;
tmax = (upbound.x - from.x) * divx;
- }
- else {
+ } else {
tmin = (upbound.x - from.x) * divx;
tmax = (position.x - from.x) * divx;
}
if (dir.y >= 0) {
tymin = (position.y - from.y) * divy;
tymax = (upbound.y - from.y) * divy;
- }
- else {
+ } else {
tymin = (upbound.y - from.y) * divy;
tymax = (position.y - from.y) * divy;
}
- if ( (tmin > tymax) || (tymin > tmax) )
+ if ((tmin > tymax) || (tymin > tmax))
return false;
if (tymin > tmin)
- tmin = tymin;
+ tmin = tymin;
if (tymax < tmax)
tmax = tymax;
if (dir.z >= 0) {
tzmin = (position.z - from.z) * divz;
tzmax = (upbound.z - from.z) * divz;
- }
- else {
+ } else {
tzmin = (upbound.z - from.z) * divz;
tzmax = (position.z - from.z) * divz;
}
- if ( (tmin > tzmax) || (tzmin > tmax) )
+ if ((tmin > tzmax) || (tzmin > tmax))
return false;
if (tzmin > tmin)
tmin = tzmin;
if (tzmax < tmax)
tmax = tzmax;
- return ( (tmin < t1) && (tmax > t0) );
+ return ((tmin < t1) && (tmax > t0));
}
void AABB::grow_by(real_t p_amount) {
- position.x-=p_amount;
- position.y-=p_amount;
- position.z-=p_amount;
- size.x+=2.0*p_amount;
- size.y+=2.0*p_amount;
- size.z+=2.0*p_amount;
+ position.x -= p_amount;
+ position.y -= p_amount;
+ position.z -= p_amount;
+ size.x += 2.0 * p_amount;
+ size.y += 2.0 * p_amount;
+ size.z += 2.0 * p_amount;
}
-
real_t AABB::get_area() const {
- return size.x*size.y*size.z;
-
+ 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));
}
-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) {
+void AABB::merge_with(const AABB &p_aabb) {
- Vector3 beg_1,beg_2;
- Vector3 end_1,end_2;
- Vector3 min,max;
+ Vector3 beg_1, beg_2;
+ Vector3 end_1, end_2;
+ Vector3 min, max;
- beg_1=position;
- beg_2=p_aabb.position;
- end_1=Vector3(size.x,size.y,size.z)+beg_1;
- end_2=Vector3(p_aabb.size.x,p_aabb.size.y,p_aabb.size.z)+beg_2;
+ beg_1 = position;
+ beg_2 = p_aabb.position;
+ end_1 = Vector3(size.x, size.y, size.z) + beg_1;
+ end_2 = Vector3(p_aabb.size.x, p_aabb.size.y, p_aabb.size.z) + beg_2;
- min.x=(beg_1.x<beg_2.x)?beg_1.x:beg_2.x;
- min.y=(beg_1.y<beg_2.y)?beg_1.y:beg_2.y;
- min.z=(beg_1.z<beg_2.z)?beg_1.z:beg_2.z;
+ min.x = (beg_1.x < beg_2.x) ? beg_1.x : beg_2.x;
+ min.y = (beg_1.y < beg_2.y) ? beg_1.y : beg_2.y;
+ min.z = (beg_1.z < beg_2.z) ? beg_1.z : beg_2.z;
- max.x=(end_1.x>end_2.x)?end_1.x:end_2.x;
- max.y=(end_1.y>end_2.y)?end_1.y:end_2.y;
- max.z=(end_1.z>end_2.z)?end_1.z:end_2.z;
+ max.x = (end_1.x > end_2.x) ? end_1.x : end_2.x;
+ max.y = (end_1.y > end_2.y) ? end_1.y : end_2.y;
+ max.z = (end_1.z > end_2.z) ? end_1.z : end_2.z;
- position=min;
- size=max-min;
+ position = min;
+ size = max - min;
}
-AABB AABB::intersection(const AABB& p_aabb) const {
+AABB AABB::intersection(const AABB &p_aabb) const {
- Vector3 src_min=position;
- Vector3 src_max=position+size;
- Vector3 dst_min=p_aabb.position;
- Vector3 dst_max=p_aabb.position+p_aabb.size;
+ Vector3 src_min = position;
+ Vector3 src_max = position + size;
+ Vector3 dst_min = p_aabb.position;
+ Vector3 dst_max = p_aabb.position + p_aabb.size;
- Vector3 min,max;
+ Vector3 min, max;
- if (src_min.x > dst_max.x || src_max.x < dst_min.x )
+ 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;
-
+ 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;
}
- if (src_min.y > dst_max.y || src_max.y < dst_min.y )
+ 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;
-
+ 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;
}
- if (src_min.z > dst_max.z || src_max.z < dst_min.z )
+ 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;
-
+ 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;
}
-
- return AABB( min, max-min );
+ return AABB(min, max - min);
}
-bool AABB::intersects_ray(const Vector3& p_from, const Vector3& p_dir,Vector3* r_clip,Vector3* r_normal) 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;
- real_t far=1e20;
- int axis=0;
+ Vector3 end = position + size;
+ real_t near = -1e20;
+ real_t far = 1e20;
+ int axis = 0;
- for (int i=0;i<3;i++){
- if (p_dir[i] == 0){
+ for (int i = 0; i < 3; i++) {
+ if (p_dir[i] == 0) {
if ((p_from[i] < position[i]) || (p_from[i] > end[i])) {
return false;
}
@@ -346,71 +331,69 @@ bool AABB::intersects_ray(const Vector3& p_from, const Vector3& p_dir,Vector3* r
c1[i] = (position[i] - p_from[i]) / p_dir[i];
c2[i] = (end[i] - p_from[i]) / p_dir[i];
- if(c1[i] > c2[i]){
- std::swap(c1,c2);
+ if (c1[i] > c2[i]) {
+ std::swap(c1, c2);
}
- if (c1[i] > near){
+ if (c1[i] > near) {
near = c1[i];
- axis=i;
+ axis = i;
}
- if (c2[i] < far){
+ if (c2[i] < far) {
far = c2[i];
}
- if( (near > far) || (far < 0) ){
+ if ((near > far) || (far < 0)) {
return false;
}
}
}
if (r_clip)
- *r_clip=c1;
+ *r_clip = c1;
if (r_normal) {
- *r_normal=Vector3();
- (*r_normal)[axis]=p_dir[axis]?-1:1;
+ *r_normal = Vector3();
+ (*r_normal)[axis] = p_dir[axis] ? -1 : 1;
}
return true;
-
}
+bool AABB::intersects_segment(const Vector3 &p_from, const Vector3 &p_to, Vector3 *r_clip, Vector3 *r_normal) const {
-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;
- real_t min=0,max=1;
- int axis=0;
- real_t sign=0;
-
- for(int i=0;i<3;i++) {
- real_t seg_from=p_from[i];
- real_t seg_to=p_to[i];
- real_t box_begin=position[i];
- real_t box_end=box_begin+size[i];
- real_t cmin,cmax;
+ for (int i = 0; i < 3; i++) {
+ real_t seg_from = p_from[i];
+ real_t seg_to = p_to[i];
+ real_t box_begin = position[i];
+ real_t box_end = box_begin + size[i];
+ real_t cmin, cmax;
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;
- cmin = (seg_from < box_begin)?((box_begin - seg_from)/length):0;
- cmax = (seg_to > box_end)?((box_end - seg_from)/length):1;
- csign=-1.0;
+ real_t length = seg_to - seg_from;
+ cmin = (seg_from < box_begin) ? ((box_begin - seg_from) / length) : 0;
+ cmax = (seg_to > box_end) ? ((box_end - seg_from) / length) : 1;
+ csign = -1.0;
} else {
if (seg_to > box_end || seg_from < box_begin)
return false;
- real_t length=seg_to-seg_from;
- cmin = (seg_from > box_end)?(box_end - seg_from)/length:0;
- cmax = (seg_to < box_begin)?(box_begin - seg_from)/length:1;
- csign=1.0;
+ real_t length = seg_to - seg_from;
+ cmin = (seg_from > box_end) ? (box_end - seg_from) / length : 0;
+ cmax = (seg_to < box_begin) ? (box_begin - seg_from) / length : 1;
+ csign = 1.0;
}
if (cmin > min) {
min = cmin;
- axis=i;
- sign=csign;
+ axis = i;
+ sign = csign;
}
if (cmax < max)
max = cmax;
@@ -418,217 +401,207 @@ bool AABB::intersects_segment(const Vector3& p_from, const Vector3& p_to,Vector3
return false;
}
-
- Vector3 rel=p_to-p_from;
+ Vector3 rel = p_to - p_from;
if (r_normal) {
Vector3 normal;
- normal[axis]=sign;
- *r_normal=normal;
+ normal[axis] = sign;
+ *r_normal = normal;
}
if (r_clip)
- *r_clip=p_from+rel*min;
+ *r_clip = p_from + rel * min;
return true;
-
}
-
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 ),
- Vector3( position.x , position.y+size.y , position.z ),
- Vector3( position.x , position.y+size.y , position.z+size.z ),
- Vector3( position.x+size.x , position.y , position.z ),
- Vector3( position.x+size.x , position.y , position.z+size.z ),
- Vector3( position.x+size.x , position.y+size.y , position.z ),
- Vector3( position.x+size.x , position.y+size.y , position.z+size.z ),
+ Vector3(position.x, position.y, position.z),
+ Vector3(position.x, position.y, position.z + size.z),
+ Vector3(position.x, position.y + size.y, position.z),
+ Vector3(position.x, position.y + size.y, position.z + size.z),
+ Vector3(position.x + size.x, position.y, position.z),
+ Vector3(position.x + size.x, position.y, position.z + size.z),
+ Vector3(position.x + size.x, position.y + size.y, position.z),
+ Vector3(position.x + size.x, position.y + size.y, position.z + size.z),
};
- bool over=false;
- bool under=false;
+ bool over = false;
+ bool under = false;
- for (int i=0;i<8;i++) {
+ for (int i = 0; i < 8; i++) {
- if (p_plane.distance_to(points[i])>0)
- over=true;
+ if (p_plane.distance_to(points[i]) > 0)
+ over = true;
else
- under=true;
-
+ under = true;
}
return under && over;
}
-
-
Vector3 AABB::get_longest_axis() const {
- Vector3 axis(1,0,0);
- real_t max_size=size.x;
+ Vector3 axis(1, 0, 0);
+ real_t max_size = size.x;
- if (size.y > max_size ) {
- axis=Vector3(0,1,0);
- max_size=size.y;
+ if (size.y > max_size) {
+ axis = Vector3(0, 1, 0);
+ max_size = size.y;
}
- if (size.z > max_size ) {
- axis=Vector3(0,0,1);
- max_size=size.z;
+ if (size.z > max_size) {
+ axis = Vector3(0, 0, 1);
+ max_size = size.z;
}
return axis;
}
int AABB::get_longest_axis_index() const {
- int axis=0;
- real_t max_size=size.x;
+ int axis = 0;
+ real_t max_size = size.x;
- if (size.y > max_size ) {
- axis=1;
- max_size=size.y;
+ if (size.y > max_size) {
+ axis = 1;
+ max_size = size.y;
}
- if (size.z > max_size ) {
- axis=2;
- max_size=size.z;
+ if (size.z > max_size) {
+ axis = 2;
+ max_size = size.z;
}
return axis;
}
-
Vector3 AABB::get_shortest_axis() const {
- Vector3 axis(1,0,0);
- real_t max_size=size.x;
+ Vector3 axis(1, 0, 0);
+ real_t max_size = size.x;
- if (size.y < max_size ) {
- axis=Vector3(0,1,0);
- max_size=size.y;
+ if (size.y < max_size) {
+ axis = Vector3(0, 1, 0);
+ max_size = size.y;
}
- if (size.z < max_size ) {
- axis=Vector3(0,0,1);
- max_size=size.z;
+ if (size.z < max_size) {
+ axis = Vector3(0, 0, 1);
+ max_size = size.z;
}
return axis;
}
int AABB::get_shortest_axis_index() const {
- int axis=0;
- real_t max_size=size.x;
+ int axis = 0;
+ real_t max_size = size.x;
- if (size.y < max_size ) {
- axis=1;
- max_size=size.y;
+ if (size.y < max_size) {
+ axis = 1;
+ max_size = size.y;
}
- if (size.z < max_size ) {
- axis=2;
- max_size=size.z;
+ if (size.z < max_size) {
+ axis = 2;
+ max_size = size.z;
}
return axis;
}
-AABB AABB::merge(const AABB& p_with) const {
+AABB AABB::merge(const AABB &p_with) const {
- AABB aabb=*this;
+ AABB aabb = *this;
aabb.merge_with(p_with);
return aabb;
}
-AABB AABB::expand(const Vector3& p_vector) const {
- AABB aabb=*this;
+AABB AABB::expand(const Vector3 &p_vector) const {
+ AABB aabb = *this;
aabb.expand_to(p_vector);
return aabb;
-
}
AABB AABB::grow(real_t p_by) const {
- AABB aabb=*this;
+ AABB aabb = *this;
aabb.grow_by(p_by);
return aabb;
}
-void AABB::get_edge(int p_edge,Vector3& r_from,Vector3& r_to) const {
+void AABB::get_edge(int p_edge, Vector3 &r_from, Vector3 &r_to) const {
- ERR_FAIL_INDEX(p_edge,12);
- switch(p_edge) {
+ ERR_FAIL_INDEX(p_edge, 12);
+ switch (p_edge) {
- case 0:{
+ case 0: {
- r_from=Vector3( position.x+size.x , position.y , position.z );
- r_to=Vector3( position.x , position.y , position.z );
+ r_from = Vector3(position.x + size.x, position.y, position.z);
+ r_to = Vector3(position.x, position.y, position.z);
} break;
- case 1:{
+ 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 );
+ 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;
- case 2:{
- r_from=Vector3( position.x , position.y , position.z+size.z );
- r_to=Vector3( position.x+size.x , position.y , position.z+size.z );
+ case 2: {
+ r_from = Vector3(position.x, position.y, position.z + size.z);
+ r_to = Vector3(position.x + size.x, position.y, position.z + size.z);
} break;
- case 3:{
+ case 3: {
- r_from=Vector3( position.x , position.y , position.z );
- r_to=Vector3( position.x , position.y , position.z+size.z );
+ r_from = Vector3(position.x, position.y, position.z);
+ r_to = Vector3(position.x, position.y, position.z + size.z);
} break;
- case 4:{
+ 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 );
+ 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:{
+ 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 );
+ 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;
- case 6:{
- r_from=Vector3( position.x+size.x , position.y+size.y , position.z+size.z );
- r_to=Vector3( position.x , position.y+size.y , position.z+size.z );
+ case 6: {
+ r_from = Vector3(position.x + size.x, position.y + size.y, position.z + size.z);
+ r_to = Vector3(position.x, position.y + size.y, position.z + size.z);
} break;
- case 7:{
+ 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 );
+ 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:{
+ 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 );
+ 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:{
+ case 9: {
- r_from=Vector3( position.x , position.y , position.z );
- r_to=Vector3( position.x , position.y+size.y , position.z );
+ r_from = Vector3(position.x, position.y, position.z);
+ r_to = Vector3(position.x, position.y + size.y, position.z);
} break;
- case 10:{
+ 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 );
+ 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:{
+ 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 );
+ 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);
} break;
-
}
-
}
AABB::operator String() const {
@@ -636,4 +609,4 @@ AABB::operator String() const {
return String() + position + " - " + size;
}
-}
+} // namespace godot
diff --git a/src/core/Array.cpp b/src/core/Array.cpp
index 0350547..9737275 100644
--- a/src/core/Array.cpp
+++ b/src/core/Array.cpp
@@ -1,6 +1,6 @@
#include "Array.hpp"
-#include "Variant.hpp"
#include "GodotGlobal.hpp"
+#include "Variant.hpp"
#include <cstdlib>
@@ -8,194 +8,158 @@ namespace godot {
class Object;
-Array::Array()
-{
+Array::Array() {
godot::api->godot_array_new(&_godot_array);
}
-Array::Array(const Array & other)
-{
+Array::Array(const Array &other) {
godot::api->godot_array_new_copy(&_godot_array, &other._godot_array);
}
-Array & Array::operator=(const Array & other)
-{
+Array &Array::operator=(const Array &other) {
godot::api->godot_array_destroy(&_godot_array);
godot::api->godot_array_new_copy(&_godot_array, &other._godot_array);
return *this;
}
-Array::Array(const PoolByteArray& a)
-{
- godot::api->godot_array_new_pool_byte_array(&_godot_array, (godot_pool_byte_array *) &a);
+Array::Array(const PoolByteArray &a) {
+ godot::api->godot_array_new_pool_byte_array(&_godot_array, (godot_pool_byte_array *)&a);
}
-Array::Array(const PoolIntArray& a)
-{
- godot::api->godot_array_new_pool_int_array(&_godot_array, (godot_pool_int_array *) &a);
+Array::Array(const PoolIntArray &a) {
+ godot::api->godot_array_new_pool_int_array(&_godot_array, (godot_pool_int_array *)&a);
}
-Array::Array(const PoolRealArray& a)
-{
- godot::api->godot_array_new_pool_real_array(&_godot_array, (godot_pool_real_array *) &a);
+Array::Array(const PoolRealArray &a) {
+ godot::api->godot_array_new_pool_real_array(&_godot_array, (godot_pool_real_array *)&a);
}
-Array::Array(const PoolStringArray& a)
-{
- godot::api->godot_array_new_pool_string_array(&_godot_array, (godot_pool_string_array *) &a);
+Array::Array(const PoolStringArray &a) {
+ godot::api->godot_array_new_pool_string_array(&_godot_array, (godot_pool_string_array *)&a);
}
-Array::Array(const PoolVector2Array& a)
-{
- godot::api->godot_array_new_pool_vector2_array(&_godot_array, (godot_pool_vector2_array *) &a);
+Array::Array(const PoolVector2Array &a) {
+ godot::api->godot_array_new_pool_vector2_array(&_godot_array, (godot_pool_vector2_array *)&a);
}
-Array::Array(const PoolVector3Array& a)
-{
- godot::api->godot_array_new_pool_vector3_array(&_godot_array, (godot_pool_vector3_array *) &a);
+Array::Array(const PoolVector3Array &a) {
+ godot::api->godot_array_new_pool_vector3_array(&_godot_array, (godot_pool_vector3_array *)&a);
}
-Array::Array(const PoolColorArray& a)
-{
- godot::api->godot_array_new_pool_color_array(&_godot_array, (godot_pool_color_array *) &a);
+Array::Array(const PoolColorArray &a) {
+ godot::api->godot_array_new_pool_color_array(&_godot_array, (godot_pool_color_array *)&a);
}
-Variant& Array::operator [](const int idx)
-{
+Variant &Array::operator[](const int idx) {
godot_variant *v = godot::api->godot_array_operator_index(&_godot_array, idx);
- return *(Variant *) v;
+ return *(Variant *)v;
}
-Variant Array::operator [](const int idx) const
-{
+Variant Array::operator[](const int idx) const {
// Yes, I'm casting away the const... you can hate me now.
// since the result is
- godot_variant *v = godot::api->godot_array_operator_index((godot_array *) &_godot_array, idx);
- return *(Variant *) v;
+ godot_variant *v = godot::api->godot_array_operator_index((godot_array *)&_godot_array, idx);
+ return *(Variant *)v;
}
-void Array::append(const Variant& v)
-{
- godot::api->godot_array_append(&_godot_array, (godot_variant *) &v);
+void Array::append(const Variant &v) {
+ godot::api->godot_array_append(&_godot_array, (godot_variant *)&v);
}
-void Array::clear()
-{
+void Array::clear() {
godot::api->godot_array_clear(&_godot_array);
}
-int Array::count(const Variant& v)
-{
- return godot::api->godot_array_count(&_godot_array, (godot_variant *) &v);
+int Array::count(const Variant &v) {
+ return godot::api->godot_array_count(&_godot_array, (godot_variant *)&v);
}
-bool Array::empty() const
-{
+bool Array::empty() const {
return godot::api->godot_array_empty(&_godot_array);
}
-void Array::erase(const Variant& v)
-{
- godot::api->godot_array_erase(&_godot_array, (godot_variant *) &v);
+void Array::erase(const Variant &v) {
+ godot::api->godot_array_erase(&_godot_array, (godot_variant *)&v);
}
-Variant Array::front() const
-{
+Variant Array::front() const {
godot_variant v = godot::api->godot_array_front(&_godot_array);
- return *(Variant *) &v;
+ return *(Variant *)&v;
}
-Variant Array::back() const
-{
+Variant Array::back() const {
godot_variant v = godot::api->godot_array_back(&_godot_array);
- return *(Variant *) &v;
+ return *(Variant *)&v;
}
-int Array::find(const Variant& what, const int from)
-{
- return godot::api->godot_array_find(&_godot_array, (godot_variant *) &what, from);
+int Array::find(const Variant &what, const int from) {
+ return godot::api->godot_array_find(&_godot_array, (godot_variant *)&what, from);
}
-int Array::find_last(const Variant& what)
-{
- return godot::api->godot_array_find_last(&_godot_array, (godot_variant *) &what);
+int Array::find_last(const Variant &what) {
+ return godot::api->godot_array_find_last(&_godot_array, (godot_variant *)&what);
}
-bool Array::has(const Variant& what) const
-{
- return godot::api->godot_array_has(&_godot_array, (godot_variant *) &what);
+bool Array::has(const Variant &what) const {
+ return godot::api->godot_array_has(&_godot_array, (godot_variant *)&what);
}
-uint32_t Array::hash() const
-{
+uint32_t Array::hash() const {
return godot::api->godot_array_hash(&_godot_array);
}
-void Array::insert(const int pos, const Variant& value)
-{
- godot::api->godot_array_insert(&_godot_array, pos, (godot_variant *) &value);
+void Array::insert(const int pos, const Variant &value) {
+ godot::api->godot_array_insert(&_godot_array, pos, (godot_variant *)&value);
}
-void Array::invert()
-{
+void Array::invert() {
godot::api->godot_array_invert(&_godot_array);
}
-Variant Array::pop_back()
-{
+Variant Array::pop_back() {
godot_variant v = godot::api->godot_array_pop_back(&_godot_array);
- return *(Variant *) &v;
+ return *(Variant *)&v;
}
-Variant Array::pop_front()
-{
+Variant Array::pop_front() {
godot_variant v = godot::api->godot_array_pop_front(&_godot_array);
- return *(Variant *) &v;
+ return *(Variant *)&v;
}
-void Array::push_back(const Variant& v)
-{
- godot::api->godot_array_push_back(&_godot_array, (godot_variant *) &v);
+void Array::push_back(const Variant &v) {
+ godot::api->godot_array_push_back(&_godot_array, (godot_variant *)&v);
}
-void Array::push_front(const Variant& v)
-{
- godot::api->godot_array_push_front(&_godot_array, (godot_variant *) &v);
+void Array::push_front(const Variant &v) {
+ godot::api->godot_array_push_front(&_godot_array, (godot_variant *)&v);
}
-void Array::remove(const int idx)
-{
+void Array::remove(const int idx) {
godot::api->godot_array_remove(&_godot_array, idx);
}
-int Array::size() const
-{
+int Array::size() const {
return godot::api->godot_array_size(&_godot_array);
}
-void Array::resize(const int size)
-{
+void Array::resize(const int size) {
godot::api->godot_array_resize(&_godot_array, size);
}
-int Array::rfind(const Variant& what, const int from)
-{
- return godot::api->godot_array_rfind(&_godot_array, (godot_variant *) &what, from);
+int Array::rfind(const Variant &what, const int from) {
+ return godot::api->godot_array_rfind(&_godot_array, (godot_variant *)&what, from);
}
-void Array::sort()
-{
+void Array::sort() {
godot::api->godot_array_sort(&_godot_array);
}
-void Array::sort_custom(Object *obj, const String& func)
-{
- godot::api->godot_array_sort_custom(&_godot_array, (godot_object *) obj, (godot_string *) &func);
+void Array::sort_custom(Object *obj, const String &func) {
+ godot::api->godot_array_sort_custom(&_godot_array, (godot_object *)obj, (godot_string *)&func);
}
-Array::~Array()
-{
+Array::~Array() {
godot::api->godot_array_destroy(&_godot_array);
}
-}
+} // namespace godot
diff --git a/src/core/Basis.cpp b/src/core/Basis.cpp
index 5919558..73d9cd5 100644
--- a/src/core/Basis.cpp
+++ b/src/core/Basis.cpp
@@ -1,18 +1,16 @@
#include "Basis.hpp"
#include "Defs.hpp"
-#include "Vector3.hpp"
#include "Quat.hpp"
+#include "Vector3.hpp"
#include <algorithm>
namespace godot {
-
-Basis::Basis(const Vector3& row0, const Vector3& row1, const Vector3& row2)
-{
- elements[0]=row0;
- elements[1]=row1;
- elements[2]=row2;
+Basis::Basis(const Vector3 &row0, const Vector3 &row1, const Vector3 &row2) {
+ elements[0] = row0;
+ elements[1] = row1;
+ elements[2] = 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) {
@@ -22,58 +20,52 @@ Basis::Basis(real_t xx, real_t xy, real_t xz, real_t yx, real_t yy, real_t yz, r
Basis::Basis() {
- elements[0][0]=1;
- elements[0][1]=0;
- elements[0][2]=0;
- elements[1][0]=0;
- elements[1][1]=1;
- elements[1][2]=0;
- elements[2][0]=0;
- elements[2][1]=0;
- elements[2][2]=1;
+ elements[0][0] = 1;
+ elements[0][1] = 0;
+ elements[0][2] = 0;
+ elements[1][0] = 0;
+ elements[1][1] = 1;
+ elements[1][2] = 0;
+ elements[2][0] = 0;
+ elements[2][1] = 0;
+ elements[2][2] = 1;
}
-
-
-
-
-const Vector3& Basis::operator[](int axis) const {
+const Vector3 &Basis::operator[](int axis) const {
return elements[axis];
}
-Vector3&Basis:: operator[](int axis) {
+Vector3 &Basis::operator[](int axis) {
return elements[axis];
}
-#define cofac(row1,col1, row2, col2)\
-(elements[row1][col1] * elements[row2][col2] - elements[row1][col2] * elements[row2][col1])
+#define cofac(row1, col1, row2, col2) \
+ (elements[row1][col1] * elements[row2][col2] - elements[row1][col2] * elements[row2][col1])
-void Basis::invert()
-{
- real_t co[3]={
+void Basis::invert() {
+ real_t co[3] = {
cofac(1, 1, 2, 2), cofac(1, 2, 2, 0), cofac(1, 0, 2, 1)
};
- real_t det = elements[0][0] * co[0]+
- elements[0][1] * co[1]+
- elements[0][2] * co[2];
+ real_t det = elements[0][0] * co[0] +
+ elements[0][1] * co[1] +
+ elements[0][2] * co[2];
-
ERR_FAIL_COND(det == 0);
-
- real_t s = 1.0/det;
- set( co[0]*s, cofac(0, 2, 2, 1) * s, cofac(0, 1, 1, 2) * s,
- co[1]*s, cofac(0, 0, 2, 2) * s, cofac(0, 2, 1, 0) * s,
- co[2]*s, cofac(0, 1, 2, 0) * s, cofac(0, 0, 1, 1) * s );
+ real_t s = 1.0 / det;
+
+ set(co[0] * s, cofac(0, 2, 2, 1) * s, cofac(0, 1, 1, 2) * s,
+ co[1] * s, cofac(0, 0, 2, 2) * s, cofac(0, 2, 1, 0) * s,
+ co[2] * s, cofac(0, 1, 2, 0) * s, cofac(0, 0, 1, 1) * s);
}
#undef cofac
-bool Basis::isequal_approx(const Basis& a, const Basis& b) const {
+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)
+ 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)
return false;
}
}
@@ -81,102 +73,89 @@ bool Basis::isequal_approx(const Basis& a, const Basis& b) const {
return true;
}
-
-bool Basis::is_orthogonal() const
-{
+bool Basis::is_orthogonal() const {
Basis id;
- Basis m = (*this)*transposed();
+ Basis m = (*this) * transposed();
- return isequal_approx(id,m);
+ return isequal_approx(id, m);
}
-bool Basis::is_rotation() const
-{
- return ::fabs(determinant()-1) < CMP_EPSILON && is_orthogonal();
+bool Basis::is_rotation() const {
+ return ::fabs(determinant() - 1) < CMP_EPSILON && is_orthogonal();
}
-void Basis::transpose()
-{
- std::swap(elements[0][1],elements[1][0]);
- std::swap(elements[0][2],elements[2][0]);
- std::swap(elements[1][2],elements[2][1]);
+void Basis::transpose() {
+ std::swap(elements[0][1], elements[1][0]);
+ std::swap(elements[0][2], elements[2][0]);
+ std::swap(elements[1][2], elements[2][1]);
}
-Basis Basis::inverse() const
-{
+Basis Basis::inverse() const {
Basis b = *this;
b.invert();
return b;
}
-Basis Basis::transposed() const
-{
+Basis Basis::transposed() const {
Basis b = *this;
b.transpose();
return b;
}
-real_t Basis::determinant() const
-{
- return elements[0][0]*(elements[1][1]*elements[2][2] - elements[2][1]*elements[1][2]) -
- elements[1][0]*(elements[0][1]*elements[2][2] - elements[2][1]*elements[0][2]) +
- elements[2][0]*(elements[0][1]*elements[1][2] - elements[1][1]*elements[0][2]);
+real_t Basis::determinant() const {
+ return elements[0][0] * (elements[1][1] * elements[2][2] - elements[2][1] * elements[1][2]) -
+ elements[1][0] * (elements[0][1] * elements[2][2] - elements[2][1] * elements[0][2]) +
+ elements[2][0] * (elements[0][1] * elements[1][2] - elements[1][1] * elements[0][2]);
}
Vector3 Basis::get_axis(int p_axis) const {
// get actual basis axis (elements is transposed for performance)
- return Vector3( elements[0][p_axis], elements[1][p_axis], elements[2][p_axis] );
+ return Vector3(elements[0][p_axis], elements[1][p_axis], elements[2][p_axis]);
}
-void Basis::set_axis(int p_axis, const Vector3& p_value) {
+void Basis::set_axis(int p_axis, const Vector3 &p_value) {
// get actual basis axis (elements is transposed for performance)
- elements[0][p_axis]=p_value.x;
- elements[1][p_axis]=p_value.y;
- elements[2][p_axis]=p_value.z;
+ elements[0][p_axis] = p_value.x;
+ elements[1][p_axis] = p_value.y;
+ elements[2][p_axis] = p_value.z;
}
-void Basis::rotate(const Vector3& p_axis, real_t p_phi)
-{
+void Basis::rotate(const Vector3 &p_axis, real_t p_phi) {
*this = rotated(p_axis, p_phi);
}
-Basis Basis::rotated(const Vector3& p_axis, real_t p_phi) const
-{
+Basis Basis::rotated(const Vector3 &p_axis, real_t p_phi) const {
return Basis(p_axis, p_phi) * (*this);
}
-void Basis::scale( const Vector3& p_scale )
-{
- elements[0][0]*=p_scale.x;
- elements[0][1]*=p_scale.x;
- elements[0][2]*=p_scale.x;
- elements[1][0]*=p_scale.y;
- elements[1][1]*=p_scale.y;
- elements[1][2]*=p_scale.y;
- elements[2][0]*=p_scale.z;
- elements[2][1]*=p_scale.z;
- elements[2][2]*=p_scale.z;
+void Basis::scale(const Vector3 &p_scale) {
+ elements[0][0] *= p_scale.x;
+ elements[0][1] *= p_scale.x;
+ elements[0][2] *= p_scale.x;
+ elements[1][0] *= p_scale.y;
+ elements[1][1] *= p_scale.y;
+ elements[1][2] *= p_scale.y;
+ elements[2][0] *= p_scale.z;
+ elements[2][1] *= p_scale.z;
+ elements[2][2] *= p_scale.z;
}
-Basis Basis::scaled( const Vector3& p_scale ) const
-{
+Basis Basis::scaled(const Vector3 &p_scale) const {
Basis b = *this;
b.scale(p_scale);
return b;
}
-Vector3 Basis::get_scale() const
-{
+Vector3 Basis::get_scale() const {
// We are assuming M = R.S, and performing a polar decomposition to extract R and S.
// FIXME: We eventually need a proper polar decomposition.
// As a cheap workaround until then, to ensure that R is a proper rotation matrix with determinant +1
// (such that it can be represented by a Quat or Euler angles), we absorb the sign flip into the scaling matrix.
// As such, it works in conjuction with get_rotation().
real_t det_sign = determinant() > 0 ? 1 : -1;
- return det_sign*Vector3(
- Vector3(elements[0][0],elements[1][0],elements[2][0]).length(),
- Vector3(elements[0][1],elements[1][1],elements[2][1]).length(),
- Vector3(elements[0][2],elements[1][2],elements[2][2]).length()
- );
+ return det_sign * Vector3(
+ Vector3(elements[0][0], elements[1][0], elements[2][0]).length(),
+ Vector3(elements[0][1], elements[1][1], elements[2][1]).length(),
+ Vector3(elements[0][2], elements[1][2], elements[2][2]).length());
}
// get_euler_xyz returns a vector containing the Euler angles in the format
@@ -322,23 +301,20 @@ void Basis::set_euler_yxz(const Vector3 &p_euler) {
*this = ymat * xmat * zmat;
}
-
-
// transposed dot products
-real_t Basis::tdotx(const Vector3& v) const {
+real_t Basis::tdotx(const Vector3 &v) const {
return elements[0][0] * v[0] + elements[1][0] * v[1] + elements[2][0] * v[2];
}
-real_t Basis::tdoty(const Vector3& v) const {
+real_t Basis::tdoty(const Vector3 &v) const {
return elements[0][1] * v[0] + elements[1][1] * v[1] + elements[2][1] * v[2];
}
-real_t Basis::tdotz(const Vector3& v) const {
+real_t Basis::tdotz(const Vector3 &v) const {
return elements[0][2] * v[0] + elements[1][2] * v[1] + elements[2][2] * v[2];
}
-bool Basis::operator==(const Basis& p_matrix) const
-{
- for (int i=0;i<3;i++) {
- for (int j=0;j<3;j++) {
+bool Basis::operator==(const Basis &p_matrix) const {
+ for (int i = 0; i < 3; i++) {
+ for (int j = 0; j < 3; j++) {
if (elements[i][j] != p_matrix.elements[i][j])
return false;
}
@@ -347,69 +323,61 @@ bool Basis::operator==(const Basis& p_matrix) const
return true;
}
-bool Basis::operator!=(const Basis& p_matrix) const
-{
- return (!(*this==p_matrix));
+bool Basis::operator!=(const Basis &p_matrix) const {
+ return (!(*this == p_matrix));
}
-Vector3 Basis::xform(const Vector3& p_vector) const {
+Vector3 Basis::xform(const Vector3 &p_vector) const {
return Vector3(
- elements[0].dot(p_vector),
- elements[1].dot(p_vector),
- elements[2].dot(p_vector)
- );
+ elements[0].dot(p_vector),
+ elements[1].dot(p_vector),
+ elements[2].dot(p_vector));
}
-Vector3 Basis::xform_inv(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 ),
- (elements[0][2]*p_vector.x ) + ( elements[1][2]*p_vector.y ) + ( elements[2][2]*p_vector.z )
- );
+ (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),
+ (elements[0][2] * p_vector.x) + (elements[1][2] * p_vector.y) + (elements[2][2] * p_vector.z));
}
-void Basis::operator*=(const Basis& p_matrix)
-{
+void Basis::operator*=(const Basis &p_matrix) {
set(
- p_matrix.tdotx(elements[0]), p_matrix.tdoty(elements[0]), p_matrix.tdotz(elements[0]),
- p_matrix.tdotx(elements[1]), p_matrix.tdoty(elements[1]), p_matrix.tdotz(elements[1]),
- p_matrix.tdotx(elements[2]), p_matrix.tdoty(elements[2]), p_matrix.tdotz(elements[2]));
-
+ p_matrix.tdotx(elements[0]), p_matrix.tdoty(elements[0]), p_matrix.tdotz(elements[0]),
+ p_matrix.tdotx(elements[1]), p_matrix.tdoty(elements[1]), p_matrix.tdotz(elements[1]),
+ p_matrix.tdotx(elements[2]), p_matrix.tdoty(elements[2]), p_matrix.tdotz(elements[2]));
}
-Basis Basis::operator*(const Basis& p_matrix) const
-{
+Basis Basis::operator*(const Basis &p_matrix) const {
return Basis(
- p_matrix.tdotx(elements[0]), p_matrix.tdoty(elements[0]), p_matrix.tdotz(elements[0]),
- p_matrix.tdotx(elements[1]), p_matrix.tdoty(elements[1]), p_matrix.tdotz(elements[1]),
- p_matrix.tdotx(elements[2]), p_matrix.tdoty(elements[2]), p_matrix.tdotz(elements[2]) );
-
+ p_matrix.tdotx(elements[0]), p_matrix.tdoty(elements[0]), p_matrix.tdotz(elements[0]),
+ p_matrix.tdotx(elements[1]), p_matrix.tdoty(elements[1]), p_matrix.tdotz(elements[1]),
+ p_matrix.tdotx(elements[2]), p_matrix.tdoty(elements[2]), p_matrix.tdotz(elements[2]));
}
-
-void Basis::operator+=(const Basis& p_matrix) {
+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 Basis::operator+(const Basis &p_matrix) const {
Basis ret(*this);
ret += p_matrix;
return ret;
}
-void Basis::operator-=(const Basis& p_matrix) {
+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 Basis::operator-(const Basis &p_matrix) const {
Basis ret(*this);
ret -= p_matrix;
@@ -418,21 +386,19 @@ Basis Basis::operator-(const Basis& p_matrix) const {
void Basis::operator*=(real_t p_val) {
- elements[0]*=p_val;
- elements[1]*=p_val;
- elements[2]*=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;
+ Basis ret(*this);
+ ret *= p_val;
+ return ret;
}
-
-Basis::operator String() const
-{
+Basis::operator String() const {
String s;
for (int i = 0; i < 3; i++) {
@@ -449,82 +415,77 @@ 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;
- elements[1][0]=yx;
- elements[1][1]=yy;
- elements[1][2]=yz;
- elements[2][0]=zx;
- elements[2][1]=zy;
- elements[2][2]=zz;
+ elements[0][0] = xx;
+ elements[0][1] = xy;
+ elements[0][2] = xz;
+ elements[1][0] = yx;
+ elements[1][1] = yy;
+ elements[1][2] = yz;
+ elements[2][0] = zx;
+ elements[2][1] = zy;
+ elements[2][2] = zz;
}
Vector3 Basis::get_column(int i) const {
- return Vector3(elements[0][i],elements[1][i],elements[2][i]);
+ 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]);
+ return Vector3(elements[i][0], elements[i][1], elements[i][2]);
}
Vector3 Basis::get_main_diagonal() const {
- return Vector3(elements[0][0],elements[1][1],elements[2][2]);
+ return Vector3(elements[0][0], elements[1][1], elements[2][2]);
}
-void Basis::set_row(int i, const Vector3& p_row) {
- elements[i][0]=p_row.x;
- elements[i][1]=p_row.y;
- elements[i][2]=p_row.z;
+void Basis::set_row(int i, const Vector3 &p_row) {
+ elements[i][0] = p_row.x;
+ elements[i][1] = p_row.y;
+ elements[i][2] = p_row.z;
}
-Basis Basis::transpose_xform(const Basis& m) const
-{
+Basis Basis::transpose_xform(const Basis &m) const {
return Basis(
- elements[0].x * m[0].x + elements[1].x * m[1].x + elements[2].x * m[2].x,
- elements[0].x * m[0].y + elements[1].x * m[1].y + elements[2].x * m[2].y,
- elements[0].x * m[0].z + elements[1].x * m[1].z + elements[2].x * m[2].z,
- elements[0].y * m[0].x + elements[1].y * m[1].x + elements[2].y * m[2].x,
- elements[0].y * m[0].y + elements[1].y * m[1].y + elements[2].y * m[2].y,
- elements[0].y * m[0].z + elements[1].y * m[1].z + elements[2].y * m[2].z,
- elements[0].z * m[0].x + elements[1].z * m[1].x + elements[2].z * m[2].x,
- elements[0].z * m[0].y + elements[1].z * m[1].y + elements[2].z * m[2].y,
- elements[0].z * m[0].z + elements[1].z * m[1].z + elements[2].z * m[2].z);
-}
-
-void Basis::orthonormalize()
-{
+ elements[0].x * m[0].x + elements[1].x * m[1].x + elements[2].x * m[2].x,
+ elements[0].x * m[0].y + elements[1].x * m[1].y + elements[2].x * m[2].y,
+ elements[0].x * m[0].z + elements[1].x * m[1].z + elements[2].x * m[2].z,
+ elements[0].y * m[0].x + elements[1].y * m[1].x + elements[2].y * m[2].x,
+ elements[0].y * m[0].y + elements[1].y * m[1].y + elements[2].y * m[2].y,
+ elements[0].y * m[0].z + elements[1].y * m[1].z + elements[2].y * m[2].z,
+ elements[0].z * m[0].x + elements[1].z * m[1].x + elements[2].z * m[2].x,
+ elements[0].z * m[0].y + elements[1].z * m[1].y + elements[2].z * m[2].y,
+ elements[0].z * m[0].z + elements[1].z * m[1].z + elements[2].z * m[2].z);
+}
+
+void Basis::orthonormalize() {
ERR_FAIL_COND(determinant() == 0);
// Gram-Schmidt Process
- Vector3 x=get_axis(0);
- Vector3 y=get_axis(1);
- Vector3 z=get_axis(2);
+ Vector3 x = get_axis(0);
+ Vector3 y = get_axis(1);
+ Vector3 z = get_axis(2);
x.normalize();
- y = (y-x*(x.dot(y)));
+ y = (y - x * (x.dot(y)));
y.normalize();
- z = (z-x*(x.dot(z))-y*(y.dot(z)));
+ z = (z - x * (x.dot(z)) - y * (y.dot(z)));
z.normalize();
- set_axis(0,x);
- set_axis(1,y);
- set_axis(2,z);
+ set_axis(0, x);
+ set_axis(1, y);
+ set_axis(2, z);
}
-Basis Basis::orthonormalized() const
-{
+Basis Basis::orthonormalized() const {
Basis b = *this;
b.orthonormalize();
return b;
}
-bool Basis::is_symmetric() const
-{
+bool Basis::is_symmetric() const {
if (::fabs(elements[0][1] - elements[1][0]) > CMP_EPSILON)
return false;
if (::fabs(elements[0][2] - elements[2][0]) > CMP_EPSILON)
@@ -535,8 +496,7 @@ bool Basis::is_symmetric() const
return true;
}
-Basis Basis::diagonalize()
-{
+Basis Basis::diagonalize() {
// I love copy paste
if (!is_symmetric())
@@ -548,7 +508,7 @@ Basis Basis::diagonalize()
int ite = 0;
Basis acc_rot;
- while (off_matrix_norm_2 > CMP_EPSILON2 && ite++ < ite_max ) {
+ while (off_matrix_norm_2 > CMP_EPSILON2 && ite++ < ite_max) {
real_t el01_2 = elements[0][1] * elements[0][1];
real_t el02_2 = elements[0][2] * elements[0][2];
real_t el12_2 = elements[1][2] * elements[1][2];
@@ -583,7 +543,7 @@ Basis Basis::diagonalize()
// Compute the rotation matrix
Basis rot;
rot.elements[i][i] = rot.elements[j][j] = ::cos(angle);
- rot.elements[i][j] = - (rot.elements[j][i] = ::sin(angle));
+ rot.elements[i][j] = -(rot.elements[j][i] = ::sin(angle));
// Update the off matrix norm
off_matrix_norm_2 -= elements[i][j] * elements[i][j];
@@ -596,8 +556,7 @@ Basis Basis::diagonalize()
return acc_rot;
}
-
-static const Basis _ortho_bases[24]={
+static const Basis _ortho_bases[24] = {
Basis(1, 0, 0, 0, 1, 0, 0, 0, 1),
Basis(0, -1, 0, 1, 0, 0, 0, 0, 1),
Basis(-1, 0, 0, 0, -1, 0, 0, 0, 1),
@@ -624,95 +583,84 @@ static const Basis _ortho_bases[24]={
Basis(0, -1, 0, 0, 0, -1, 1, 0, 0)
};
-
-int Basis::get_orthogonal_index() const
-{
+int Basis::get_orthogonal_index() const {
//could be sped up if i come up with a way
- Basis orth=*this;
- for(int i=0;i<3;i++) {
- for(int j=0;j<3;j++) {
+ 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;
- else if (v<-0.5)
- v=-1.0;
+ if (v > 0.5)
+ v = 1.0;
+ else if (v < -0.5)
+ v = -1.0;
else
- v=0;
+ v = 0;
- orth[i][j]=v;
+ orth[i][j] = v;
}
}
- for(int i=0;i<24;i++) {
+ for (int i = 0; i < 24; i++) {
- if (_ortho_bases[i]==orth)
+ if (_ortho_bases[i] == orth)
return i;
-
-
}
return 0;
}
-
-void Basis::set_orthogonal_index(int p_index){
+void Basis::set_orthogonal_index(int p_index) {
//there only exist 24 orthogonal bases in r3
ERR_FAIL_COND(p_index >= 24);
- *this=_ortho_bases[p_index];
-
+ *this = _ortho_bases[p_index];
}
+Basis::Basis(const Vector3 &p_euler) {
-
-Basis::Basis(const Vector3& p_euler) {
-
- set_euler( p_euler );
-
+ set_euler(p_euler);
}
-}
+} // namespace godot
#include "Quat.hpp"
namespace godot {
-Basis::Basis(const Quat& p_quat) {
+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;
- real_t wx = p_quat.w * xs, wy = p_quat.w * ys, wz = p_quat.w * zs;
- real_t xx = p_quat.x * xs, xy = p_quat.x * ys, xz = p_quat.x * zs;
- real_t yy = p_quat.y * ys, yz = p_quat.y * zs, zz = p_quat.z * zs;
- set( 1.0 - (yy + zz), xy - wz, xz + wy,
- xy + wz, 1.0 - (xx + zz), yz - wx,
- xz - wy, yz + wx, 1.0 - (xx + yy)) ;
-
+ real_t xs = p_quat.x * s, ys = p_quat.y * s, zs = p_quat.z * s;
+ real_t wx = p_quat.w * xs, wy = p_quat.w * ys, wz = p_quat.w * zs;
+ real_t xx = p_quat.x * xs, xy = p_quat.x * ys, xz = p_quat.x * zs;
+ real_t yy = p_quat.y * ys, yz = p_quat.y * zs, zz = p_quat.z * zs;
+ set(1.0 - (yy + zz), xy - wz, xz + wy,
+ xy + wz, 1.0 - (xx + zz), yz - wx,
+ xz - wy, yz + wx, 1.0 - (xx + yy));
}
-Basis::Basis(const Vector3& p_axis, real_t p_phi) {
+Basis::Basis(const Vector3 &p_axis, real_t p_phi) {
// Rotation matrix from axis and angle, see https://en.wikipedia.org/wiki/Rotation_matrix#Rotation_matrix_from_axis_and_angle
- Vector3 axis_sq(p_axis.x*p_axis.x,p_axis.y*p_axis.y,p_axis.z*p_axis.z);
-
- real_t cosine= ::cos(p_phi);
- real_t sine= ::sin(p_phi);
+ Vector3 axis_sq(p_axis.x * p_axis.x, p_axis.y * p_axis.y, p_axis.z * p_axis.z);
- elements[0][0] = axis_sq.x + cosine * ( 1.0 - axis_sq.x );
- elements[0][1] = p_axis.x * p_axis.y * ( 1.0 - cosine ) - p_axis.z * sine;
- elements[0][2] = p_axis.z * p_axis.x * ( 1.0 - cosine ) + p_axis.y * sine;
+ real_t cosine = ::cos(p_phi);
+ real_t sine = ::sin(p_phi);
- elements[1][0] = p_axis.x * p_axis.y * ( 1.0 - cosine ) + p_axis.z * sine;
- elements[1][1] = axis_sq.y + cosine * ( 1.0 - axis_sq.y );
- elements[1][2] = p_axis.y * p_axis.z * ( 1.0 - cosine ) - p_axis.x * sine;
+ elements[0][0] = axis_sq.x + cosine * (1.0 - axis_sq.x);
+ elements[0][1] = p_axis.x * p_axis.y * (1.0 - cosine) - p_axis.z * sine;
+ elements[0][2] = p_axis.z * p_axis.x * (1.0 - cosine) + p_axis.y * sine;
- elements[2][0] = p_axis.z * p_axis.x * ( 1.0 - cosine ) - p_axis.y * sine;
- elements[2][1] = p_axis.y * p_axis.z * ( 1.0 - cosine ) + p_axis.x * sine;
- elements[2][2] = axis_sq.z + cosine * ( 1.0 - axis_sq.z );
+ elements[1][0] = p_axis.x * p_axis.y * (1.0 - cosine) + p_axis.z * sine;
+ elements[1][1] = axis_sq.y + cosine * (1.0 - axis_sq.y);
+ elements[1][2] = p_axis.y * p_axis.z * (1.0 - cosine) - p_axis.x * sine;
+ elements[2][0] = p_axis.z * p_axis.x * (1.0 - cosine) - p_axis.y * sine;
+ elements[2][1] = p_axis.y * p_axis.z * (1.0 - cosine) + p_axis.x * sine;
+ elements[2][2] = axis_sq.z + cosine * (1.0 - axis_sq.z);
}
Basis::operator Quat() const {
@@ -722,21 +670,18 @@ Basis::operator Quat() const {
real_t trace = elements[0][0] + elements[1][1] + elements[2][2];
real_t temp[4];
- if (trace > 0.0)
- {
+ if (trace > 0.0) {
real_t s = ::sqrt(trace + 1.0);
- temp[3]=(s * 0.5);
+ temp[3] = (s * 0.5);
s = 0.5 / s;
- temp[0]=((elements[2][1] - elements[1][2]) * s);
- temp[1]=((elements[0][2] - elements[2][0]) * s);
- temp[2]=((elements[1][0] - elements[0][1]) * s);
- }
- else
- {
+ temp[0] = ((elements[2][1] - elements[1][2]) * s);
+ temp[1] = ((elements[0][2] - elements[2][0]) * s);
+ temp[2] = ((elements[1][0] - elements[0][1]) * s);
+ } else {
int i = elements[0][0] < elements[1][1] ?
- (elements[1][1] < elements[2][2] ? 2 : 1) :
- (elements[0][0] < elements[2][2] ? 2 : 0);
+ (elements[1][1] < elements[2][2] ? 2 : 1) :
+ (elements[0][0] < elements[2][2] ? 2 : 0);
int j = (i + 1) % 3;
int k = (i + 2) % 3;
@@ -749,11 +694,7 @@ Basis::operator Quat() const {
temp[k] = (elements[k][i] + elements[i][k]) * s;
}
- return Quat(temp[0],temp[1],temp[2],temp[3]);
-
+ return Quat(temp[0], temp[1], temp[2], temp[3]);
}
-
-
-
-}
+} // namespace godot
diff --git a/src/core/Color.cpp b/src/core/Color.cpp
index 3e9817c..a8e6651 100644
--- a/src/core/Color.cpp
+++ b/src/core/Color.cpp
@@ -12,138 +12,128 @@ namespace godot {
static String _to_hex(float p_val);
-static float _parse_col(const String& p_str, int p_ofs) {
+static float _parse_col(const String &p_str, int p_ofs) {
- int ig=0;
+ int ig = 0;
- for(int i=0;i<2;i++) {
+ for (int i = 0; i < 2; i++) {
- int c= (int) (wchar_t) p_str[i+p_ofs];
- int v=0;
+ int c = (int)(wchar_t)p_str[i + p_ofs];
+ int v = 0;
- if (c>='0' && c<='9') {
- v=c-'0';
- } else if (c>='a' && c<='f') {
- v=c-'a';
- v+=10;
- } else if (c>='A' && c<='F') {
- v=c-'A';
- v+=10;
+ if (c >= '0' && c <= '9') {
+ v = c - '0';
+ } else if (c >= 'a' && c <= 'f') {
+ v = c - 'a';
+ v += 10;
+ } else if (c >= 'A' && c <= 'F') {
+ v = c - 'A';
+ v += 10;
} else {
return -1;
}
- if (i==0)
- ig+=v*16;
+ if (i == 0)
+ ig += v * 16;
else
- ig+=v;
-
+ ig += v;
}
return ig;
-
}
-uint32_t Color::to_32() const
-{
+uint32_t Color::to_32() const {
- uint32_t c=(uint8_t)(a*255);
- c<<=8;
- c|=(uint8_t)(r*255);
- c<<=8;
- c|=(uint8_t)(g*255);
- c<<=8;
- c|=(uint8_t)(b*255);
+ uint32_t c = (uint8_t)(a * 255);
+ c <<= 8;
+ c |= (uint8_t)(r * 255);
+ c <<= 8;
+ c |= (uint8_t)(g * 255);
+ c <<= 8;
+ c |= (uint8_t)(b * 255);
return c;
}
-uint32_t Color::to_ARGB32() const
-{
- uint32_t c=(uint8_t)(a*255);
- c<<=8;
- c|=(uint8_t)(r*255);
- c<<=8;
- c|=(uint8_t)(g*255);
- c<<=8;
- c|=(uint8_t)(b*255);
+uint32_t Color::to_ARGB32() const {
+ uint32_t c = (uint8_t)(a * 255);
+ c <<= 8;
+ c |= (uint8_t)(r * 255);
+ c <<= 8;
+ c |= (uint8_t)(g * 255);
+ c <<= 8;
+ c |= (uint8_t)(b * 255);
return c;
}
-float Color::gray() const
-{
- return (r+g+b)/3.0;
+float Color::gray() const {
+ return (r + g + b) / 3.0;
}
-float Color::get_h() const
-{
+float Color::get_h() const {
- float min = MIN( r, g );
- min = MIN( min, b );
- float max = MAX( r, g );
- max = MAX( max, b );
+ float min = MIN(r, g);
+ min = MIN(min, b);
+ float max = MAX(r, g);
+ max = MAX(max, b);
float delta = max - min;
- if( delta == 0 )
+ if (delta == 0)
return 0;
float h;
- if( r == max )
- h = ( g - b ) / delta; // between yellow & magenta
- else if( g == max )
- h = 2 + ( b - r ) / delta; // between cyan & yellow
+ if (r == max)
+ h = (g - b) / delta; // between yellow & magenta
+ else if (g == max)
+ h = 2 + (b - r) / delta; // between cyan & yellow
else
- h = 4 + ( r - g ) / delta; // between magenta & cyan
+ h = 4 + (r - g) / delta; // between magenta & cyan
- h/=6.0;
- if (h<0)
- h+=1.0;
+ h /= 6.0;
+ if (h < 0)
+ h += 1.0;
return h;
}
-float Color::get_s() const
-{
- float min = MIN( r, g );
- min = MIN( min, b );
- float max = MAX( r, g );
- max = MAX( max, b );
+float Color::get_s() const {
+ float min = MIN(r, g);
+ min = MIN(min, b);
+ float max = MAX(r, g);
+ max = MAX(max, b);
float delta = max - min;
- return (max!=0) ? (delta / max) : 0;
-
+ return (max != 0) ? (delta / max) : 0;
}
-float Color::get_v() const
-{
- float max = MAX( r, g );
- max = MAX( max, b );
+float Color::get_v() const {
+ float max = MAX(r, g);
+ max = MAX(max, b);
return max;
}
-void Color::set_hsv(float p_h, float p_s, float p_v, float p_alpha)
-{
+void Color::set_hsv(float p_h, float p_s, float p_v, float p_alpha) {
int i;
float f, p, q, t;
- a=p_alpha;
+ a = p_alpha;
- if( p_s == 0 ) {
+ if (p_s == 0) {
// acp_hromatic (grey)
r = g = b = p_v;
return;
}
- p_h *=6.0;
- p_h = ::fmod(p_h,6);
- i = ::floor( p_h );
+ p_h *= 6.0;
+ p_h = ::fmod(p_h, 6);
+ i = ::floor(p_h);
f = p_h - i;
- p = p_v * ( 1 - p_s );
- q = p_v * ( 1 - p_s * f );
- t = p_v * ( 1 - p_s * ( 1 - f ) );
+ p = p_v * (1 - p_s);
+ q = p_v * (1 - p_s * f);
+ t = p_v * (1 - p_s * (1 - f));
- switch( i ) {
+ switch (i) {
case 0: // Red is the dominant color
r = p_v;
g = t;
@@ -177,56 +167,51 @@ void Color::set_hsv(float p_h, float p_s, float p_v, float p_alpha)
}
}
-void Color::invert()
-{
- r=1.0-r;
- g=1.0-g;
- b=1.0-b;
+void Color::invert() {
+ r = 1.0 - r;
+ g = 1.0 - g;
+ b = 1.0 - b;
}
-void Color::contrast()
-{
- r=::fmod(r+0.5,1.0);
- g=::fmod(g+0.5,1.0);
- b=::fmod(b+0.5,1.0);
+void Color::contrast() {
+ r = ::fmod(r + 0.5, 1.0);
+ g = ::fmod(g + 0.5, 1.0);
+ b = ::fmod(b + 0.5, 1.0);
}
-Color Color::inverted() const
-{
- Color c=*this;
+Color Color::inverted() const {
+ Color c = *this;
c.invert();
return c;
}
-Color Color::contrasted() const
-{
- Color c=*this;
+Color Color::contrasted() const {
+ Color c = *this;
c.contrast();
return c;
}
-Color Color::linear_interpolate(const Color& p_b, float p_t) const {
+Color Color::linear_interpolate(const Color &p_b, float p_t) const {
- Color res=*this;
+ Color res = *this;
- res.r+= (p_t * (p_b.r-r));
- res.g+= (p_t * (p_b.g-g));
- res.b+= (p_t * (p_b.b-b));
- res.a+= (p_t * (p_b.a-a));
+ res.r += (p_t * (p_b.r - r));
+ res.g += (p_t * (p_b.g - g));
+ res.b += (p_t * (p_b.b - b));
+ res.a += (p_t * (p_b.a - a));
return res;
}
-Color Color::blend(const Color& p_over) 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;
- if (res.a==0) {
- return Color(0,0,0,0);
+ res.a = a * sa + p_over.a;
+ if (res.a == 0) {
+ return Color(0, 0, 0, 0);
} else {
- res.r = (r*a*sa + p_over.r * p_over.a)/res.a;
- res.g = (g*a*sa + p_over.g * p_over.a)/res.a;
- res.b = (b*a*sa + p_over.b * p_over.a)/res.a;
+ res.r = (r * a * sa + p_over.r * p_over.a) / res.a;
+ res.g = (g * a * sa + p_over.g * p_over.a) / res.a;
+ res.b = (b * a * sa + p_over.b * p_over.a) / res.a;
}
return res;
}
@@ -234,114 +219,110 @@ 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),
- b<0.04045 ? b * (1.0 / 12.92) : ::pow((b + 0.055) * (1.0 / (1 + 0.055)), 2.4),
- a
- );
+ 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),
+ b < 0.04045 ? b * (1.0 / 12.92) : ::pow((b + 0.055) * (1.0 / (1 + 0.055)), 2.4),
+ a);
}
-Color Color::hex(uint32_t p_hex)
-{
- float a = (p_hex&0xFF)/255.0;
- p_hex>>=8;
- float b = (p_hex&0xFF)/255.0;
- p_hex>>=8;
- float g = (p_hex&0xFF)/255.0;
- p_hex>>=8;
- float r = (p_hex&0xFF)/255.0;
-
- return Color(r,g,b,a);
+Color Color::hex(uint32_t p_hex) {
+ float a = (p_hex & 0xFF) / 255.0;
+ p_hex >>= 8;
+ float b = (p_hex & 0xFF) / 255.0;
+ p_hex >>= 8;
+ float g = (p_hex & 0xFF) / 255.0;
+ p_hex >>= 8;
+ float r = (p_hex & 0xFF) / 255.0;
+
+ return Color(r, g, b, a);
}
-Color Color::html(const String& p_color)
-{
+Color Color::html(const String &p_color) {
String color = p_color;
- if (color.length()==0)
+ if (color.length() == 0)
return Color();
- if (color[0]=='#')
- color=color.substr(1,color.length()-1);
+ if (color[0] == '#')
+ color = color.substr(1, color.length() - 1);
- bool alpha=false;
+ bool alpha = false;
- if (color.length()==8) {
- alpha=true;
- } else if (color.length()==6) {
- alpha=false;
+ if (color.length() == 8) {
+ alpha = true;
+ } else if (color.length() == 6) {
+ alpha = false;
} else {
ERR_PRINTS(String("Invalid Color Code: ") + p_color);
ERR_FAIL_V(Color());
}
- int a=255;
+ int a = 255;
if (alpha) {
- a=_parse_col(color,0);
- if (a<0) {
+ a = _parse_col(color, 0);
+ if (a < 0) {
ERR_PRINTS(String("Invalid Color Code: ") + p_color);
ERR_FAIL_V(Color());
}
}
- int from=alpha?2:0;
+ int from = alpha ? 2 : 0;
- int r=_parse_col(color,from+0);
- if (r<0) {
+ int r = _parse_col(color, from + 0);
+ if (r < 0) {
ERR_PRINTS(String("Invalid Color Code: ") + p_color);
ERR_FAIL_V(Color());
}
- int g=_parse_col(color,from+2);
- if (g<0) {
+ int g = _parse_col(color, from + 2);
+ if (g < 0) {
ERR_PRINTS(String("Invalid Color Code: ") + p_color);
ERR_FAIL_V(Color());
}
- int b=_parse_col(color,from+4);
- if (b<0) {
+ int b = _parse_col(color, from + 4);
+ if (b < 0) {
ERR_PRINTS(String("Invalid Color Code: ") + p_color);
ERR_FAIL_V(Color());
}
- return Color(r/255.0,g/255.0,b/255.0,a/255.0);
+ return Color(r / 255.0, g / 255.0, b / 255.0, a / 255.0);
}
-bool Color::html_is_valid(const String& p_color)
-{
+bool Color::html_is_valid(const String &p_color) {
String color = p_color;
- if (color.length()==0)
+ if (color.length() == 0)
return false;
- if (color[0]=='#')
- color=color.substr(1,color.length()-1);
+ if (color[0] == '#')
+ color = color.substr(1, color.length() - 1);
- bool alpha=false;
+ bool alpha = false;
- if (color.length()==8) {
- alpha=true;
- } else if (color.length()==6) {
- alpha=false;
+ if (color.length() == 8) {
+ alpha = true;
+ } else if (color.length() == 6) {
+ alpha = false;
} else {
return false;
}
- int a=255;
+ int a = 255;
if (alpha) {
- a=_parse_col(color,0);
- if (a<0) {
+ a = _parse_col(color, 0);
+ if (a < 0) {
return false;
}
}
- int from=alpha?2:0;
+ int from = alpha ? 2 : 0;
- int r=_parse_col(color,from+0);
- if (r<0) {
+ int r = _parse_col(color, from + 0);
+ if (r < 0) {
return false;
}
- int g=_parse_col(color,from+2);
- if (g<0) {
+ int g = _parse_col(color, from + 2);
+ if (g < 0) {
return false;
}
- int b=_parse_col(color,from+4);
- if (b<0) {
+ int b = _parse_col(color, from + 4);
+ if (b < 0) {
return false;
}
@@ -349,62 +330,57 @@ bool Color::html_is_valid(const String& p_color)
}
#ifndef CLAMP
-#define CLAMP(m_a,m_min,m_max) (((m_a)<(m_min))?(m_min):(((m_a)>(m_max))?m_max:m_a))
+#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);
+ v = CLAMP(v, 0, 255);
String ret;
- for(int i=0;i<2;i++) {
+ for (int i = 0; i < 2; i++) {
- wchar_t c[2]={0,0};
- int lv = v&0xF;
- if (lv<10)
- c[0]='0'+lv;
+ wchar_t c[2] = { 0, 0 };
+ int lv = v & 0xF;
+ if (lv < 10)
+ c[0] = '0' + lv;
else
- c[0]='a'+lv-10;
+ c[0] = 'a' + lv - 10;
- v>>=4;
- String cs=(const wchar_t*)c;
+ v >>= 4;
+ String cs = (const wchar_t *)c;
ret = cs + ret;
}
return ret;
-
}
-String Color::to_html(bool p_alpha) const
-{
+String Color::to_html(bool p_alpha) const {
String txt;
- txt+=_to_hex(r);
- txt+=_to_hex(g);
- txt+=_to_hex(b);
+ txt += _to_hex(r);
+ txt += _to_hex(g);
+ txt += _to_hex(b);
if (p_alpha)
- txt=_to_hex(a)+txt;
+ txt = _to_hex(a) + txt;
return txt;
}
-Color::operator String() const
-{
+Color::operator String() const {
return String::num(r) + ", " + String::num(g) + ", " + String::num(b) + ", " + String::num(a);
}
+bool Color::operator<(const Color &p_color) const {
-bool Color::operator<(const Color& p_color) const {
-
- if (r==p_color.r) {
- if (g==p_color.g) {
- if(b==p_color.b) {
- return (a<p_color.a);
+ if (r == p_color.r) {
+ if (g == p_color.g) {
+ if (b == p_color.b) {
+ return (a < p_color.a);
} else
- return (b<p_color.b);
+ return (b < p_color.b);
} else
- return g<p_color.g;
+ return g < p_color.g;
} else
- return r<p_color.r;
-
+ return r < p_color.r;
}
-}
+} // namespace godot
diff --git a/src/core/Dictionary.cpp b/src/core/Dictionary.cpp
index bb40017..17f16a4 100644
--- a/src/core/Dictionary.cpp
+++ b/src/core/Dictionary.cpp
@@ -1,95 +1,78 @@
#include "Dictionary.hpp"
-#include "Variant.hpp"
#include "Array.hpp"
#include "GodotGlobal.hpp"
+#include "Variant.hpp"
namespace godot {
-Dictionary::Dictionary()
-{
+Dictionary::Dictionary() {
godot::api->godot_dictionary_new(&_godot_dictionary);
}
-Dictionary::Dictionary(const Dictionary & other)
-{
+Dictionary::Dictionary(const Dictionary &other) {
godot::api->godot_dictionary_new_copy(&_godot_dictionary, &other._godot_dictionary);
}
-Dictionary & Dictionary::operator=(const Dictionary & other)
-{
+Dictionary &Dictionary::operator=(const Dictionary &other) {
godot::api->godot_dictionary_destroy(&_godot_dictionary);
godot::api->godot_dictionary_new_copy(&_godot_dictionary, &other._godot_dictionary);
return *this;
}
-void Dictionary::clear()
-{
+void Dictionary::clear() {
godot::api->godot_dictionary_clear(&_godot_dictionary);
}
-bool Dictionary::empty() const
-{
+bool Dictionary::empty() const {
return godot::api->godot_dictionary_empty(&_godot_dictionary);
}
-void Dictionary::erase(const Variant& key)
-{
- godot::api->godot_dictionary_erase(&_godot_dictionary, (godot_variant *) &key);
+void Dictionary::erase(const Variant &key) {
+ godot::api->godot_dictionary_erase(&_godot_dictionary, (godot_variant *)&key);
}
-bool Dictionary::has(const Variant& key) const
-{
- return godot::api->godot_dictionary_has(&_godot_dictionary, (godot_variant *) &key);
+bool Dictionary::has(const Variant &key) const {
+ return godot::api->godot_dictionary_has(&_godot_dictionary, (godot_variant *)&key);
}
-bool Dictionary::has_all(const Array& keys) const
-{
- return godot::api->godot_dictionary_has_all(&_godot_dictionary, (godot_array *) &keys);
+bool Dictionary::has_all(const Array &keys) const {
+ return godot::api->godot_dictionary_has_all(&_godot_dictionary, (godot_array *)&keys);
}
-uint32_t Dictionary::hash() const
-{
+uint32_t Dictionary::hash() const {
return godot::api->godot_dictionary_hash(&_godot_dictionary);
}
-Array Dictionary::keys() const
-{
+Array Dictionary::keys() const {
godot_array a = godot::api->godot_dictionary_keys(&_godot_dictionary);
- return *(Array *) &a;
+ return *(Array *)&a;
}
-Variant &Dictionary::operator [](const Variant& key)
-{
- return *(Variant *) godot::api->godot_dictionary_operator_index(&_godot_dictionary, (godot_variant *) &key);
+Variant &Dictionary::operator[](const Variant &key) {
+ return *(Variant *)godot::api->godot_dictionary_operator_index(&_godot_dictionary, (godot_variant *)&key);
}
-const Variant &Dictionary::operator [](const Variant& key) const
-{
+const Variant &Dictionary::operator[](const Variant &key) const {
// oops I did it again
- return *(Variant *) godot::api->godot_dictionary_operator_index((godot_dictionary *) &_godot_dictionary, (godot_variant *) &key);
+ return *(Variant *)godot::api->godot_dictionary_operator_index((godot_dictionary *)&_godot_dictionary, (godot_variant *)&key);
}
-int Dictionary::size() const
-{
+int Dictionary::size() const {
return godot::api->godot_dictionary_size(&_godot_dictionary);
}
-String Dictionary::to_json() const
-{
+String Dictionary::to_json() const {
godot_string s = godot::api->godot_dictionary_to_json(&_godot_dictionary);
- return *(String *) &s;
+ return *(String *)&s;
}
-Array Dictionary::values() const
-{
+Array Dictionary::values() const {
godot_array a = godot::api->godot_dictionary_values(&_godot_dictionary);
- return *(Array *) &a;
+ return *(Array *)&a;
}
-Dictionary::~Dictionary()
-{
+Dictionary::~Dictionary() {
godot::api->godot_dictionary_destroy(&_godot_dictionary);
}
-
-}
+} // namespace godot
diff --git a/src/core/GodotGlobal.cpp b/src/core/GodotGlobal.cpp
index 37a8bf5..23054cf 100644
--- a/src/core/GodotGlobal.cpp
+++ b/src/core/GodotGlobal.cpp
@@ -4,20 +4,18 @@
#include "Wrapped.hpp"
-static GDCALLINGCONV void *wrapper_create(void *data, const void *type_tag, godot_object *instance)
-{
- godot::_Wrapped *wrapper_memory = (godot::_Wrapped *) godot::api->godot_alloc(sizeof(godot::_Wrapped));
+static GDCALLINGCONV void *wrapper_create(void *data, const void *type_tag, godot_object *instance) {
+ godot::_Wrapped *wrapper_memory = (godot::_Wrapped *)godot::api->godot_alloc(sizeof(godot::_Wrapped));
if (!wrapper_memory)
return NULL;
wrapper_memory->_owner = instance;
- wrapper_memory->_type_tag = (size_t) type_tag;
+ wrapper_memory->_type_tag = (size_t)type_tag;
- return (void *) wrapper_memory;
+ return (void *)wrapper_memory;
}
-static GDCALLINGCONV void wrapper_destroy(void *data, void *wrapper)
-{
+static GDCALLINGCONV void wrapper_destroy(void *data, void *wrapper) {
if (wrapper)
godot::api->godot_free(wrapper);
}
@@ -32,20 +30,18 @@ const godot_gdnative_ext_nativescript_1_1_api_struct *nativescript_1_1_api = nul
const void *gdnlib = NULL;
-void Godot::print(const String& message)
-{
- godot::api->godot_print((godot_string *) &message);
+void Godot::print(const String &message) {
+ godot::api->godot_print((godot_string *)&message);
}
-void Godot::print_warning(const String& description, const String& function, const String& file, int line)
-{
+void Godot::print_warning(const String &description, const String &function, const String &file, int line) {
int len;
- char * c_desc = description.alloc_c_string();
- char * c_func = function.alloc_c_string();
- char * c_file = file.alloc_c_string();
+ char *c_desc = description.alloc_c_string();
+ char *c_func = function.alloc_c_string();
+ char *c_file = file.alloc_c_string();
- if (c_desc != nullptr && c_func !=nullptr && c_file != nullptr) {
+ if (c_desc != nullptr && c_func != nullptr && c_file != nullptr) {
godot::api->godot_print_warning(c_desc, c_func, c_file, line);
};
@@ -54,15 +50,14 @@ void Godot::print_warning(const String& description, const String& function, con
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)
-{
+void Godot::print_error(const String &description, const String &function, const String &file, int line) {
int len;
- char * c_desc = description.alloc_c_string();
- char * c_func = function.alloc_c_string();
- char * c_file = file.alloc_c_string();
+ char *c_desc = description.alloc_c_string();
+ char *c_func = function.alloc_c_string();
+ char *c_file = file.alloc_c_string();
- if (c_desc != nullptr && c_func !=nullptr && c_file != nullptr) {
+ if (c_desc != nullptr && c_func != nullptr && c_file != nullptr) {
godot::api->godot_print_error(c_desc, c_func, c_file, line);
};
@@ -73,22 +68,21 @@ void Godot::print_error(const String& description, const String& function, const
void ___register_types();
-void Godot::gdnative_init(godot_gdnative_init_options *options)
-{
+void Godot::gdnative_init(godot_gdnative_init_options *options) {
godot::api = options->api_struct;
godot::gdnlib = options->gd_native_library;
// now find our extensions
for (int i = 0; i < godot::api->num_extensions; i++) {
switch (godot::api->extensions[i]->type) {
- case GDNATIVE_EXT_NATIVESCRIPT: {
- godot::nativescript_api = (const godot_gdnative_ext_nativescript_api_struct *)godot::api->extensions[i];
+ case GDNATIVE_EXT_NATIVESCRIPT: {
+ godot::nativescript_api = (const godot_gdnative_ext_nativescript_api_struct *)godot::api->extensions[i];
const godot_gdnative_api_struct *extension = godot::nativescript_api->next;
while (extension) {
if (extension->version.major == 1 && extension->version.minor == 1) {
- godot::nativescript_1_1_api = (const godot_gdnative_ext_nativescript_1_1_api_struct *) extension;
+ godot::nativescript_1_1_api = (const godot_gdnative_ext_nativescript_1_1_api_struct *)extension;
}
extension = extension->next;
@@ -97,16 +91,13 @@ void Godot::gdnative_init(godot_gdnative_init_options *options)
default: break;
}
}
-
}
-void Godot::gdnative_terminate(godot_gdnative_terminate_options *options)
-{
+void Godot::gdnative_terminate(godot_gdnative_terminate_options *options) {
// reserved for future use.
}
-void Godot::nativescript_init(void *handle)
-{
+void Godot::nativescript_init(void *handle) {
godot::_RegisterState::nativescript_handle = handle;
godot_instance_binding_functions binding_funcs = {};
@@ -118,9 +109,8 @@ void Godot::nativescript_init(void *handle)
___register_types();
}
-void Godot::nativescript_terminate(void *handle)
-{
+void Godot::nativescript_terminate(void *handle) {
godot::nativescript_1_1_api->godot_nativescript_unregister_instance_binding_data_functions(godot::_RegisterState::language_index);
}
-}
+} // namespace godot
diff --git a/src/core/NodePath.cpp b/src/core/NodePath.cpp
index b1fb9cc..021bf35 100644
--- a/src/core/NodePath.cpp
+++ b/src/core/NodePath.cpp
@@ -1,94 +1,77 @@
#include "NodePath.hpp"
-#include "String.hpp"
#include "GodotGlobal.hpp"
+#include "String.hpp"
#include <gdnative/node_path.h>
namespace godot {
-
-NodePath::NodePath()
-{
+NodePath::NodePath() {
String from = "";
- godot::api->godot_node_path_new(&_node_path, (godot_string *) &from);
+ godot::api->godot_node_path_new(&_node_path, (godot_string *)&from);
}
-NodePath::NodePath(const NodePath &other)
-{
+NodePath::NodePath(const NodePath &other) {
String from = other;
- godot::api->godot_node_path_new(&_node_path, (godot_string *) &from);
+ godot::api->godot_node_path_new(&_node_path, (godot_string *)&from);
}
-NodePath::NodePath(const String &from)
-{
- godot::api->godot_node_path_new(&_node_path, (godot_string *) &from);
+NodePath::NodePath(const String &from) {
+ godot::api->godot_node_path_new(&_node_path, (godot_string *)&from);
}
-NodePath::NodePath(const char *contents)
-{
+NodePath::NodePath(const char *contents) {
String from = contents;
- godot::api->godot_node_path_new(&_node_path, (godot_string *) &from);
+ godot::api->godot_node_path_new(&_node_path, (godot_string *)&from);
}
-String NodePath::get_name(const int idx) const
-{
+String NodePath::get_name(const int idx) const {
godot_string str = godot::api->godot_node_path_get_name(&_node_path, idx);
- return *(String *) &str;
+ return *(String *)&str;
}
-int NodePath::get_name_count() const
-{
+int NodePath::get_name_count() const {
return godot::api->godot_node_path_get_name_count(&_node_path);
}
-String NodePath::get_subname(const int idx) const
-{
+String NodePath::get_subname(const int idx) const {
godot_string str = godot::api->godot_node_path_get_subname(&_node_path, idx);
- return *(String *) &str;
+ return *(String *)&str;
}
-int NodePath::get_subname_count() const
-{
+int NodePath::get_subname_count() const {
return godot::api->godot_node_path_get_subname_count(&_node_path);
}
-bool NodePath::is_absolute() const
-{
+bool NodePath::is_absolute() const {
return godot::api->godot_node_path_is_absolute(&_node_path);
}
-bool NodePath::is_empty() const
-{
+bool NodePath::is_empty() const {
return godot::api->godot_node_path_is_empty(&_node_path);
}
-NodePath::operator String() const
-{
+NodePath::operator String() const {
godot_string str = godot::api->godot_node_path_as_string(&_node_path);
- return *(String *) &str;
+ return *(String *)&str;
}
-bool NodePath::operator ==(const NodePath& other)
-{
+bool NodePath::operator==(const NodePath &other) {
return godot::api->godot_node_path_operator_equal(&_node_path, &other._node_path);
}
-void NodePath::operator =(const NodePath& other)
-{
+void NodePath::operator=(const NodePath &other) {
godot::api->godot_node_path_destroy(&_node_path);
- String other_string = (String) other;
+ String other_string = (String)other;
- godot::api->godot_node_path_new(&_node_path, (godot_string *) &other_string);
+ godot::api->godot_node_path_new(&_node_path, (godot_string *)&other_string);
}
-NodePath::~NodePath()
-{
+NodePath::~NodePath() {
godot::api->godot_node_path_destroy(&_node_path);
}
-
-
-}
+} // namespace godot
diff --git a/src/core/Plane.cpp b/src/core/Plane.cpp
index a01928c..8e5e30b 100644
--- a/src/core/Plane.cpp
+++ b/src/core/Plane.cpp
@@ -5,27 +5,24 @@
namespace godot {
-
-void Plane::set_normal(const Vector3& p_normal)
-{
+void Plane::set_normal(const Vector3 &p_normal) {
this->normal = p_normal;
}
-Vector3 Plane::project(const Vector3& p_point) const {
+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);
+ if (l == 0) {
+ *this = Plane(0, 0, 0, 0);
return;
}
- normal/=l;
- d/=l;
+ normal /= l;
+ d /= l;
}
Plane Plane::normalized() const {
@@ -37,96 +34,95 @@ Plane Plane::normalized() const {
Vector3 Plane::get_any_point() const {
- return get_normal()*d;
+ 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);
+ static const Vector3 p1 = Vector3(1, 0, 0);
+ static const Vector3 p2 = Vector3(0, 1, 0);
Vector3 p;
if (::fabs(normal.dot(p1)) > 0.99) // if too similar to p1
- p=p2; // use p2
+ p = p2; // use p2
else
- p=p1; // use p1
+ p = p1; // use p1
- p-=normal * normal.dot(p);
+ p -= normal * normal.dot(p);
p.normalize();
return p;
}
-
/* 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;
- Vector3 normal2=p_plane2.normal;
+ const Plane &p_plane0 = *this;
+ Vector3 normal0 = p_plane0.normal;
+ Vector3 normal1 = p_plane1.normal;
+ Vector3 normal2 = p_plane2.normal;
- real_t denom=vec3_cross(normal0,normal1).dot(normal2);
+ real_t denom = vec3_cross(normal0, normal1).dot(normal2);
- if (::fabs(denom)<=CMP_EPSILON)
+ if (::fabs(denom) <= CMP_EPSILON)
return false;
if (r_result) {
- *r_result = ( (vec3_cross(normal1, normal2) * p_plane0.d) +
- (vec3_cross(normal2, normal0) * p_plane1.d) +
- (vec3_cross(normal0, normal1) * p_plane2.d) )/denom;
+ *r_result = ((vec3_cross(normal1, normal2) * p_plane0.d) +
+ (vec3_cross(normal2, normal0) * p_plane1.d) +
+ (vec3_cross(normal0, normal1) * p_plane2.d)) /
+ denom;
}
return true;
}
+bool Plane::intersects_ray(Vector3 p_from, Vector3 p_dir, Vector3 *p_intersection) const {
-bool Plane::intersects_ray(Vector3 p_from, Vector3 p_dir, Vector3* p_intersection) const {
-
- Vector3 segment=p_dir;
- real_t den=normal.dot( segment );
+ Vector3 segment = p_dir;
+ real_t den = normal.dot(segment);
//printf("den is %i\n",den);
- if (::fabs(den)<=CMP_EPSILON) {
+ if (::fabs(den) <= CMP_EPSILON) {
return false;
}
- real_t dist=(normal.dot( p_from ) - d) / den;
+ real_t dist = (normal.dot(p_from) - d) / den;
//printf("dist is %i\n",dist);
- if (dist>CMP_EPSILON) { //this is a ray, before the emiting pos (p_from) doesnt exist
+ if (dist > CMP_EPSILON) { //this is a ray, before the emiting pos (p_from) doesnt exist
return false;
}
- dist=-dist;
+ dist = -dist;
*p_intersection = p_from + segment * dist;
return true;
}
-bool Plane::intersects_segment(Vector3 p_begin, Vector3 p_end, Vector3* p_intersection) const {
+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 );
+ Vector3 segment = p_begin - p_end;
+ real_t den = normal.dot(segment);
//printf("den is %i\n",den);
- if (::fabs(den)<=CMP_EPSILON) {
+ if (::fabs(den) <= CMP_EPSILON) {
return false;
}
- real_t dist=(normal.dot( p_begin ) - d) / den;
+ real_t dist = (normal.dot(p_begin) - d) / den;
//printf("dist is %i\n",dist);
- if (dist<-CMP_EPSILON || dist > (1.0 +CMP_EPSILON)) {
+ if (dist < -CMP_EPSILON || dist > (1.0 + CMP_EPSILON)) {
return false;
}
- dist=-dist;
+ dist = -dist;
*p_intersection = p_begin + segment * dist;
return true;
@@ -134,20 +130,17 @@ bool Plane::intersects_segment(Vector3 p_begin, Vector3 p_end, Vector3* p_inters
/* misc */
-bool Plane::is_almost_like(const Plane& p_plane) const {
+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);
+ 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);
@@ -155,55 +148,47 @@ bool Plane::is_point_over(const Vector3 &p_point) const {
real_t Plane::distance_to(const Vector3 &p_point) const {
- return (normal.dot(p_point)-d);
+ 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);
+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;
+ normal = p_normal;
+ d = p_d;
}
-Plane::Plane(const Vector3 &p_point, const Vector3& p_normal) {
+Plane::Plane(const Vector3 &p_point, const Vector3 &p_normal) {
- normal=p_normal;
- d=p_normal.dot(p_point);
+ 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) {
+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);
+ normal = (p_point1 - p_point3).cross(p_point1 - p_point2);
else
- normal=(p_point1-p_point2).cross(p_point1-p_point3);
-
+ normal = (p_point1 - p_point2).cross(p_point1 - p_point3);
normal.normalize();
d = normal.dot(p_point1);
-
-
}
-bool Plane::operator==(const Plane& p_plane) const {
+bool Plane::operator==(const Plane &p_plane) const {
- return normal==p_plane.normal && d == p_plane.d;
+ 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;
+bool Plane::operator!=(const Plane &p_plane) const {
+ return normal != p_plane.normal || d != p_plane.d;
}
-
-
-
-}
+} // namespace godot
diff --git a/src/core/PoolArrays.cpp b/src/core/PoolArrays.cpp
index 7f82720..2667c09 100644
--- a/src/core/PoolArrays.cpp
+++ b/src/core/PoolArrays.cpp
@@ -1,679 +1,541 @@
#include "PoolArrays.hpp"
+#include "Color.hpp"
#include "Defs.hpp"
+#include "GodotGlobal.hpp"
#include "String.hpp"
-#include "Color.hpp"
#include "Vector2.hpp"
#include "Vector3.hpp"
-#include "GodotGlobal.hpp"
#include <gdnative/pool_arrays.h>
namespace godot {
-PoolByteArray::PoolByteArray()
-{
+PoolByteArray::PoolByteArray() {
godot::api->godot_pool_byte_array_new(&_godot_array);
}
-PoolByteArray::PoolByteArray(const PoolByteArray &p_other)
-{
+PoolByteArray::PoolByteArray(const PoolByteArray &p_other) {
godot::api->godot_pool_byte_array_new_copy(&_godot_array, &p_other._godot_array);
}
-PoolByteArray &PoolByteArray::operator=(const PoolByteArray & p_other)
-{
+PoolByteArray &PoolByteArray::operator=(const PoolByteArray &p_other) {
godot::api->godot_pool_byte_array_destroy(&_godot_array);
godot::api->godot_pool_byte_array_new_copy(&_godot_array, &p_other._godot_array);
return *this;
}
-PoolByteArray::PoolByteArray(const Array& array)
-{
- godot::api->godot_pool_byte_array_new_with_array(&_godot_array, (godot_array *) &array);
+PoolByteArray::PoolByteArray(const Array &array) {
+ godot::api->godot_pool_byte_array_new_with_array(&_godot_array, (godot_array *)&array);
}
-PoolByteArray::Read PoolByteArray::read() const
-{
+PoolByteArray::Read PoolByteArray::read() const {
Read read;
read._read_access = godot::api->godot_pool_byte_array_read(&_godot_array);
return read;
}
-PoolByteArray::Write PoolByteArray::write()
-{
+PoolByteArray::Write PoolByteArray::write() {
Write write;
write._write_access = godot::api->godot_pool_byte_array_write(&_godot_array);
return write;
}
-void PoolByteArray::append(const uint8_t data)
-{
+void PoolByteArray::append(const uint8_t data) {
godot::api->godot_pool_byte_array_append(&_godot_array, data);
}
-void PoolByteArray::append_array(const PoolByteArray& array)
-{
+void PoolByteArray::append_array(const PoolByteArray &array) {
godot::api->godot_pool_byte_array_append_array(&_godot_array, &array._godot_array);
}
-int PoolByteArray::insert(const int idx, const uint8_t data)
-{
+int PoolByteArray::insert(const int idx, const uint8_t data) {
return godot::api->godot_pool_byte_array_insert(&_godot_array, idx, data);
}
-void PoolByteArray::invert()
-{
+void PoolByteArray::invert() {
godot::api->godot_pool_byte_array_invert(&_godot_array);
}
-void PoolByteArray::push_back(const uint8_t data)
-{
+void PoolByteArray::push_back(const uint8_t data) {
godot::api->godot_pool_byte_array_push_back(&_godot_array, data);
}
-void PoolByteArray::remove(const int idx)
-{
+void PoolByteArray::remove(const int idx) {
godot::api->godot_pool_byte_array_remove(&_godot_array, idx);
}
-void PoolByteArray::resize(const int size)
-{
+void PoolByteArray::resize(const int size) {
godot::api->godot_pool_byte_array_resize(&_godot_array, size);
}
-void PoolByteArray::set(const int idx, const uint8_t data)
-{
+void PoolByteArray::set(const int idx, const uint8_t data) {
godot::api->godot_pool_byte_array_set(&_godot_array, idx, data);
}
-uint8_t PoolByteArray::operator [](const int idx)
-{
+uint8_t PoolByteArray::operator[](const int idx) {
return godot::api->godot_pool_byte_array_get(&_godot_array, idx);
}
-int PoolByteArray::size() const
-{
+int PoolByteArray::size() const {
return godot::api->godot_pool_byte_array_size(&_godot_array);
}
-
-PoolByteArray::~PoolByteArray()
-{
+PoolByteArray::~PoolByteArray() {
godot::api->godot_pool_byte_array_destroy(&_godot_array);
}
-
-
-PoolIntArray::PoolIntArray()
-{
+PoolIntArray::PoolIntArray() {
godot::api->godot_pool_int_array_new(&_godot_array);
}
-PoolIntArray::PoolIntArray(const PoolIntArray &p_other)
-{
+PoolIntArray::PoolIntArray(const PoolIntArray &p_other) {
godot::api->godot_pool_int_array_new_copy(&_godot_array, &p_other._godot_array);
}
-PoolIntArray &PoolIntArray::operator=(const PoolIntArray &p_other)
-{
+PoolIntArray &PoolIntArray::operator=(const PoolIntArray &p_other) {
godot::api->godot_pool_int_array_destroy(&_godot_array);
godot::api->godot_pool_int_array_new_copy(&_godot_array, &p_other._godot_array);
return *this;
}
-PoolIntArray::PoolIntArray(const Array& array)
-{
- godot::api->godot_pool_int_array_new_with_array(&_godot_array, (godot_array *) &array);
+PoolIntArray::PoolIntArray(const Array &array) {
+ godot::api->godot_pool_int_array_new_with_array(&_godot_array, (godot_array *)&array);
}
-PoolIntArray::Read PoolIntArray::read() const
-{
+PoolIntArray::Read PoolIntArray::read() const {
Read read;
read._read_access = godot::api->godot_pool_int_array_read(&_godot_array);
return read;
}
-PoolIntArray::Write PoolIntArray::write()
-{
+PoolIntArray::Write PoolIntArray::write() {
Write write;
write._write_access = godot::api->godot_pool_int_array_write(&_godot_array);
return write;
}
-void PoolIntArray::append(const int data)
-{
+void PoolIntArray::append(const int data) {
godot::api->godot_pool_int_array_append(&_godot_array, data);
}
-void PoolIntArray::append_array(const PoolIntArray& array)
-{
+void PoolIntArray::append_array(const PoolIntArray &array) {
godot::api->godot_pool_int_array_append_array(&_godot_array, &array._godot_array);
}
-int PoolIntArray::insert(const int idx, const int data)
-{
+int PoolIntArray::insert(const int idx, const int data) {
return godot::api->godot_pool_int_array_insert(&_godot_array, idx, data);
}
-void PoolIntArray::invert()
-{
+void PoolIntArray::invert() {
godot::api->godot_pool_int_array_invert(&_godot_array);
}
-void PoolIntArray::push_back(const int data)
-{
+void PoolIntArray::push_back(const int data) {
godot::api->godot_pool_int_array_push_back(&_godot_array, data);
}
-void PoolIntArray::remove(const int idx)
-{
+void PoolIntArray::remove(const int idx) {
godot::api->godot_pool_int_array_remove(&_godot_array, idx);
}
-void PoolIntArray::resize(const int size)
-{
+void PoolIntArray::resize(const int size) {
godot::api->godot_pool_int_array_resize(&_godot_array, size);
}
-void PoolIntArray::set(const int idx, const int data)
-{
+void PoolIntArray::set(const int idx, const int data) {
godot::api->godot_pool_int_array_set(&_godot_array, idx, data);
}
-int PoolIntArray::operator [](const int idx)
-{
+int PoolIntArray::operator[](const int idx) {
return godot::api->godot_pool_int_array_get(&_godot_array, idx);
}
-int PoolIntArray::size() const
-{
+int PoolIntArray::size() const {
return godot::api->godot_pool_int_array_size(&_godot_array);
}
-
-PoolIntArray::~PoolIntArray()
-{
+PoolIntArray::~PoolIntArray() {
godot::api->godot_pool_int_array_destroy(&_godot_array);
}
-
-PoolRealArray::PoolRealArray()
-{
+PoolRealArray::PoolRealArray() {
godot::api->godot_pool_real_array_new(&_godot_array);
}
-PoolRealArray::PoolRealArray(const PoolRealArray &p_other)
-{
+PoolRealArray::PoolRealArray(const PoolRealArray &p_other) {
godot::api->godot_pool_real_array_new_copy(&_godot_array, &p_other._godot_array);
}
-PoolRealArray &PoolRealArray::operator=(const PoolRealArray &p_other)
-{
+PoolRealArray &PoolRealArray::operator=(const PoolRealArray &p_other) {
godot::api->godot_pool_real_array_destroy(&_godot_array);
godot::api->godot_pool_real_array_new_copy(&_godot_array, &p_other._godot_array);
return *this;
}
-PoolRealArray::Read PoolRealArray::read() const
-{
+PoolRealArray::Read PoolRealArray::read() const {
Read read;
read._read_access = godot::api->godot_pool_real_array_read(&_godot_array);
return read;
}
-PoolRealArray::Write PoolRealArray::write()
-{
+PoolRealArray::Write PoolRealArray::write() {
Write write;
write._write_access = godot::api->godot_pool_real_array_write(&_godot_array);
return write;
}
-PoolRealArray::PoolRealArray(const Array& array)
-{
- godot::api->godot_pool_real_array_new_with_array(&_godot_array, (godot_array *) &array);
+PoolRealArray::PoolRealArray(const Array &array) {
+ godot::api->godot_pool_real_array_new_with_array(&_godot_array, (godot_array *)&array);
}
-void PoolRealArray::append(const real_t data)
-{
+void PoolRealArray::append(const real_t data) {
godot::api->godot_pool_real_array_append(&_godot_array, data);
}
-void PoolRealArray::append_array(const PoolRealArray& array)
-{
+void PoolRealArray::append_array(const PoolRealArray &array) {
godot::api->godot_pool_real_array_append_array(&_godot_array, &array._godot_array);
}
-int PoolRealArray::insert(const int idx, const real_t data)
-{
+int PoolRealArray::insert(const int idx, const real_t data) {
return godot::api->godot_pool_real_array_insert(&_godot_array, idx, data);
}
-void PoolRealArray::invert()
-{
+void PoolRealArray::invert() {
godot::api->godot_pool_real_array_invert(&_godot_array);
}
-void PoolRealArray::push_back(const real_t data)
-{
+void PoolRealArray::push_back(const real_t data) {
godot::api->godot_pool_real_array_push_back(&_godot_array, data);
}
-void PoolRealArray::remove(const int idx)
-{
+void PoolRealArray::remove(const int idx) {
godot::api->godot_pool_real_array_remove(&_godot_array, idx);
}
-void PoolRealArray::resize(const int size)
-{
+void PoolRealArray::resize(const int size) {
godot::api->godot_pool_real_array_resize(&_godot_array, size);
}
-void PoolRealArray::set(const int idx, const real_t data)
-{
+void PoolRealArray::set(const int idx, const real_t data) {
godot::api->godot_pool_real_array_set(&_godot_array, idx, data);
}
-real_t PoolRealArray::operator [](const int idx)
-{
+real_t PoolRealArray::operator[](const int idx) {
return godot::api->godot_pool_real_array_get(&_godot_array, idx);
}
-int PoolRealArray::size() const
-{
+int PoolRealArray::size() const {
return godot::api->godot_pool_real_array_size(&_godot_array);
}
-
-PoolRealArray::~PoolRealArray()
-{
+PoolRealArray::~PoolRealArray() {
godot::api->godot_pool_real_array_destroy(&_godot_array);
}
-
-
-PoolStringArray::PoolStringArray()
-{
+PoolStringArray::PoolStringArray() {
godot::api->godot_pool_string_array_new(&_godot_array);
}
-PoolStringArray::PoolStringArray(const PoolStringArray &p_other)
-{
+PoolStringArray::PoolStringArray(const PoolStringArray &p_other) {
godot::api->godot_pool_string_array_new_copy(&_godot_array, &p_other._godot_array);
}
-PoolStringArray &PoolStringArray::operator=(const PoolStringArray &p_other)
-{
+PoolStringArray &PoolStringArray::operator=(const PoolStringArray &p_other) {
godot::api->godot_pool_string_array_destroy(&_godot_array);
godot::api->godot_pool_string_array_new_copy(&_godot_array, &p_other._godot_array);
return *this;
}
-PoolStringArray::PoolStringArray(const Array& array)
-{
- godot::api->godot_pool_string_array_new_with_array(&_godot_array, (godot_array *) &array);
+PoolStringArray::PoolStringArray(const Array &array) {
+ godot::api->godot_pool_string_array_new_with_array(&_godot_array, (godot_array *)&array);
}
-PoolStringArray::Read PoolStringArray::read() const
-{
+PoolStringArray::Read PoolStringArray::read() const {
Read read;
read._read_access = godot::api->godot_pool_string_array_read(&_godot_array);
return read;
}
-PoolStringArray::Write PoolStringArray::write()
-{
+PoolStringArray::Write PoolStringArray::write() {
Write write;
write._write_access = godot::api->godot_pool_string_array_write(&_godot_array);
return write;
}
-void PoolStringArray::append(const String& data)
-{
- godot::api->godot_pool_string_array_append(&_godot_array, (godot_string *) &data);
+void PoolStringArray::append(const String &data) {
+ godot::api->godot_pool_string_array_append(&_godot_array, (godot_string *)&data);
}
-void PoolStringArray::append_array(const PoolStringArray& array)
-{
+void PoolStringArray::append_array(const PoolStringArray &array) {
godot::api->godot_pool_string_array_append_array(&_godot_array, &array._godot_array);
}
-int PoolStringArray::insert(const int idx, const String& data)
-{
- return godot::api->godot_pool_string_array_insert(&_godot_array, idx, (godot_string *) &data);
+int PoolStringArray::insert(const int idx, const String &data) {
+ return godot::api->godot_pool_string_array_insert(&_godot_array, idx, (godot_string *)&data);
}
-void PoolStringArray::invert()
-{
+void PoolStringArray::invert() {
godot::api->godot_pool_string_array_invert(&_godot_array);
}
-void PoolStringArray::push_back(const String& data)
-{
- godot::api->godot_pool_string_array_push_back(&_godot_array, (godot_string *) &data);
+void PoolStringArray::push_back(const String &data) {
+ godot::api->godot_pool_string_array_push_back(&_godot_array, (godot_string *)&data);
}
-void PoolStringArray::remove(const int idx)
-{
+void PoolStringArray::remove(const int idx) {
godot::api->godot_pool_string_array_remove(&_godot_array, idx);
}
-void PoolStringArray::resize(const int size)
-{
+void PoolStringArray::resize(const int size) {
godot::api->godot_pool_string_array_resize(&_godot_array, size);
}
-void PoolStringArray::set(const int idx, const String& data)
-{
- godot::api->godot_pool_string_array_set(&_godot_array, idx, (godot_string *) &data);
+void PoolStringArray::set(const int idx, const String &data) {
+ godot::api->godot_pool_string_array_set(&_godot_array, idx, (godot_string *)&data);
}
-const String PoolStringArray::operator [](const int idx)
-{
+const String PoolStringArray::operator[](const int idx) {
String s;
godot_string str = godot::api->godot_pool_string_array_get(&_godot_array, idx);
- godot::api->godot_string_new_copy((godot_string *) &s, &str);
+ godot::api->godot_string_new_copy((godot_string *)&s, &str);
godot::api->godot_string_destroy(&str);
return s;
}
-int PoolStringArray::size() const
-{
+int PoolStringArray::size() const {
return godot::api->godot_pool_string_array_size(&_godot_array);
}
-
-PoolStringArray::~PoolStringArray()
-{
+PoolStringArray::~PoolStringArray() {
godot::api->godot_pool_string_array_destroy(&_godot_array);
}
-
-
-PoolVector2Array::PoolVector2Array()
-{
+PoolVector2Array::PoolVector2Array() {
godot::api->godot_pool_vector2_array_new(&_godot_array);
}
-PoolVector2Array::PoolVector2Array(const PoolVector2Array &p_other)
-{
+PoolVector2Array::PoolVector2Array(const PoolVector2Array &p_other) {
godot::api->godot_pool_vector2_array_new_copy(&_godot_array, &p_other._godot_array);
}
-PoolVector2Array &PoolVector2Array::operator=(const PoolVector2Array &p_other)
-{
+PoolVector2Array &PoolVector2Array::operator=(const PoolVector2Array &p_other) {
godot::api->godot_pool_vector2_array_destroy(&_godot_array);
godot::api->godot_pool_vector2_array_new_copy(&_godot_array, &p_other._godot_array);
return *this;
}
-PoolVector2Array::PoolVector2Array(const Array& array)
-{
- godot::api->godot_pool_vector2_array_new_with_array(&_godot_array, (godot_array *) &array);
+PoolVector2Array::PoolVector2Array(const Array &array) {
+ godot::api->godot_pool_vector2_array_new_with_array(&_godot_array, (godot_array *)&array);
}
-PoolVector2Array::Read PoolVector2Array::read() const
-{
+PoolVector2Array::Read PoolVector2Array::read() const {
Read read;
read._read_access = godot::api->godot_pool_vector2_array_read(&_godot_array);
return read;
}
-PoolVector2Array::Write PoolVector2Array::write()
-{
+PoolVector2Array::Write PoolVector2Array::write() {
Write write;
write._write_access = godot::api->godot_pool_vector2_array_write(&_godot_array);
return write;
}
-void PoolVector2Array::append(const Vector2& data)
-{
- godot::api->godot_pool_vector2_array_append(&_godot_array, (godot_vector2 *) &data);
+void PoolVector2Array::append(const Vector2 &data) {
+ godot::api->godot_pool_vector2_array_append(&_godot_array, (godot_vector2 *)&data);
}
-void PoolVector2Array::append_array(const PoolVector2Array& array)
-{
+void PoolVector2Array::append_array(const PoolVector2Array &array) {
godot::api->godot_pool_vector2_array_append_array(&_godot_array, &array._godot_array);
}
-int PoolVector2Array::insert(const int idx, const Vector2& data)
-{
- return godot::api->godot_pool_vector2_array_insert(&_godot_array, idx, (godot_vector2 *) &data);
+int PoolVector2Array::insert(const int idx, const Vector2 &data) {
+ return godot::api->godot_pool_vector2_array_insert(&_godot_array, idx, (godot_vector2 *)&data);
}
-void PoolVector2Array::invert()
-{
+void PoolVector2Array::invert() {
godot::api->godot_pool_vector2_array_invert(&_godot_array);
}
-void PoolVector2Array::push_back(const Vector2& data)
-{
- godot::api->godot_pool_vector2_array_push_back(&_godot_array, (godot_vector2 *) &data);
+void PoolVector2Array::push_back(const Vector2 &data) {
+ godot::api->godot_pool_vector2_array_push_back(&_godot_array, (godot_vector2 *)&data);
}
-void PoolVector2Array::remove(const int idx)
-{
+void PoolVector2Array::remove(const int idx) {
godot::api->godot_pool_vector2_array_remove(&_godot_array, idx);
}
-void PoolVector2Array::resize(const int size)
-{
+void PoolVector2Array::resize(const int size) {
godot::api->godot_pool_vector2_array_resize(&_godot_array, size);
}
-void PoolVector2Array::set(const int idx, const Vector2& data)
-{
- godot::api->godot_pool_vector2_array_set(&_godot_array, idx, (godot_vector2 *) &data);
+void PoolVector2Array::set(const int idx, const Vector2 &data) {
+ godot::api->godot_pool_vector2_array_set(&_godot_array, idx, (godot_vector2 *)&data);
}
-const Vector2 PoolVector2Array::operator [](const int idx)
-{
+const Vector2 PoolVector2Array::operator[](const int idx) {
Vector2 v;
- *(godot_vector2 *) &v = godot::api->godot_pool_vector2_array_get(&_godot_array, idx);
+ *(godot_vector2 *)&v = godot::api->godot_pool_vector2_array_get(&_godot_array, idx);
return v;
}
-int PoolVector2Array::size() const
-{
+int PoolVector2Array::size() const {
return godot::api->godot_pool_vector2_array_size(&_godot_array);
}
-
-PoolVector2Array::~PoolVector2Array()
-{
+PoolVector2Array::~PoolVector2Array() {
godot::api->godot_pool_vector2_array_destroy(&_godot_array);
}
-
-
-PoolVector3Array::PoolVector3Array()
-{
+PoolVector3Array::PoolVector3Array() {
godot::api->godot_pool_vector3_array_new(&_godot_array);
}
-PoolVector3Array::PoolVector3Array(const PoolVector3Array &p_other)
-{
+PoolVector3Array::PoolVector3Array(const PoolVector3Array &p_other) {
godot::api->godot_pool_vector3_array_new_copy(&_godot_array, &p_other._godot_array);
}
-PoolVector3Array &PoolVector3Array::operator=(const PoolVector3Array &p_other)
-{
+PoolVector3Array &PoolVector3Array::operator=(const PoolVector3Array &p_other) {
godot::api->godot_pool_vector3_array_destroy(&_godot_array);
godot::api->godot_pool_vector3_array_new_copy(&_godot_array, &p_other._godot_array);
return *this;
}
-PoolVector3Array::PoolVector3Array(const Array& array)
-{
- godot::api->godot_pool_vector3_array_new_with_array(&_godot_array, (godot_array *) &array);
+PoolVector3Array::PoolVector3Array(const Array &array) {
+ godot::api->godot_pool_vector3_array_new_with_array(&_godot_array, (godot_array *)&array);
}
-PoolVector3Array::Read PoolVector3Array::read() const
-{
+PoolVector3Array::Read PoolVector3Array::read() const {
Read read;
read._read_access = godot::api->godot_pool_vector3_array_read(&_godot_array);
return read;
}
-PoolVector3Array::Write PoolVector3Array::write()
-{
+PoolVector3Array::Write PoolVector3Array::write() {
Write write;
write._write_access = godot::api->godot_pool_vector3_array_write(&_godot_array);
return write;
}
-void PoolVector3Array::append(const Vector3& data)
-{
- godot::api->godot_pool_vector3_array_append(&_godot_array, (godot_vector3 *) &data);
+void PoolVector3Array::append(const Vector3 &data) {
+ godot::api->godot_pool_vector3_array_append(&_godot_array, (godot_vector3 *)&data);
}
-void PoolVector3Array::append_array(const PoolVector3Array& array)
-{
+void PoolVector3Array::append_array(const PoolVector3Array &array) {
godot::api->godot_pool_vector3_array_append_array(&_godot_array, &array._godot_array);
}
-int PoolVector3Array::insert(const int idx, const Vector3& data)
-{
- return godot::api->godot_pool_vector3_array_insert(&_godot_array, idx, (godot_vector3 *) &data);
+int PoolVector3Array::insert(const int idx, const Vector3 &data) {
+ return godot::api->godot_pool_vector3_array_insert(&_godot_array, idx, (godot_vector3 *)&data);
}
-void PoolVector3Array::invert()
-{
+void PoolVector3Array::invert() {
godot::api->godot_pool_vector3_array_invert(&_godot_array);
}
-void PoolVector3Array::push_back(const Vector3& data)
-{
- godot::api->godot_pool_vector3_array_push_back(&_godot_array, (godot_vector3 *) &data);
+void PoolVector3Array::push_back(const Vector3 &data) {
+ godot::api->godot_pool_vector3_array_push_back(&_godot_array, (godot_vector3 *)&data);
}
-void PoolVector3Array::remove(const int idx)
-{
+void PoolVector3Array::remove(const int idx) {
godot::api->godot_pool_vector3_array_remove(&_godot_array, idx);
}
-void PoolVector3Array::resize(const int size)
-{
+void PoolVector3Array::resize(const int size) {
godot::api->godot_pool_vector3_array_resize(&_godot_array, size);
}
-void PoolVector3Array::set(const int idx, const Vector3& data)
-{
- godot::api->godot_pool_vector3_array_set(&_godot_array, idx, (godot_vector3 *) &data);
+void PoolVector3Array::set(const int idx, const Vector3 &data) {
+ godot::api->godot_pool_vector3_array_set(&_godot_array, idx, (godot_vector3 *)&data);
}
-const Vector3 PoolVector3Array::operator [](const int idx)
-{
+const Vector3 PoolVector3Array::operator[](const int idx) {
Vector3 v;
- *(godot_vector3 *) &v = godot::api->godot_pool_vector3_array_get(&_godot_array, idx);
+ *(godot_vector3 *)&v = godot::api->godot_pool_vector3_array_get(&_godot_array, idx);
return v;
}
-int PoolVector3Array::size() const
-{
+int PoolVector3Array::size() const {
return godot::api->godot_pool_vector3_array_size(&_godot_array);
}
-
-PoolVector3Array::~PoolVector3Array()
-{
+PoolVector3Array::~PoolVector3Array() {
godot::api->godot_pool_vector3_array_destroy(&_godot_array);
}
-
-PoolColorArray::PoolColorArray()
-{
+PoolColorArray::PoolColorArray() {
godot::api->godot_pool_color_array_new(&_godot_array);
}
-PoolColorArray::PoolColorArray(const PoolColorArray &p_other)
-{
+PoolColorArray::PoolColorArray(const PoolColorArray &p_other) {
godot::api->godot_pool_color_array_new_copy(&_godot_array, &p_other._godot_array);
}
-PoolColorArray &PoolColorArray::operator=(const PoolColorArray &p_other)
-{
+PoolColorArray &PoolColorArray::operator=(const PoolColorArray &p_other) {
godot::api->godot_pool_color_array_destroy(&_godot_array);
godot::api->godot_pool_color_array_new_copy(&_godot_array, &p_other._godot_array);
return *this;
}
-PoolColorArray::PoolColorArray(const Array& array)
-{
- godot::api->godot_pool_color_array_new_with_array(&_godot_array, (godot_array *) &array);
+PoolColorArray::PoolColorArray(const Array &array) {
+ godot::api->godot_pool_color_array_new_with_array(&_godot_array, (godot_array *)&array);
}
-PoolColorArray::Read PoolColorArray::read() const
-{
+PoolColorArray::Read PoolColorArray::read() const {
Read read;
read._read_access = godot::api->godot_pool_color_array_read(&_godot_array);
return read;
}
-PoolColorArray::Write PoolColorArray::write()
-{
+PoolColorArray::Write PoolColorArray::write() {
Write write;
write._write_access = godot::api->godot_pool_color_array_write(&_godot_array);
return write;
}
-void PoolColorArray::append(const Color& data)
-{
- godot::api->godot_pool_color_array_append(&_godot_array, (godot_color *) &data);
+void PoolColorArray::append(const Color &data) {
+ godot::api->godot_pool_color_array_append(&_godot_array, (godot_color *)&data);
}
-void PoolColorArray::append_array(const PoolColorArray& array)
-{
+void PoolColorArray::append_array(const PoolColorArray &array) {
godot::api->godot_pool_color_array_append_array(&_godot_array, &array._godot_array);
}
-int PoolColorArray::insert(const int idx, const Color& data)
-{
- return godot::api->godot_pool_color_array_insert(&_godot_array, idx, (godot_color *) &data);
+int PoolColorArray::insert(const int idx, const Color &data) {
+ return godot::api->godot_pool_color_array_insert(&_godot_array, idx, (godot_color *)&data);
}
-void PoolColorArray::invert()
-{
+void PoolColorArray::invert() {
godot::api->godot_pool_color_array_invert(&_godot_array);
}
-void PoolColorArray::push_back(const Color& data)
-{
- godot::api->godot_pool_color_array_push_back(&_godot_array, (godot_color *) &data);
+void PoolColorArray::push_back(const Color &data) {
+ godot::api->godot_pool_color_array_push_back(&_godot_array, (godot_color *)&data);
}
-void PoolColorArray::remove(const int idx)
-{
+void PoolColorArray::remove(const int idx) {
godot::api->godot_pool_color_array_remove(&_godot_array, idx);
}
-void PoolColorArray::resize(const int size)
-{
+void PoolColorArray::resize(const int size) {
godot::api->godot_pool_color_array_resize(&_godot_array, size);
}
-void PoolColorArray::set(const int idx, const Color& data)
-{
- godot::api->godot_pool_color_array_set(&_godot_array, idx, (godot_color *) &data);
+void PoolColorArray::set(const int idx, const Color &data) {
+ godot::api->godot_pool_color_array_set(&_godot_array, idx, (godot_color *)&data);
}
-const Color PoolColorArray::operator [](const int idx)
-{
+const Color PoolColorArray::operator[](const int idx) {
Color v;
- *(godot_color *) &v = godot::api->godot_pool_color_array_get(&_godot_array, idx);
+ *(godot_color *)&v = godot::api->godot_pool_color_array_get(&_godot_array, idx);
return v;
}
-int PoolColorArray::size() const
-{
+int PoolColorArray::size() const {
return godot::api->godot_pool_color_array_size(&_godot_array);
}
-
-PoolColorArray::~PoolColorArray()
-{
+PoolColorArray::~PoolColorArray() {
godot::api->godot_pool_color_array_destroy(&_godot_array);
}
-
-
-}
+} // namespace godot
diff --git a/src/core/Quat.cpp b/src/core/Quat.cpp
index 8739be3..abfe056 100644
--- a/src/core/Quat.cpp
+++ b/src/core/Quat.cpp
@@ -1,7 +1,7 @@
#include "Quat.hpp"
+#include "Basis.hpp"
#include "Defs.hpp"
#include "Vector3.hpp"
-#include "Basis.hpp"
#include <cmath>
@@ -77,53 +77,47 @@ Vector3 Quat::get_euler_yxz() const {
return m.get_euler_yxz();
}
-real_t Quat::length() const
-{
+real_t Quat::length() const {
return ::sqrt(length_squared());
}
-void Quat::normalize()
-{
+void Quat::normalize() {
*this /= length();
}
-Quat Quat::normalized() const
-{
+Quat Quat::normalized() const {
return *this / length();
}
-Quat Quat::inverse() const
-{
- return Quat( -x, -y, -z, w );
+Quat Quat::inverse() const {
+ return Quat(-x, -y, -z, w);
}
-Quat Quat::slerp(const Quat& q, const real_t& t) const {
-
- Quat to1;
- real_t omega, cosom, sinom, scale0, scale1;
+Quat Quat::slerp(const Quat &q, const real_t &t) const {
+ Quat to1;
+ real_t omega, cosom, sinom, scale0, scale1;
// calc cosine
cosom = dot(q);
// adjust signs (if necessary)
- if ( cosom <0.0 ) {
+ if (cosom < 0.0) {
cosom = -cosom;
- to1.x = - q.x;
- to1.y = - q.y;
- to1.z = - q.z;
- to1.w = - q.w;
- } else {
+ to1.x = -q.x;
+ to1.y = -q.y;
+ to1.z = -q.z;
+ to1.w = -q.w;
+ } else {
to1.x = q.x;
to1.y = q.y;
to1.z = q.z;
to1.w = q.w;
}
-
// calculate coefficients
- if ( (1.0 - cosom) > CMP_EPSILON ) {
+ if ((1.0 - cosom) > CMP_EPSILON) {
// standard case (slerp)
omega = ::acos(cosom);
sinom = ::sin(omega);
@@ -137,14 +131,13 @@ Quat Quat::slerp(const Quat& q, const real_t& t) const {
}
// calculate final values
return Quat(
- scale0 * x + scale1 * to1.x,
- scale0 * y + scale1 * to1.y,
- scale0 * z + scale1 * to1.z,
- scale0 * w + scale1 * to1.w
- );
+ scale0 * x + scale1 * to1.x,
+ scale0 * y + scale1 * to1.y,
+ scale0 * z + scale1 * to1.z,
+ scale0 * w + scale1 * to1.w);
}
-Quat Quat::slerpni(const Quat& q, const real_t& t) const {
+Quat Quat::slerpni(const Quat &q, const real_t &t) const {
const Quat &from = *this;
@@ -152,162 +145,161 @@ Quat Quat::slerpni(const Quat& q, const real_t& t) const {
if (::fabs(dot) > 0.9999) return from;
- real_t theta = ::acos(dot),
- sinT = 1.0 / ::sin(theta),
- newFactor = ::sin(t * theta) * sinT,
- invFactor = ::sin((1.0 - t) * theta) * sinT;
+ real_t theta = ::acos(dot),
+ sinT = 1.0 / ::sin(theta),
+ newFactor = ::sin(t * theta) * sinT,
+ invFactor = ::sin((1.0 - t) * theta) * sinT;
return Quat(invFactor * from.x + newFactor * q.x,
- invFactor * from.y + newFactor * q.y,
- invFactor * from.z + newFactor * q.z,
- invFactor * from.w + newFactor * q.w);
+ invFactor * from.y + newFactor * q.y,
+ invFactor * from.z + newFactor * q.z,
+ invFactor * from.w + newFactor * q.w);
}
-Quat Quat::cubic_slerp(const Quat& q, const Quat& prep, const Quat& postq,const real_t& t) const
-{
+Quat Quat::cubic_slerp(const Quat &q, const Quat &prep, const Quat &postq, const real_t &t) const {
//the only way to do slerp :|
- real_t t2 = (1.0-t)*t*2;
- Quat sp = this->slerp(q,t);
- Quat sq = prep.slerpni(postq,t);
- return sp.slerpni(sq,t2);
+ real_t t2 = (1.0 - t) * t * 2;
+ Quat sp = this->slerp(q, t);
+ Quat sq = prep.slerpni(postq, t);
+ return sp.slerpni(sq, t2);
}
-void Quat::get_axis_and_angle(Vector3& r_axis, real_t &r_angle) const {
+void Quat::get_axis_and_angle(Vector3 &r_axis, real_t &r_angle) const {
r_angle = 2 * ::acos(w);
- r_axis.x = x / ::sqrt(1-w*w);
- r_axis.y = y / ::sqrt(1-w*w);
- r_axis.z = z / ::sqrt(1-w*w);
+ r_axis.x = x / ::sqrt(1 - w * w);
+ r_axis.y = y / ::sqrt(1 - w * w);
+ r_axis.z = z / ::sqrt(1 - w * w);
}
-
-
-Quat Quat::operator*(const Vector3& v) const
-{
- return Quat( w * v.x + y * v.z - z * v.y,
- w * v.y + z * v.x - x * v.z,
- w * v.z + x * v.y - y * v.x,
- -x * v.x - y * v.y - z * v.z);
+Quat Quat::operator*(const Vector3 &v) const {
+ return Quat(w * v.x + y * v.z - z * v.y,
+ w * v.y + z * v.x - x * v.z,
+ w * v.z + x * v.y - y * v.x,
+ -x * v.x - y * v.y - z * v.z);
}
-Vector3 Quat::xform(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);
+ return Vector3(q.x, q.y, q.z);
}
-
-Quat::operator String() const
-{
+Quat::operator String() const {
return String(); // @Todo
}
-
-Quat::Quat(const Vector3& axis, const real_t& angle)
-{
+Quat::Quat(const Vector3 &axis, const real_t &angle) {
real_t d = axis.length();
- if (d==0)
- set(0,0,0,0);
+ if (d == 0)
+ set(0, 0, 0, 0);
else {
real_t sin_angle = ::sin(angle * 0.5);
real_t cos_angle = ::cos(angle * 0.5);
real_t s = sin_angle / d;
set(axis.x * s, axis.y * s, axis.z * s,
- cos_angle);
+ cos_angle);
}
}
-Quat::Quat(const Vector3& v0, const Vector3& v1) // shortest arc
+Quat::Quat(const Vector3 &v0, const Vector3 &v1) // shortest arc
{
Vector3 c = v0.cross(v1);
- real_t d = v0.dot(v1);
+ real_t d = v0.dot(v1);
if (d < -1.0 + CMP_EPSILON) {
- x=0;
- y=1;
- z=0;
- w=0;
+ x = 0;
+ y = 1;
+ z = 0;
+ w = 0;
} else {
- real_t s = ::sqrt((1.0 + d) * 2.0);
+ real_t s = ::sqrt((1.0 + d) * 2.0);
real_t rs = 1.0 / s;
- x=c.x*rs;
- y=c.y*rs;
- z=c.z*rs;
- w=s * 0.5;
+ x = c.x * rs;
+ y = c.y * rs;
+ z = c.z * rs;
+ w = s * 0.5;
}
}
-
-real_t Quat::dot(const Quat& q) const {
- return x * q.x+y * q.y+z * q.z+w * q.w;
+real_t Quat::dot(const Quat &q) const {
+ return x * q.x + y * q.y + z * q.z + w * q.w;
}
real_t Quat::length_squared() const {
return dot(*this);
}
-void Quat::operator+=(const Quat& q) {
- x += q.x; y += q.y; z += q.z; w += q.w;
+void Quat::operator+=(const Quat &q) {
+ x += q.x;
+ y += q.y;
+ z += q.z;
+ w += q.w;
}
-void Quat::operator-=(const Quat& q) {
- x -= q.x; y -= q.y; z -= q.z; w -= q.w;
+void Quat::operator-=(const Quat &q) {
+ x -= q.x;
+ y -= q.y;
+ z -= q.z;
+ w -= q.w;
}
-void Quat::operator*=(const Quat& q) {
- x *= q.x; y *= q.y; z *= q.z; w *= q.w;
+void Quat::operator*=(const Quat &q) {
+ x *= q.x;
+ y *= q.y;
+ z *= q.z;
+ w *= q.w;
}
-
-void Quat::operator*=(const real_t& s) {
- x *= s; y *= s; z *= s; w *= s;
+void Quat::operator*=(const real_t &s) {
+ x *= s;
+ y *= s;
+ z *= s;
+ w *= s;
}
-
-void Quat::operator/=(const real_t& s) {
+void Quat::operator/=(const real_t &s) {
*this *= 1.0 / s;
}
-Quat Quat::operator+(const Quat& q2) const {
- const Quat& q1 = *this;
- return Quat( q1.x+q2.x, q1.y+q2.y, q1.z+q2.z, q1.w+q2.w );
+Quat Quat::operator+(const Quat &q2) const {
+ const Quat &q1 = *this;
+ return Quat(q1.x + q2.x, q1.y + q2.y, q1.z + q2.z, q1.w + q2.w);
}
-Quat Quat::operator-(const Quat& q2) const {
- const Quat& q1 = *this;
- return Quat( q1.x-q2.x, q1.y-q2.y, q1.z-q2.z, q1.w-q2.w);
+Quat Quat::operator-(const Quat &q2) const {
+ const Quat &q1 = *this;
+ return Quat(q1.x - q2.x, q1.y - q2.y, q1.z - q2.z, q1.w - q2.w);
}
-Quat Quat::operator*(const Quat& q2) const {
+Quat Quat::operator*(const Quat &q2) const {
Quat q1 = *this;
q1 *= q2;
return q1;
}
-
Quat Quat::operator-() const {
- const Quat& q2 = *this;
- return Quat( -q2.x, -q2.y, -q2.z, -q2.w);
+ const Quat &q2 = *this;
+ return Quat(-q2.x, -q2.y, -q2.z, -q2.w);
}
-Quat Quat::operator*(const real_t& s) const {
+Quat Quat::operator*(const real_t &s) const {
return Quat(x * s, y * s, z * s, w * s);
}
-Quat Quat::operator/(const real_t& s) const {
+Quat Quat::operator/(const real_t &s) const {
return *this * (1.0 / s);
}
-
-bool Quat::operator==(const Quat& p_quat) const {
- return x==p_quat.x && y==p_quat.y && z==p_quat.z && w==p_quat.w;
+bool Quat::operator==(const Quat &p_quat) const {
+ return x == p_quat.x && y == p_quat.y && z == p_quat.z && w == p_quat.w;
}
-bool Quat::operator!=(const Quat& p_quat) const {
- return x!=p_quat.x || y!=p_quat.y || z!=p_quat.z || w!=p_quat.w;
+bool Quat::operator!=(const Quat &p_quat) const {
+ return x != p_quat.x || y != p_quat.y || z != p_quat.z || w != p_quat.w;
}
-}
+} // namespace godot
diff --git a/src/core/RID.cpp b/src/core/RID.cpp
index aaf8e7a..7ca1e7a 100644
--- a/src/core/RID.cpp
+++ b/src/core/RID.cpp
@@ -6,50 +6,40 @@
namespace godot {
-RID::RID()
-{
+RID::RID() {
godot::api->godot_rid_new(&_godot_rid);
}
-RID::RID(Object *p)
-{
- godot::api->godot_rid_new_with_resource(&_godot_rid, (const godot_object *) p);
+RID::RID(Object *p) {
+ godot::api->godot_rid_new_with_resource(&_godot_rid, (const godot_object *)p);
}
-int32_t RID::get_rid() const
-{
+int32_t RID::get_rid() const {
return godot::api->godot_rid_get_id(&_godot_rid);
}
-bool RID::operator==(const RID & p_other) const
-{
+bool RID::operator==(const RID &p_other) const {
return godot::api->godot_rid_operator_equal(&_godot_rid, &p_other._godot_rid);
}
-bool RID::operator!=(const RID & p_other) const
-{
+bool RID::operator!=(const RID &p_other) const {
return !(*this == p_other);
}
-bool RID::operator<(const RID & p_other) const
-{
+bool RID::operator<(const RID &p_other) const {
return godot::api->godot_rid_operator_less(&_godot_rid, &p_other._godot_rid);
}
-bool RID::operator>(const RID & p_other) const
-{
+bool RID::operator>(const RID &p_other) const {
return !(*this < p_other) && *this != p_other;
}
-bool RID::operator<=(const RID & p_other) const
-{
+bool RID::operator<=(const RID &p_other) const {
return (*this < p_other) || *this == p_other;
}
-bool RID::operator>=(const RID & p_other) const
-{
+bool RID::operator>=(const RID &p_other) const {
return !(*this < p_other);
}
-
-}
+} // namespace godot
diff --git a/src/core/Rect2.cpp b/src/core/Rect2.cpp
index da057aa..deef229 100644
--- a/src/core/Rect2.cpp
+++ b/src/core/Rect2.cpp
@@ -1,7 +1,7 @@
#include "Rect2.hpp"
-#include "Vector2.hpp"
#include "String.hpp"
#include "Transform2D.hpp"
+#include "Vector2.hpp"
#include <cmath>
@@ -15,110 +15,104 @@ namespace godot {
#define MIN(a, b) (a < b ? a : b)
#endif
+real_t Rect2::distance_to(const Vector2 &p_point) const {
-real_t Rect2::distance_to(const Vector2& p_point) const {
-
- real_t dist = 1e20;
-
- if (p_point.x < pos.x) {
- dist=MIN(dist,pos.x-p_point.x);
- }
- if (p_point.y < pos.y) {
- dist=MIN(dist,pos.y-p_point.y);
- }
- if (p_point.x >= (pos.x+size.x) ) {
- dist=MIN(p_point.x-(pos.x+size.x),dist);
- }
- if (p_point.y >= (pos.y+size.y) ) {
- dist=MIN(p_point.y-(pos.y+size.y),dist);
- }
+ real_t dist = 1e20;
- if (dist==1e20)
- return 0;
- else
- return dist;
+ if (p_point.x < pos.x) {
+ dist = MIN(dist, pos.x - p_point.x);
+ }
+ if (p_point.y < pos.y) {
+ dist = MIN(dist, pos.y - p_point.y);
}
+ if (p_point.x >= (pos.x + size.x)) {
+ dist = MIN(p_point.x - (pos.x + size.x), dist);
+ }
+ if (p_point.y >= (pos.y + size.y)) {
+ dist = MIN(p_point.y - (pos.y + size.y), dist);
+ }
+
+ if (dist == 1e20)
+ return 0;
+ else
+ return dist;
+}
-Rect2 Rect2::clip(const Rect2& p_rect) const { /// return a clipped rect
+Rect2 Rect2::clip(const Rect2 &p_rect) const { /// return a clipped rect
- Rect2 new_rect=p_rect;
+ Rect2 new_rect = p_rect;
- if (!intersects( new_rect ))
+ if (!intersects(new_rect))
return Rect2();
- new_rect.pos.x = MAX( p_rect.pos.x , pos.x );
- new_rect.pos.y = MAX( p_rect.pos.y , pos.y );
+ new_rect.pos.x = MAX(p_rect.pos.x, pos.x);
+ new_rect.pos.y = MAX(p_rect.pos.y, pos.y);
- Point2 p_rect_end=p_rect.pos+p_rect.size;
- Point2 end=pos+size;
+ Point2 p_rect_end = p_rect.pos + p_rect.size;
+ Point2 end = pos + size;
- new_rect.size.x=MIN(p_rect_end.x,end.x) - new_rect.pos.x;
- new_rect.size.y=MIN(p_rect_end.y,end.y) - new_rect.pos.y;
+ new_rect.size.x = MIN(p_rect_end.x, end.x) - new_rect.pos.x;
+ new_rect.size.y = MIN(p_rect_end.y, end.y) - new_rect.pos.y;
return new_rect;
}
-Rect2 Rect2::merge(const Rect2& p_rect) const { ///< return a merged rect
+Rect2 Rect2::merge(const Rect2 &p_rect) const { ///< return a merged rect
Rect2 new_rect;
- new_rect.pos.x=MIN( p_rect.pos.x , pos.x );
- new_rect.pos.y=MIN( p_rect.pos.y , pos.y );
-
+ new_rect.pos.x = MIN(p_rect.pos.x, pos.x);
+ new_rect.pos.y = MIN(p_rect.pos.y, pos.y);
- new_rect.size.x = MAX( p_rect.pos.x+p_rect.size.x , pos.x+size.x );
- new_rect.size.y = MAX( p_rect.pos.y+p_rect.size.y , pos.y+size.y );
+ new_rect.size.x = MAX(p_rect.pos.x + p_rect.size.x, pos.x + size.x);
+ new_rect.size.y = MAX(p_rect.pos.y + p_rect.size.y, pos.y + size.y);
new_rect.size = new_rect.size - new_rect.pos; //make relative again
return new_rect;
}
-
-
-Rect2::operator String() const
-{
- return String(pos)+", "+String(size);
+Rect2::operator String() const {
+ return String(pos) + ", " + String(size);
}
+bool Rect2::intersects_segment(const Point2 &p_from, const Point2 &p_to, Point2 *r_pos, Point2 *r_normal) const {
-bool Rect2::intersects_segment(const Point2& p_from, const Point2& p_to, Point2* r_pos,Point2* r_normal) const {
-
- real_t min=0,max=1;
- int axis=0;
- real_t sign=0;
+ real_t min = 0, max = 1;
+ int axis = 0;
+ real_t sign = 0;
- for(int i=0;i<2;i++) {
- real_t seg_from=p_from[i];
- real_t seg_to=p_to[i];
- real_t box_begin=pos[i];
- real_t box_end=box_begin+size[i];
- real_t cmin,cmax;
+ for (int i = 0; i < 2; i++) {
+ real_t seg_from = p_from[i];
+ real_t seg_to = p_to[i];
+ real_t box_begin = pos[i];
+ real_t box_end = box_begin + size[i];
+ real_t cmin, cmax;
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;
- cmin = (seg_from < box_begin)?((box_begin - seg_from)/length):0;
- cmax = (seg_to > box_end)?((box_end - seg_from)/length):1;
- csign=-1.0;
+ real_t length = seg_to - seg_from;
+ cmin = (seg_from < box_begin) ? ((box_begin - seg_from) / length) : 0;
+ cmax = (seg_to > box_end) ? ((box_end - seg_from) / length) : 1;
+ csign = -1.0;
} else {
if (seg_to > box_end || seg_from < box_begin)
return false;
- real_t length=seg_to-seg_from;
- cmin = (seg_from > box_end)?(box_end - seg_from)/length:0;
- cmax = (seg_to < box_begin)?(box_begin - seg_from)/length:1;
- csign=1.0;
+ real_t length = seg_to - seg_from;
+ cmin = (seg_from > box_end) ? (box_end - seg_from) / length : 0;
+ cmax = (seg_to < box_begin) ? (box_begin - seg_from) / length : 1;
+ csign = 1.0;
}
if (cmin > min) {
min = cmin;
- axis=i;
- sign=csign;
+ axis = i;
+ sign = csign;
}
if (cmax < max)
max = cmax;
@@ -126,175 +120,169 @@ bool Rect2::intersects_segment(const Point2& p_from, const Point2& p_to, Point2*
return false;
}
-
- Vector2 rel=p_to-p_from;
+ Vector2 rel = p_to - p_from;
if (r_normal) {
Vector2 normal;
- normal[axis]=sign;
- *r_normal=normal;
+ normal[axis] = sign;
+ *r_normal = normal;
}
if (r_pos)
- *r_pos=p_from+rel*min;
+ *r_pos = p_from + rel * min;
return true;
}
-
-bool Rect2::intersects_transformed(const Transform2D& p_xform, const Rect2& p_rect) const {
+bool Rect2::intersects_transformed(const Transform2D &p_xform, const Rect2 &p_rect) const {
//SAT intersection between local and transformed rect2
- Vector2 xf_points[4]={
+ Vector2 xf_points[4] = {
p_xform.xform(p_rect.pos),
- p_xform.xform(Vector2(p_rect.pos.x+p_rect.size.x,p_rect.pos.y)),
- p_xform.xform(Vector2(p_rect.pos.x,p_rect.pos.y+p_rect.size.y)),
- p_xform.xform(Vector2(p_rect.pos.x+p_rect.size.x,p_rect.pos.y+p_rect.size.y)),
+ p_xform.xform(Vector2(p_rect.pos.x + p_rect.size.x, p_rect.pos.y)),
+ p_xform.xform(Vector2(p_rect.pos.x, p_rect.pos.y + p_rect.size.y)),
+ p_xform.xform(Vector2(p_rect.pos.x + p_rect.size.x, p_rect.pos.y + p_rect.size.y)),
};
real_t low_limit;
//base rect2 first (faster)
- if (xf_points[0].y>pos.y)
+ if (xf_points[0].y > pos.y)
goto next1;
- if (xf_points[1].y>pos.y)
+ if (xf_points[1].y > pos.y)
goto next1;
- if (xf_points[2].y>pos.y)
+ if (xf_points[2].y > pos.y)
goto next1;
- if (xf_points[3].y>pos.y)
+ if (xf_points[3].y > pos.y)
goto next1;
return false;
- next1:
+next1:
- low_limit=pos.y+size.y;
+ low_limit = pos.y + size.y;
- if (xf_points[0].y<low_limit)
+ if (xf_points[0].y < low_limit)
goto next2;
- if (xf_points[1].y<low_limit)
+ if (xf_points[1].y < low_limit)
goto next2;
- if (xf_points[2].y<low_limit)
+ if (xf_points[2].y < low_limit)
goto next2;
- if (xf_points[3].y<low_limit)
+ if (xf_points[3].y < low_limit)
goto next2;
return false;
- next2:
+next2:
- if (xf_points[0].x>pos.x)
+ if (xf_points[0].x > pos.x)
goto next3;
- if (xf_points[1].x>pos.x)
+ if (xf_points[1].x > pos.x)
goto next3;
- if (xf_points[2].x>pos.x)
+ if (xf_points[2].x > pos.x)
goto next3;
- if (xf_points[3].x>pos.x)
+ if (xf_points[3].x > pos.x)
goto next3;
return false;
- next3:
+next3:
- low_limit=pos.x+size.x;
+ low_limit = pos.x + size.x;
- if (xf_points[0].x<low_limit)
+ if (xf_points[0].x < low_limit)
goto next4;
- if (xf_points[1].x<low_limit)
+ if (xf_points[1].x < low_limit)
goto next4;
- if (xf_points[2].x<low_limit)
+ if (xf_points[2].x < low_limit)
goto next4;
- if (xf_points[3].x<low_limit)
+ if (xf_points[3].x < low_limit)
goto next4;
return false;
- next4:
+next4:
- Vector2 xf_points2[4]={
+ Vector2 xf_points2[4] = {
pos,
- Vector2(pos.x+size.x,pos.y),
- Vector2(pos.x,pos.y+size.y),
- Vector2(pos.x+size.x,pos.y+size.y),
+ Vector2(pos.x + size.x, pos.y),
+ Vector2(pos.x, pos.y + size.y),
+ Vector2(pos.x + size.x, pos.y + size.y),
};
- real_t maxa=p_xform.elements[0].dot(xf_points2[0]);
- real_t mina=maxa;
+ real_t maxa = p_xform.elements[0].dot(xf_points2[0]);
+ real_t mina = maxa;
real_t dp = p_xform.elements[0].dot(xf_points2[1]);
- maxa=MAX(dp,maxa);
- mina=MIN(dp,mina);
+ maxa = MAX(dp, maxa);
+ mina = MIN(dp, mina);
dp = p_xform.elements[0].dot(xf_points2[2]);
- maxa=MAX(dp,maxa);
- mina=MIN(dp,mina);
+ maxa = MAX(dp, maxa);
+ mina = MIN(dp, mina);
dp = p_xform.elements[0].dot(xf_points2[3]);
- maxa=MAX(dp,maxa);
- mina=MIN(dp,mina);
+ maxa = MAX(dp, maxa);
+ mina = MIN(dp, mina);
- real_t maxb=p_xform.elements[0].dot(xf_points[0]);
- real_t minb=maxb;
+ real_t maxb = p_xform.elements[0].dot(xf_points[0]);
+ real_t minb = maxb;
dp = p_xform.elements[0].dot(xf_points[1]);
- maxb=MAX(dp,maxb);
- minb=MIN(dp,minb);
+ maxb = MAX(dp, maxb);
+ minb = MIN(dp, minb);
dp = p_xform.elements[0].dot(xf_points[2]);
- maxb=MAX(dp,maxb);
- minb=MIN(dp,minb);
+ maxb = MAX(dp, maxb);
+ minb = MIN(dp, minb);
dp = p_xform.elements[0].dot(xf_points[3]);
- maxb=MAX(dp,maxb);
- minb=MIN(dp,minb);
-
+ maxb = MAX(dp, maxb);
+ minb = MIN(dp, minb);
- if ( mina > maxb )
+ if (mina > maxb)
return false;
- if ( minb > maxa )
+ if (minb > maxa)
return false;
- maxa=p_xform.elements[1].dot(xf_points2[0]);
- mina=maxa;
+ maxa = p_xform.elements[1].dot(xf_points2[0]);
+ mina = maxa;
dp = p_xform.elements[1].dot(xf_points2[1]);
- maxa=MAX(dp,maxa);
- mina=MIN(dp,mina);
+ maxa = MAX(dp, maxa);
+ mina = MIN(dp, mina);
dp = p_xform.elements[1].dot(xf_points2[2]);
- maxa=MAX(dp,maxa);
- mina=MIN(dp,mina);
+ maxa = MAX(dp, maxa);
+ mina = MIN(dp, mina);
dp = p_xform.elements[1].dot(xf_points2[3]);
- maxa=MAX(dp,maxa);
- mina=MIN(dp,mina);
+ maxa = MAX(dp, maxa);
+ mina = MIN(dp, mina);
- maxb=p_xform.elements[1].dot(xf_points[0]);
- minb=maxb;
+ maxb = p_xform.elements[1].dot(xf_points[0]);
+ minb = maxb;
dp = p_xform.elements[1].dot(xf_points[1]);
- maxb=MAX(dp,maxb);
- minb=MIN(dp,minb);
+ maxb = MAX(dp, maxb);
+ minb = MIN(dp, minb);
dp = p_xform.elements[1].dot(xf_points[2]);
- maxb=MAX(dp,maxb);
- minb=MIN(dp,minb);
+ maxb = MAX(dp, maxb);
+ minb = MIN(dp, minb);
dp = p_xform.elements[1].dot(xf_points[3]);
- maxb=MAX(dp,maxb);
- minb=MIN(dp,minb);
-
+ maxb = MAX(dp, maxb);
+ minb = MIN(dp, minb);
- if ( mina > maxb )
+ if (mina > maxb)
return false;
- if ( minb > maxa )
+ if (minb > maxa)
return false;
-
return true;
-
}
-}
+} // namespace godot
diff --git a/src/core/String.cpp b/src/core/String.cpp
index 788cb2f..3535322 100644
--- a/src/core/String.cpp
+++ b/src/core/String.cpp
@@ -1,10 +1,10 @@
#include "String.hpp"
#include "Array.hpp"
+#include "GodotGlobal.hpp"
#include "NodePath.hpp"
#include "PoolArrays.hpp"
#include "Variant.hpp"
-#include "GodotGlobal.hpp"
#include <gdnative/string.h>
@@ -169,7 +169,7 @@ char *String::alloc_c_string() const {
int length = godot::api->godot_char_string_length(&contents);
- char *result = (char *) godot::api->godot_alloc(length + 1);
+ char *result = (char *)godot::api->godot_alloc(length + 1);
if (result) {
memcpy(result, godot::api->godot_char_string_get_data(&contents), length + 1);
@@ -549,11 +549,10 @@ signed char String::casecmp_to(String p_str) const {
signed char String::nocasecmp_to(String p_str) const {
return godot::api->godot_string_nocasecmp_to(&_godot_string, &p_str._godot_string);
-
}
signed char String::naturalnocasecmp_to(String p_str) const {
return godot::api->godot_string_naturalnocasecmp_to(&_godot_string, &p_str._godot_string);
}
-}
+} // namespace godot
diff --git a/src/core/TagDB.cpp b/src/core/TagDB.cpp
index 0e7fb8f..8c0b717 100644
--- a/src/core/TagDB.cpp
+++ b/src/core/TagDB.cpp
@@ -10,29 +10,25 @@ namespace _TagDB {
std::unordered_map<size_t, size_t> parent_to;
-void register_type(size_t type_tag, size_t base_type_tag)
-{
+void register_type(size_t type_tag, size_t base_type_tag) {
if (type_tag == base_type_tag) {
return;
}
parent_to[type_tag] = base_type_tag;
}
-bool is_type_known(size_t type_tag)
-{
+bool is_type_known(size_t type_tag) {
return parent_to.find(type_tag) != parent_to.end();
}
-void register_global_type(const char *name, size_t type_tag, size_t base_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);
+ 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)
-{
+bool is_type_compatible(size_t ask_tag, size_t have_tag) {
if (have_tag == 0)
return false;
@@ -49,7 +45,6 @@ bool is_type_compatible(size_t ask_tag, size_t have_tag)
return false;
}
-}
-
+} // namespace _TagDB
-}
+} // namespace godot
diff --git a/src/core/Transform.cpp b/src/core/Transform.cpp
index 926b9bc..9a1028a 100644
--- a/src/core/Transform.cpp
+++ b/src/core/Transform.cpp
@@ -2,134 +2,122 @@
#include "Basis.hpp"
-#include "Plane.hpp"
#include "AABB.hpp"
+#include "Plane.hpp"
#include "Quat.hpp"
namespace godot {
-
-
-Transform Transform::inverse_xform(const Transform& t) const {
+Transform Transform::inverse_xform(const Transform &t) const {
Vector3 v = t.origin - origin;
return Transform(basis.transpose_xform(t.basis),
- basis.xform(v));
+ 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) {
+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;
- basis.elements[1][0]=yx;
- basis.elements[1][1]=yy;
- basis.elements[1][2]=yz;
- basis.elements[2][0]=zx;
- basis.elements[2][1]=zy;
- basis.elements[2][2]=zz;
- origin.x=tx;
- origin.y=ty;
- origin.z=tz;
+ basis.elements[0][0] = xx;
+ basis.elements[0][1] = xy;
+ basis.elements[0][2] = xz;
+ basis.elements[1][0] = yx;
+ basis.elements[1][1] = yy;
+ basis.elements[1][2] = yz;
+ basis.elements[2][0] = zx;
+ basis.elements[2][1] = zy;
+ basis.elements[2][2] = zz;
+ origin.x = tx;
+ origin.y = ty;
+ origin.z = tz;
}
-
-
-Vector3 Transform::xform(const Vector3& p_vector) const {
+Vector3 Transform::xform(const Vector3 &p_vector) const {
return Vector3(
- basis[0].dot(p_vector)+origin.x,
- basis[1].dot(p_vector)+origin.y,
- basis[2].dot(p_vector)+origin.z
- );
+ basis[0].dot(p_vector) + origin.x,
+ basis[1].dot(p_vector) + origin.y,
+ basis[2].dot(p_vector) + origin.z);
}
-Vector3 Transform::xform_inv(const Vector3& p_vector) const {
+Vector3 Transform::xform_inv(const Vector3 &p_vector) const {
Vector3 v = p_vector - origin;
return Vector3(
- (basis.elements[0][0]*v.x ) + ( basis.elements[1][0]*v.y ) + ( basis.elements[2][0]*v.z ),
- (basis.elements[0][1]*v.x ) + ( basis.elements[1][1]*v.y ) + ( basis.elements[2][1]*v.z ),
- (basis.elements[0][2]*v.x ) + ( basis.elements[1][2]*v.y ) + ( basis.elements[2][2]*v.z )
- );
+ (basis.elements[0][0] * v.x) + (basis.elements[1][0] * v.y) + (basis.elements[2][0] * v.z),
+ (basis.elements[0][1] * v.x) + (basis.elements[1][1] * v.y) + (basis.elements[2][1] * v.z),
+ (basis.elements[0][2] * v.x) + (basis.elements[1][2] * v.y) + (basis.elements[2][2] * v.z));
}
-Plane Transform::xform(const Plane& p_plane) 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);
+ point_dir = xform(point_dir);
- Vector3 point=p_plane.normal*p_plane.d;
- Vector3 point_dir=point+p_plane.normal;
- point=xform(point);
- point_dir=xform(point_dir);
-
- Vector3 normal=point_dir-point;
+ Vector3 normal = point_dir - point;
normal.normalize();
- real_t d=normal.dot(point);
-
- return Plane(normal,d);
+ real_t d = normal.dot(point);
+ return Plane(normal, d);
}
-Plane Transform::xform_inv(const Plane& p_plane) const {
+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);
- point_dir=xform_inv(point_dir);
+ Vector3 point = p_plane.normal * p_plane.d;
+ Vector3 point_dir = point + p_plane.normal;
+ point = xform_inv(point);
+ point_dir = xform_inv(point_dir);
- Vector3 normal=point_dir-point;
+ Vector3 normal = point_dir - point;
normal.normalize();
- real_t d=normal.dot(point);
-
- return Plane(normal,d);
+ real_t d = normal.dot(point);
+ return Plane(normal, d);
}
-AABB Transform::xform(const AABB& p_aabb) const {
+AABB Transform::xform(const AABB &p_aabb) const {
/* define vertices */
- Vector3 x=basis.get_axis(0)*p_aabb.size.x;
- Vector3 y=basis.get_axis(1)*p_aabb.size.y;
- Vector3 z=basis.get_axis(2)*p_aabb.size.z;
- Vector3 pos = xform( p_aabb.position );
-//could be even further optimized
+ Vector3 x = basis.get_axis(0) * p_aabb.size.x;
+ Vector3 y = basis.get_axis(1) * p_aabb.size.y;
+ Vector3 z = basis.get_axis(2) * p_aabb.size.z;
+ Vector3 pos = xform(p_aabb.position);
+ //could be even further optimized
AABB new_aabb;
- new_aabb.position=pos;
- new_aabb.expand_to( pos+x );
- new_aabb.expand_to( pos+y );
- new_aabb.expand_to( pos+z );
- new_aabb.expand_to( pos+x+y );
- new_aabb.expand_to( pos+x+z );
- new_aabb.expand_to( pos+y+z );
- new_aabb.expand_to( pos+x+y+z );
+ new_aabb.position = pos;
+ new_aabb.expand_to(pos + x);
+ new_aabb.expand_to(pos + y);
+ new_aabb.expand_to(pos + z);
+ new_aabb.expand_to(pos + x + y);
+ new_aabb.expand_to(pos + x + z);
+ new_aabb.expand_to(pos + y + z);
+ new_aabb.expand_to(pos + x + y + z);
return new_aabb;
-
}
-AABB Transform::xform_inv(const AABB& p_aabb) const {
+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),
- Vector3(p_aabb.position.x+p_aabb.size.x, p_aabb.position.y+p_aabb.size.y, p_aabb.position.z),
- Vector3(p_aabb.position.x+p_aabb.size.x, p_aabb.position.y, p_aabb.position.z+p_aabb.size.z),
- Vector3(p_aabb.position.x+p_aabb.size.x, p_aabb.position.y, p_aabb.position.z),
- Vector3(p_aabb.position.x, p_aabb.position.y+p_aabb.size.y, p_aabb.position.z+p_aabb.size.z),
- Vector3(p_aabb.position.x, p_aabb.position.y+p_aabb.size.y, p_aabb.position.z),
- Vector3(p_aabb.position.x, p_aabb.position.y, p_aabb.position.z+p_aabb.size.z),
- Vector3(p_aabb.position.x, p_aabb.position.y, p_aabb.position.z)
+ 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),
+ Vector3(p_aabb.position.x + p_aabb.size.x, p_aabb.position.y + p_aabb.size.y, p_aabb.position.z),
+ Vector3(p_aabb.position.x + p_aabb.size.x, p_aabb.position.y, p_aabb.position.z + p_aabb.size.z),
+ Vector3(p_aabb.position.x + p_aabb.size.x, p_aabb.position.y, p_aabb.position.z),
+ Vector3(p_aabb.position.x, p_aabb.position.y + p_aabb.size.y, p_aabb.position.z + p_aabb.size.z),
+ Vector3(p_aabb.position.x, p_aabb.position.y + p_aabb.size.y, p_aabb.position.z),
+ Vector3(p_aabb.position.x, p_aabb.position.y, p_aabb.position.z + p_aabb.size.z),
+ Vector3(p_aabb.position.x, p_aabb.position.y, p_aabb.position.z)
};
-
AABB ret;
- ret.position=xform_inv(vertices[0]);
+ ret.position = xform_inv(vertices[0]);
- for (int i=1;i<8;i++) {
+ for (int i = 1; i < 8; i++) {
- ret.expand_to( xform_inv(vertices[i]) );
+ ret.expand_to(xform_inv(vertices[i]));
}
return ret;
-
}
void Transform::affine_invert() {
@@ -140,13 +128,11 @@ void Transform::affine_invert() {
Transform Transform::affine_inverse() const {
- Transform ret=*this;
+ Transform ret = *this;
ret.affine_invert();
return ret;
-
}
-
void Transform::invert() {
basis.transpose();
@@ -156,35 +142,34 @@ void Transform::invert() {
Transform Transform::inverse() const {
// FIXME: this function assumes the basis is a rotation matrix, with no scaling.
// Transform::affine_inverse can handle matrices with scaling, so GDScript should eventually use that.
- Transform ret=*this;
+ Transform ret = *this;
ret.invert();
return ret;
}
-
-void Transform::rotate(const Vector3& p_axis,real_t p_phi) {
+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{
+Transform Transform::rotated(const Vector3 &p_axis, real_t p_phi) const {
- return Transform(Basis( p_axis, p_phi ), Vector3()) * (*this);
+ return Transform(Basis(p_axis, p_phi), Vector3()) * (*this);
}
-void Transform::rotate_basis(const Vector3& p_axis,real_t p_phi) {
+void Transform::rotate_basis(const Vector3 &p_axis, real_t p_phi) {
- basis.rotate(p_axis,p_phi);
+ basis.rotate(p_axis, p_phi);
}
-Transform Transform::looking_at( const Vector3& p_target, const Vector3& p_up ) const {
+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);
+ 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 ) {
+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;
@@ -198,23 +183,21 @@ void Transform::set_look_at( const Vector3& p_eye, const Vector3& p_target, cons
v_y = p_up;
-
- v_x=v_y.cross(v_z);
+ v_x = v_y.cross(v_z);
/* Recompute Y = Z cross X */
- v_y=v_z.cross(v_x);
+ v_y = v_z.cross(v_x);
v_x.normalize();
v_y.normalize();
- basis.set_axis(0,v_x);
- basis.set_axis(1,v_y);
- basis.set_axis(2,v_z);
- origin=p_eye;
-
+ basis.set_axis(0, v_x);
+ basis.set_axis(1, v_y);
+ basis.set_axis(2, v_z);
+ origin = p_eye;
}
-Transform Transform::interpolate_with(const Transform& p_transform, real_t p_c) const {
+Transform Transform::interpolate_with(const Transform &p_transform, real_t p_c) const {
/* not sure if very "efficient" but good enough? */
@@ -227,45 +210,44 @@ Transform Transform::interpolate_with(const Transform& p_transform, real_t p_c)
Vector3 dst_loc = p_transform.origin;
Transform dst;
- dst.basis=src_rot.slerp(dst_rot,p_c);
- dst.basis.scale(src_scale.linear_interpolate(dst_scale,p_c));
- dst.origin=src_loc.linear_interpolate(dst_loc,p_c);
+ dst.basis = src_rot.slerp(dst_rot, p_c);
+ dst.basis.scale(src_scale.linear_interpolate(dst_scale, p_c));
+ dst.origin = src_loc.linear_interpolate(dst_loc, p_c);
return dst;
}
-void Transform::scale(const Vector3& p_scale) {
+void Transform::scale(const Vector3 &p_scale) {
basis.scale(p_scale);
- origin*=p_scale;
+ origin *= p_scale;
}
-Transform Transform::scaled(const Vector3& p_scale) const {
+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) {
+void Transform::scale_basis(const Vector3 &p_scale) {
basis.scale(p_scale);
}
-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(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 ) {
+void Transform::translate(const Vector3 &p_translation) {
- for( int i = 0; i < 3; i++ ) {
+ for (int i = 0; i < 3; i++) {
origin[i] += basis[i].dot(p_translation);
}
}
-Transform Transform::translated( const Vector3& p_translation ) const {
+Transform Transform::translated(const Vector3 &p_translation) const {
- Transform t=*this;
+ Transform t = *this;
t.translate(p_translation);
return t;
}
@@ -282,25 +264,25 @@ Transform Transform::orthonormalized() const {
return _copy;
}
-bool Transform::operator==(const Transform& p_transform) const {
+bool Transform::operator==(const Transform &p_transform) const {
- return (basis==p_transform.basis && origin==p_transform.origin);
+ return (basis == p_transform.basis && origin == p_transform.origin);
}
-bool Transform::operator!=(const Transform& p_transform) const {
+bool Transform::operator!=(const Transform &p_transform) const {
- return (basis!=p_transform.basis || origin!=p_transform.origin);
+ return (basis != p_transform.basis || origin != p_transform.origin);
}
-void Transform::operator*=(const Transform& p_transform) {
+void Transform::operator*=(const Transform &p_transform) {
- origin=xform(p_transform.origin);
- basis*=p_transform.basis;
+ origin = xform(p_transform.origin);
+ basis *= p_transform.basis;
}
-Transform Transform::operator*(const Transform& p_transform) const {
+Transform Transform::operator*(const Transform &p_transform) const {
- Transform t=*this;
- t*=p_transform;
+ Transform t = *this;
+ t *= p_transform;
return t;
}
@@ -309,11 +291,10 @@ Transform::operator String() const {
return basis.operator String() + " - " + origin.operator String();
}
+Transform::Transform(const Basis &p_basis, const Vector3 &p_origin) {
-Transform::Transform(const Basis& p_basis, const Vector3& p_origin) {
-
- basis=p_basis;
- origin=p_origin;
+ basis = p_basis;
+ origin = p_origin;
}
-}
+} // namespace godot
diff --git a/src/core/Transform2D.cpp b/src/core/Transform2D.cpp
index e528465..1bc3710 100644
--- a/src/core/Transform2D.cpp
+++ b/src/core/Transform2D.cpp
@@ -1,7 +1,7 @@
#include "Transform2D.hpp"
-#include "Vector2.hpp"
-#include "String.hpp"
#include "Rect2.hpp"
+#include "String.hpp"
+#include "Vector2.hpp"
#include <algorithm>
@@ -17,75 +17,68 @@ Transform2D::Transform2D(real_t xx, real_t xy, real_t yx, real_t yy, real_t ox,
elements[2][1] = oy;
}
-
-
-Vector2 Transform2D::basis_xform(const Vector2& v) const {
+Vector2 Transform2D::basis_xform(const Vector2 &v) const {
return Vector2(
- tdotx(v),
- tdoty(v)
- );
+ tdotx(v),
+ tdoty(v));
}
-Vector2 Transform2D::basis_xform_inv(const Vector2& v) const{
+Vector2 Transform2D::basis_xform_inv(const Vector2 &v) const {
return Vector2(
- elements[0].dot(v),
- elements[1].dot(v)
- );
+ elements[0].dot(v),
+ elements[1].dot(v));
}
-Vector2 Transform2D::xform(const Vector2& v) const {
+Vector2 Transform2D::xform(const Vector2 &v) const {
return Vector2(
- tdotx(v),
- tdoty(v)
- ) + elements[2];
+ tdotx(v),
+ tdoty(v)) +
+ elements[2];
}
-Vector2 Transform2D::xform_inv(const Vector2& p_vec) const {
+Vector2 Transform2D::xform_inv(const Vector2 &p_vec) const {
Vector2 v = p_vec - elements[2];
return Vector2(
- elements[0].dot(v),
- elements[1].dot(v)
- );
-
+ elements[0].dot(v),
+ elements[1].dot(v));
}
-Rect2 Transform2D::xform(const Rect2& p_rect) const {
+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 pos = xform( p_rect.pos );
+ Vector2 x = elements[0] * p_rect.size.x;
+ Vector2 y = elements[1] * p_rect.size.y;
+ Vector2 pos = xform(p_rect.pos);
Rect2 new_rect;
- new_rect.pos=pos;
- new_rect.expand_to( pos+x );
- new_rect.expand_to( pos+y );
- new_rect.expand_to( pos+x+y );
+ new_rect.pos = pos;
+ new_rect.expand_to(pos + x);
+ new_rect.expand_to(pos + y);
+ new_rect.expand_to(pos + x + y);
return new_rect;
}
-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;
- elements[0][1]=::sin(p_rot)*p_scale.x;
+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;
+ elements[0][1] = ::sin(p_rot) * p_scale.x;
}
-Rect2 Transform2D::xform_inv(const Rect2& p_rect) const {
+Rect2 Transform2D::xform_inv(const Rect2 &p_rect) const {
- Vector2 ends[4]={
- xform_inv( p_rect.pos ),
- xform_inv( Vector2(p_rect.pos.x,p_rect.pos.y+p_rect.size.y ) ),
- xform_inv( Vector2(p_rect.pos.x+p_rect.size.x,p_rect.pos.y+p_rect.size.y ) ),
- xform_inv( Vector2(p_rect.pos.x+p_rect.size.x,p_rect.pos.y ) )
+ Vector2 ends[4] = {
+ xform_inv(p_rect.pos),
+ xform_inv(Vector2(p_rect.pos.x, p_rect.pos.y + p_rect.size.y)),
+ xform_inv(Vector2(p_rect.pos.x + p_rect.size.x, p_rect.pos.y + p_rect.size.y)),
+ xform_inv(Vector2(p_rect.pos.x + p_rect.size.x, p_rect.pos.y))
};
Rect2 new_rect;
- new_rect.pos=ends[0];
+ new_rect.pos = ends[0];
new_rect.expand_to(ends[1]);
new_rect.expand_to(ends[2]);
new_rect.expand_to(ends[3]);
@@ -96,205 +89,194 @@ Rect2 Transform2D::xform_inv(const Rect2& p_rect) const {
void Transform2D::invert() {
// FIXME: this function assumes the basis is a rotation matrix, with no scaling.
// Transform2D::affine_inverse can handle matrices with scaling, so GDScript should eventually use that.
- std::swap(elements[0][1],elements[1][0]);
+ std::swap(elements[0][1], elements[1][0]);
elements[2] = basis_xform(-elements[2]);
}
Transform2D Transform2D::inverse() const {
- Transform2D inv=*this;
+ Transform2D inv = *this;
inv.invert();
return inv;
-
}
void Transform2D::affine_invert() {
real_t det = basis_determinant();
- ERR_FAIL_COND(det==0);
+ ERR_FAIL_COND(det == 0);
real_t idet = 1.0 / det;
- std::swap( elements[0][0],elements[1][1] );
- elements[0]*=Vector2(idet,-idet);
- elements[1]*=Vector2(-idet,idet);
+ std::swap(elements[0][0], elements[1][1]);
+ elements[0] *= Vector2(idet, -idet);
+ elements[1] *= Vector2(-idet, idet);
elements[2] = basis_xform(-elements[2]);
-
}
Transform2D Transform2D::affine_inverse() const {
- Transform2D inv=*this;
+ Transform2D inv = *this;
inv.affine_invert();
return inv;
}
void Transform2D::rotate(real_t p_phi) {
- *this = Transform2D(p_phi,Vector2()) * (*this);
+ *this = Transform2D(p_phi, Vector2()) * (*this);
}
real_t Transform2D::get_rotation() const {
real_t det = basis_determinant();
Transform2D m = orthonormalized();
if (det < 0) {
- m.scale_basis(Size2(-1,-1));
+ m.scale_basis(Size2(-1, -1));
}
- return ::atan2(m[0].y,m[0].x);
+ return ::atan2(m[0].y, m[0].x);
}
void Transform2D::set_rotation(real_t p_rot) {
real_t cr = ::cos(p_rot);
real_t sr = ::sin(p_rot);
- elements[0][0]=cr;
- elements[0][1]=sr;
- elements[1][0]=-sr;
- elements[1][1]=cr;
+ elements[0][0] = cr;
+ elements[0][1] = sr;
+ elements[1][0] = -sr;
+ elements[1][1] = cr;
}
-Transform2D::Transform2D(real_t p_rot, const Vector2& p_pos) {
+Transform2D::Transform2D(real_t p_rot, const Vector2 &p_pos) {
real_t cr = ::cos(p_rot);
real_t sr = ::sin(p_rot);
- elements[0][0]=cr;
- elements[0][1]=sr;
- elements[1][0]=-sr;
- elements[1][1]=cr;
- elements[2]=p_pos;
+ elements[0][0] = cr;
+ elements[0][1] = sr;
+ elements[1][0] = -sr;
+ elements[1][1] = cr;
+ elements[2] = p_pos;
}
Size2 Transform2D::get_scale() const {
real_t det_sign = basis_determinant() > 0 ? 1 : -1;
- return det_sign * Size2( elements[0].length(), elements[1].length() );
+ return det_sign * Size2(elements[0].length(), elements[1].length());
}
-void Transform2D::scale(const Size2& p_scale) {
+void Transform2D::scale(const Size2 &p_scale) {
scale_basis(p_scale);
- elements[2]*=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::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) {
+void Transform2D::translate(real_t p_tx, real_t p_ty) {
- translate(Vector2(p_tx,p_ty));
+ translate(Vector2(p_tx, p_ty));
}
-void Transform2D::translate( const Vector2& p_translation ) {
+void Transform2D::translate(const Vector2 &p_translation) {
- elements[2]+=basis_xform(p_translation);
+ elements[2] += basis_xform(p_translation);
}
void Transform2D::orthonormalize() {
// Gram-Schmidt Process
- Vector2 x=elements[0];
- Vector2 y=elements[1];
+ Vector2 x = elements[0];
+ Vector2 y = elements[1];
x.normalize();
- y = (y-x*(x.dot(y)));
+ y = (y - x * (x.dot(y)));
y.normalize();
- elements[0]=x;
- elements[1]=y;
+ elements[0] = x;
+ elements[1] = y;
}
Transform2D Transform2D::orthonormalized() const {
- Transform2D on=*this;
+ Transform2D on = *this;
on.orthonormalize();
return on;
-
}
-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])
+ for (int i = 0; i < 3; i++) {
+ if (elements[i] != p_transform.elements[i])
return false;
}
return true;
}
-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])
+ for (int i = 0; i < 3; i++) {
+ if (elements[i] != p_transform.elements[i])
return true;
}
return false;
-
}
-void Transform2D::operator*=(const Transform2D& p_transform) {
+void Transform2D::operator*=(const Transform2D &p_transform) {
elements[2] = xform(p_transform.elements[2]);
- real_t x0,x1,y0,y1;
+ real_t x0, x1, y0, y1;
x0 = tdotx(p_transform.elements[0]);
x1 = tdoty(p_transform.elements[0]);
y0 = tdotx(p_transform.elements[1]);
y1 = tdoty(p_transform.elements[1]);
- elements[0][0]=x0;
- elements[0][1]=x1;
- elements[1][0]=y0;
- elements[1][1]=y1;
+ elements[0][0] = x0;
+ elements[0][1] = x1;
+ elements[1][0] = y0;
+ elements[1][1] = y1;
}
-
-Transform2D Transform2D::operator*(const Transform2D& p_transform) const {
+Transform2D Transform2D::operator*(const Transform2D &p_transform) const {
Transform2D t = *this;
- t*=p_transform;
+ t *= p_transform;
return t;
-
}
-Transform2D Transform2D::scaled(const Size2& p_scale) const {
+Transform2D Transform2D::scaled(const Size2 &p_scale) const {
- Transform2D copy=*this;
+ Transform2D copy = *this;
copy.scale(p_scale);
return copy;
-
}
-Transform2D Transform2D::basis_scaled(const Size2& p_scale) const {
+Transform2D Transform2D::basis_scaled(const Size2 &p_scale) const {
- Transform2D copy=*this;
+ Transform2D copy = *this;
copy.scale_basis(p_scale);
return copy;
-
}
Transform2D Transform2D::untranslated() const {
- Transform2D copy=*this;
- copy.elements[2]=Vector2();
+ Transform2D copy = *this;
+ copy.elements[2] = Vector2();
return copy;
}
-Transform2D Transform2D::translated(const Vector2& p_offset) const {
+Transform2D Transform2D::translated(const Vector2 &p_offset) const {
- Transform2D copy=*this;
+ Transform2D copy = *this;
copy.translate(p_offset);
return copy;
-
}
Transform2D Transform2D::rotated(real_t p_phi) const {
- Transform2D copy=*this;
+ Transform2D copy = *this;
copy.rotate(p_phi);
return copy;
-
}
real_t Transform2D::basis_determinant() const {
@@ -302,7 +284,7 @@ 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 {
+Transform2D Transform2D::interpolate_with(const Transform2D &p_transform, real_t p_c) const {
//extract parameters
Vector2 p1 = get_origin();
@@ -327,9 +309,9 @@ Transform2D Transform2D::interpolate_with(const Transform2D& p_transform, real_t
if (dot > 0.9995) {
v = Vector2::linear_interpolate(v1, v2, p_c).normalized(); //linearly interpolate to avoid numerical precision issues
} else {
- real_t angle = p_c*::acos(dot);
- Vector2 v3 = (v2 - v1*dot).normalized();
- v = v1*::cos(angle) + v3*::sin(angle);
+ real_t angle = p_c * ::acos(dot);
+ Vector2 v3 = (v2 - v1 * dot).normalized();
+ v = v1 * ::cos(angle) + v3 * ::sin(angle);
}
//construct matrix
@@ -343,4 +325,4 @@ Transform2D::operator String() const {
return String(String() + elements[0] + ", " + elements[1] + ", " + elements[2]);
}
-}
+} // namespace godot
diff --git a/src/core/Variant.cpp b/src/core/Variant.cpp
index 4f88951..a013639 100644
--- a/src/core/Variant.cpp
+++ b/src/core/Variant.cpp
@@ -2,8 +2,8 @@
#include <gdnative/variant.h>
-#include "Defs.hpp"
#include "CoreTypes.hpp"
+#include "Defs.hpp"
#include "GodotGlobal.hpp"
#include "Object.hpp"
@@ -11,18 +11,15 @@
namespace godot {
-Variant::Variant()
-{
+Variant::Variant() {
godot::api->godot_variant_new_nil(&_godot_variant);
}
-Variant::Variant(const Variant& v)
-{
+Variant::Variant(const Variant &v) {
godot::api->godot_variant_new_copy(&_godot_variant, &v._godot_variant);
}
-Variant::Variant(bool p_bool)
-{
+Variant::Variant(bool p_bool) {
godot::api->godot_variant_new_bool(&_godot_variant, p_bool);
}
@@ -31,410 +28,326 @@ Variant::Variant(signed int p_int) // real one
godot::api->godot_variant_new_int(&_godot_variant, p_int);
}
-Variant::Variant(unsigned int p_int)
-{
+Variant::Variant(unsigned int p_int) {
godot::api->godot_variant_new_uint(&_godot_variant, p_int);
}
Variant::Variant(signed short p_short) // real one
{
- godot::api->godot_variant_new_int(&_godot_variant, (int) p_short);
+ godot::api->godot_variant_new_int(&_godot_variant, (int)p_short);
}
-
Variant::Variant(int64_t p_char) // real one
{
godot::api->godot_variant_new_int(&_godot_variant, p_char);
}
-Variant::Variant(uint64_t p_char)
-{
+Variant::Variant(uint64_t p_char) {
godot::api->godot_variant_new_uint(&_godot_variant, p_char);
}
-Variant::Variant(float p_float)
-{
+Variant::Variant(float p_float) {
godot::api->godot_variant_new_real(&_godot_variant, p_float);
}
-Variant::Variant(double p_double)
-{
+Variant::Variant(double p_double) {
godot::api->godot_variant_new_real(&_godot_variant, p_double);
}
-Variant::Variant(const String& p_string)
-{
- godot::api->godot_variant_new_string(&_godot_variant, (godot_string *) &p_string);
+Variant::Variant(const String &p_string) {
+ godot::api->godot_variant_new_string(&_godot_variant, (godot_string *)&p_string);
}
-Variant::Variant(const char * const p_cstring)
-{
+Variant::Variant(const char *const p_cstring) {
String s = String(p_cstring);
- godot::api->godot_variant_new_string(&_godot_variant, (godot_string *) &s);
+ godot::api->godot_variant_new_string(&_godot_variant, (godot_string *)&s);
}
-Variant::Variant(const wchar_t * p_wstring)
-{
+Variant::Variant(const wchar_t *p_wstring) {
String s = p_wstring;
- godot::api->godot_variant_new_string(&_godot_variant, (godot_string *) &s);
+ godot::api->godot_variant_new_string(&_godot_variant, (godot_string *)&s);
}
-Variant::Variant(const Vector2& p_vector2)
-{
- godot::api->godot_variant_new_vector2(&_godot_variant, (godot_vector2 *) &p_vector2);
+Variant::Variant(const Vector2 &p_vector2) {
+ godot::api->godot_variant_new_vector2(&_godot_variant, (godot_vector2 *)&p_vector2);
}
-Variant::Variant(const Rect2& p_rect2)
-{
- godot::api->godot_variant_new_rect2(&_godot_variant, (godot_rect2 *) &p_rect2);
+Variant::Variant(const Rect2 &p_rect2) {
+ godot::api->godot_variant_new_rect2(&_godot_variant, (godot_rect2 *)&p_rect2);
}
-Variant::Variant(const Vector3& p_vector3)
-{
- godot::api->godot_variant_new_vector3(&_godot_variant, (godot_vector3 *) &p_vector3);
+Variant::Variant(const Vector3 &p_vector3) {
+ godot::api->godot_variant_new_vector3(&_godot_variant, (godot_vector3 *)&p_vector3);
}
-Variant::Variant(const Plane& p_plane)
-{
- godot::api->godot_variant_new_plane(&_godot_variant, (godot_plane *) &p_plane);
+Variant::Variant(const Plane &p_plane) {
+ godot::api->godot_variant_new_plane(&_godot_variant, (godot_plane *)&p_plane);
}
-
-Variant::Variant(const AABB& p_aabb)
-{
- godot::api->godot_variant_new_aabb(&_godot_variant, (godot_aabb *) &p_aabb);
+Variant::Variant(const AABB &p_aabb) {
+ godot::api->godot_variant_new_aabb(&_godot_variant, (godot_aabb *)&p_aabb);
}
-Variant::Variant(const Quat& p_quat)
-{
- godot::api->godot_variant_new_quat(&_godot_variant, (godot_quat *) &p_quat);
+Variant::Variant(const Quat &p_quat) {
+ godot::api->godot_variant_new_quat(&_godot_variant, (godot_quat *)&p_quat);
}
-Variant::Variant(const Basis& p_transform)
-{
- godot::api->godot_variant_new_basis(&_godot_variant, (godot_basis *) &p_transform);
+Variant::Variant(const Basis &p_transform) {
+ godot::api->godot_variant_new_basis(&_godot_variant, (godot_basis *)&p_transform);
}
-Variant::Variant(const Transform2D& p_transform)
-{
- godot::api->godot_variant_new_transform2d(&_godot_variant, (godot_transform2d *) &p_transform);
+Variant::Variant(const Transform2D &p_transform) {
+ godot::api->godot_variant_new_transform2d(&_godot_variant, (godot_transform2d *)&p_transform);
}
-Variant::Variant(const Transform& p_transform)
-{
- godot::api->godot_variant_new_transform(&_godot_variant, (godot_transform *) &p_transform);
+Variant::Variant(const Transform &p_transform) {
+ godot::api->godot_variant_new_transform(&_godot_variant, (godot_transform *)&p_transform);
}
-Variant::Variant(const Color& p_color)
-{
- godot::api->godot_variant_new_color(&_godot_variant, (godot_color *) &p_color);
+Variant::Variant(const Color &p_color) {
+ godot::api->godot_variant_new_color(&_godot_variant, (godot_color *)&p_color);
}
-Variant::Variant(const NodePath& p_path)
-{
- godot::api->godot_variant_new_node_path(&_godot_variant, (godot_node_path *) &p_path);
+Variant::Variant(const NodePath &p_path) {
+ godot::api->godot_variant_new_node_path(&_godot_variant, (godot_node_path *)&p_path);
}
-Variant::Variant(const RID& p_rid)
-{
- godot::api->godot_variant_new_rid(&_godot_variant, (godot_rid *) &p_rid);
+Variant::Variant(const RID &p_rid) {
+ godot::api->godot_variant_new_rid(&_godot_variant, (godot_rid *)&p_rid);
}
-Variant::Variant(const Object* p_object)
-{
+Variant::Variant(const Object *p_object) {
if (p_object)
godot::api->godot_variant_new_object(&_godot_variant, p_object->_owner);
else
godot::api->godot_variant_new_nil(&_godot_variant);
}
-Variant::Variant(const Dictionary& p_dictionary)
-{
- godot::api->godot_variant_new_dictionary(&_godot_variant, (godot_dictionary *) &p_dictionary);
+Variant::Variant(const Dictionary &p_dictionary) {
+ godot::api->godot_variant_new_dictionary(&_godot_variant, (godot_dictionary *)&p_dictionary);
}
-Variant::Variant(const Array& p_array)
-{
- godot::api->godot_variant_new_array(&_godot_variant, (godot_array *) &p_array);
+Variant::Variant(const Array &p_array) {
+ godot::api->godot_variant_new_array(&_godot_variant, (godot_array *)&p_array);
}
-Variant::Variant(const PoolByteArray& p_raw_array)
-{
- godot::api->godot_variant_new_pool_byte_array(&_godot_variant, (godot_pool_byte_array *) &p_raw_array);
+Variant::Variant(const PoolByteArray &p_raw_array) {
+ godot::api->godot_variant_new_pool_byte_array(&_godot_variant, (godot_pool_byte_array *)&p_raw_array);
}
-Variant::Variant(const PoolIntArray& p_int_array)
-{
- godot::api->godot_variant_new_pool_int_array(&_godot_variant, (godot_pool_int_array *) &p_int_array);
+Variant::Variant(const PoolIntArray &p_int_array) {
+ godot::api->godot_variant_new_pool_int_array(&_godot_variant, (godot_pool_int_array *)&p_int_array);
}
-Variant::Variant(const PoolRealArray& p_real_array)
-{
- godot::api->godot_variant_new_pool_real_array(&_godot_variant, (godot_pool_real_array *) &p_real_array);
+Variant::Variant(const PoolRealArray &p_real_array) {
+ godot::api->godot_variant_new_pool_real_array(&_godot_variant, (godot_pool_real_array *)&p_real_array);
}
-Variant::Variant(const PoolStringArray& p_string_array)
-{
- godot::api->godot_variant_new_pool_string_array(&_godot_variant, (godot_pool_string_array *) &p_string_array);
+Variant::Variant(const PoolStringArray &p_string_array) {
+ godot::api->godot_variant_new_pool_string_array(&_godot_variant, (godot_pool_string_array *)&p_string_array);
}
-Variant::Variant(const PoolVector2Array& p_vector2_array)
-{
- godot::api->godot_variant_new_pool_vector2_array(&_godot_variant, (godot_pool_vector2_array *) &p_vector2_array);
+Variant::Variant(const PoolVector2Array &p_vector2_array) {
+ godot::api->godot_variant_new_pool_vector2_array(&_godot_variant, (godot_pool_vector2_array *)&p_vector2_array);
}
-Variant::Variant(const PoolVector3Array& p_vector3_array)
-{
- godot::api->godot_variant_new_pool_vector3_array(&_godot_variant, (godot_pool_vector3_array *) &p_vector3_array);
+Variant::Variant(const PoolVector3Array &p_vector3_array) {
+ godot::api->godot_variant_new_pool_vector3_array(&_godot_variant, (godot_pool_vector3_array *)&p_vector3_array);
}
-Variant::Variant(const PoolColorArray& p_color_array)
-{
- godot::api->godot_variant_new_pool_color_array(&_godot_variant, (godot_pool_color_array *) &p_color_array);
+Variant::Variant(const PoolColorArray &p_color_array) {
+ godot::api->godot_variant_new_pool_color_array(&_godot_variant, (godot_pool_color_array *)&p_color_array);
}
-
-Variant &Variant::operator =(const Variant& v)
-{
+Variant &Variant::operator=(const Variant &v) {
godot::api->godot_variant_new_copy(&_godot_variant, &v._godot_variant);
return *this;
}
-
-Variant::operator bool() const
-{
+Variant::operator bool() const {
return booleanize();
}
-Variant::operator signed int() const
-{
+Variant::operator signed int() const {
return godot::api->godot_variant_as_int(&_godot_variant);
}
Variant::operator unsigned int() const // this is the real one
{
return godot::api->godot_variant_as_uint(&_godot_variant);
}
-Variant::operator signed short() const
-{
+Variant::operator signed short() const {
return godot::api->godot_variant_as_int(&_godot_variant);
}
-Variant::operator unsigned short() const
-{
+Variant::operator unsigned short() const {
return godot::api->godot_variant_as_uint(&_godot_variant);
}
-Variant::operator signed char() const
-{
+Variant::operator signed char() const {
return godot::api->godot_variant_as_int(&_godot_variant);
}
-Variant::operator unsigned char() const
-{
+Variant::operator unsigned char() const {
return godot::api->godot_variant_as_uint(&_godot_variant);
}
-Variant::operator int64_t() const
-{
+Variant::operator int64_t() const {
return godot::api->godot_variant_as_int(&_godot_variant);
}
-Variant::operator uint64_t() const
-{
+Variant::operator uint64_t() const {
return godot::api->godot_variant_as_uint(&_godot_variant);
}
-
-Variant::operator wchar_t() const
-{
+Variant::operator wchar_t() const {
return godot::api->godot_variant_as_int(&_godot_variant);
}
-Variant::operator float() const
-{
+Variant::operator float() const {
return godot::api->godot_variant_as_real(&_godot_variant);
}
-Variant::operator double() const
-{
+Variant::operator double() const {
return godot::api->godot_variant_as_real(&_godot_variant);
}
-Variant::operator String() const
-{
+Variant::operator String() const {
godot_string s = godot::api->godot_variant_as_string(&_godot_variant);
- return *(String *) &s;
+ return *(String *)&s;
}
-Variant::operator Vector2() const
-{
+Variant::operator Vector2() const {
godot_vector2 s = godot::api->godot_variant_as_vector2(&_godot_variant);
- return *(Vector2 *) &s;
+ return *(Vector2 *)&s;
}
-Variant::operator Rect2() const
-{
+Variant::operator Rect2() const {
godot_rect2 s = godot::api->godot_variant_as_rect2(&_godot_variant);
- return *(Rect2 *) &s;
+ return *(Rect2 *)&s;
}
-Variant::operator Vector3() const
-{
+Variant::operator Vector3() const {
godot_vector3 s = godot::api->godot_variant_as_vector3(&_godot_variant);
- return *(Vector3 *) &s;
+ return *(Vector3 *)&s;
}
-Variant::operator Plane() const
-{
+Variant::operator Plane() const {
godot_plane s = godot::api->godot_variant_as_plane(&_godot_variant);
- return *(Plane *) &s;
+ return *(Plane *)&s;
}
-Variant::operator AABB() const
-{
+Variant::operator AABB() const {
godot_aabb s = godot::api->godot_variant_as_aabb(&_godot_variant);
- return *(AABB *) &s;
+ return *(AABB *)&s;
}
-Variant::operator Quat() const
-{
+Variant::operator Quat() const {
godot_quat s = godot::api->godot_variant_as_quat(&_godot_variant);
- return *(Quat *) &s;
+ return *(Quat *)&s;
}
-Variant::operator Basis() const
-{
+Variant::operator Basis() const {
godot_basis s = godot::api->godot_variant_as_basis(&_godot_variant);
- return *(Basis *) &s;
+ return *(Basis *)&s;
}
-Variant::operator Transform() const
-{
+Variant::operator Transform() const {
godot_transform s = godot::api->godot_variant_as_transform(&_godot_variant);
- return *(Transform *) &s;
+ return *(Transform *)&s;
}
-Variant::operator Transform2D() const
-{
+Variant::operator Transform2D() const {
godot_transform2d s = godot::api->godot_variant_as_transform2d(&_godot_variant);
- return *(Transform2D *) &s;
+ return *(Transform2D *)&s;
}
-Variant::operator Color() const
-{
+Variant::operator Color() const {
godot_color s = godot::api->godot_variant_as_color(&_godot_variant);
- return *(Color *) &s;
+ return *(Color *)&s;
}
-Variant::operator NodePath() const
-{
+Variant::operator NodePath() const {
godot_node_path s = godot::api->godot_variant_as_node_path(&_godot_variant);
- return *(NodePath *) &s;
+ return *(NodePath *)&s;
}
-Variant::operator RID() const
-{
+Variant::operator RID() const {
godot_rid s = godot::api->godot_variant_as_rid(&_godot_variant);
- return *(RID *) &s;
+ return *(RID *)&s;
}
-Variant::operator Dictionary() const
-{
+Variant::operator Dictionary() const {
godot_dictionary d = godot::api->godot_variant_as_dictionary(&_godot_variant);
- return *(Dictionary *) &d;
+ return *(Dictionary *)&d;
}
-Variant::operator Array() const
-{
+Variant::operator Array() const {
godot_array s = godot::api->godot_variant_as_array(&_godot_variant);
- return *(Array *) &s;
+ return *(Array *)&s;
}
-Variant::operator PoolByteArray() const
-{
+Variant::operator PoolByteArray() const {
godot_pool_byte_array s = godot::api->godot_variant_as_pool_byte_array(&_godot_variant);
- return *(PoolByteArray *) &s;
+ return *(PoolByteArray *)&s;
}
-Variant::operator PoolIntArray() const
-{
+Variant::operator PoolIntArray() const {
godot_pool_int_array s = godot::api->godot_variant_as_pool_int_array(&_godot_variant);
- return *(PoolIntArray *) &s;
+ return *(PoolIntArray *)&s;
}
-Variant::operator PoolRealArray() const
-{
+Variant::operator PoolRealArray() const {
godot_pool_real_array s = godot::api->godot_variant_as_pool_real_array(&_godot_variant);
- return *(PoolRealArray *) &s;
+ return *(PoolRealArray *)&s;
}
-Variant::operator PoolStringArray() const
-{
+Variant::operator PoolStringArray() const {
godot_pool_string_array s = godot::api->godot_variant_as_pool_string_array(&_godot_variant);
- return *(PoolStringArray *) &s;
+ return *(PoolStringArray *)&s;
}
-Variant::operator PoolVector2Array() const
-{
+Variant::operator PoolVector2Array() const {
godot_pool_vector2_array s = godot::api->godot_variant_as_pool_vector2_array(&_godot_variant);
- return *(PoolVector2Array *) &s;
+ return *(PoolVector2Array *)&s;
}
-Variant::operator PoolVector3Array() const
-{
+Variant::operator PoolVector3Array() const {
godot_pool_vector3_array s = godot::api->godot_variant_as_pool_vector3_array(&_godot_variant);
- return *(PoolVector3Array *) &s;
+ return *(PoolVector3Array *)&s;
}
-Variant::operator PoolColorArray() const
-{
+Variant::operator PoolColorArray() const {
godot_pool_color_array s = godot::api->godot_variant_as_pool_color_array(&_godot_variant);
- return *(PoolColorArray *) &s;
+ return *(PoolColorArray *)&s;
}
-Variant::operator godot_object*() const {
+Variant::operator godot_object *() const {
return godot::api->godot_variant_as_object(&_godot_variant);
}
-Variant::Type Variant::get_type() const
-{
- return (Type) godot::api->godot_variant_get_type(&_godot_variant);
+Variant::Type Variant::get_type() const {
+ return (Type)godot::api->godot_variant_get_type(&_godot_variant);
}
-
-Variant Variant::call(const String& method, const Variant **args, const int arg_count)
-{
+Variant Variant::call(const String &method, const Variant **args, const int arg_count) {
Variant v;
- *(godot_variant *) &v = godot::api->godot_variant_call(&_godot_variant, (godot_string *) &method, (const godot_variant **)args, arg_count, nullptr);
+ *(godot_variant *)&v = godot::api->godot_variant_call(&_godot_variant, (godot_string *)&method, (const godot_variant **)args, arg_count, nullptr);
return v;
}
-bool Variant::has_method(const String& method)
-{
- return godot::api->godot_variant_has_method(&_godot_variant, (godot_string *) &method);
+bool Variant::has_method(const String &method) {
+ return godot::api->godot_variant_has_method(&_godot_variant, (godot_string *)&method);
}
-bool Variant::operator ==(const Variant& b) const
-{
+bool Variant::operator==(const Variant &b) const {
return godot::api->godot_variant_operator_equal(&_godot_variant, &b._godot_variant);
}
-bool Variant::operator !=(const Variant& b) const
-{
+bool Variant::operator!=(const Variant &b) const {
return !(*this == b);
}
-bool Variant::operator <(const Variant& b) const
-{
+bool Variant::operator<(const Variant &b) const {
return godot::api->godot_variant_operator_less(&_godot_variant, &b._godot_variant);
}
-bool Variant::operator <=(const Variant& b) const
-{
+bool Variant::operator<=(const Variant &b) const {
return (*this < b) || (*this == b);
}
-bool Variant::operator >(const Variant& b) const
-{
+bool Variant::operator>(const Variant &b) const {
return !(*this <= b);
}
-bool Variant::operator >=(const Variant& b) const
-{
+bool Variant::operator>=(const Variant &b) const {
return !(*this < b);
}
-bool Variant::hash_compare(const Variant& b) const
-{
+bool Variant::hash_compare(const Variant &b) const {
return godot::api->godot_variant_hash_compare(&_godot_variant, &b._godot_variant);
}
-bool Variant::booleanize() const
-{
+bool Variant::booleanize() const {
return godot::api->godot_variant_booleanize(&_godot_variant);
}
-Variant::~Variant()
-{
+Variant::~Variant() {
godot::api->godot_variant_destroy(&_godot_variant);
}
-
-
-}
-
+} // namespace godot
diff --git a/src/core/Vector2.cpp b/src/core/Vector2.cpp
index 379af9e..66f6bdd 100644
--- a/src/core/Vector2.cpp
+++ b/src/core/Vector2.cpp
@@ -8,78 +8,64 @@
namespace godot {
-Vector2 Vector2::operator+(const Vector2& p_v) const
-{
+Vector2 Vector2::operator+(const Vector2 &p_v) const {
return Vector2(x + p_v.x, y + p_v.y);
}
-void Vector2::operator+=(const Vector2& p_v)
-{
+void Vector2::operator+=(const Vector2 &p_v) {
x += p_v.x;
y += p_v.y;
}
-Vector2 Vector2::operator-(const Vector2& p_v) const
-{
+Vector2 Vector2::operator-(const Vector2 &p_v) const {
return Vector2(x - p_v.x, y - p_v.y);
}
-void Vector2::operator-=(const Vector2& p_v)
-{
+void Vector2::operator-=(const Vector2 &p_v) {
x -= p_v.x;
y -= p_v.y;
}
-Vector2 Vector2::operator*(const Vector2 &p_v1) const
-{
+Vector2 Vector2::operator*(const Vector2 &p_v1) const {
return Vector2(x * p_v1.x, y * p_v1.y);
}
-Vector2 Vector2::operator*(const real_t &rvalue) const
-{
+Vector2 Vector2::operator*(const real_t &rvalue) const {
return Vector2(x * rvalue, y * rvalue);
}
-void Vector2::operator*=(const real_t &rvalue)
-{
+void Vector2::operator*=(const real_t &rvalue) {
x *= rvalue;
y *= rvalue;
}
-Vector2 Vector2::operator/(const Vector2 &p_v1) const
-{
+Vector2 Vector2::operator/(const Vector2 &p_v1) const {
return Vector2(x / p_v1.x, y / p_v1.y);
}
-Vector2 Vector2::operator/(const real_t &rvalue) const
-{
+Vector2 Vector2::operator/(const real_t &rvalue) const {
return Vector2(x / rvalue, y / rvalue);
}
-void Vector2::operator/=(const real_t &rvalue)
-{
+void Vector2::operator/=(const real_t &rvalue) {
x /= rvalue;
y /= rvalue;
}
-Vector2 Vector2::operator-() const
-{
+Vector2 Vector2::operator-() const {
return Vector2(-x, -y);
}
-bool Vector2::operator==(const Vector2& p_vec2) const
-{
+bool Vector2::operator==(const Vector2 &p_vec2) const {
return x == p_vec2.x && y == p_vec2.y;
}
-bool Vector2::operator!=(const Vector2& p_vec2) const
-{
+bool Vector2::operator!=(const Vector2 &p_vec2) const {
return x != p_vec2.x || y != p_vec2.y;
}
-void Vector2::normalize()
-{
- real_t l = x*x + y*y;
+void Vector2::normalize() {
+ real_t l = x * x + y * y;
if (l != 0) {
l = sqrt(l);
x /= l;
@@ -87,71 +73,58 @@ void Vector2::normalize()
}
}
-Vector2 Vector2::normalized() const
-{
+Vector2 Vector2::normalized() const {
Vector2 v = *this;
v.normalize();
return v;
}
-real_t Vector2::length() const
-{
- return sqrt(x*x + y*y);
+real_t Vector2::length() const {
+ return sqrt(x * x + y * y);
}
-real_t Vector2::length_squared() const
-{
- return x*x + y*y;
+real_t Vector2::length_squared() const {
+ return x * x + y * y;
}
-real_t Vector2::distance_to(const Vector2& p_vector2) const
-{
+real_t Vector2::distance_to(const Vector2 &p_vector2) const {
return sqrt((x - p_vector2.x) * (x - p_vector2.x) + (y - p_vector2.y) * (y - p_vector2.y));
}
-real_t Vector2::distance_squared_to(const Vector2& p_vector2) const
-{
+real_t Vector2::distance_squared_to(const Vector2 &p_vector2) const {
return (x - p_vector2.x) * (x - p_vector2.x) + (y - p_vector2.y) * (y - p_vector2.y);
}
-real_t Vector2::angle_to(const Vector2& p_vector2) const
-{
+real_t Vector2::angle_to(const Vector2 &p_vector2) const {
return atan2(cross(p_vector2), dot(p_vector2));
}
-real_t Vector2::angle_to_point(const Vector2& p_vector2) const
-{
- return atan2(y - p_vector2.y, x-p_vector2.x);
+real_t Vector2::angle_to_point(const Vector2 &p_vector2) const {
+ return atan2(y - p_vector2.y, x - p_vector2.x);
}
-real_t Vector2::dot(const Vector2& p_other) const
-{
+real_t Vector2::dot(const Vector2 &p_other) const {
return x * p_other.x + y * p_other.y;
}
-real_t Vector2::cross(const Vector2& p_other) const
-{
+real_t Vector2::cross(const Vector2 &p_other) const {
return x * p_other.y - y * p_other.x;
}
-Vector2 Vector2::cross(real_t p_other) const
-{
+Vector2 Vector2::cross(real_t p_other) const {
return Vector2(p_other * y, -p_other * x);
}
-Vector2 Vector2::project(const Vector2& p_vec) const
-{
+Vector2 Vector2::project(const Vector2 &p_vec) const {
Vector2 v1 = p_vec;
Vector2 v2 = *this;
return v2 * (v1.dot(v2) / v2.dot(v2));
}
-Vector2 Vector2::plane_project(real_t p_d, const Vector2& p_vec) const
-{
- return p_vec - *this * ( dot(p_vec) -p_d);
+Vector2 Vector2::plane_project(real_t p_d, const Vector2 &p_vec) const {
+ return p_vec - *this * (dot(p_vec) - p_d);
}
-Vector2 Vector2::clamped(real_t p_len) const
-{
+Vector2 Vector2::clamped(real_t p_len) const {
real_t l = length();
Vector2 v = *this;
if (l > 0 && p_len < l) {
@@ -161,55 +134,48 @@ Vector2 Vector2::clamped(real_t p_len) const
return v;
}
-Vector2 Vector2::linear_interpolate(const Vector2& p_a, const Vector2& p_b,real_t p_t)
-{
- Vector2 res=p_a;
- res.x+= (p_t * (p_b.x-p_a.x));
- res.y+= (p_t * (p_b.y-p_a.y));
+Vector2 Vector2::linear_interpolate(const Vector2 &p_a, const Vector2 &p_b, real_t p_t) {
+ Vector2 res = p_a;
+ res.x += (p_t * (p_b.x - p_a.x));
+ res.y += (p_t * (p_b.y - p_a.y));
return res;
}
-Vector2 Vector2::linear_interpolate(const Vector2& p_b,real_t p_t) const
-{
- Vector2 res=*this;
- res.x+= (p_t * (p_b.x-x));
- res.y+= (p_t * (p_b.y-y));
+Vector2 Vector2::linear_interpolate(const Vector2 &p_b, real_t p_t) const {
+ Vector2 res = *this;
+ res.x += (p_t * (p_b.x - x));
+ res.y += (p_t * (p_b.y - y));
return res;
-
}
-Vector2 Vector2::cubic_interpolate(const Vector2& p_b,const Vector2& p_pre_a, const Vector2& p_post_b,real_t p_t) const
-{
- Vector2 p0=p_pre_a;
- Vector2 p1=*this;
- Vector2 p2=p_b;
- Vector2 p3=p_post_b;
+Vector2 Vector2::cubic_interpolate(const Vector2 &p_b, const Vector2 &p_pre_a, const Vector2 &p_post_b, real_t p_t) const {
+ Vector2 p0 = p_pre_a;
+ Vector2 p1 = *this;
+ Vector2 p2 = p_b;
+ Vector2 p3 = p_post_b;
real_t t = p_t;
real_t t2 = t * t;
real_t t3 = t2 * t;
Vector2 out;
- out = ( ( p1 * 2.0) +
- ( -p0 + p2 ) * t +
- ( p0 * 2.0 - p1 * 5.0 + p2 * 4 - p3 ) * t2 +
- ( -p0 + p1 * 3.0 - p2 * 3.0 + p3 ) * t3 ) * 0.5;
+ out = ((p1 * 2.0) +
+ (-p0 + p2) * t +
+ (p0 * 2.0 - p1 * 5.0 + p2 * 4 - p3) * t2 +
+ (-p0 + p1 * 3.0 - p2 * 3.0 + p3) * t3) *
+ 0.5;
return out;
}
-
-Vector2 Vector2::slide(const Vector2& p_vec) const
-{
+Vector2 Vector2::slide(const Vector2 &p_vec) const {
return p_vec - *this * this->dot(p_vec);
}
-Vector2 Vector2::reflect(const Vector2& p_vec) const
-{
+Vector2 Vector2::reflect(const Vector2 &p_vec) const {
return p_vec - *this * this->dot(p_vec) * 2.0;
}
-real_t Vector2::angle() const
-{
+real_t Vector2::angle() const {
return atan2(y, x);
}
@@ -221,11 +187,10 @@ void Vector2::set_rotation(real_t p_radians) {
Vector2 Vector2::abs() const {
- return Vector2( fabs(x), fabs(y) );
+ return Vector2(fabs(x), fabs(y));
}
-Vector2 Vector2::rotated(real_t p_by) const
-{
+Vector2 Vector2::rotated(real_t p_by) const {
Vector2 v;
v.set_rotation(angle() + p_by);
v *= length();
@@ -234,26 +199,21 @@ Vector2 Vector2::rotated(real_t p_by) const
Vector2 Vector2::tangent() const {
- return Vector2(y,-x);
+ return Vector2(y, -x);
}
-Vector2 Vector2::floor() const
-{
+Vector2 Vector2::floor() const {
return Vector2(::floor(x), ::floor(y));
}
-Vector2 Vector2::snapped(const Vector2& p_by) const
-{
+Vector2 Vector2::snapped(const Vector2 &p_by) const {
return Vector2(
- p_by.x != 0 ? ::floor(x / p_by.x + 0.5) * p_by.x : x,
- p_by.y != 0 ? ::floor(y / p_by.y + 0.5) * p_by.y : y
- );
+ p_by.x != 0 ? ::floor(x / p_by.x + 0.5) * p_by.x : x,
+ p_by.y != 0 ? ::floor(y / p_by.y + 0.5) * p_by.y : y);
}
-Vector2::operator String() const
-{
+Vector2::operator String() const {
return String::num(x) + ", " + String::num(y);
}
-
-}
+} // namespace godot
diff --git a/src/core/Vector3.cpp b/src/core/Vector3.cpp
index 4098825..a15fb78 100644
--- a/src/core/Vector3.cpp
+++ b/src/core/Vector3.cpp
@@ -10,346 +10,293 @@
namespace godot {
-Vector3::Vector3(real_t x, real_t y, real_t z)
-{
+Vector3::Vector3(real_t x, real_t y, real_t z) {
this->x = x;
this->y = y;
this->z = z;
}
-Vector3::Vector3()
-{
+Vector3::Vector3() {
this->x = 0;
this->y = 0;
this->z = 0;
}
-const real_t& Vector3::operator[](int p_axis) const
-{
+const real_t &Vector3::operator[](int p_axis) const {
return coord[p_axis];
}
-real_t& Vector3::operator[](int p_axis)
-{
+real_t &Vector3::operator[](int p_axis) {
return coord[p_axis];
}
-Vector3& Vector3::operator+=(const Vector3& p_v)
-{
+Vector3 &Vector3::operator+=(const Vector3 &p_v) {
x += p_v.x;
y += p_v.y;
z += p_v.z;
return *this;
}
-Vector3 Vector3::operator+(const Vector3& p_v) const
-{
+Vector3 Vector3::operator+(const Vector3 &p_v) const {
Vector3 v = *this;
v += p_v;
return v;
}
-Vector3& Vector3::operator-=(const Vector3& p_v)
-{
+Vector3 &Vector3::operator-=(const Vector3 &p_v) {
x -= p_v.x;
y -= p_v.y;
z -= p_v.z;
return *this;
}
-Vector3 Vector3::operator-(const Vector3& p_v) const
-{
+Vector3 Vector3::operator-(const Vector3 &p_v) const {
Vector3 v = *this;
v -= p_v;
return v;
}
-Vector3& Vector3::operator*=(const Vector3& p_v)
-{
+Vector3 &Vector3::operator*=(const Vector3 &p_v) {
x *= p_v.x;
y *= p_v.y;
z *= p_v.z;
return *this;
}
-Vector3 Vector3::operator*(const Vector3& p_v) const
-{
+Vector3 Vector3::operator*(const Vector3 &p_v) const {
Vector3 v = *this;
v *= p_v;
return v;
}
-Vector3& Vector3::operator/=(const Vector3& p_v)
-{
+Vector3 &Vector3::operator/=(const Vector3 &p_v) {
x /= p_v.x;
y /= p_v.y;
z /= p_v.z;
return *this;
}
-Vector3 Vector3::operator/(const Vector3& p_v) const
-{
+Vector3 Vector3::operator/(const Vector3 &p_v) const {
Vector3 v = *this;
v /= p_v;
return v;
}
-
-Vector3& Vector3::operator*=(real_t p_scalar)
-{
+Vector3 &Vector3::operator*=(real_t p_scalar) {
*this *= Vector3(p_scalar, p_scalar, p_scalar);
return *this;
}
-Vector3 Vector3::operator*(real_t p_scalar) const
-{
+Vector3 Vector3::operator*(real_t p_scalar) const {
Vector3 v = *this;
v *= p_scalar;
return v;
}
-Vector3& Vector3::operator/=(real_t p_scalar)
-{
+Vector3 &Vector3::operator/=(real_t p_scalar) {
*this /= Vector3(p_scalar, p_scalar, p_scalar);
return *this;
}
-Vector3 Vector3::operator/(real_t p_scalar) const
-{
+Vector3 Vector3::operator/(real_t p_scalar) const {
Vector3 v = *this;
v /= p_scalar;
return v;
}
-Vector3 Vector3::operator-() const
-{
+Vector3 Vector3::operator-() const {
return Vector3(-x, -y, -z);
}
-bool Vector3::operator==(const Vector3& p_v) const
-{
- return (x==p_v.x && y==p_v.y && z==p_v.z);
+bool Vector3::operator==(const Vector3 &p_v) const {
+ return (x == p_v.x && y == p_v.y && z == p_v.z);
}
-bool Vector3::operator!=(const Vector3& p_v) const
-{
- return (x!=p_v.x || y!=p_v.y || z!=p_v.z);
+bool Vector3::operator!=(const Vector3 &p_v) const {
+ return (x != p_v.x || y != p_v.y || z != p_v.z);
}
-bool Vector3::operator<(const Vector3& p_v) const
-{
- if (x==p_v.x) {
- if (y==p_v.y)
- return z<p_v.z;
+bool Vector3::operator<(const Vector3 &p_v) const {
+ if (x == p_v.x) {
+ if (y == p_v.y)
+ return z < p_v.z;
else
- return y<p_v.y;
+ return y < p_v.y;
} else {
- return x<p_v.x;
+ return x < p_v.x;
}
}
-bool Vector3::operator<=(const Vector3& p_v) const
-{
- if (x==p_v.x) {
- if (y==p_v.y)
- return z<=p_v.z;
+bool Vector3::operator<=(const Vector3 &p_v) const {
+ if (x == p_v.x) {
+ if (y == p_v.y)
+ return z <= p_v.z;
else
- return y<p_v.y;
+ return y < p_v.y;
} else {
- return x<p_v.x;
+ return x < p_v.x;
}
}
-Vector3 Vector3::abs() const
-{
+Vector3 Vector3::abs() const {
return Vector3(::fabs(x), ::fabs(y), ::fabs(z));
}
-Vector3 Vector3::ceil() const
-{
+Vector3 Vector3::ceil() const {
return Vector3(::ceil(x), ::ceil(y), ::ceil(z));
}
-Vector3 Vector3::cross(const Vector3& b) const
-{
- Vector3 ret (
- (y * b.z) - (z * b.y),
- (z * b.x) - (x * b.z),
- (x * b.y) - (y * b.x)
- );
+Vector3 Vector3::cross(const Vector3 &b) const {
+ Vector3 ret(
+ (y * b.z) - (z * b.y),
+ (z * b.x) - (x * b.z),
+ (x * b.y) - (y * b.x));
return ret;
}
-Vector3 Vector3::linear_interpolate(const Vector3& p_b,real_t p_t) const
-{
+Vector3 Vector3::linear_interpolate(const Vector3 &p_b, real_t p_t) const {
return Vector3(
- x+(p_t * (p_b.x-x)),
- y+(p_t * (p_b.y-y)),
- z+(p_t * (p_b.z-z))
- );
+ x + (p_t * (p_b.x - x)),
+ y + (p_t * (p_b.y - y)),
+ z + (p_t * (p_b.z - z)));
}
-Vector3 Vector3::cubic_interpolate(const Vector3& b, const Vector3& pre_a, const Vector3& post_b, const real_t t) const
-{
- Vector3 p0=pre_a;
- Vector3 p1=*this;
- Vector3 p2=b;
- Vector3 p3=post_b;
+Vector3 Vector3::cubic_interpolate(const Vector3 &b, const Vector3 &pre_a, const Vector3 &post_b, const real_t t) const {
+ Vector3 p0 = pre_a;
+ Vector3 p1 = *this;
+ Vector3 p2 = b;
+ Vector3 p3 = post_b;
real_t t2 = t * t;
real_t t3 = t2 * t;
Vector3 out;
- out = ( ( p1 * 2.0) +
- ( -p0 + p2 ) * t +
- ( p0 * 2.0 - p1 * 5.0 + p2 * 4 - p3 ) * t2 +
- ( -p0 + p1 * 3.0 - p2 * 3.0 + p3 ) * t3 ) * 0.5;
+ out = ((p1 * 2.0) +
+ (-p0 + p2) * t +
+ (p0 * 2.0 - p1 * 5.0 + p2 * 4 - p3) * t2 +
+ (-p0 + p1 * 3.0 - p2 * 3.0 + p3) * t3) *
+ 0.5;
return out;
}
-Vector3 Vector3::bounce(const Vector3& p_normal) const
-{
+Vector3 Vector3::bounce(const Vector3 &p_normal) const {
return -reflect(p_normal);
}
-real_t Vector3::length() const
-{
- real_t x2=x*x;
- real_t y2=y*y;
- real_t z2=z*z;
+real_t Vector3::length() const {
+ real_t x2 = x * x;
+ real_t y2 = y * y;
+ real_t z2 = z * z;
- return ::sqrt(x2+y2+z2);
+ return ::sqrt(x2 + y2 + z2);
}
-real_t Vector3::length_squared() const
-{
- real_t x2=x*x;
- real_t y2=y*y;
- real_t z2=z*z;
+real_t Vector3::length_squared() const {
+ real_t x2 = x * x;
+ real_t y2 = y * y;
+ real_t z2 = z * z;
- return x2+y2+z2;
+ return x2 + y2 + z2;
}
-real_t Vector3::distance_squared_to(const Vector3& b) const
-{
- return (b-*this).length_squared();
+real_t Vector3::distance_squared_to(const Vector3 &b) const {
+ return (b - *this).length_squared();
}
-real_t Vector3::distance_to(const Vector3& b) const
-{
- return (b-*this).length();
+real_t Vector3::distance_to(const Vector3 &b) const {
+ return (b - *this).length();
}
-real_t Vector3::dot(const Vector3& b) const
-{
- return x*b.x + y*b.y + z*b.z;
+real_t Vector3::dot(const Vector3 &b) const {
+ return x * b.x + y * b.y + z * b.z;
}
-real_t Vector3::angle_to(const Vector3& b) const
-{
+real_t Vector3::angle_to(const Vector3 &b) const {
return std::atan2(cross(b).length(), dot(b));
}
-Vector3 Vector3::floor() const
-{
+Vector3 Vector3::floor() const {
return Vector3(::floor(x), ::floor(y), ::floor(z));
}
-Vector3 Vector3::inverse() const
-{
- return Vector3( 1.0/x, 1.0/y, 1.0/z );
+Vector3 Vector3::inverse() const {
+ return Vector3(1.0 / x, 1.0 / y, 1.0 / z);
}
-bool Vector3::is_normalized() const
-{
+bool Vector3::is_normalized() const {
return std::abs(length_squared() - 1.0) < 0.00001;
}
-Basis Vector3::outer(const Vector3& b) const
-{
+Basis Vector3::outer(const Vector3 &b) const {
Vector3 row0(x * b.x, x * b.y, x * b.z);
Vector3 row1(y * b.x, y * b.y, y * b.z);
Vector3 row2(z * b.x, z * b.y, z * b.z);
return Basis(row0, row1, row2);
}
-
-int Vector3::max_axis() const
-{
+int Vector3::max_axis() const {
return x < y ? (y < z ? 2 : 1) : (x < z ? 2 : 0);
}
-int Vector3::min_axis() const
-{
+int Vector3::min_axis() const {
return x < y ? (x < z ? 0 : 2) : (y < z ? 1 : 2);
}
-void Vector3::normalize()
-{
- real_t l=length();
- if (l==0) {
- x=y=z=0;
+void Vector3::normalize() {
+ real_t l = length();
+ if (l == 0) {
+ x = y = z = 0;
} else {
- x/=l;
- y/=l;
- z/=l;
+ x /= l;
+ y /= l;
+ z /= l;
}
}
-Vector3 Vector3::normalized() const
-{
+Vector3 Vector3::normalized() const {
Vector3 v = *this;
v.normalize();
return v;
}
-Vector3 Vector3::reflect(const Vector3& by) const
-{
+Vector3 Vector3::reflect(const Vector3 &by) const {
return by - *this * this->dot(by) * 2.0;
}
-Vector3 Vector3::rotated(const Vector3& axis, const real_t phi) const
-{
+Vector3 Vector3::rotated(const Vector3 &axis, const real_t phi) const {
Vector3 v = *this;
v.rotate(axis, phi);
return v;
}
-void Vector3::rotate(const Vector3& p_axis,real_t p_phi)
-{
- *this=Basis(p_axis,p_phi).xform(*this);
+void Vector3::rotate(const Vector3 &p_axis, real_t p_phi) {
+ *this = Basis(p_axis, p_phi).xform(*this);
}
-Vector3 Vector3::slide(const Vector3& by) const
-{
+Vector3 Vector3::slide(const Vector3 &by) const {
return by - *this * this->dot(by);
}
// this is ugly as well, but hey, I'm a simple man
#define _ugly_stepify(val, step) (step != 0 ? ::floor(val / step + 0.5) * step : val)
-void Vector3::snap(real_t p_val)
-{
- x = _ugly_stepify(x,p_val);
- y = _ugly_stepify(y,p_val);
- z = _ugly_stepify(z,p_val);
+void Vector3::snap(real_t p_val) {
+ x = _ugly_stepify(x, p_val);
+ y = _ugly_stepify(y, p_val);
+ z = _ugly_stepify(z, p_val);
}
#undef _ugly_stepify
-Vector3 Vector3::snapped(const float by)
-{
+Vector3 Vector3::snapped(const float by) {
Vector3 v = *this;
v.snap(by);
return v;
}
-Vector3::operator String() const
-{
+Vector3::operator String() const {
return String::num(x) + ", " + String::num(y) + ", " + String::num(z);
}
-
-}
-
+} // namespace godot