maxmustermann/godot
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Synchronize parameter names in definition and declaration

Browse source 
Fixes #10244.
This commit is contained in:
TwistedTwigleg 2017-08-11 15:10:05 -04:00 committed by Rémi Verschelde
parent b1ecaaa22b
commit 00f6c85928
134 changed files with 974 additions and 974 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
core/bind/core_bind.h
View file

@ -458,7 +458,7 @@ protected:
public:
Error open(const String &p_path);
Error list_dir_begin(bool p_skip_internal = false, bool p_skip_hidden = false); ///< This starts dir listing
Error list_dir_begin(bool p_skip_navigational = false, bool p_skip_hidden = false); ///< This starts dir listing
String get_next();
bool current_is_dir() const;

12
core/io/file_access_buffered.cpp
View file

@ -106,11 +106,11 @@ uint8_t FileAccessBuffered::get_8() const {
return byte;
};
int FileAccessBuffered::get_buffer(uint8_t *p_dest, int p_elements) const {
int FileAccessBuffered::get_buffer(uint8_t *p_dest, int p_length) const {
ERR_FAIL_COND_V(!file.open, -1);
if (p_elements > cache_size) {
if (p_length > cache_size) {
int total_read = 0;
@ -122,12 +122,12 @@ int FileAccessBuffered::get_buffer(uint8_t *p_dest, int p_elements) const {
//memcpy(p_dest, read.ptr() + (file.offset - cache.offset), size);
memcpy(p_dest, cache.buffer.ptr() + (file.offset - cache.offset), size);
p_dest += size;
p_elements -= size;
p_length -= size;
file.offset += size;
total_read += size;
};
int err = read_data_block(file.offset, p_elements, p_dest);
int err = read_data_block(file.offset, p_length, p_dest);
if (err >= 0) {
total_read += err;
file.offset += err;
@ -136,7 +136,7 @@ int FileAccessBuffered::get_buffer(uint8_t *p_dest, int p_elements) const {
return total_read;
};
int to_read = p_elements;
int to_read = p_length;
int total_read = 0;
while (to_read > 0) {
@ -161,7 +161,7 @@ int FileAccessBuffered::get_buffer(uint8_t *p_dest, int p_elements) const {
to_read -= r;
};
return p_elements;
return p_length;
};
bool FileAccessBuffered::is_open() const {

2
core/io/file_access_buffered.h
View file

@ -81,7 +81,7 @@ public:
virtual bool eof_reached() const;
virtual uint8_t get_8() const;
virtual int get_buffer(uint8_t *p_dst, int p_length) const; ///< get an array of bytes
virtual int get_buffer(uint8_t *p_dest, int p_length) const; ///< get an array of bytes
virtual bool is_open() const;

2
core/io/file_access_memory.h
View file

@ -62,7 +62,7 @@ public:
virtual Error get_error() const; ///< get last error
virtual void store_8(uint8_t p_dest); ///< store a byte
virtual void store_8(uint8_t p_byte); ///< store a byte
virtual void store_buffer(const uint8_t *p_src, int p_length); ///< store an array of bytes
virtual bool file_exists(const String &p_name); ///< return true if a file exists

12
core/io/file_access_zip.cpp
View file

@ -159,15 +159,15 @@ unzFile ZipArchive::get_file_handle(String p_file) const {
return pkg;
};
bool ZipArchive::try_open_pack(const String &p_name) {
bool ZipArchive::try_open_pack(const String &p_path) {
//printf("opening zip pack %ls, %i, %i\n", p_name.c_str(), p_name.extension().nocasecmp_to("zip"), p_name.extension().nocasecmp_to("pcz"));
if (p_name.get_extension().nocasecmp_to("zip") != 0 && p_name.get_extension().nocasecmp_to("pcz") != 0)
if (p_path.get_extension().nocasecmp_to("zip") != 0 && p_path.get_extension().nocasecmp_to("pcz") != 0)
return false;
zlib_filefunc_def io;
FileAccess *f = FileAccess::open(p_name, FileAccess::READ);
FileAccess *f = FileAccess::open(p_path, FileAccess::READ);
if (!f)
return false;
io.opaque = f;
@ -180,7 +180,7 @@ bool ZipArchive::try_open_pack(const String &p_name) {
io.zclose_file = godot_close;
io.zerror_file = godot_testerror;
unzFile zfile = unzOpen2(p_name.utf8().get_data(), &io);
unzFile zfile = unzOpen2(p_path.utf8().get_data(), &io);
ERR_FAIL_COND_V(!zfile, false);
unz_global_info64 gi;
@ -188,7 +188,7 @@ bool ZipArchive::try_open_pack(const String &p_name) {
ERR_FAIL_COND_V(err != UNZ_OK, false);
Package pkg;
pkg.filename = p_name;
pkg.filename = p_path;
pkg.zfile = zfile;
packages.push_back(pkg);
int pkg_num = packages.size() - 1;
@ -209,7 +209,7 @@ bool ZipArchive::try_open_pack(const String &p_name) {
files[fname] = f;
uint8_t md5[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
PackedData::get_singleton()->add_path(p_name, fname, 1, 0, md5, this);
PackedData::get_singleton()->add_path(p_path, fname, 1, 0, md5, this);
//printf("packed data add path %ls, %ls\n", p_name.c_str(), fname.c_str());
if ((i + 1) < gi.number_entry) {

2
core/io/ip_address.h
View file

@ -75,7 +75,7 @@ public:
void set_ipv4(const uint8_t *p_ip);
const uint8_t *get_ipv6() const;
void set_ipv6(const uint8_t *buf);
void set_ipv6(const uint8_t *p_buf);
operator String() const;
IP_Address(const String &p_string);

60
core/io/json.cpp
View file

@ -94,15 +94,15 @@ String JSON::print(const Variant &p_var) {
return _print_var(p_var);
}
Error JSON::_get_token(const CharType *p_str, int &idx, int p_len, Token &r_token, int &line, String &r_err_str) {
Error JSON::_get_token(const CharType *p_str, int &index, int p_len, Token &r_token, int &line, String &r_err_str) {
while (p_len > 0) {
switch (p_str[idx]) {
switch (p_str[index]) {
case '\n': {
line++;
idx++;
index++;
break;
};
case 0: {
@ -112,54 +112,54 @@ Error JSON::_get_token(const CharType *p_str, int &idx, int p_len, Token &r_toke
case '{': {
r_token.type = TK_CURLY_BRACKET_OPEN;
idx++;
index++;
return OK;
};
case '}': {
r_token.type = TK_CURLY_BRACKET_CLOSE;
idx++;
index++;
return OK;
};
case '[': {
r_token.type = TK_BRACKET_OPEN;
idx++;
index++;
return OK;
};
case ']': {
r_token.type = TK_BRACKET_CLOSE;
idx++;
index++;
return OK;
};
case ':': {
r_token.type = TK_COLON;
idx++;
index++;
return OK;
};
case ',': {
r_token.type = TK_COMMA;
idx++;
index++;
return OK;
};
case '"': {
idx++;
index++;
String str;
while (true) {
if (p_str[idx] == 0) {
if (p_str[index] == 0) {
r_err_str = "Unterminated String";
return ERR_PARSE_ERROR;
} else if (p_str[idx] == '"') {
idx++;
} else if (p_str[index] == '"') {
index++;
break;
} else if (p_str[idx] == '\\') {
} else if (p_str[index] == '\\') {
//escaped characters...
idx++;
CharType next = p_str[idx];
index++;
CharType next = p_str[index];
if (next == 0) {
r_err_str = "Unterminated String";
return ERR_PARSE_ERROR;
@ -177,7 +177,7 @@ Error JSON::_get_token(const CharType *p_str, int &idx, int p_len, Token &r_toke
//hexnumbarh - oct is deprecated
for (int j = 0; j < 4; j++) {
CharType c = p_str[idx + j + 1];
CharType c = p_str[index + j + 1];
if (c == 0) {
r_err_str = "Unterminated String";
return ERR_PARSE_ERROR;
@ -204,7 +204,7 @@ Error JSON::_get_token(const CharType *p_str, int &idx, int p_len, Token &r_toke
res <<= 4;
res |= v;
}
idx += 4; //will add at the end anyway
index += 4; //will add at the end anyway
} break;
//case '\"': res='\"'; break;
@ -220,11 +220,11 @@ Error JSON::_get_token(const CharType *p_str, int &idx, int p_len, Token &r_toke
str += res;
} else {
if (p_str[idx] == '\n')
if (p_str[index] == '\n')
line++;
str += p_str[idx];
str += p_str[index];
}
idx++;
index++;
}
r_token.type = TK_STRING;
@ -234,28 +234,28 @@ Error JSON::_get_token(const CharType *p_str, int &idx, int p_len, Token &r_toke
} break;
default: {
if (p_str[idx] <= 32) {
idx++;
if (p_str[index] <= 32) {
index++;
break;
}
if (p_str[idx] == '-' || (p_str[idx] >= '0' && p_str[idx] <= '9')) {
if (p_str[index] == '-' || (p_str[index] >= '0' && p_str[index] <= '9')) {
//a number
const CharType *rptr;
double number = String::to_double(&p_str[idx], &rptr);
idx += (rptr - &p_str[idx]);
double number = String::to_double(&p_str[index], &rptr);
index += (rptr - &p_str[index]);
r_token.type = TK_NUMBER;
r_token.value = number;
return OK;
} else if ((p_str[idx] >= 'A' && p_str[idx] <= 'Z') || (p_str[idx] >= 'a' && p_str[idx] <= 'z')) {
} else if ((p_str[index] >= 'A' && p_str[index] <= 'Z') || (p_str[index] >= 'a' && p_str[index] <= 'z')) {
String id;
while ((p_str[idx] >= 'A' && p_str[idx] <= 'Z') || (p_str[idx] >= 'a' && p_str[idx] <= 'z')) {
while ((p_str[index] >= 'A' && p_str[index] <= 'Z') || (p_str[index] >= 'a' && p_str[index] <= 'z')) {
id += p_str[idx];
idx++;
id += p_str[index];
index++;
}
r_token.type = TK_IDENTIFIER;

16
core/math/math_2d.cpp
View file

@ -281,22 +281,22 @@ Vector2 Vector2::cubic_interpolate(const Vector2 &p_b, const Vector2 &p_pre_a, c
}
// slide returns the component of the vector along the given plane, specified by its normal vector.
Vector2 Vector2::slide(const Vector2 &p_n) const {
Vector2 Vector2::slide(const Vector2 &p_normal) const {
#ifdef MATH_CHECKS
ERR_FAIL_COND_V(p_n.is_normalized() == false, Vector2());
ERR_FAIL_COND_V(p_normal.is_normalized() == false, Vector2());
#endif
return *this - p_n * this->dot(p_n);
return *this - p_normal * this->dot(p_normal);
}
Vector2 Vector2::bounce(const Vector2 &p_n) const {
return -reflect(p_n);
Vector2 Vector2::bounce(const Vector2 &p_normal) const {
return -reflect(p_normal);
}
Vector2 Vector2::reflect(const Vector2 &p_n) const {
Vector2 Vector2::reflect(const Vector2 &p_normal) const {
#ifdef MATH_CHECKS
ERR_FAIL_COND_V(p_n.is_normalized() == false, Vector2());
ERR_FAIL_COND_V(p_normal.is_normalized() == false, Vector2());
#endif
return 2.0 * p_n * this->dot(p_n) - *this;
return 2.0 * p_normal * this->dot(p_normal) - *this;
}
bool Rect2::intersects_segment(const Point2 &p_from, const Point2 &p_to, Point2 *r_pos, Point2 *r_normal) const {

32
core/math/math_2d.h
View file

@ -107,9 +107,9 @@ struct Vector2 {
Vector2 cubic_interpolate(const Vector2 &p_b, const Vector2 &p_pre_a, const Vector2 &p_post_b, real_t p_t) const;
Vector2 cubic_interpolate_soft(const Vector2 &p_b, const Vector2 &p_pre_a, const Vector2 &p_post_b, real_t p_t) const;
Vector2 slide(const Vector2 &p_vec) const;
Vector2 bounce(const Vector2 &p_vec) const;
Vector2 reflect(const Vector2 &p_vec) const;
Vector2 slide(const Vector2 &p_normal) const;
Vector2 bounce(const Vector2 &p_normal) const;
Vector2 reflect(const Vector2 &p_normal) const;
Vector2 operator+(const Vector2 &p_v) const;
void operator+=(const Vector2 &p_v);
@ -621,9 +621,9 @@ struct Transform2D {
void affine_invert();
Transform2D affine_inverse() const;
void set_rotation(real_t p_phi);
void set_rotation(real_t p_rot);
real_t get_rotation() const;
_FORCE_INLINE_ void set_rotation_and_scale(real_t p_phi, const Size2 &p_scale);
_FORCE_INLINE_ void set_rotation_and_scale(real_t p_rot, const Size2 &p_scale);
void rotate(real_t p_phi);
void scale(const Size2 &p_scale);
@ -660,8 +660,8 @@ struct Transform2D {
_FORCE_INLINE_ Vector2 basis_xform_inv(const Vector2 &p_vec) const;
_FORCE_INLINE_ Vector2 xform(const Vector2 &p_vec) const;
_FORCE_INLINE_ Vector2 xform_inv(const Vector2 &p_vec) const;
_FORCE_INLINE_ Rect2 xform(const Rect2 &p_vec) const;
_FORCE_INLINE_ Rect2 xform_inv(const Rect2 &p_vec) const;
_FORCE_INLINE_ Rect2 xform(const Rect2 &p_rect) const;
_FORCE_INLINE_ Rect2 xform_inv(const Rect2 &p_rect) const;
operator String() const;
@ -833,25 +833,25 @@ next4:
return true;
}
Vector2 Transform2D::basis_xform(const Vector2 &v) const {
Vector2 Transform2D::basis_xform(const Vector2 &p_vec) const {
return Vector2(
tdotx(v),
tdoty(v));
tdotx(p_vec),
tdoty(p_vec));
}
Vector2 Transform2D::basis_xform_inv(const Vector2 &v) const {
Vector2 Transform2D::basis_xform_inv(const Vector2 &p_vec) const {
return Vector2(
elements[0].dot(v),
elements[1].dot(v));
elements[0].dot(p_vec),
elements[1].dot(p_vec));
}
Vector2 Transform2D::xform(const Vector2 &v) const {
Vector2 Transform2D::xform(const Vector2 &p_vec) const {
return Vector2(
tdotx(v),
tdoty(v)) +
tdotx(p_vec),
tdoty(p_vec)) +
elements[2];
}
Vector2 Transform2D::xform_inv(const Vector2 &p_vec) const {

42
core/math/rect3.h
View file

@ -72,9 +72,9 @@ public:
Rect3 intersection(const Rect3 &p_aabb) const; ///get box where two intersect, empty if no intersection occurs
bool intersects_segment(const Vector3 &p_from, const Vector3 &p_to, Vector3 *r_clip = NULL, Vector3 *r_normal = NULL) const;
bool intersects_ray(const Vector3 &p_from, const Vector3 &p_dir, Vector3 *r_clip = NULL, Vector3 *r_normal = NULL) const;
_FORCE_INLINE_ bool smits_intersect_ray(const Vector3 &from, const Vector3 &p_dir, real_t t0, real_t t1) const;
_FORCE_INLINE_ bool smits_intersect_ray(const Vector3 &p_from, const Vector3 &p_dir, real_t t0, real_t t1) const;
_FORCE_INLINE_ bool intersects_convex_shape(const Plane *p_plane, int p_plane_count) const;
_FORCE_INLINE_ bool intersects_convex_shape(const Plane *p_planes, int p_plane_count) const;
bool intersects_plane(const Plane &p_plane) const;
_FORCE_INLINE_ bool has_point(const Vector3 &p_point) const;
@ -326,27 +326,27 @@ inline real_t Rect3::get_shortest_axis_size() const {
return max_size;
}
bool Rect3::smits_intersect_ray(const Vector3 &from, const Vector3 &dir, real_t t0, real_t t1) const {
bool Rect3::smits_intersect_ray(const Vector3 &p_from, const Vector3 &p_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 / p_dir.x;
real_t divy = 1.0 / p_dir.y;
real_t divz = 1.0 / p_dir.z;
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;
if (p_dir.x >= 0) {
tmin = (position.x - p_from.x) * divx;
tmax = (upbound.x - p_from.x) * divx;
} else {
tmin = (upbound.x - from.x) * divx;
tmax = (position.x - from.x) * divx;
tmin = (upbound.x - p_from.x) * divx;
tmax = (position.x - p_from.x) * divx;
}
if (dir.y >= 0) {
tymin = (position.y - from.y) * divy;
tymax = (upbound.y - from.y) * divy;
if (p_dir.y >= 0) {
tymin = (position.y - p_from.y) * divy;
tymax = (upbound.y - p_from.y) * divy;
} else {
tymin = (upbound.y - from.y) * divy;
tymax = (position.y - from.y) * divy;
tymin = (upbound.y - p_from.y) * divy;
tymax = (position.y - p_from.y) * divy;
}
if ((tmin > tymax) || (tymin > tmax))
return false;
@ -354,12 +354,12 @@ bool Rect3::smits_intersect_ray(const Vector3 &from, const Vector3 &dir, real_t
tmin = tymin;
if (tymax < tmax)
tmax = tymax;
if (dir.z >= 0) {
tzmin = (position.z - from.z) * divz;
tzmax = (upbound.z - from.z) * divz;
if (p_dir.z >= 0) {
tzmin = (position.z - p_from.z) * divz;
tzmax = (upbound.z - p_from.z) * divz;
} else {
tzmin = (upbound.z - from.z) * divz;
tzmax = (position.z - from.z) * divz;
tzmin = (upbound.z - p_from.z) * divz;
tzmax = (position.z - p_from.z) * divz;
}
if ((tmin > tzmax) || (tzmin > tmax))
return false;

22
core/math/vector3.h
View file

@ -108,9 +108,9 @@ struct Vector3 {
_FORCE_INLINE_ real_t angle_to(const Vector3 &p_b) const;
_FORCE_INLINE_ Vector3 slide(const Vector3 &p_vec) const;
_FORCE_INLINE_ Vector3 bounce(const Vector3 &p_vec) const;
_FORCE_INLINE_ Vector3 reflect(const Vector3 &p_vec) const;
_FORCE_INLINE_ Vector3 slide(const Vector3 &p_normal) const;
_FORCE_INLINE_ Vector3 bounce(const Vector3 &p_normal) const;
_FORCE_INLINE_ Vector3 reflect(const Vector3 &p_normal) const;
/* Operators */
@ -410,22 +410,22 @@ void Vector3::zero() {
}
// slide returns the component of the vector along the given plane, specified by its normal vector.
Vector3 Vector3::slide(const Vector3 &p_n) const {
Vector3 Vector3::slide(const Vector3 &p_normal) const {
#ifdef MATH_CHECKS
ERR_FAIL_COND_V(p_n.is_normalized() == false, Vector3());
ERR_FAIL_COND_V(p_normal.is_normalized() == false, Vector3());
#endif
return *this - p_n * this->dot(p_n);
return *this - p_normal * this->dot(p_normal);
}
Vector3 Vector3::bounce(const Vector3 &p_n) const {
return -reflect(p_n);
Vector3 Vector3::bounce(const Vector3 &p_normal) const {
return -reflect(p_normal);
}
Vector3 Vector3::reflect(const Vector3 &p_n) const {
Vector3 Vector3::reflect(const Vector3 &p_normal) const {
#ifdef MATH_CHECKS
ERR_FAIL_COND_V(p_n.is_normalized() == false, Vector3());
ERR_FAIL_COND_V(p_normal.is_normalized() == false, Vector3());
#endif
return 2.0 * p_n * this->dot(p_n) - *this;
return 2.0 * p_normal * this->dot(p_normal) - *this;
}
#endif

2
core/object.h
View file

@ -443,7 +443,7 @@ private:
mutable StringName _class_name;
mutable const StringName *_class_ptr;
void _add_user_signal(const String &p_name, const Array &p_pargs = Array());
void _add_user_signal(const String &p_name, const Array &p_args = Array());
bool _has_user_signal(const StringName &p_name) const;
Variant _emit_signal(const Variant **p_args, int p_argcount, Variant::CallError &r_error);
Array _get_signal_list() const;

4
core/os/file_access.cpp
View file

@ -475,9 +475,9 @@ void FileAccess::store_buffer(const uint8_t *p_src, int p_length) {
store_8(p_src[i]);
}
Vector<uint8_t> FileAccess::get_file_as_array(const String &p_file) {
Vector<uint8_t> FileAccess::get_file_as_array(const String &p_path) {
FileAccess *f = FileAccess::open(p_file, READ);
FileAccess *f = FileAccess::open(p_path, READ);
ERR_FAIL_COND_V(!f, Vector<uint8_t>());
Vector<uint8_t> data;
data.resize(f->get_len());

2
core/os/file_access.h
View file

@ -129,7 +129,7 @@ public:
virtual void store_real(real_t p_real);
virtual void store_string(const String &p_string);
virtual void store_line(const String &p_string);
virtual void store_line(const String &p_line);
virtual void store_pascal_string(const String &p_string);
virtual String get_pascal_string();

2
core/os/keyboard.h
View file

@ -324,7 +324,7 @@ enum KeyModifierMask {
};
String keycode_get_string(uint32_t p_code);
bool keycode_has_unicode(uint32_t p_unicode);
bool keycode_has_unicode(uint32_t p_keycode);
int find_keycode(const String &p_code);
int keycode_get_count();
int keycode_get_value_by_index(int p_index);

2
core/project_settings.h
View file

@ -158,7 +158,7 @@ public:
bool is_using_datapack() const;
void set_registering_order(bool p_registering);
void set_registering_order(bool p_enable);
ProjectSettings();
~ProjectSettings();

2
core/resource.h
View file

@ -107,7 +107,7 @@ public:
int get_subindex() const;
virtual Ref<Resource> duplicate(bool p_subresources = false) const;
Ref<Resource> duplicate_for_local_scene(Node *p_scene, Map<Ref<Resource>, Ref<Resource> > &remap_cache);
Ref<Resource> duplicate_for_local_scene(Node *p_for_scene, Map<Ref<Resource>, Ref<Resource> > &remap_cache);
void set_local_to_scene(bool p_enable);
bool is_local_to_scene() const;

36
core/script_debugger_remote.cpp
View file

@ -429,9 +429,9 @@ void ScriptDebuggerRemote::_err_handler(void *ud, const char *p_func, const char
sdr->mutex->unlock();
}
bool ScriptDebuggerRemote::_parse_live_edit(const Array &cmd) {
bool ScriptDebuggerRemote::_parse_live_edit(const Array &p_command) {
String cmdstr = cmd[0];
String cmdstr = p_command[0];
if (!live_edit_funcs || !cmdstr.begins_with("live_"))
return false;
@ -441,7 +441,7 @@ bool ScriptDebuggerRemote::_parse_live_edit(const Array &cmd) {
if (!live_edit_funcs->root_func)
return true;
//print_line("root: "+Variant(cmd).get_construct_string());
live_edit_funcs->root_func(live_edit_funcs->udata, cmd[1], cmd[2]);
live_edit_funcs->root_func(live_edit_funcs->udata, p_command[1], p_command[2]);
} else if (cmdstr == "live_node_path") {
@ -449,75 +449,75 @@ bool ScriptDebuggerRemote::_parse_live_edit(const Array &cmd) {
return true;
//print_line("path: "+Variant(cmd).get_construct_string());
live_edit_funcs->node_path_func(live_edit_funcs->udata, cmd[1], cmd[2]);
live_edit_funcs->node_path_func(live_edit_funcs->udata, p_command[1], p_command[2]);
} else if (cmdstr == "live_res_path") {
if (!live_edit_funcs->res_path_func)
return true;
live_edit_funcs->res_path_func(live_edit_funcs->udata, cmd[1], cmd[2]);
live_edit_funcs->res_path_func(live_edit_funcs->udata, p_command[1], p_command[2]);
} else if (cmdstr == "live_node_prop_res") {
if (!live_edit_funcs->node_set_res_func)
return true;
live_edit_funcs->node_set_res_func(live_edit_funcs->udata, cmd[1], cmd[2], cmd[3]);
live_edit_funcs->node_set_res_func(live_edit_funcs->udata, p_command[1], p_command[2], p_command[3]);
} else if (cmdstr == "live_node_prop") {
if (!live_edit_funcs->node_set_func)
return true;
live_edit_funcs->node_set_func(live_edit_funcs->udata, cmd[1], cmd[2], cmd[3]);
live_edit_funcs->node_set_func(live_edit_funcs->udata, p_command[1], p_command[2], p_command[3]);
} else if (cmdstr == "live_res_prop_res") {
if (!live_edit_funcs->res_set_res_func)
return true;
live_edit_funcs->res_set_res_func(live_edit_funcs->udata, cmd[1], cmd[2], cmd[3]);
live_edit_funcs->res_set_res_func(live_edit_funcs->udata, p_command[1], p_command[2], p_command[3]);
} else if (cmdstr == "live_res_prop") {
if (!live_edit_funcs->res_set_func)
return true;
live_edit_funcs->res_set_func(live_edit_funcs->udata, cmd[1], cmd[2], cmd[3]);
live_edit_funcs->res_set_func(live_edit_funcs->udata, p_command[1], p_command[2], p_command[3]);
} else if (cmdstr == "live_node_call") {
if (!live_edit_funcs->node_call_func)
return true;
live_edit_funcs->node_call_func(live_edit_funcs->udata, cmd[1], cmd[2], cmd[3], cmd[4], cmd[5], cmd[6], cmd[7]);
live_edit_funcs->node_call_func(live_edit_funcs->udata, p_command[1], p_command[2], p_command[3], p_command[4], p_command[5], p_command[6], p_command[7]);
} else if (cmdstr == "live_res_call") {
if (!live_edit_funcs->res_call_func)
return true;
live_edit_funcs->res_call_func(live_edit_funcs->udata, cmd[1], cmd[2], cmd[3], cmd[4], cmd[5], cmd[6], cmd[7]);
live_edit_funcs->res_call_func(live_edit_funcs->udata, p_command[1], p_command[2], p_command[3], p_command[4], p_command[5], p_command[6], p_command[7]);
} else if (cmdstr == "live_create_node") {
live_edit_funcs->tree_create_node_func(live_edit_funcs->udata, cmd[1], cmd[2], cmd[3]);
live_edit_funcs->tree_create_node_func(live_edit_funcs->udata, p_command[1], p_command[2], p_command[3]);
} else if (cmdstr == "live_instance_node") {
live_edit_funcs->tree_instance_node_func(live_edit_funcs->udata, cmd[1], cmd[2], cmd[3]);
live_edit_funcs->tree_instance_node_func(live_edit_funcs->udata, p_command[1], p_command[2], p_command[3]);
} else if (cmdstr == "live_remove_node") {
live_edit_funcs->tree_remove_node_func(live_edit_funcs->udata, cmd[1]);
live_edit_funcs->tree_remove_node_func(live_edit_funcs->udata, p_command[1]);
} else if (cmdstr == "live_remove_and_keep_node") {
live_edit_funcs->tree_remove_and_keep_node_func(live_edit_funcs->udata, cmd[1], cmd[2]);
live_edit_funcs->tree_remove_and_keep_node_func(live_edit_funcs->udata, p_command[1], p_command[2]);
} else if (cmdstr == "live_restore_node") {
live_edit_funcs->tree_restore_node_func(live_edit_funcs->udata, cmd[1], cmd[2], cmd[3]);
live_edit_funcs->tree_restore_node_func(live_edit_funcs->udata, p_command[1], p_command[2], p_command[3]);
} else if (cmdstr == "live_duplicate_node") {
live_edit_funcs->tree_duplicate_node_func(live_edit_funcs->udata, cmd[1], cmd[2]);
live_edit_funcs->tree_duplicate_node_func(live_edit_funcs->udata, p_command[1], p_command[2]);
} else if (cmdstr == "live_reparent_node") {
live_edit_funcs->tree_reparent_node_func(live_edit_funcs->udata, cmd[1], cmd[2], cmd[3], cmd[4]);
live_edit_funcs->tree_reparent_node_func(live_edit_funcs->udata, p_command[1], p_command[2], p_command[3], p_command[4]);
} else {

6
core/ustring.cpp
View file

@ -279,16 +279,16 @@ void String::operator=(const CharType *p_str) {
copy_from(p_str);
}
bool String::operator==(const StrRange &p_range) const {
bool String::operator==(const StrRange &p_str_range) const {
int len = p_range.len;
int len = p_str_range.len;
if (length() != len)
return false;
if (empty())
return true;
const CharType *c_str = p_range.c_str;
const CharType *c_str = p_str_range.c_str;
const CharType *dst = &operator[](0);
/* Compare char by char */

8
core/ustring.h
View file

@ -78,7 +78,7 @@ public:
//String operator+(CharType p_char) const;
String &operator+=(const String &);
String &operator+=(CharType p_str);
String &operator+=(CharType p_char);
String &operator+=(const char *p_str);
String &operator+=(const CharType *p_str);
@ -156,7 +156,7 @@ public:
int get_slice_count(String p_splitter) const;
String get_slice(String p_splitter, int p_slice) const;
String get_slicec(CharType splitter, int p_slice) const;
String get_slicec(CharType p_splitter, int p_slice) const;
Vector<String> split(const String &p_splitter, bool p_allow_empty = true) const;
Vector<String> split_spaces() const;
@ -186,8 +186,8 @@ public:
bool parse_utf8(const char *p_utf8, int p_len = -1); //return true on error
static String utf8(const char *p_utf8, int p_len = -1);
static uint32_t hash(const CharType *p_str, int p_len); /* hash the string */
static uint32_t hash(const CharType *p_str); /* hash the string */
static uint32_t hash(const CharType *p_cstr, int p_len); /* hash the string */
static uint32_t hash(const CharType *p_cstr); /* hash the string */
static uint32_t hash(const char *p_cstr, int p_len); /* hash the string */
static uint32_t hash(const char *p_cstr); /* hash the string */
uint32_t hash() const; /* hash the string */

62
core/variant_construct_string.cpp
View file

@ -66,7 +66,7 @@ class VariantConstruct {
static Error _get_token(const CharType *p_str, int &index, int p_len, Token &r_token, int &line, String &r_err_str);
static Error _parse_value(Variant &value, Token &token, const CharType *p_str, int &index, int p_len, int &line, String &r_err_str, Variant::ObjectConstruct *p_construct, void *p_ud);
static Error _parse_array(Array &array, const CharType *p_str, int &index, int p_len, int &line, String &r_err_str, Variant::ObjectConstruct *p_construct, void *p_ud);
static Error _parse_dict(Dictionary &object, const CharType *p_str, int &index, int p_len, int &line, String &r_err_str, Variant::ObjectConstruct *p_construct, void *p_ud);
static Error _parse_dict(Dictionary &dict, const CharType *p_str, int &index, int p_len, int &line, String &r_err_str, Variant::ObjectConstruct *p_construct, void *p_ud);
public:
static Error parse(const String &p_string, Variant &r_ret, String &r_err_str, int &r_err_line, Variant::ObjectConstruct *p_construct, void *p_ud);
@ -85,15 +85,15 @@ const char *VariantConstruct::tk_name[TK_MAX] = {
"EOF",
};
Error VariantConstruct::_get_token(const CharType *p_str, int &idx, int p_len, Token &r_token, int &line, String &r_err_str) {
Error VariantConstruct::_get_token(const CharType *p_str, int &index, int p_len, Token &r_token, int &line, String &r_err_str) {
while (true) {
switch (p_str[idx]) {
switch (p_str[index]) {
case '\n': {
line++;
idx++;
index++;
break;
};
case 0: {
@ -103,54 +103,54 @@ Error VariantConstruct::_get_token(const CharType *p_str, int &idx, int p_len, T
case '{': {
r_token.type = TK_CURLY_BRACKET_OPEN;
idx++;
index++;
return OK;
};
case '}': {
r_token.type = TK_CURLY_BRACKET_CLOSE;
idx++;
index++;
return OK;
};
case '[': {
r_token.type = TK_BRACKET_OPEN;
idx++;
index++;
return OK;
};
case ']': {
r_token.type = TK_BRACKET_CLOSE;
idx++;
index++;
return OK;
};
case ':': {
r_token.type = TK_COLON;
idx++;
index++;
return OK;
};
case ',': {
r_token.type = TK_COMMA;
idx++;
index++;
return OK;
};
case '"': {
idx++;
index++;
String str;
while (true) {
if (p_str[idx] == 0) {
if (p_str[index] == 0) {
r_err_str = "Unterminated String";
return ERR_PARSE_ERROR;
} else if (p_str[idx] == '"') {
idx++;
} else if (p_str[index] == '"') {
index++;
break;
} else if (p_str[idx] == '\\') {
} else if (p_str[index] == '\\') {
//escaped characters...
idx++;
CharType next = p_str[idx];
index++;
CharType next = p_str[index];
if (next == 0) {
r_err_str = "Unterminated String";
return ERR_PARSE_ERROR;
@ -171,7 +171,7 @@ Error VariantConstruct::_get_token(const CharType *p_str, int &idx, int p_len, T
//hexnumbarh - oct is deprecated
for (int j = 0; j < 4; j++) {
CharType c = p_str[idx + j + 1];
CharType c = p_str[index + j + 1];
if (c == 0) {
r_err_str = "Unterminated String";
return ERR_PARSE_ERROR;
@ -198,7 +198,7 @@ Error VariantConstruct::_get_token(const CharType *p_str, int &idx, int p_len, T
res <<= 4;
res |= v;
}
idx += 4; //will add at the end anyway
index += 4; //will add at the end anyway
} break;
default: {
@ -211,11 +211,11 @@ Error VariantConstruct::_get_token(const CharType *p_str, int &idx, int p_len, T
str += res;
} else {
if (p_str[idx] == '\n')
if (p_str[index] == '\n')
line++;
str += p_str[idx];
str += p_str[index];
}
idx++;
index++;
}
r_token.type = TK_STRING;
@ -225,28 +225,28 @@ Error VariantConstruct::_get_token(const CharType *p_str, int &idx, int p_len, T
} break;
default: {
if (p_str[idx] <= 32) {
idx++;
if (p_str[index] <= 32) {
index++;
break;
}
if (p_str[idx] == '-' || (p_str[idx] >= '0' && p_str[idx] <= '9')) {
if (p_str[index] == '-' || (p_str[index] >= '0' && p_str[index] <= '9')) {
//a number
const CharType *rptr;
double number = String::to_double(&p_str[idx], &rptr);
idx += (rptr - &p_str[idx]);
double number = String::to_double(&p_str[index], &rptr);
index += (rptr - &p_str[index]);
r_token.type = TK_NUMBER;
r_token.value = number;
return OK;
} else if ((p_str[idx] >= 'A' && p_str[idx] <= 'Z') || (p_str[idx] >= 'a' && p_str[idx] <= 'z')) {
} else if ((p_str[index] >= 'A' && p_str[index] <= 'Z') || (p_str[index] >= 'a' && p_str[index] <= 'z')) {
String id;
while ((p_str[idx] >= 'A' && p_str[idx] <= 'Z') || (p_str[idx] >= 'a' && p_str[idx] <= 'z')) {
while ((p_str[index] >= 'A' && p_str[index] <= 'Z') || (p_str[index] >= 'a' && p_str[index] <= 'z')) {
id += p_str[idx];
idx++;
id += p_str[index];
index++;
}
r_token.type = TK_IDENTIFIER;

66
drivers/gles2/rasterizer_gles2.cpp
View file

@ -1600,9 +1600,9 @@ RID RasterizerGLES2::material_create() {
return material;
}
void RasterizerGLES2::material_set_shader(RID p_material, RID p_shader) {
void RasterizerGLES2::material_set_shader(RID p_shader_material, RID p_shader) {
Material *material = material_owner.get(p_material);
Material *material = material_owner.get(p_shader_material);
ERR_FAIL_COND(!material);
if (material->shader == p_shader)
return;
@ -1610,9 +1610,9 @@ void RasterizerGLES2::material_set_shader(RID p_material, RID p_shader) {
material->shader_version = 0;
}
RID RasterizerGLES2::material_get_shader(RID p_material) const {
RID RasterizerGLES2::material_get_shader(RID p_shader_material) const {
Material *material = material_owner.get(p_material);
Material *material = material_owner.get(p_shader_material);
ERR_FAIL_COND_V(!material, RID());
return material->shader;
}
@ -7891,7 +7891,7 @@ void RasterizerGLES2::canvas_draw_rect(const Rect2 &p_rect, int p_flags, const R
_rinfo.ci_draw_commands++;
}
void RasterizerGLES2::canvas_draw_style_box(const Rect2 &p_rect, const Rect2 &p_src_region, RID p_texture, const float *p_margin, bool p_draw_center, const Color &p_modulate) {
void RasterizerGLES2::canvas_draw_style_box(const Rect2 &p_rect, const Rect2 &p_src_region, RID p_texture, const float *p_margins, bool p_draw_center, const Color &p_modulate) {
Color m = p_modulate;
m.a *= canvas_opacity;
@ -7907,47 +7907,47 @@ void RasterizerGLES2::canvas_draw_style_box(const Rect2 &p_rect, const Rect2 &p_
region.size.height = texture->height;
/* CORNERS */
_draw_textured_quad( // top left
Rect2(p_rect.pos, Size2(p_margin[MARGIN_LEFT], p_margin[MARGIN_TOP])),
Rect2(region.pos, Size2(p_margin[MARGIN_LEFT], p_margin[MARGIN_TOP])),
Rect2(p_rect.pos, Size2(p_margins[MARGIN_LEFT], p_margins[MARGIN_TOP])),
Rect2(region.pos, Size2(p_margins[MARGIN_LEFT], p_margins[MARGIN_TOP])),
Size2(texture->width, texture->height));
_draw_textured_quad( // top right
Rect2(Point2(p_rect.pos.x + p_rect.size.width - p_margin[MARGIN_RIGHT], p_rect.pos.y), Size2(p_margin[MARGIN_RIGHT], p_margin[MARGIN_TOP])),
Rect2(Point2(region.pos.x + region.size.width - p_margin[MARGIN_RIGHT], region.pos.y), Size2(p_margin[MARGIN_RIGHT], p_margin[MARGIN_TOP])),
Rect2(Point2(p_rect.pos.x + p_rect.size.width - p_margins[MARGIN_RIGHT], p_rect.pos.y), Size2(p_margins[MARGIN_RIGHT], p_margins[MARGIN_TOP])),
Rect2(Point2(region.pos.x + region.size.width - p_margins[MARGIN_RIGHT], region.pos.y), Size2(p_margins[MARGIN_RIGHT], p_margins[MARGIN_TOP])),
Size2(texture->width, texture->height));
_draw_textured_quad( // bottom left
Rect2(Point2(p_rect.pos.x, p_rect.pos.y + p_rect.size.height - p_margin[MARGIN_BOTTOM]), Size2(p_margin[MARGIN_LEFT], p_margin[MARGIN_BOTTOM])),
Rect2(Point2(region.pos.x, region.pos.y + region.size.height - p_margin[MARGIN_BOTTOM]), Size2(p_margin[MARGIN_LEFT], p_margin[MARGIN_BOTTOM])),
Rect2(Point2(p_rect.pos.x, p_rect.pos.y + p_rect.size.height - p_margins[MARGIN_BOTTOM]), Size2(p_margins[MARGIN_LEFT], p_margins[MARGIN_BOTTOM])),
Rect2(Point2(region.pos.x, region.pos.y + region.size.height - p_margins[MARGIN_BOTTOM]), Size2(p_margins[MARGIN_LEFT], p_margins[MARGIN_BOTTOM])),
Size2(texture->width, texture->height));
_draw_textured_quad( // bottom right
Rect2(Point2(p_rect.pos.x + p_rect.size.width - p_margin[MARGIN_RIGHT], p_rect.pos.y + p_rect.size.height - p_margin[MARGIN_BOTTOM]), Size2(p_margin[MARGIN_RIGHT], p_margin[MARGIN_BOTTOM])),
Rect2(Point2(region.pos.x + region.size.width - p_margin[MARGIN_RIGHT], region.pos.y + region.size.height - p_margin[MARGIN_BOTTOM]), Size2(p_margin[MARGIN_RIGHT], p_margin[MARGIN_BOTTOM])),
Rect2(Point2(p_rect.pos.x + p_rect.size.width - p_margins[MARGIN_RIGHT], p_rect.pos.y + p_rect.size.height - p_margins[MARGIN_BOTTOM]), Size2(p_margins[MARGIN_RIGHT], p_margins[MARGIN_BOTTOM])),
Rect2(Point2(region.pos.x + region.size.width - p_margins[MARGIN_RIGHT], region.pos.y + region.size.height - p_margins[MARGIN_BOTTOM]), Size2(p_margins[MARGIN_RIGHT], p_margins[MARGIN_BOTTOM])),
Size2(texture->width, texture->height));
Rect2 rect_center(p_rect.pos + Point2(p_margin[MARGIN_LEFT], p_margin[MARGIN_TOP]), Size2(p_rect.size.width - p_margin[MARGIN_LEFT] - p_margin[MARGIN_RIGHT], p_rect.size.height - p_margin[MARGIN_TOP] - p_margin[MARGIN_BOTTOM]));
Rect2 rect_center(p_rect.pos + Point2(p_margins[MARGIN_LEFT], p_margins[MARGIN_TOP]), Size2(p_rect.size.width - p_margins[MARGIN_LEFT] - p_margins[MARGIN_RIGHT], p_rect.size.height - p_margins[MARGIN_TOP] - p_margins[MARGIN_BOTTOM]));
Rect2 src_center(Point2(region.pos.x + p_margin[MARGIN_LEFT], region.pos.y + p_margin[MARGIN_TOP]), Size2(region.size.width - p_margin[MARGIN_LEFT] - p_margin[MARGIN_RIGHT], region.size.height - p_margin[MARGIN_TOP] - p_margin[MARGIN_BOTTOM]));
Rect2 src_center(Point2(region.pos.x + p_margins[MARGIN_LEFT], region.pos.y + p_margins[MARGIN_TOP]), Size2(region.size.width - p_margins[MARGIN_LEFT] - p_margins[MARGIN_RIGHT], region.size.height - p_margins[MARGIN_TOP] - p_margins[MARGIN_BOTTOM]));
_draw_textured_quad( // top
Rect2(Point2(rect_center.pos.x, p_rect.pos.y), Size2(rect_center.size.width, p_margin[MARGIN_TOP])),
Rect2(Point2(src_center.pos.x, region.pos.y), Size2(src_center.size.width, p_margin[MARGIN_TOP])),
Rect2(Point2(rect_center.pos.x, p_rect.pos.y), Size2(rect_center.size.width, p_margins[MARGIN_TOP])),
Rect2(Point2(src_center.pos.x, region.pos.y), Size2(src_center.size.width, p_margins[MARGIN_TOP])),
Size2(texture->width, texture->height));
_draw_textured_quad( // bottom
Rect2(Point2(rect_center.pos.x, rect_center.pos.y + rect_center.size.height), Size2(rect_center.size.width, p_margin[MARGIN_BOTTOM])),
Rect2(Point2(src_center.pos.x, src_center.pos.y + src_center.size.height), Size2(src_center.size.width, p_margin[MARGIN_BOTTOM])),
Rect2(Point2(rect_center.pos.x, rect_center.pos.y + rect_center.size.height), Size2(rect_center.size.width, p_margins[MARGIN_BOTTOM])),
Rect2(Point2(src_center.pos.x, src_center.pos.y + src_center.size.height), Size2(src_center.size.width, p_margins[MARGIN_BOTTOM])),
Size2(texture->width, texture->height));
_draw_textured_quad( // left
Rect2(Point2(p_rect.pos.x, rect_center.pos.y), Size2(p_margin[MARGIN_LEFT], rect_center.size.height)),
Rect2(Point2(region.pos.x, region.pos.y + p_margin[MARGIN_TOP]), Size2(p_margin[MARGIN_LEFT], src_center.size.height)),
Rect2(Point2(p_rect.pos.x, rect_center.pos.y), Size2(p_margins[MARGIN_LEFT], rect_center.size.height)),
Rect2(Point2(region.pos.x, region.pos.y + p_margins[MARGIN_TOP]), Size2(p_margins[MARGIN_LEFT], src_center.size.height)),
Size2(texture->width, texture->height));
_draw_textured_quad( // right
Rect2(Point2(rect_center.pos.x + rect_center.size.width, rect_center.pos.y), Size2(p_margin[MARGIN_RIGHT], rect_center.size.height)),
Rect2(Point2(src_center.pos.x + src_center.size.width, region.pos.y + p_margin[MARGIN_TOP]), Size2(p_margin[MARGIN_RIGHT], src_center.size.height)),
Rect2(Point2(rect_center.pos.x + rect_center.size.width, rect_center.pos.y), Size2(p_margins[MARGIN_RIGHT], rect_center.size.height)),
Rect2(Point2(src_center.pos.x + src_center.size.width, region.pos.y + p_margins[MARGIN_TOP]), Size2(p_margins[MARGIN_RIGHT], src_center.size.height)),
Size2(texture->width, texture->height));
if (p_draw_center) {
@ -8700,17 +8700,17 @@ void RasterizerGLES2::_canvas_item_render_commands(CanvasItem *p_item, CanvasIte
}
}
void RasterizerGLES2::_canvas_item_setup_shader_params(ShaderMaterial *material, Shader *shader) {
void RasterizerGLES2::_canvas_item_setup_shader_params(ShaderMaterial *material, Shader *p_shader) {
if (canvas_shader.bind())
rebind_texpixel_size = true;
if (material->shader_version != shader->version) {
if (material->shader_version != p_shader->version) {
//todo optimize uniforms
material->shader_version = shader->version;
material->shader_version = p_shader->version;
}
if (shader->has_texscreen && framebuffer.active) {
if (p_shader->has_texscreen && framebuffer.active) {
int x = viewport.x;
int y = window_size.height - (viewport.height + viewport.y);
@ -8742,19 +8742,19 @@ void RasterizerGLES2::_canvas_item_setup_shader_params(ShaderMaterial *material,
glActiveTexture(GL_TEXTURE0);
}
if (shader->has_screen_uv) {
if (p_shader->has_screen_uv) {
canvas_shader.set_uniform(CanvasShaderGLES2::SCREEN_UV_MULT, Vector2(1.0 / viewport.width, 1.0 / viewport.height));
}
uses_texpixel_size = shader->uses_texpixel_size;
uses_texpixel_size = p_shader->uses_texpixel_size;
}
void RasterizerGLES2::_canvas_item_setup_shader_uniforms(ShaderMaterial *material, Shader *shader) {
void RasterizerGLES2::_canvas_item_setup_shader_uniforms(ShaderMaterial *material, Shader *p_shader) {
//this can be optimized..
int tex_id = 1;
int idx = 0;
for (Map<StringName, ShaderLanguage::Uniform>::Element *E = shader->uniforms.front(); E; E = E->next()) {
for (Map<StringName, ShaderLanguage::Uniform>::Element *E = p_shader->uniforms.front(); E; E = E->next()) {
Map<StringName, Variant>::Element *F = material->shader_param.find(E->key());
@ -8767,7 +8767,7 @@ void RasterizerGLES2::_canvas_item_setup_shader_uniforms(ShaderMaterial *materia
if (!rid.is_valid()) {
Map<StringName, RID>::Element *DT = shader->default_textures.find(E->key());
Map<StringName, RID>::Element *DT = p_shader->default_textures.find(E->key());
if (DT) {
rid = DT->get();
}
@ -8799,7 +8799,7 @@ void RasterizerGLES2::_canvas_item_setup_shader_uniforms(ShaderMaterial *materia
glActiveTexture(GL_TEXTURE0);
}
if (shader->uses_time) {
if (p_shader->uses_time) {
canvas_shader.set_uniform(CanvasShaderGLES2::TIME, Math::fmod(last_time, shader_time_rollback));
draw_next_frame = true;
}

2
drivers/gles2/rasterizer_gles2.h
View file

@ -1524,7 +1524,7 @@ public:
virtual void light_directional_set_shadow_param(RID p_light, VS::LightDirectionalShadowParam p_param, float p_value);
virtual float light_directional_get_shadow_param(RID p_light, VS::LightDirectionalShadowParam p_param) const;
virtual AABB light_get_aabb(RID p_poly) const;
virtual AABB light_get_aabb(RID p_light) const;
virtual RID light_instance_create(RID p_light);
virtual void light_instance_set_transform(RID p_light_instance, const Transform &p_transform);

4
drivers/gles2/shader_gles2.cpp
View file

@ -103,11 +103,11 @@ void ShaderGLES2::bind_uniforms() {
uniforms_dirty = false;
};
GLint ShaderGLES2::get_uniform_location(int p_idx) const {
GLint ShaderGLES2::get_uniform_location(int p_index) const {
ERR_FAIL_COND_V(!version, -1);
return version->uniform_location[p_idx];
return version->uniform_location[p_index];
};
bool ShaderGLES2::bind() {

8
drivers/gles2/shader_gles2.h
View file

@ -281,7 +281,7 @@ public:
};
GLint get_uniform_location(const String &p_name) const;
GLint get_uniform_location(int p_uniform) const;
GLint get_uniform_location(int p_index) const;
static _FORCE_INLINE_ ShaderGLES2 *get_active() { return active; };
bool bind();
@ -293,9 +293,9 @@ public:
void clear_caches();
uint32_t create_custom_shader();
void set_custom_shader_code(uint32_t p_id, const String &p_vertex, const String &p_vertex_globals, const String &p_fragment, const String &p_p_light, const String &p_fragment_globals, const Vector<StringName> &p_uniforms, const Vector<const char *> &p_custom_defines);
void set_custom_shader(uint32_t p_id);
void free_custom_shader(uint32_t p_id);
void set_custom_shader_code(uint32_t p_code_id, const String &p_vertex, const String &p_vertex_globals, const String &p_fragment, const String &p_light, const String &p_fragment_globals, const Vector<StringName> &p_uniforms, const Vector<const char *> &p_custom_defines);
void set_custom_shader(uint32_t p_code_id);
void free_custom_shader(uint32_t p_code_id);
void set_uniform_default(int p_idx, const Variant &p_value) {

28
drivers/gles3/rasterizer_scene_gles3.cpp
View file

@ -2180,38 +2180,38 @@ void RasterizerSceneGLES3::_add_geometry(RasterizerStorageGLES3::Geometry *p_geo
}
}
void RasterizerSceneGLES3::_add_geometry_with_material(RasterizerStorageGLES3::Geometry *p_geometry, InstanceBase *p_instance, RasterizerStorageGLES3::GeometryOwner *p_owner, RasterizerStorageGLES3::Material *m, bool p_shadow) {
void RasterizerSceneGLES3::_add_geometry_with_material(RasterizerStorageGLES3::Geometry *p_geometry, InstanceBase *p_instance, RasterizerStorageGLES3::GeometryOwner *p_owner, RasterizerStorageGLES3::Material *p_material, bool p_shadow) {
bool has_base_alpha = (m->shader->spatial.uses_alpha && !m->shader->spatial.uses_alpha_scissor) || m->shader->spatial.uses_screen_texture || m->shader->spatial.unshaded;
bool has_blend_alpha = m->shader->spatial.blend_mode != RasterizerStorageGLES3::Shader::Spatial::BLEND_MODE_MIX || m->shader->spatial.ontop;
bool has_base_alpha = (p_material->shader->spatial.uses_alpha && !p_material->shader->spatial.uses_alpha_scissor) || p_material->shader->spatial.uses_screen_texture || p_material->shader->spatial.unshaded;
bool has_blend_alpha = p_material->shader->spatial.blend_mode != RasterizerStorageGLES3::Shader::Spatial::BLEND_MODE_MIX || p_material->shader->spatial.ontop;
bool has_alpha = has_base_alpha || has_blend_alpha;
bool shadow = false;
bool mirror = p_instance->mirror;
if (m->shader->spatial.cull_mode == RasterizerStorageGLES3::Shader::Spatial::CULL_MODE_FRONT) {
if (p_material->shader->spatial.cull_mode == RasterizerStorageGLES3::Shader::Spatial::CULL_MODE_FRONT) {
mirror = !mirror;
}
if (m->shader->spatial.uses_sss) {
if (p_material->shader->spatial.uses_sss) {
state.used_sss = true;
}
if (m->shader->spatial.uses_screen_texture) {
if (p_material->shader->spatial.uses_screen_texture) {
state.used_screen_texture = true;
}
if (p_shadow) {
if (has_blend_alpha || (has_base_alpha && m->shader->spatial.depth_draw_mode != RasterizerStorageGLES3::Shader::Spatial::DEPTH_DRAW_ALPHA_PREPASS))
if (has_blend_alpha || (has_base_alpha && p_material->shader->spatial.depth_draw_mode != RasterizerStorageGLES3::Shader::Spatial::DEPTH_DRAW_ALPHA_PREPASS))
return; //bye
if (!m->shader->spatial.uses_alpha_scissor && !m->shader->spatial.writes_modelview_or_projection && !m->shader->spatial.uses_vertex && !m->shader->spatial.uses_discard && m->shader->spatial.depth_draw_mode != RasterizerStorageGLES3::Shader::Spatial::DEPTH_DRAW_ALPHA_PREPASS) {
if (!p_material->shader->spatial.uses_alpha_scissor && !p_material->shader->spatial.writes_modelview_or_projection && !p_material->shader->spatial.uses_vertex && !p_material->shader->spatial.uses_discard && p_material->shader->spatial.depth_draw_mode != RasterizerStorageGLES3::Shader::Spatial::DEPTH_DRAW_ALPHA_PREPASS) {
//shader does not use discard and does not write a vertex position, use generic material
if (p_instance->cast_shadows == VS::SHADOW_CASTING_SETTING_DOUBLE_SIDED)
m = storage->material_owner.getptr(default_material_twosided);
p_material = storage->material_owner.getptr(default_material_twosided);
else
m = storage->material_owner.getptr(default_material);
p_material = storage->material_owner.getptr(default_material);
}
has_alpha = false;
@ -2223,7 +2223,7 @@ void RasterizerSceneGLES3::_add_geometry_with_material(RasterizerStorageGLES3::G
return;
e->geometry = p_geometry;
e->material = m;
e->material = p_material;
e->instance = p_instance;
e->owner = p_owner;
e->sort_key = 0;
@ -2250,7 +2250,7 @@ void RasterizerSceneGLES3::_add_geometry_with_material(RasterizerStorageGLES3::G
e->sort_key |= uint64_t(e->material->index) << RenderList::SORT_KEY_MATERIAL_INDEX_SHIFT;
e->sort_key |= uint64_t(e->instance->depth_layer) << RenderList::SORT_KEY_DEPTH_LAYER_SHIFT;
if (!has_blend_alpha && has_alpha && m->shader->spatial.depth_draw_mode == RasterizerStorageGLES3::Shader::Spatial::DEPTH_DRAW_ALPHA_PREPASS) {
if (!has_blend_alpha && has_alpha && p_material->shader->spatial.depth_draw_mode == RasterizerStorageGLES3::Shader::Spatial::DEPTH_DRAW_ALPHA_PREPASS) {
//if nothing exists, add this element as opaque too
RenderList::Element *oe = render_list.add_element();
@ -2277,12 +2277,12 @@ void RasterizerSceneGLES3::_add_geometry_with_material(RasterizerStorageGLES3::G
//e->light_type=0xFF; // no lights!
if (shadow || m->shader->spatial.unshaded || state.debug_draw == VS::VIEWPORT_DEBUG_DRAW_UNSHADED) {
if (shadow || p_material->shader->spatial.unshaded || state.debug_draw == VS::VIEWPORT_DEBUG_DRAW_UNSHADED) {
e->sort_key |= SORT_KEY_UNSHADED_FLAG;
}
if (!shadow && (m->shader->spatial.uses_vertex_lighting || storage->config.force_vertex_shading)) {
if (!shadow && (p_material->shader->spatial.uses_vertex_lighting || storage->config.force_vertex_shading)) {
e->sort_key |= SORT_KEY_VERTEX_LIT_FLAG;
}

6
drivers/gles3/rasterizer_scene_gles3.h
View file

@ -523,8 +523,8 @@ public:
virtual void environment_set_canvas_max_layer(RID p_env, int p_max_layer);
virtual void environment_set_ambient_light(RID p_env, const Color &p_color, float p_energy = 1.0, float p_sky_contribution = 0.0);
virtual void environment_set_dof_blur_near(RID p_env, bool p_enable, float p_distance, float p_transition, float p_far_amount, VS::EnvironmentDOFBlurQuality p_quality);
virtual void environment_set_dof_blur_far(RID p_env, bool p_enable, float p_distance, float p_transition, float p_far_amount, VS::EnvironmentDOFBlurQuality p_quality);
virtual void environment_set_dof_blur_near(RID p_env, bool p_enable, float p_distance, float p_transition, float p_amount, VS::EnvironmentDOFBlurQuality p_quality);
virtual void environment_set_dof_blur_far(RID p_env, bool p_enable, float p_distance, float p_transition, float p_amount, VS::EnvironmentDOFBlurQuality p_quality);
virtual void environment_set_glow(RID p_env, bool p_enable, int p_level_flags, float p_intensity, float p_strength, float p_bloom_threshold, VS::EnvironmentGlowBlendMode p_blend_mode, float p_hdr_bleed_threshold, float p_hdr_bleed_scale, bool p_bicubic_upscale);
virtual void environment_set_fog(RID p_env, bool p_enable, float p_begin, float p_end, RID p_gradient_texture);
@ -795,7 +795,7 @@ public:
void _draw_sky(RasterizerStorageGLES3::Sky *p_sky, const CameraMatrix &p_projection, const Transform &p_transform, bool p_vflip, float p_scale, float p_energy);
void _setup_environment(Environment *env, const CameraMatrix &p_cam_projection, const Transform &p_cam_transform);
void _setup_directional_light(int p_index, const Transform &p_camera_inverse_transformm, bool p_use_shadows);
void _setup_directional_light(int p_index, const Transform &p_camera_inverse_transform, bool p_use_shadows);
void _setup_lights(RID *p_light_cull_result, int p_light_cull_count, const Transform &p_camera_inverse_transform, const CameraMatrix &p_camera_projection, RID p_shadow_atlas);
void _setup_reflections(RID *p_reflection_probe_cull_result, int p_reflection_probe_cull_count, const Transform &p_camera_inverse_transform, const CameraMatrix &p_camera_projection, RID p_reflection_atlas, Environment *p_env);

52
drivers/gles3/rasterizer_storage_gles3.cpp
View file

@ -5468,58 +5468,58 @@ RID RasterizerStorageGLES3::particles_get_draw_pass_mesh(RID p_particles, int p_
return particles->draw_passes[p_pass];
}
void RasterizerStorageGLES3::_particles_process(Particles *particles, float p_delta) {
void RasterizerStorageGLES3::_particles_process(Particles *p_particles, float p_delta) {
float new_phase = Math::fmod((float)particles->phase + (p_delta / particles->lifetime) * particles->speed_scale, (float)1.0);
float new_phase = Math::fmod((float)p_particles->phase + (p_delta / p_particles->lifetime) * p_particles->speed_scale, (float)1.0);
if (particles->clear) {
particles->cycle_number = 0;
particles->random_seed = Math::rand();
} else if (new_phase < particles->phase) {
if (particles->one_shot) {
particles->emitting = false;
if (p_particles->clear) {
p_particles->cycle_number = 0;
p_particles->random_seed = Math::rand();
} else if (new_phase < p_particles->phase) {
if (p_particles->one_shot) {
p_particles->emitting = false;
shaders.particles.set_uniform(ParticlesShaderGLES3::EMITTING, false);
}
particles->cycle_number++;
p_particles->cycle_number++;
}
shaders.particles.set_uniform(ParticlesShaderGLES3::SYSTEM_PHASE, new_phase);
shaders.particles.set_uniform(ParticlesShaderGLES3::PREV_SYSTEM_PHASE, particles->phase);
particles->phase = new_phase;
shaders.particles.set_uniform(ParticlesShaderGLES3::PREV_SYSTEM_PHASE, p_particles->phase);
p_particles->phase = new_phase;
shaders.particles.set_uniform(ParticlesShaderGLES3::DELTA, p_delta * particles->speed_scale);
shaders.particles.set_uniform(ParticlesShaderGLES3::CLEAR, particles->clear);
glUniform1ui(shaders.particles.get_uniform_location(ParticlesShaderGLES3::RANDOM_SEED), particles->random_seed);
shaders.particles.set_uniform(ParticlesShaderGLES3::DELTA, p_delta * p_particles->speed_scale);
shaders.particles.set_uniform(ParticlesShaderGLES3::CLEAR, p_particles->clear);
glUniform1ui(shaders.particles.get_uniform_location(ParticlesShaderGLES3::RANDOM_SEED), p_particles->random_seed);
if (particles->use_local_coords)
if (p_particles->use_local_coords)
shaders.particles.set_uniform(ParticlesShaderGLES3::EMISSION_TRANSFORM, Transform());
else
shaders.particles.set_uniform(ParticlesShaderGLES3::EMISSION_TRANSFORM, particles->emission_transform);
shaders.particles.set_uniform(ParticlesShaderGLES3::EMISSION_TRANSFORM, p_particles->emission_transform);
glUniform1ui(shaders.particles.get_uniform(ParticlesShaderGLES3::CYCLE), particles->cycle_number);
glUniform1ui(shaders.particles.get_uniform(ParticlesShaderGLES3::CYCLE), p_particles->cycle_number);
particles->clear = false;
p_particles->clear = false;
glBindVertexArray(particles->particle_vaos[0]);
glBindVertexArray(p_particles->particle_vaos[0]);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, particles->particle_buffers[1]);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, p_particles->particle_buffers[1]);
// GLint size = 0;
// glGetBufferParameteriv(GL_ARRAY_BUFFER, GL_BUFFER_SIZE, &size);
glBeginTransformFeedback(GL_POINTS);
glDrawArrays(GL_POINTS, 0, particles->amount);
glDrawArrays(GL_POINTS, 0, p_particles->amount);
glEndTransformFeedback();
SWAP(particles->particle_buffers[0], particles->particle_buffers[1]);
SWAP(particles->particle_vaos[0], particles->particle_vaos[1]);
SWAP(p_particles->particle_buffers[0], p_particles->particle_buffers[1]);
SWAP(p_particles->particle_vaos[0], p_particles->particle_vaos[1]);
glBindVertexArray(0);
/* //debug particles :D
glBindBuffer(GL_ARRAY_BUFFER, particles->particle_buffers[0]);
glBindBuffer(GL_ARRAY_BUFFER, p_particles->particle_buffers[0]);
float *data = (float *)glMapBufferRange(GL_ARRAY_BUFFER, 0, particles->amount * 16 * 6, GL_MAP_READ_BIT);
for (int i = 0; i < particles->amount; i++) {
float *data = (float *)glMapBufferRange(GL_ARRAY_BUFFER, 0, p_particles->amount * 16 * 6, GL_MAP_READ_BIT);
for (int i = 0; i < p_particles->amount; i++) {
int ofs = i * 24;
print_line(itos(i) + ":");
print_line("\tColor: " + Color(data[ofs + 0], data[ofs + 1], data[ofs + 2], data[ofs + 3]));

8
drivers/gles3/rasterizer_storage_gles3.h
View file

@ -314,7 +314,7 @@ public:
mutable RID_Owner<Texture> texture_owner;
Ref<Image> _get_gl_image_and_format(const Ref<Image> &p_image, Image::Format p_format, uint32_t p_flags, GLenum &r_gl_format, GLenum &r_gl_internal_format, GLenum &r_type, bool &r_compressed, bool &srgb);
Ref<Image> _get_gl_image_and_format(const Ref<Image> &p_image, Image::Format p_format, uint32_t p_flags, GLenum &r_gl_format, GLenum &r_gl_internal_format, GLenum &r_gl_type, bool &r_compressed, bool &srgb);
virtual RID texture_create();
virtual void texture_allocate(RID p_texture, int p_width, int p_height, Image::Format p_format, uint32_t p_flags = VS::TEXTURE_FLAGS_DEFAULT);
@ -528,8 +528,8 @@ public:
mutable SelfList<Material>::List _material_dirty_list;
void _material_make_dirty(Material *p_material) const;
void _material_add_geometry(RID p_material, Geometry *p_instantiable);
void _material_remove_geometry(RID p_material, Geometry *p_instantiable);
void _material_add_geometry(RID p_material, Geometry *p_geometry);
void _material_remove_geometry(RID p_material, Geometry *p_geometry);
mutable RID_Owner<Material> material_owner;
@ -1168,7 +1168,7 @@ public:
virtual void particles_set_draw_order(RID p_particles, VS::ParticlesDrawOrder p_order);
virtual void particles_set_draw_passes(RID p_particles, int p_count);
virtual void particles_set_draw_passes(RID p_particles, int p_passes);
virtual void particles_set_draw_pass_mesh(RID p_particles, int p_pass, RID p_mesh);
virtual void particles_request_process(RID p_particles);

4
drivers/gles3/shader_gles3.cpp
View file

@ -102,11 +102,11 @@ void ShaderGLES3::bind_uniforms() {
uniforms_dirty = false;
}
GLint ShaderGLES3::get_uniform_location(int p_idx) const {
GLint ShaderGLES3::get_uniform_location(int p_index) const {
ERR_FAIL_COND_V(!version, -1);
return version->uniform_location[p_idx];
return version->uniform_location[p_index];
}
bool ShaderGLES3::bind() {

8
drivers/gles3/shader_gles3.h
View file

@ -306,7 +306,7 @@ public:
};
GLint get_uniform_location(const String &p_name) const;
GLint get_uniform_location(int p_uniform) const;
GLint get_uniform_location(int p_index) const;
static _FORCE_INLINE_ ShaderGLES3 *get_active() { return active; };
bool bind();
@ -318,9 +318,9 @@ public:
void clear_caches();
uint32_t create_custom_shader();
void set_custom_shader_code(uint32_t p_id, const String &p_vertex, const String &p_vertex_globals, const String &p_fragment, const String &p_p_light, const String &p_fragment_globals, const String &p_uniforms, const Vector<StringName> &p_texture_uniforms, const Vector<CharString> &p_custom_defines);
void set_custom_shader(uint32_t p_id);
void free_custom_shader(uint32_t p_id);
void set_custom_shader_code(uint32_t p_code_id, const String &p_vertex, const String &p_vertex_globals, const String &p_fragment, const String &p_light, const String &p_fragment_globals, const String &p_uniforms, const Vector<StringName> &p_texture_uniforms, const Vector<CharString> &p_custom_defines);
void set_custom_shader(uint32_t p_code_id);
void free_custom_shader(uint32_t p_code_id);
void set_uniform_default(int p_idx, const Variant &p_value) {

4
drivers/unix/dir_access_unix.h
View file

@ -75,8 +75,8 @@ public:
virtual uint64_t get_modified_time(String p_file);
virtual Error rename(String p_from, String p_to);
virtual Error remove(String p_name);
virtual Error rename(String p_path, String p_new_path);
virtual Error remove(String p_path);
virtual size_t get_space_left();

2
drivers/unix/os_unix.h
View file

@ -69,7 +69,7 @@ public:
virtual void print_error(const char *p_function, const char *p_file, int p_line, const char *p_code, const char *p_rationale, ErrorType p_type = ERR_ERROR);
virtual void print(const char *p_format, ...);
virtual void vprint(const char *p_format, va_list p_list, bool p_stderr = false);
virtual void vprint(const char *p_format, va_list p_list, bool p_stder = false);
virtual void alert(const String &p_alert, const String &p_title = "ALERT!");
virtual String get_stdin_string(bool p_block);

6
drivers/unix/packet_peer_udp_posix.cpp
View file

@ -172,13 +172,13 @@ Error PacketPeerUDPPosix::wait() {
return _poll(true);
}
Error PacketPeerUDPPosix::_poll(bool p_wait) {
Error PacketPeerUDPPosix::_poll(bool p_block) {
if (sockfd == -1) {
return FAILED;
}
_set_sock_blocking(p_wait);
_set_sock_blocking(p_block);
struct sockaddr_storage from = { 0 };
socklen_t len = sizeof(struct sockaddr_storage);
@ -216,7 +216,7 @@ Error PacketPeerUDPPosix::_poll(bool p_wait) {
len = sizeof(struct sockaddr_storage);
++queue_count;
if (p_wait)
if (p_block)
break;
};

4
drivers/windows/dir_access_windows.h
View file

@ -75,8 +75,8 @@ public:
virtual Error make_dir(String p_dir);
virtual Error rename(String p_from, String p_to);
virtual Error remove(String p_name);
virtual Error rename(String p_path, String p_new_path);
virtual Error remove(String p_path);
//virtual FileType get_file_type() const;
size_t get_space_left();

4
drivers/windows/file_access_windows.cpp
View file

@ -53,9 +53,9 @@ void FileAccessWindows::check_errors() const {
}
}
Error FileAccessWindows::_open(const String &p_filename, int p_mode_flags) {
Error FileAccessWindows::_open(const String &p_path, int p_mode_flags) {
String filename = fix_path(p_filename);
String filename = fix_path(p_path);
if (f)
close();

2
main/input_default.h
View file

@ -214,7 +214,7 @@ public:
virtual void start_joy_vibration(int p_device, float p_weak_magnitude, float p_strong_magnitude, float p_duration = 0);
virtual void stop_joy_vibration(int p_device);
void set_main_loop(MainLoop *main_loop);
void set_main_loop(MainLoop *p_main_loop);
void set_mouse_position(const Point2 &p_posf);
void action_press(const StringName &p_action);

12
main/tests/test_gdscript.cpp
View file

@ -911,7 +911,7 @@ static void _disassemble_class(const Ref<GDScript> &p_class, const Vector<String
}
}
MainLoop *test(TestType p_test) {
MainLoop *test(TestType p_type) {
List<String> cmdlargs = OS::get_singleton()->get_cmdline_args();
@ -950,7 +950,7 @@ MainLoop *test(TestType p_test) {
}
}
if (p_test == TEST_TOKENIZER) {
if (p_type == TEST_TOKENIZER) {
GDTokenizerText tk;
tk.set_code(code);
@ -993,7 +993,7 @@ MainLoop *test(TestType p_test) {
}
}
if (p_test == TEST_PARSER) {
if (p_type == TEST_PARSER) {
GDParser parser;
Error err = parser.parse(code);
@ -1010,7 +1010,7 @@ MainLoop *test(TestType p_test) {
_parser_show_class(cnode, 0, lines);
}
if (p_test == TEST_COMPILER) {
if (p_type == TEST_COMPILER) {
GDParser parser;
@ -1044,7 +1044,7 @@ MainLoop *test(TestType p_test) {
current = current->get_base();
}
} else if (p_test == TEST_BYTECODE) {
} else if (p_type == TEST_BYTECODE) {
Vector<uint8_t> buf = GDTokenizerBuffer::parse_code_string(code);
String dst = test.get_basename() + ".gdc";
@ -1073,7 +1073,7 @@ MainLoop *test(TestType p_test) {
namespace TestGDScript {
MainLoop *test(TestType p_test) {
MainLoop *test(TestType p_type) {
return NULL;
}

2
platform/android/audio_driver_jandroid.h
View file

@ -71,7 +71,7 @@ public:
virtual void set_pause(bool p_pause);
static void setup(jobject act);
static void setup(jobject p_io);
static void thread_func(JNIEnv *env);
AudioDriverAndroid();

2
platform/android/dir_access_jandroid.h
View file

@ -79,7 +79,7 @@ public:
//virtual FileType get_file_type() const;
size_t get_space_left();
static void setup(jobject io);
static void setup(jobject p_io);
DirAccessJAndroid();
~DirAccessJAndroid();

2
platform/android/file_access_jandroid.h
View file

@ -71,7 +71,7 @@ public:
virtual bool file_exists(const String &p_path); ///< return true if a file exists
static void setup(jobject io);
static void setup(jobject p_io);
virtual uint64_t _get_modified_time(const String &p_file) { return 0; }

24
platform/android/godot_android.cpp
View file

@ -739,21 +739,21 @@ static void engine_handle_cmd(struct android_app *app, int32_t cmd) {
}
}
void android_main(struct android_app *state) {
void android_main(struct android_app *app) {
struct engine engine;
// Make sure glue isn't stripped.
app_dummy();
memset(&engine, 0, sizeof(engine));
state->userData = &engine;
state->onAppCmd = engine_handle_cmd;
state->onInputEvent = engine_handle_input;
engine.app = state;
app->userData = &engine;
app->onAppCmd = engine_handle_cmd;
app->onInputEvent = engine_handle_input;
engine.app = app;
engine.requested_quit = false;
engine.os = NULL;
engine.display_active = false;
FileAccessAndroid::asset_manager = state->activity->assetManager;
FileAccessAndroid::asset_manager = app->activity->assetManager;
// Prepare to monitor sensors
engine.sensorManager = ASensorManager_getInstance();
@ -764,11 +764,11 @@ void android_main(struct android_app *state) {
engine.gyroscopeSensor = ASensorManager_getDefaultSensor(engine.sensorManager,
ASENSOR_TYPE_GYROSCOPE);
engine.sensorEventQueue = ASensorManager_createEventQueue(engine.sensorManager,
state->looper, LOOPER_ID_USER, NULL, NULL);
app->looper, LOOPER_ID_USER, NULL, NULL);
ANativeActivity_setWindowFlags(state->activity, AWINDOW_FLAG_FULLSCREEN | AWINDOW_FLAG_KEEP_SCREEN_ON, 0);
ANativeActivity_setWindowFlags(app->activity, AWINDOW_FLAG_FULLSCREEN | AWINDOW_FLAG_KEEP_SCREEN_ON, 0);
state->activity->vm->AttachCurrentThread(&engine.jni, NULL);
app->activity->vm->AttachCurrentThread(&engine.jni, NULL);
// loop waiting for stuff to do.
@ -790,7 +790,7 @@ void android_main(struct android_app *state) {
if (source != NULL) {
// LOGI("process\n");
source->process(state, source);
source->process(app, source);
} else {
nullmax--;
if (nullmax < 0)
@ -824,11 +824,11 @@ void android_main(struct android_app *state) {
}
// Check if we are exiting.
if (state->destroyRequested != 0) {
if (app->destroyRequested != 0) {
if (engine.os) {
engine.os->main_loop_request_quit();
}
state->destroyRequested = 0;
app->destroyRequested = 0;
}
if (engine.requested_quit) {

4
platform/android/java_glue.h
View file

@ -56,8 +56,8 @@ JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_focusout(JNIEnv *env,
JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_singleton(JNIEnv *env, jobject obj, jstring name, jobject p_object);
JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_method(JNIEnv *env, jobject obj, jstring sname, jstring name, jstring ret, jobjectArray args);
JNIEXPORT jstring JNICALL Java_org_godotengine_godot_GodotLib_getGlobal(JNIEnv *env, jobject obj, jstring path);
JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_callobject(JNIEnv *env, jobject obj, jint ID, jstring method, jobjectArray params);
JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_calldeferred(JNIEnv *env, jobject obj, jint ID, jstring method, jobjectArray params);
JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_callobject(JNIEnv *env, jobject p_obj, jint ID, jstring method, jobjectArray params);
JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_calldeferred(JNIEnv *env, jobject p_obj, jint ID, jstring method, jobjectArray params);
}
#endif

8
platform/windows/joypad.cpp
View file

@ -235,13 +235,13 @@ void JoypadWindows::setup_joypad_object(const DIDEVICEOBJECTINSTANCE *ob, int p_
}
}
BOOL CALLBACK JoypadWindows::enumCallback(const DIDEVICEINSTANCE *instance, void *pContext) {
BOOL CALLBACK JoypadWindows::enumCallback(const DIDEVICEINSTANCE *p_instance, void *p_context) {
JoypadWindows *self = (JoypadWindows *)pContext;
if (self->is_xinput_device(&instance->guidProduct)) {
JoypadWindows *self = (JoypadWindows *)p_context;
if (self->is_xinput_device(&p_instance->guidProduct)) {
return DIENUM_CONTINUE;
}
self->setup_dinput_joypad(instance);
self->setup_dinput_joypad(p_instance);
return DIENUM_CONTINUE;
}

10
platform/x11/joypad_linux.h
View file

@ -80,22 +80,22 @@ private:
static void joy_thread_func(void *p_user);
int get_joy_from_path(String path) const;
int get_joy_from_path(String p_path) const;
void setup_joypad_properties(int p_id);
void close_joypad(int p_id = -1);
#ifdef UDEV_ENABLED
void enumerate_joypads(struct udev *_udev);
void monitor_joypads(struct udev *_udev);
void enumerate_joypads(struct udev *p_udev);
void monitor_joypads(struct udev *p_udev);
#endif
void monitor_joypads();
void run_joypad_thread();
void open_joypad(const char *path);
void open_joypad(const char *p_path);
void joypad_vibration_start(int p_id, float p_weak_magnitude, float p_strong_magnitude, float p_duration, uint64_t p_timestamp);
void joypad_vibration_stop(int p_id, uint64_t p_timestamp);
InputDefault::JoyAxis axis_correct(const input_absinfo *abs, int value) const;
InputDefault::JoyAxis axis_correct(const input_absinfo *p_abs, int p_value) const;
};
#endif

6
scene/2d/camera_2d.cpp
View file

@ -552,11 +552,11 @@ float Camera2D::get_h_offset() const {
return h_ofs;
}
void Camera2D::_set_old_smoothing(float p_val) {
void Camera2D::_set_old_smoothing(float p_enable) {
//compatibility
if (p_val > 0) {
if (p_enable > 0) {
smoothing_enabled = true;
set_follow_smoothing(p_val);
set_follow_smoothing(p_enable);
}
}

2
scene/2d/canvas_item.h
View file

@ -297,7 +297,7 @@ public:
void set_use_parent_material(bool p_use_parent_material);
bool get_use_parent_material() const;
Ref<InputEvent> make_input_local(const Ref<InputEvent> &pevent) const;
Ref<InputEvent> make_input_local(const Ref<InputEvent> &p_event) const;
Vector2 make_canvas_pos_local(const Vector2 &screen_point) const;
Vector2 get_global_mouse_position() const;

2
scene/2d/joints_2d.h
View file

@ -81,7 +81,7 @@ protected:
static void _bind_methods();
public:
void set_softness(real_t p_stiffness);
void set_softness(real_t p_softness);
real_t get_softness() const;
PinJoint2D();

2
scene/2d/node_2d.h
View file

@ -49,7 +49,7 @@ class Node2D : public CanvasItem {
void _update_transform();
// Deprecated, should be removed in a future version.
void _set_rotd(float p_angle);
void _set_rotd(float p_degrees);
float _get_rotd() const;
void _update_xform_values();

2
scene/2d/parallax_background.h
View file

@ -60,7 +60,7 @@ public:
void set_scroll_offset(const Point2 &p_ofs);
Point2 get_scroll_offset() const;
void set_scroll_scale(float p_ofs);
void set_scroll_scale(float p_scale);
float get_scroll_scale() const;
void set_scroll_base_offset(const Point2 &p_ofs);

4
scene/2d/parallax_layer.h
View file

@ -48,7 +48,7 @@ protected:
static void _bind_methods();
public:
void set_motion_offset(const Size2 &p_scale);
void set_motion_offset(const Size2 &p_offset);
Size2 get_motion_offset() const;
void set_motion_scale(const Size2 &p_scale);
@ -57,7 +57,7 @@ public:
void set_mirroring(const Size2 &p_mirroring);
Size2 get_mirroring() const;
void set_base_offset_and_scale(const Point2 &p_offsetf, float p_scale);
void set_base_offset_and_scale(const Point2 &p_offset, float p_scale);
virtual String get_configuration_warning() const;
ParallaxLayer();

2
scene/2d/particles_2d.h
View file

@ -80,7 +80,7 @@ public:
void set_emitting(bool p_emitting);
void set_amount(int p_amount);
void set_lifetime(float p_lifetime);
void set_one_shot(bool p_enabled);
void set_one_shot(bool p_enable);
void set_pre_process_time(float p_time);
void set_explosiveness_ratio(float p_ratio);
void set_randomness_ratio(float p_ratio);

2
scene/2d/path_2d.h
View file

@ -96,7 +96,7 @@ public:
void set_loop(bool p_loop);
bool has_loop() const;
void set_rotate(bool p_enabled);
void set_rotate(bool p_rotate);
bool is_rotating() const;
void set_cubic_interpolation(bool p_enable);

4
scene/2d/polygon_2d.h
View file

@ -84,10 +84,10 @@ public:
void set_texture_scale(const Size2 &p_scale);
Size2 get_texture_scale() const;
void set_invert(bool p_rot);
void set_invert(bool p_invert);
bool get_invert() const;
void set_invert_border(float p_border);
void set_invert_border(float p_invert_border);
float get_invert_border() const;
void set_offset(const Vector2 &p_offset);

2
scene/2d/screen_button.h
View file

@ -61,7 +61,7 @@ private:
VisibilityMode visibility;
void _input(const Ref<InputEvent> &p_Event);
void _input(const Ref<InputEvent> &p_event);
bool _is_point_inside(const Point2 &p_point);

8
scene/2d/tile_map.cpp
View file

@ -1068,20 +1068,20 @@ Transform2D TileMap::get_custom_transform() const {
return custom_transform;
}
Vector2 TileMap::_map_to_world(int x, int y, bool p_ignore_ofs) const {
Vector2 TileMap::_map_to_world(int p_x, int p_y, bool p_ignore_ofs) const {
Vector2 ret = get_cell_transform().xform(Vector2(x, y));
Vector2 ret = get_cell_transform().xform(Vector2(p_x, p_y));
if (!p_ignore_ofs) {
switch (half_offset) {
case HALF_OFFSET_X: {
if (ABS(y) & 1) {
if (ABS(p_y) & 1) {
ret += get_cell_transform()[0] * 0.5;
}
} break;
case HALF_OFFSET_Y: {
if (ABS(x) & 1) {
if (ABS(p_x) & 1) {
ret += get_cell_transform()[1] * 0.5;
}
} break;

6
scene/3d/camera.h
View file

@ -126,9 +126,9 @@ public:
virtual Transform get_camera_transform() const;
Vector3 project_ray_normal(const Point2 &p_point) const;
Vector3 project_ray_origin(const Point2 &p_point) const;
Vector3 project_local_ray_normal(const Point2 &p_point) const;
Vector3 project_ray_normal(const Point2 &p_pos) const;
Vector3 project_ray_origin(const Point2 &p_pos) const;
Vector3 project_local_ray_normal(const Point2 &p_pos) const;
Point2 unproject_position(const Vector3 &p_pos) const;
bool is_position_behind(const Vector3 &p_pos) const;
Vector3 project_position(const Point2 &p_point) const;

4
scene/3d/immediate_geometry.h
View file

@ -52,8 +52,8 @@ public:
void set_normal(const Vector3 &p_normal);
void set_tangent(const Plane &p_tangent);
void set_color(const Color &p_color);
void set_uv(const Vector2 &tex_uv);
void set_uv2(const Vector2 &tex_uv);
void set_uv(const Vector2 &p_uv);
void set_uv2(const Vector2 &p_uv2);
void add_vertex(const Vector3 &p_vertex);

2
scene/3d/particles.h
View file

@ -88,7 +88,7 @@ public:
void set_emitting(bool p_emitting);
void set_amount(int p_amount);
void set_lifetime(float p_lifetime);
void set_one_shot(bool p_enabled);
void set_one_shot(bool p_one_shot);
void set_pre_process_time(float p_time);
void set_explosiveness_ratio(float p_ratio);
void set_randomness_ratio(float p_ratio);

4
scene/3d/proximity_group.cpp
View file

@ -116,9 +116,9 @@ void ProximityGroup::set_group_name(String p_group_name) {
group_name = p_group_name;
};
void ProximityGroup::_notification(int what) {
void ProximityGroup::_notification(int p_what) {
switch (what) {
switch (p_what) {
case NOTIFICATION_EXIT_TREE:
++group_version;

4
scene/3d/skeleton.cpp
View file

@ -82,9 +82,9 @@ bool Skeleton::_set(const StringName &p_path, const Variant &p_value) {
return true;
}
bool Skeleton::_get(const StringName &p_name, Variant &r_ret) const {
bool Skeleton::_get(const StringName &p_path, Variant &r_ret) const {
String path = p_name;
String path = p_path;
if (!path.begins_with("bones/"))
return false;

6
scene/3d/skeleton.h
View file

@ -91,8 +91,8 @@ class Skeleton : public Spatial {
}
protected:
bool _get(const StringName &p_name, Variant &r_ret) const;
bool _set(const StringName &p_name, const Variant &p_value);
bool _get(const StringName &p_path, Variant &r_ret) const;
bool _set(const StringName &p_path, const Variant &p_value);
void _get_property_list(List<PropertyInfo> *p_list) const;
void _notification(int p_what);
static void _bind_methods();
@ -113,7 +113,7 @@ public:
void set_bone_parent(int p_bone, int p_parent);
int get_bone_parent(int p_bone) const;
void unparent_bone_and_rest(int p_idx);
void unparent_bone_and_rest(int p_bone);
void set_bone_disable_rest(int p_bone, bool p_disable);
bool is_bone_rest_disabled(int p_bone) const;

2
scene/3d/spatial_velocity_tracker.h
View file

@ -20,7 +20,7 @@ protected:
public:
void reset(const Vector3 &p_new_pos);
void set_track_fixed_step(bool p_use_fixed_step);
void set_track_fixed_step(bool p_track_fixed_step);
bool is_tracking_fixed_step() const;
void update_position(const Vector3 &p_position);
Vector3 get_tracked_linear_velocity() const;

2
scene/3d/sprite_3d.h
View file

@ -119,7 +119,7 @@ public:
void set_pixel_size(float p_amount);
float get_pixel_size() const;
void set_axis(Vector3::Axis p_amount);
void set_axis(Vector3::Axis p_axis);
Vector3::Axis get_axis() const;
void set_draw_flag(DrawFlags p_flag, bool p_enable);

4
scene/3d/vehicle_body.cpp
View file

@ -893,9 +893,9 @@ real_t VehicleBody::get_friction() const {
return friction;
}
void VehicleBody::set_engine_force(float p_force) {
void VehicleBody::set_engine_force(float p_engine_force) {
engine_force = p_force;
engine_force = p_engine_force;
}
float VehicleBody::get_engine_force() const {

2
scene/3d/vehicle_body.h
View file

@ -196,7 +196,7 @@ public:
void set_engine_force(float p_engine_force);
float get_engine_force() const;
void set_brake(float p_force);
void set_brake(float p_brake);
float get_brake() const;
void set_steering(float p_steering);

2
scene/animation/animation_player.h
View file

@ -271,7 +271,7 @@ public:
void set_speed_scale(float p_speed);
float get_speed_scale() const;
void set_autoplay(const String &pname);
void set_autoplay(const String &p_name);
String get_autoplay() const;
void set_animation_process_mode(AnimationProcessMode p_mode);

8
scene/animation/animation_tree_player.h
View file

@ -312,7 +312,7 @@ private:
Map<StringName, NodeBase *> node_map;
// return time left to finish animation
float _process_node(const StringName &p_node, AnimationNode **r_prev_anim, float p_step, bool p_seek = false, float p_fallback_weight = 1.0, HashMap<NodePath, float> *p_weights = NULL);
float _process_node(const StringName &p_node, AnimationNode **r_prev_anim, float p_time, bool p_seek = false, float p_fallback_weight = 1.0, HashMap<NodePath, float> *p_weights = NULL);
void _process_animation(float p_delta);
bool reset_request;
@ -367,7 +367,7 @@ public:
float oneshot_node_get_autorestart_delay(const StringName &p_node) const;
float oneshot_node_get_autorestart_random_delay(const StringName &p_node) const;
void oneshot_node_set_mix_mode(const StringName &p_node, bool p_enabled);
void oneshot_node_set_mix_mode(const StringName &p_node, bool p_mix);
bool oneshot_node_get_mix_mode(const StringName &p_node) const;
void oneshot_node_start(const StringName &p_node);
@ -428,8 +428,8 @@ public:
void remove_node(const StringName &p_node);
Error connect_nodes(const StringName &p_src_node, const StringName &p_dst_node, int p_dst_input);
bool are_nodes_connected(const StringName &p_src_node, const StringName &p_dst_node, int p_input) const;
void disconnect_nodes(const StringName &p_src_node, int p_input);
bool are_nodes_connected(const StringName &p_src_node, const StringName &p_dst_node, int p_dst_input) const;
void disconnect_nodes(const StringName &p_node, int p_input);
void set_base_path(const NodePath &p_path);
NodePath get_base_path() const;

22
scene/animation/tween.h
View file

@ -132,7 +132,7 @@ private:
void _tween_process(float p_delta);
void _set_process(bool p_process, bool p_force = false);
void _remove(Object *p_node, String p_key, bool first_only);
void _remove(Object *p_object, String p_key, bool first_only);
protected:
bool _set(const StringName &p_name, const Variant &p_value);
@ -156,34 +156,34 @@ public:
float get_speed_scale() const;
bool start();
bool reset(Object *p_node, String p_key);
bool reset(Object *p_object, String p_key);
bool reset_all();
bool stop(Object *p_node, String p_key);
bool stop(Object *p_object, String p_key);
bool stop_all();
bool resume(Object *p_node, String p_key);
bool resume(Object *p_object, String p_key);
bool resume_all();
bool remove(Object *p_node, String p_key);
bool remove(Object *p_object, String p_key);
bool remove_all();
bool seek(real_t p_time);
real_t tell() const;
real_t get_runtime() const;
bool interpolate_property(Object *p_node, String p_property, Variant p_initial_val, Variant p_final_val, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay = 0);
bool interpolate_property(Object *p_object, String p_property, Variant p_initial_val, Variant p_final_val, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay = 0);
bool interpolate_method(Object *p_node, String p_method, Variant p_initial_val, Variant p_final_val, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay = 0);
bool interpolate_method(Object *p_object, String p_method, Variant p_initial_val, Variant p_final_val, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay = 0);
bool interpolate_callback(Object *p_object, real_t p_duration, String p_callback, VARIANT_ARG_DECLARE);
bool interpolate_deferred_callback(Object *p_object, real_t p_duration, String p_callback, VARIANT_ARG_DECLARE);
bool follow_property(Object *p_node, String p_property, Variant p_initial_val, Object *p_target, String p_target_property, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay = 0);
bool follow_property(Object *p_object, String p_property, Variant p_initial_val, Object *p_target, String p_target_property, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay = 0);
bool follow_method(Object *p_node, String p_method, Variant p_initial_val, Object *p_target, String p_target_method, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay = 0);
bool follow_method(Object *p_object, String p_method, Variant p_initial_val, Object *p_target, String p_target_method, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay = 0);
bool targeting_property(Object *p_node, String p_property, Object *p_initial, String p_initial_property, Variant p_final_val, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay = 0);
bool targeting_property(Object *p_object, String p_property, Object *p_initial, String p_initial_property, Variant p_final_val, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay = 0);
bool targeting_method(Object *p_node, String p_method, Object *p_initial, String p_initial_method, Variant p_final_val, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay = 0);
bool targeting_method(Object *p_object, String p_method, Object *p_initial, String p_initial_method, Variant p_final_val, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay = 0);
Tween();
~Tween();

24
scene/gui/color_picker.cpp
View file

@ -314,9 +314,9 @@ void ColorPicker::_hsv_draw(int p_which, Control *c) {
}
}
void ColorPicker::_uv_input(const Ref<InputEvent> &ev) {
void ColorPicker::_uv_input(const Ref<InputEvent> &p_event) {
Ref<InputEventMouseButton> bev = ev;
Ref<InputEventMouseButton> bev = p_event;
if (bev.is_valid()) {
if (bev->is_pressed() && bev->get_button_index() == BUTTON_LEFT) {
@ -335,7 +335,7 @@ void ColorPicker::_uv_input(const Ref<InputEvent> &ev) {
}
}
Ref<InputEventMouseMotion> mev = ev;
Ref<InputEventMouseMotion> mev = p_event;
if (mev.is_valid()) {
if (!changing_color)
@ -352,9 +352,9 @@ void ColorPicker::_uv_input(const Ref<InputEvent> &ev) {
}
}
void ColorPicker::_w_input(const Ref<InputEvent> &ev) {
void ColorPicker::_w_input(const Ref<InputEvent> &p_event) {
Ref<InputEventMouseButton> bev = ev;
Ref<InputEventMouseButton> bev = p_event;
if (bev.is_valid()) {
@ -372,7 +372,7 @@ void ColorPicker::_w_input(const Ref<InputEvent> &ev) {
emit_signal("color_changed", color);
}
Ref<InputEventMouseMotion> mev = ev;
Ref<InputEventMouseMotion> mev = p_event;
if (mev.is_valid()) {
@ -388,9 +388,9 @@ void ColorPicker::_w_input(const Ref<InputEvent> &ev) {
}
}
void ColorPicker::_preset_input(const Ref<InputEvent> &ev) {
void ColorPicker::_preset_input(const Ref<InputEvent> &p_event) {
Ref<InputEventMouseButton> bev = ev;
Ref<InputEventMouseButton> bev = p_event;
if (bev.is_valid()) {
@ -407,7 +407,7 @@ void ColorPicker::_preset_input(const Ref<InputEvent> &ev) {
emit_signal("color_changed", color);
}
Ref<InputEventMouseMotion> mev = ev;
Ref<InputEventMouseMotion> mev = p_event;
if (mev.is_valid()) {
@ -423,9 +423,9 @@ void ColorPicker::_preset_input(const Ref<InputEvent> &ev) {
}
}
void ColorPicker::_screen_input(const Ref<InputEvent> &ev) {
void ColorPicker::_screen_input(const Ref<InputEvent> &p_event) {
Ref<InputEventMouseButton> bev = ev;
Ref<InputEventMouseButton> bev = p_event;
if (bev.is_valid()) {
@ -435,7 +435,7 @@ void ColorPicker::_screen_input(const Ref<InputEvent> &ev) {
}
}
Ref<InputEventMouseMotion> mev = ev;
Ref<InputEventMouseMotion> mev = p_event;
if (mev.is_valid()) {
Viewport *r = get_tree()->get_root();

8
scene/gui/color_picker.h
View file

@ -81,10 +81,10 @@ private:
void _sample_draw();
void _hsv_draw(int p_which, Control *c);
void _uv_input(const Ref<InputEvent> &p_input);
void _w_input(const Ref<InputEvent> &p_input);
void _preset_input(const Ref<InputEvent> &p_input);
void _screen_input(const Ref<InputEvent> &p_input);
void _uv_input(const Ref<InputEvent> &p_event);
void _w_input(const Ref<InputEvent> &p_event);
void _preset_input(const Ref<InputEvent> &p_event);
void _screen_input(const Ref<InputEvent> &p_event);
void _add_preset_pressed();
void _screen_pick_pressed();

2
scene/gui/input_action.h
View file

@ -45,7 +45,7 @@ protected:
public:
void set_shortcut(const Ref<InputEvent> &p_shortcut);
Ref<InputEvent> get_shortcut() const;
bool is_shortcut(const Ref<InputEvent> &p_Event) const;
bool is_shortcut(const Ref<InputEvent> &p_event) const;
bool is_valid() const;
String get_as_text() const;

2
scene/gui/item_list.h
View file

@ -171,7 +171,7 @@ public:
void set_same_column_width(bool p_enable);
int is_same_column_width() const;
void set_max_text_lines(int p_amount);
void set_max_text_lines(int p_lines);
int get_max_text_lines() const;
void set_max_columns(int p_amount);

2
scene/gui/line_edit.h
View file

@ -177,7 +177,7 @@ public:
virtual Size2 get_minimum_size() const;
void set_expand_to_text_length(bool p_len);
void set_expand_to_text_length(bool p_enabled);
bool get_expand_to_text_length() const;
virtual bool is_text_field() const;

12
scene/gui/option_button.cpp
View file

@ -185,21 +185,21 @@ void OptionButton::clear() {
current = -1;
}
void OptionButton::_select(int p_idx, bool p_emit) {
void OptionButton::_select(int p_which, bool p_emit) {
if (p_idx < 0)
if (p_which < 0)
return;
if (p_idx == current)
if (p_which == current)
return;
ERR_FAIL_INDEX(p_idx, popup->get_item_count());
ERR_FAIL_INDEX(p_which, popup->get_item_count());
for (int i = 0; i < popup->get_item_count(); i++) {
popup->set_item_checked(i, i == p_idx);
popup->set_item_checked(i, i == p_which);
}
current = p_idx;
current = p_which;
set_text(popup->get_item_text(current));
set_icon(popup->get_item_icon(current));

2
scene/gui/patch_9_rect.h
View file

@ -67,7 +67,7 @@ public:
void set_region_rect(const Rect2 &p_region_rect);
Rect2 get_region_rect() const;
void set_draw_center(bool p_enable);
void set_draw_center(bool p_draw);
bool get_draw_center() const;
void set_h_axis_stretch_mode(AxisStretchMode p_mode);

8
scene/gui/popup.cpp
View file

@ -203,15 +203,15 @@ void Popup::popup_centered_ratio(float p_screen_ratio) {
popped_up = true;
}
void Popup::popup(const Rect2 &bounds) {
void Popup::popup(const Rect2 &p_bounds) {
emit_signal("about_to_show");
show_modal(exclusive);
// Fit the popup into the optionally provided bounds.
if (!bounds.has_no_area()) {
set_position(bounds.position);
set_size(bounds.size);
if (!p_bounds.has_no_area()) {
set_position(p_bounds.position);
set_size(p_bounds.size);
}
_fix_size();

2
scene/gui/popup_menu.h
View file

@ -140,7 +140,7 @@ public:
uint32_t get_item_accelerator(int p_idx) const;
Variant get_item_metadata(int p_idx) const;
bool is_item_disabled(int p_idx) const;
String get_item_submenu(int p_ID) const;
String get_item_submenu(int p_idx) const;
bool is_item_separator(int p_idx) const;
bool is_item_checkable(int p_idx) const;
String get_item_tooltip(int p_idx) const;

2
scene/gui/rich_text_label.h
View file

@ -296,7 +296,7 @@ public:
void push_align(Align p_align);
void push_indent(int p_level);
void push_list(ListType p_list);
void push_meta(const Variant &p_data);
void push_meta(const Variant &p_meta);
void push_table(int p_columns);
void set_table_column_expand(int p_column, bool p_expand, int p_ratio = 1);
int get_current_table_column() const;

4
scene/gui/tab_container.cpp
View file

@ -548,11 +548,11 @@ Ref<Texture> TabContainer::get_tab_icon(int p_tab) const {
return Ref<Texture>();
}
void TabContainer::set_tab_disabled(int p_tab, bool p_enabled) {
void TabContainer::set_tab_disabled(int p_tab, bool p_disabled) {
Control *child = _get_tab(p_tab);
ERR_FAIL_COND(!child);
child->set_meta("_tab_disabled", p_enabled);
child->set_meta("_tab_disabled", p_disabled);
update();
}

2
scene/gui/tab_container.h
View file

@ -54,7 +54,7 @@ private:
bool tabs_visible;
bool buttons_visible_cache;
TabAlign align;
Control *_get_tab(int idx) const;
Control *_get_tab(int p_idx) const;
int _get_top_margin() const;
Popup *popup;

6
scene/gui/text_edit.cpp
View file

@ -2933,7 +2933,7 @@ void TextEdit::_base_remove_text(int p_from_line, int p_from_column, int p_to_li
}
}
void TextEdit::_insert_text(int p_line, int p_char, const String &p_text, int *r_end_line, int *r_end_column) {
void TextEdit::_insert_text(int p_line, int p_char, const String &p_text, int *r_end_line, int *r_end_char) {
if (!setting_text)
idle_detect->start();
@ -2946,8 +2946,8 @@ void TextEdit::_insert_text(int p_line, int p_char, const String &p_text, int *r
_base_insert_text(p_line, p_char, p_text, retline, retchar);
if (r_end_line)
*r_end_line = retline;
if (r_end_column)
*r_end_column = retchar;
if (r_end_char)
*r_end_char = retchar;
if (!undo_enabled)
return;

12
scene/gui/text_edit.h
View file

@ -152,7 +152,7 @@ class TextEdit : public Control {
int get_line_width(int p_line) const;
int get_max_width() const;
const Map<int, ColorRegionInfo> &get_color_region_info(int p_line);
void set(int p_line, const String &p_string);
void set(int p_line, const String &p_text);
void set_marked(int p_line, bool p_marked) { text[p_line].marked = p_marked; }
bool is_marked(int p_line) const { return text[p_line].marked; }
void set_breakpoint(int p_line, bool p_breakpoint) { text[p_line].breakpoint = p_breakpoint; }
@ -288,8 +288,8 @@ class TextEdit : public Control {
int get_char_count();
int get_char_pos_for(int p_px, String p_pos) const;
int get_column_x_offset(int p_column, String p_pos);
int get_char_pos_for(int p_px, String p_str) const;
int get_column_x_offset(int p_char, String p_str);
void adjust_viewport_to_cursor();
void _scroll_moved(double);
@ -320,7 +320,7 @@ class TextEdit : public Control {
/* super internal api, undo/redo builds on it */
void _base_insert_text(int p_line, int p_column, const String &p_text, int &r_end_line, int &r_end_column);
void _base_insert_text(int p_line, int p_char, const String &p_text, int &r_end_line, int &r_end_column);
String _base_get_text(int p_from_line, int p_from_column, int p_to_line, int p_to_column) const;
void _base_remove_text(int p_from_line, int p_from_column, int p_to_line, int p_to_column);
@ -339,10 +339,10 @@ class TextEdit : public Control {
protected:
virtual String get_tooltip(const Point2 &p_pos) const;
void _insert_text(int p_line, int p_column, const String &p_text, int *r_end_line = NULL, int *r_end_char = NULL);
void _insert_text(int p_line, int p_char, const String &p_text, int *r_end_line = NULL, int *r_end_char = NULL);
void _remove_text(int p_from_line, int p_from_column, int p_to_line, int p_to_column);
void _insert_text_at_cursor(const String &p_text);
void _gui_input(const Ref<InputEvent> &p_input);
void _gui_input(const Ref<InputEvent> &p_gui_input);
void _notification(int p_what);
void _consume_pair_symbol(CharType ch);

4
scene/gui/texture_button.cpp
View file

@ -286,8 +286,8 @@ void TextureButton::set_expand(bool p_expand) {
update();
}
void TextureButton::set_stretch_mode(StretchMode p_mode) {
stretch_mode = p_mode;
void TextureButton::set_stretch_mode(StretchMode p_stretch_mode) {
stretch_mode = p_stretch_mode;
update();
}

4
scene/gui/texture_button.h
View file

@ -69,7 +69,7 @@ public:
void set_hover_texture(const Ref<Texture> &p_hover);
void set_disabled_texture(const Ref<Texture> &p_disabled);
void set_focused_texture(const Ref<Texture> &p_focused);
void set_click_mask(const Ref<BitMap> &p_image);
void set_click_mask(const Ref<BitMap> &p_click_mask);
Ref<Texture> get_normal_texture() const;
Ref<Texture> get_pressed_texture() const;
@ -81,7 +81,7 @@ public:
bool get_expand() const;
void set_expand(bool p_expand);
void set_stretch_mode(StretchMode stretch_mode);
void set_stretch_mode(StretchMode p_stretch_mode);
StretchMode get_stretch_mode() const;
TextureButton();

4
scene/gui/tree.h
View file

@ -471,7 +471,7 @@ private:
TreeItem *_search_item_text(TreeItem *p_at, const String &p_find, int *r_col, bool p_selectable, bool p_backwards = false);
TreeItem *_find_item_at_pos(TreeItem *p_current, const Point2 &p_pos, int &r_column, int &h, int &section) const;
TreeItem *_find_item_at_pos(TreeItem *p_item, const Point2 &p_pos, int &r_column, int &h, int &section) const;
/* float drag_speed;
float drag_accum;
@ -524,7 +524,7 @@ public:
void set_column_expand(int p_column, bool p_expand);
int get_column_width(int p_column) const;
void set_hide_root(bool p_eanbled);
void set_hide_root(bool p_enabled);
TreeItem *get_next_selected(TreeItem *p_item);
TreeItem *get_selected() const;
int get_selected_column() const;

2
scene/gui/video_player.h
View file

@ -105,7 +105,7 @@ public:
String get_stream_name() const;
float get_stream_pos() const;
void set_autoplay(bool p_vol);
void set_autoplay(bool p_enable);
bool has_autoplay() const;
void set_audio_track(int p_track);

2
scene/main/canvas_layer.h
View file

@ -55,7 +55,7 @@ class CanvasLayer : public Node {
int sort_index;
// Deprecated, should be removed in a future version.
void _set_rotationd(real_t p_rotation);
void _set_rotationd(real_t p_degrees);
real_t _get_rotationd() const;
void _update_xform();

8
scene/main/node.h
View file

@ -32,8 +32,8 @@
#include "class_db.h"
#include "map.h"
#include "object.h"
#include "node_path.h"
#include "object.h"
#include "project_settings.h"
#include "scene/main/scene_tree.h"
#include "script_language.h"
@ -303,14 +303,14 @@ public:
float get_fixed_process_delta_time() const;
bool is_fixed_processing() const;
void set_process(bool p_process);
void set_process(bool p_idle_process);
float get_process_delta_time() const;
bool is_processing() const;
void set_fixed_process_internal(bool p_process);
void set_fixed_process_internal(bool p_process_internal);
bool is_fixed_processing_internal() const;
void set_process_internal(bool p_process);
void set_process_internal(bool p_idle_process_internal);
bool is_processing_internal() const;
void set_process_input(bool p_enable);

20
scene/resources/animation.cpp
View file

@ -733,7 +733,7 @@ int Animation::track_find_key(int p_track, float p_time, bool p_exact) const {
return -1;
}
void Animation::track_insert_key(int p_track, float p_time, const Variant &p_value, float p_transition) {
void Animation::track_insert_key(int p_track, float p_time, const Variant &p_key, float p_transition) {
ERR_FAIL_INDEX(p_track, tracks.size());
Track *t = tracks[p_track];
@ -742,7 +742,7 @@ void Animation::track_insert_key(int p_track, float p_time, const Variant &p_val
case TYPE_TRANSFORM: {
Dictionary d = p_value;
Dictionary d = p_key;
Vector3 loc;
if (d.has("loc"))
loc = d["loc"];
@ -766,7 +766,7 @@ void Animation::track_insert_key(int p_track, float p_time, const Variant &p_val
TKey<Variant> k;
k.time = p_time;
k.transition = p_transition;
k.value = p_value;
k.value = p_key;
_insert(p_time, vt->values, k);
} break;
@ -774,9 +774,9 @@ void Animation::track_insert_key(int p_track, float p_time, const Variant &p_val
MethodTrack *mt = static_cast<MethodTrack *>(t);
ERR_FAIL_COND(p_value.get_type() != Variant::DICTIONARY);
ERR_FAIL_COND(p_key.get_type() != Variant::DICTIONARY);
Dictionary d = p_value;
Dictionary d = p_key;
ERR_FAIL_COND(!d.has("method") || d["method"].get_type() != Variant::STRING);
ERR_FAIL_COND(!d.has("args") || !d["args"].is_array());
@ -1871,7 +1871,7 @@ bool Animation::_transform_track_optimize_key(const TKey<TransformKey> &t0, cons
return erase;
}
void Animation::_transform_track_optimize(int p_idx, float p_alowed_linear_err, float p_alowed_angular_err, float p_max_optimizable_angle) {
void Animation::_transform_track_optimize(int p_idx, float p_allowed_linear_err, float p_allowed_angular_err, float p_max_optimizable_angle) {
ERR_FAIL_INDEX(p_idx, tracks.size());
ERR_FAIL_COND(tracks[p_idx]->type != TYPE_TRANSFORM);
@ -1887,12 +1887,12 @@ void Animation::_transform_track_optimize(int p_idx, float p_alowed_linear_err,
TKey<TransformKey> &t1 = tt->transforms[i];
TKey<TransformKey> &t2 = tt->transforms[i + 1];
bool erase = _transform_track_optimize_key(t0, t1, t2, p_alowed_linear_err, p_alowed_angular_err, p_max_optimizable_angle, norm);
bool erase = _transform_track_optimize_key(t0, t1, t2, p_allowed_linear_err, p_allowed_angular_err, p_max_optimizable_angle, norm);
if (erase && !prev_erased) {
norm = (t2.value.loc - t1.value.loc).normalized();
}
if (prev_erased && !_transform_track_optimize_key(t0, first_erased, t2, p_alowed_linear_err, p_alowed_angular_err, p_max_optimizable_angle, norm)) {
if (prev_erased && !_transform_track_optimize_key(t0, first_erased, t2, p_allowed_linear_err, p_allowed_angular_err, p_max_optimizable_angle, norm)) {
//avoid error to go beyond first erased key
erase = false;
}
@ -1914,12 +1914,12 @@ void Animation::_transform_track_optimize(int p_idx, float p_alowed_linear_err,
}
}
void Animation::optimize(float p_allowed_linear_err, float p_allowed_angular_err, float p_angle_max) {
void Animation::optimize(float p_allowed_linear_err, float p_allowed_angular_err, float p_max_optimizable_angle) {
for (int i = 0; i < tracks.size(); i++) {
if (tracks[i]->type == TYPE_TRANSFORM)
_transform_track_optimize(i, p_allowed_linear_err, p_allowed_angular_err, p_angle_max);
_transform_track_optimize(i, p_allowed_linear_err, p_allowed_angular_err, p_max_optimizable_angle);
}
}

2
scene/resources/animation.h
View file

@ -212,7 +212,7 @@ private:
}
bool _transform_track_optimize_key(const TKey<TransformKey> &t0, const TKey<TransformKey> &t1, const TKey<TransformKey> &t2, float p_alowed_linear_err, float p_alowed_angular_err, float p_max_optimizable_angle, const Vector3 &p_norm);
void _transform_track_optimize(int p_idx, float p_allowed_err = 0.05, float p_alowed_angular_err = 0.01, float p_max_optimizable_angle = Math_PI * 0.125);
void _transform_track_optimize(int p_idx, float p_allowed_linear_err = 0.05, float p_allowed_angular_err = 0.01, float p_max_optimizable_angle = Math_PI * 0.125);
protected:
bool _set(const StringName &p_name, const Variant &p_value);

6
scene/resources/color_ramp.h
View file

@ -60,7 +60,7 @@ public:
void add_point(float p_offset, const Color &p_color);
void remove_point(int p_index);
void set_points(Vector<Point> &points);
void set_points(Vector<Point> &p_points);
Vector<Point> &get_points();
void set_offset(int pos, const float offset);
@ -69,10 +69,10 @@ public:
void set_color(int pos, const Color &color);
Color get_color(int pos) const;
void set_offsets(const Vector<float> &offsets);
void set_offsets(const Vector<float> &p_offsets);
Vector<float> get_offsets() const;
void set_colors(const Vector<Color> &colors);
void set_colors(const Vector<Color> &p_colors);
Vector<Color> get_colors() const;
_FORCE_INLINE_ Color get_color_at_offset(float p_offset) {

6
scene/resources/curve.h
View file

@ -174,7 +174,7 @@ public:
void bake();
int get_bake_resolution() const { return _bake_resolution; }
void set_bake_resolution(int p_interval);
void set_bake_resolution(int p_resolution);
real_t interpolate_baked(real_t offset);
protected:
@ -242,7 +242,7 @@ public:
Vector2 interpolate(int p_index, float p_offset) const;
Vector2 interpolatef(real_t p_findex) const;
void set_bake_interval(float p_distance);
void set_bake_interval(float p_tolerance);
float get_bake_interval() const;
float get_baked_length() const;
@ -309,7 +309,7 @@ public:
Vector3 interpolate(int p_index, float p_offset) const;
Vector3 interpolatef(real_t p_findex) const;
void set_bake_interval(float p_distance);
void set_bake_interval(float p_tolerance);
float get_bake_interval() const;
float get_baked_length() const;

798
scene/resources/default_theme/default_theme.cpp
View file

File diff suppressed because it is too large Load diff

10
scene/resources/dynamic_font.cpp
View file

@ -43,10 +43,10 @@ bool DynamicFontData::CacheID::operator<(CacheID right) const {
return false;
}
Ref<DynamicFontAtSize> DynamicFontData::_get_dynamic_font_at_size(CacheID p_id) {
Ref<DynamicFontAtSize> DynamicFontData::_get_dynamic_font_at_size(CacheID p_cache_id) {
if (size_cache.has(p_id)) {
return Ref<DynamicFontAtSize>(size_cache[p_id]);
if (size_cache.has(p_cache_id)) {
return Ref<DynamicFontAtSize>(size_cache[p_cache_id]);
}
Ref<DynamicFontAtSize> dfas;
@ -55,8 +55,8 @@ Ref<DynamicFontAtSize> DynamicFontData::_get_dynamic_font_at_size(CacheID p_id)
dfas->font = Ref<DynamicFontData>(this);
size_cache[p_id] = dfas.ptr();
dfas->id = p_id;
size_cache[p_cache_id] = dfas.ptr();
dfas->id = p_cache_id;
dfas->_load();
return dfas;

2
scene/resources/dynamic_font.h
View file

@ -72,7 +72,7 @@ private:
friend class DynamicFont;
Ref<DynamicFontAtSize> _get_dynamic_font_at_size(CacheID p_cache);
Ref<DynamicFontAtSize> _get_dynamic_font_at_size(CacheID p_cache_id);
protected:
static void _bind_methods();

4
scene/resources/environment.h
View file

@ -224,10 +224,10 @@ public:
void set_ssr_max_steps(int p_steps);
int get_ssr_max_steps() const;
void set_ssr_fade_in(float p_transition);
void set_ssr_fade_in(float p_fade_in);
float get_ssr_fade_in() const;
void set_ssr_fade_out(float p_transition);
void set_ssr_fade_out(float p_fade_out);
float get_ssr_fade_out() const;
void set_ssr_depth_tolerance(float p_depth_tolerance);

8
scene/resources/font.cpp
View file

@ -179,14 +179,14 @@ Vector<Variant> BitmapFont::_get_textures() const {
return rtextures;
}
Error BitmapFont::create_from_fnt(const String &p_string) {
Error BitmapFont::create_from_fnt(const String &p_file) {
//fnt format used by angelcode bmfont
//http://www.angelcode.com/products/bmfont/
FileAccess *f = FileAccess::open(p_string, FileAccess::READ);
FileAccess *f = FileAccess::open(p_file, FileAccess::READ);
if (!f) {
ERR_EXPLAIN("Can't open font: " + p_string);
ERR_EXPLAIN("Can't open font: " + p_file);
ERR_FAIL_V(ERR_FILE_NOT_FOUND);
}
@ -255,7 +255,7 @@ Error BitmapFont::create_from_fnt(const String &p_string) {
if (keys.has("file")) {
String file = keys["file"];
file = p_string.get_base_dir() + "/" + file;
file = p_file.get_base_dir() + "/" + file;
Ref<Texture> tex = ResourceLoader::load(file);
if (tex.is_null()) {
ERR_PRINT("Can't load font texture!");

2
scene/resources/material.h
View file

@ -431,7 +431,7 @@ public:
void set_depth_deep_parallax_max_layers(int p_layer);
int get_depth_deep_parallax_max_layers() const;
void set_subsurface_scattering_strength(float p_strength);
void set_subsurface_scattering_strength(float p_subsurface_scattering_strength);
float get_subsurface_scattering_strength() const;
void set_refraction(float p_refraction);

2
scene/resources/mesh.h
View file

@ -187,7 +187,7 @@ public:
int get_surface_count() const;
void surface_remove(int p_idx);
void surface_set_custom_aabb(int p_surface, const Rect3 &p_aabb); //only recognized by driver
void surface_set_custom_aabb(int p_idx, const Rect3 &p_aabb); //only recognized by driver
int surface_get_array_len(int p_idx) const;
int surface_get_array_index_len(int p_idx) const;

Some files were not shown because too many files have changed in this diff Show more