godotengine
/
godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Enable shadow warnings and fix raised errors

This commit is contained in:
Ninni Pipping 2023-05-11 12:32:23 +02:00
parent fd4a06c515
commit 71ee65dc57
27 changed files with 779 additions and 761 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
SConstruct
View File

@ -698,7 +698,8 @@ if selected_platform in platform_list:
if env["warnings"] == "extra": if env["warnings"] == "extra":
env.Append(CCFLAGS=["/W4"]) env.Append(CCFLAGS=["/W4"])
elif env["warnings"] == "all": elif env["warnings"] == "all":
env.Append(CCFLAGS=["/W3"]) # C4458 is like -Wshadow. Part of /W4 but let's apply it for the default /W3 too.
env.Append(CCFLAGS=["/W3", "/w4458"])
elif env["warnings"] == "moderate": elif env["warnings"] == "moderate":
env.Append(CCFLAGS=["/W2"]) env.Append(CCFLAGS=["/W2"])
# Disable warnings which we don't plan to fix. # Disable warnings which we don't plan to fix.
@ -727,7 +728,7 @@ if selected_platform in platform_list:
common_warnings = [] common_warnings = []
if methods.using_gcc(env): if methods.using_gcc(env):
common_warnings += ["-Wshadow-local", "-Wno-misleading-indentation"] common_warnings += ["-Wshadow", "-Wno-misleading-indentation"]
if cc_version_major == 7: # Bogus warning fixed in 8+. if cc_version_major == 7: # Bogus warning fixed in 8+.
common_warnings += ["-Wno-strict-overflow"] common_warnings += ["-Wno-strict-overflow"]
if cc_version_major < 11: if cc_version_major < 11:
@ -737,6 +738,7 @@ if selected_platform in platform_list:
if cc_version_major >= 12: # False positives in our error macros, see GH-58747. if cc_version_major >= 12: # False positives in our error macros, see GH-58747.
common_warnings += ["-Wno-return-type"] common_warnings += ["-Wno-return-type"]
elif methods.using_clang(env) or methods.using_emcc(env): elif methods.using_clang(env) or methods.using_emcc(env):
common_warnings += ["-Wshadow-field-in-constructor", "-Wshadow-uncaptured-local"]
# We often implement `operator<` for structs of pointers as a requirement # We often implement `operator<` for structs of pointers as a requirement
# for putting them in `Set` or `Map`. We don't mind about unreliable ordering. # for putting them in `Set` or `Map`. We don't mind about unreliable ordering.
common_warnings += ["-Wno-ordered-compare-function-pointers"] common_warnings += ["-Wno-ordered-compare-function-pointers"]

20
core/math/convex_hull.cpp
View File

@ -596,9 +596,9 @@ private:
} }
}; };
enum Orientation { NONE, enum Orientation { ORIENTATION_NONE,
CLOCKWISE, ORIENTATION_CLOCKWISE,
COUNTER_CLOCKWISE }; ORIENTATION_COUNTER_CLOCKWISE };
Vector3 scaling; Vector3 scaling;
Vector3 center; Vector3 center;
@ -1140,13 +1140,13 @@ ConvexHullInternal::Orientation ConvexHullInternal::get_orientation(const Edge *
CHULL_ASSERT(!m.is_zero()); CHULL_ASSERT(!m.is_zero());
int64_t dot = n.dot(m); int64_t dot = n.dot(m);
CHULL_ASSERT(dot != 0); CHULL_ASSERT(dot != 0);
return (dot > 0) ? COUNTER_CLOCKWISE : CLOCKWISE; return (dot > 0) ? ORIENTATION_COUNTER_CLOCKWISE : ORIENTATION_CLOCKWISE;
} }
return COUNTER_CLOCKWISE; return ORIENTATION_COUNTER_CLOCKWISE;
} else if (p_prev->prev == p_next) { } else if (p_prev->prev == p_next) {
return CLOCKWISE; return ORIENTATION_CLOCKWISE;
} else { } else {
return NONE; return ORIENTATION_NONE;
} }
} }
@ -1176,7 +1176,7 @@ ConvexHullInternal::Edge *ConvexHullInternal::find_max_angle(bool p_ccw, const V
} else if ((cmp = cot.compare(p_min_cot)) < 0) { } else if ((cmp = cot.compare(p_min_cot)) < 0) {
p_min_cot = cot; p_min_cot = cot;
min_edge = e; min_edge = e;
} else if ((cmp == 0) && (p_ccw == (get_orientation(min_edge, e, p_s, t) == COUNTER_CLOCKWISE))) { } else if ((cmp == 0) && (p_ccw == (get_orientation(min_edge, e, p_s, t) == ORIENTATION_COUNTER_CLOCKWISE))) {
min_edge = e; min_edge = e;
} }
} }
@ -1375,7 +1375,7 @@ void ConvexHullInternal::merge(IntermediateHull &p_h0, IntermediateHull &p_h1) {
int64_t dot = (*e->target - *c0).dot(normal); int64_t dot = (*e->target - *c0).dot(normal);
CHULL_ASSERT(dot <= 0); CHULL_ASSERT(dot <= 0);
if ((dot == 0) && ((*e->target - *c0).dot(t) > 0)) { if ((dot == 0) && ((*e->target - *c0).dot(t) > 0)) {
if (!start0 || (get_orientation(start0, e, s, Point32(0, 0, -1)) == CLOCKWISE)) { if (!start0 || (get_orientation(start0, e, s, Point32(0, 0, -1)) == ORIENTATION_CLOCKWISE)) {
start0 = e; start0 = e;
} }
} }
@ -1390,7 +1390,7 @@ void ConvexHullInternal::merge(IntermediateHull &p_h0, IntermediateHull &p_h1) {
int64_t dot = (*e->target - *c1).dot(normal); int64_t dot = (*e->target - *c1).dot(normal);
CHULL_ASSERT(dot <= 0); CHULL_ASSERT(dot <= 0);
if ((dot == 0) && ((*e->target - *c1).dot(t) > 0)) { if ((dot == 0) && ((*e->target - *c1).dot(t) > 0)) {
if (!start1 || (get_orientation(start1, e, s, Point32(0, 0, -1)) == COUNTER_CLOCKWISE)) { if (!start1 || (get_orientation(start1, e, s, Point32(0, 0, -1)) == ORIENTATION_COUNTER_CLOCKWISE)) {
start1 = e; start1 = e;
} }
} }

16
core/math/static_raycaster.h
View File

@ -59,15 +59,15 @@ public:
/*! Constructs a ray from origin, direction, and ray segment. Near /*! Constructs a ray from origin, direction, and ray segment. Near
* has to be smaller than far. */ * has to be smaller than far. */
_FORCE_INLINE_ Ray(const Vector3 &org, _FORCE_INLINE_ Ray(const Vector3 &p_org,
const Vector3 &dir, const Vector3 &p_dir,
float tnear = 0.0f, float p_tnear = 0.0f,
float tfar = INFINITY) : float p_tfar = INFINITY) :
org(org), org(p_org),
tnear(tnear), tnear(p_tnear),
dir(dir), dir(p_dir),
time(0.0f), time(0.0f),
tfar(tfar), tfar(p_tfar),
mask(-1), mask(-1),
u(0.0), u(0.0),
v(0.0), v(0.0),

8
core/os/time.cpp
View File

@ -382,10 +382,10 @@ String Time::get_time_string_from_system(bool p_utc) const {
Dictionary Time::get_time_zone_from_system() const { Dictionary Time::get_time_zone_from_system() const {
OS::TimeZoneInfo info = OS::get_singleton()->get_time_zone_info(); OS::TimeZoneInfo info = OS::get_singleton()->get_time_zone_info();
Dictionary timezone; Dictionary ret_timezone;
timezone["bias"] = info.bias; ret_timezone["bias"] = info.bias;
timezone["name"] = info.name; ret_timezone["name"] = info.name;
return timezone; return ret_timezone;
} }
double Time::get_unix_time_from_system() const { double Time::get_unix_time_from_system() const {

6
drivers/gl_context/SCsub
View File

@ -10,7 +10,11 @@ if env["platform"] in ["haiku", "macos", "windows", "linuxbsd"]:
] ]
thirdparty_sources = [thirdparty_dir + file for file in thirdparty_sources] thirdparty_sources = [thirdparty_dir + file for file in thirdparty_sources]
env.Prepend(CPPPATH=[thirdparty_dir]) # Treat glad headers as system headers to avoid raising warnings. Not supported on MSVC.
if not env.msvc:
env.Append(CPPFLAGS=["-isystem", Dir(thirdparty_dir).path])
else:
env.Prepend(CPPPATH=[thirdparty_dir])
env.Append(CPPDEFINES=["GLAD_ENABLED"]) env.Append(CPPDEFINES=["GLAD_ENABLED"])
env.Append(CPPDEFINES=["GLES_OVER_GL"]) env.Append(CPPDEFINES=["GLES_OVER_GL"])

4
drivers/pulseaudio/audio_driver_pulseaudio.cpp
View File

@ -222,8 +222,8 @@ Error AudioDriverPulseAudio::init_output_device() {
break; break;
} }
int latency = GLOBAL_GET("audio/driver/output_latency"); int tmp_latency = GLOBAL_GET("audio/driver/output_latency");
buffer_frames = closest_power_of_2(latency * mix_rate / 1000); buffer_frames = closest_power_of_2(tmp_latency * mix_rate / 1000);
pa_buffer_size = buffer_frames * pa_map.channels; pa_buffer_size = buffer_frames * pa_map.channels;
print_verbose("PulseAudio: detected " + itos(pa_map.channels) + " output channels"); print_verbose("PulseAudio: detected " + itos(pa_map.channels) + " output channels");

12
drivers/unix/file_access_unix.cpp
View File

@ -301,11 +301,11 @@ bool FileAccessUnix::file_exists(const String &p_path) {
uint64_t FileAccessUnix::_get_modified_time(const String &p_file) { uint64_t FileAccessUnix::_get_modified_time(const String &p_file) {
String file = fix_path(p_file); String file = fix_path(p_file);
struct stat flags = {}; struct stat status = {};
int err = stat(file.utf8().get_data(), &flags); int err = stat(file.utf8().get_data(), &status);
if (!err) { if (!err) {
return flags.st_mtime; return status.st_mtime;
} else { } else {
print_verbose("Failed to get modified time for: " + p_file + ""); print_verbose("Failed to get modified time for: " + p_file + "");
return 0; return 0;
@ -314,11 +314,11 @@ uint64_t FileAccessUnix::_get_modified_time(const String &p_file) {
uint32_t FileAccessUnix::_get_unix_permissions(const String &p_file) { uint32_t FileAccessUnix::_get_unix_permissions(const String &p_file) {
String file = fix_path(p_file); String file = fix_path(p_file);
struct stat flags = {}; struct stat status = {};
int err = stat(file.utf8().get_data(), &flags); int err = stat(file.utf8().get_data(), &status);
if (!err) { if (!err) {
return flags.st_mode & 0x7FF; //only permissions return status.st_mode & 0x7FF; //only permissions
} else { } else {
ERR_FAIL_V_MSG(0, "Failed to get unix permissions for: " + p_file + "."); ERR_FAIL_V_MSG(0, "Failed to get unix permissions for: " + p_file + ".");
} }

1008
editor/import/collada.cpp
View File

File diff suppressed because it is too large Load Diff

60
editor/import/collada.h
View File

@ -69,7 +69,7 @@ public:
bool double_sided = true; bool double_sided = true;
bool unshaded = false; bool unshaded = false;
String get_texture_path(const String &p_source, Collada &state) const; String get_texture_path(const String &p_source, Collada &p_state) const;
Effect() { Effect() {
diffuse.color = Color(1, 1, 1, 1); diffuse.color = Color(1, 1, 1, 1);
@ -266,7 +266,7 @@ public:
} }
} }
void fix_unit_scale(const Collada &state); void fix_unit_scale(const Collada &p_state);
bool operator<(const Vertex &p_vert) const { bool operator<(const Vertex &p_vert) const {
if (uid == p_vert.uid) { if (uid == p_vert.uid) {
@ -348,7 +348,7 @@ public:
Node *parent = nullptr; Node *parent = nullptr;
Transform3D compute_transform(const Collada &state) const; Transform3D compute_transform(const Collada &p_state) const;
Transform3D get_global_transform() const; Transform3D get_global_transform() const;
Transform3D get_transform() const; Transform3D get_transform() const;
@ -526,39 +526,39 @@ public:
private: // private stuff private: // private stuff
HashMap<String, int> channel_map; HashMap<String, int> channel_map;
void _parse_asset(XMLParser &parser); void _parse_asset(XMLParser &p_parser);
void _parse_image(XMLParser &parser); void _parse_image(XMLParser &p_parser);
void _parse_material(XMLParser &parser); void _parse_material(XMLParser &p_parser);
void _parse_effect_material(XMLParser &parser, Effect &effect, String &id); void _parse_effect_material(XMLParser &p_parser, Effect &p_effect, String &p_id);
void _parse_effect(XMLParser &parser); void _parse_effect(XMLParser &p_parser);
void _parse_camera(XMLParser &parser); void _parse_camera(XMLParser &p_parser);
void _parse_light(XMLParser &parser); void _parse_light(XMLParser &p_parser);
void _parse_animation_clip(XMLParser &parser); void _parse_animation_clip(XMLParser &p_parser);
void _parse_mesh_geometry(XMLParser &parser, String p_id, String p_name); void _parse_mesh_geometry(XMLParser &p_parser, String p_id, String p_name);
void _parse_curve_geometry(XMLParser &parser, String p_id, String p_name); void _parse_curve_geometry(XMLParser &p_parser, String p_id, String p_name);
void _parse_skin_controller(XMLParser &parser, String p_id); void _parse_skin_controller(XMLParser &p_parser, String p_id);
void _parse_morph_controller(XMLParser &parser, String p_id); void _parse_morph_controller(XMLParser &p_parser, String p_id);
void _parse_controller(XMLParser &parser); void _parse_controller(XMLParser &p_parser);
Node *_parse_visual_instance_geometry(XMLParser &parser); Node *_parse_visual_instance_geometry(XMLParser &p_parser);
Node *_parse_visual_instance_camera(XMLParser &parser); Node *_parse_visual_instance_camera(XMLParser &p_parser);
Node *_parse_visual_instance_light(XMLParser &parser); Node *_parse_visual_instance_light(XMLParser &p_parser);
Node *_parse_visual_node_instance_data(XMLParser &parser); Node *_parse_visual_node_instance_data(XMLParser &p_parser);
Node *_parse_visual_scene_node(XMLParser &parser); Node *_parse_visual_scene_node(XMLParser &p_parser);
void _parse_visual_scene(XMLParser &parser); void _parse_visual_scene(XMLParser &p_parser);
void _parse_animation(XMLParser &parser); void _parse_animation(XMLParser &p_parser);
void _parse_scene(XMLParser &parser); void _parse_scene(XMLParser &p_parser);
void _parse_library(XMLParser &parser); void _parse_library(XMLParser &p_parser);
Variant _parse_param(XMLParser &parser); Variant _parse_param(XMLParser &p_parser);
Vector<float> _read_float_array(XMLParser &parser); Vector<float> _read_float_array(XMLParser &p_parser);
Vector<String> _read_string_array(XMLParser &parser); Vector<String> _read_string_array(XMLParser &p_parser);
Transform3D _read_transform(XMLParser &parser); Transform3D _read_transform(XMLParser &p_parser);
String _read_empty_draw_type(XMLParser &parser); String _read_empty_draw_type(XMLParser &p_parser);
void _joint_set_owner(Collada::Node *p_node, NodeSkeleton *p_owner); void _joint_set_owner(Collada::Node *p_node, NodeSkeleton *p_owner);
void _create_skeletons(Collada::Node **p_node, NodeSkeleton *p_skeleton = nullptr); void _create_skeletons(Collada::Node **p_node, NodeSkeleton *p_skeleton = nullptr);

36
modules/csg/csg.cpp
View File

@ -467,7 +467,7 @@ void CSGBrushOperation::merge_brushes(Operation p_operation, const CSGBrush &p_b
// Use a limit to speed up bvh and limit the depth. // Use a limit to speed up bvh and limit the depth.
#define BVH_LIMIT 8 #define BVH_LIMIT 8
int CSGBrushOperation::MeshMerge::_create_bvh(FaceBVH *facebvhptr, FaceBVH **facebvhptrptr, int p_from, int p_size, int p_depth, int &r_max_depth, int &r_max_alloc) { int CSGBrushOperation::MeshMerge::_create_bvh(FaceBVH *r_facebvhptr, FaceBVH **r_facebvhptrptr, int p_from, int p_size, int p_depth, int &r_max_depth, int &r_max_alloc) {
if (p_depth > r_max_depth) { if (p_depth > r_max_depth) {
r_max_depth = p_depth; r_max_depth = p_depth;
} }
@ -478,15 +478,15 @@ int CSGBrushOperation::MeshMerge::_create_bvh(FaceBVH *facebvhptr, FaceBVH **fac
if (p_size <= BVH_LIMIT) { if (p_size <= BVH_LIMIT) {
for (int i = 0; i < p_size - 1; i++) { for (int i = 0; i < p_size - 1; i++) {
facebvhptrptr[p_from + i]->next = facebvhptrptr[p_from + i + 1] - facebvhptr; r_facebvhptrptr[p_from + i]->next = r_facebvhptrptr[p_from + i + 1] - r_facebvhptr;
} }
return facebvhptrptr[p_from] - facebvhptr; return r_facebvhptrptr[p_from] - r_facebvhptr;
} }
AABB aabb; AABB aabb;
aabb = facebvhptrptr[p_from]->aabb; aabb = r_facebvhptrptr[p_from]->aabb;
for (int i = 1; i < p_size; i++) { for (int i = 1; i < p_size; i++) {
aabb.merge_with(facebvhptrptr[p_from + i]->aabb); aabb.merge_with(r_facebvhptrptr[p_from + i]->aabb);
} }
int li = aabb.get_longest_axis_index(); int li = aabb.get_longest_axis_index();
@ -494,28 +494,28 @@ int CSGBrushOperation::MeshMerge::_create_bvh(FaceBVH *facebvhptr, FaceBVH **fac
switch (li) { switch (li) {
case Vector3::AXIS_X: { case Vector3::AXIS_X: {
SortArray<FaceBVH *, FaceBVHCmpX> sort_x; SortArray<FaceBVH *, FaceBVHCmpX> sort_x;
sort_x.nth_element(0, p_size, p_size / 2, &facebvhptrptr[p_from]); sort_x.nth_element(0, p_size, p_size / 2, &r_facebvhptrptr[p_from]);
//sort_x.sort(&p_bb[p_from],p_size); //sort_x.sort(&p_bb[p_from],p_size);
} break; } break;
case Vector3::AXIS_Y: { case Vector3::AXIS_Y: {
SortArray<FaceBVH *, FaceBVHCmpY> sort_y; SortArray<FaceBVH *, FaceBVHCmpY> sort_y;
sort_y.nth_element(0, p_size, p_size / 2, &facebvhptrptr[p_from]); sort_y.nth_element(0, p_size, p_size / 2, &r_facebvhptrptr[p_from]);
//sort_y.sort(&p_bb[p_from],p_size); //sort_y.sort(&p_bb[p_from],p_size);
} break; } break;
case Vector3::AXIS_Z: { case Vector3::AXIS_Z: {
SortArray<FaceBVH *, FaceBVHCmpZ> sort_z; SortArray<FaceBVH *, FaceBVHCmpZ> sort_z;
sort_z.nth_element(0, p_size, p_size / 2, &facebvhptrptr[p_from]); sort_z.nth_element(0, p_size, p_size / 2, &r_facebvhptrptr[p_from]);
//sort_z.sort(&p_bb[p_from],p_size); //sort_z.sort(&p_bb[p_from],p_size);
} break; } break;
} }
int left = _create_bvh(facebvhptr, facebvhptrptr, p_from, p_size / 2, p_depth + 1, r_max_depth, r_max_alloc); int left = _create_bvh(r_facebvhptr, r_facebvhptrptr, p_from, p_size / 2, p_depth + 1, r_max_depth, r_max_alloc);
int right = _create_bvh(facebvhptr, facebvhptrptr, p_from + p_size / 2, p_size - p_size / 2, p_depth + 1, r_max_depth, r_max_alloc); int right = _create_bvh(r_facebvhptr, r_facebvhptrptr, p_from + p_size / 2, p_size - p_size / 2, p_depth + 1, r_max_depth, r_max_alloc);
int index = r_max_alloc++; int index = r_max_alloc++;
FaceBVH *_new = &facebvhptr[index]; FaceBVH *_new = &r_facebvhptr[index];
_new->aabb = aabb; _new->aabb = aabb;
_new->center = aabb.get_center(); _new->center = aabb.get_center();
_new->face = -1; _new->face = -1;
@ -535,13 +535,13 @@ void CSGBrushOperation::MeshMerge::_add_distance(List<IntersectionDistance> &r_i
return; return;
} }
} }
IntersectionDistance IntersectionDistance; IntersectionDistance distance;
IntersectionDistance.is_conormal = p_is_conormal; distance.is_conormal = p_is_conormal;
IntersectionDistance.distance_squared = p_distance_squared; distance.distance_squared = p_distance_squared;
intersections.push_back(IntersectionDistance); intersections.push_back(distance);
} }
bool CSGBrushOperation::MeshMerge::_bvh_inside(FaceBVH *facebvhptr, int p_max_depth, int p_bvh_first, int p_face_idx) const { bool CSGBrushOperation::MeshMerge::_bvh_inside(FaceBVH *r_facebvhptr, int p_max_depth, int p_bvh_first, int p_face_idx) const {
Face face = faces[p_face_idx]; Face face = faces[p_face_idx];
Vector3 face_points[3] = { Vector3 face_points[3] = {
points[face.points[0]], points[face.points[0]],
@ -575,7 +575,7 @@ bool CSGBrushOperation::MeshMerge::_bvh_inside(FaceBVH *facebvhptr, int p_max_de
while (true) { while (true) {
uint32_t node = stack[level] & NODE_IDX_MASK; uint32_t node = stack[level] & NODE_IDX_MASK;
const FaceBVH *current_facebvhptr = &(facebvhptr[node]); const FaceBVH *current_facebvhptr = &(r_facebvhptr[node]);
bool done = false; bool done = false;
switch (stack[level] >> VISITED_BIT_SHIFT) { switch (stack[level] >> VISITED_BIT_SHIFT) {
@ -651,7 +651,7 @@ bool CSGBrushOperation::MeshMerge::_bvh_inside(FaceBVH *facebvhptr, int p_max_de
} }
if (current_facebvhptr->next != -1) { if (current_facebvhptr->next != -1) {
current_facebvhptr = &facebvhptr[current_facebvhptr->next]; current_facebvhptr = &r_facebvhptr[current_facebvhptr->next];
} else { } else {
current_facebvhptr = nullptr; current_facebvhptr = nullptr;
} }

4
modules/csg/csg.h
View File

@ -155,8 +155,8 @@ struct CSGBrushOperation {
float vertex_snap = 0.0; float vertex_snap = 0.0;
inline void _add_distance(List<IntersectionDistance> &r_intersectionsA, List<IntersectionDistance> &r_intersectionsB, bool p_from_B, real_t p_distance, bool p_is_conormal) const; inline void _add_distance(List<IntersectionDistance> &r_intersectionsA, List<IntersectionDistance> &r_intersectionsB, bool p_from_B, real_t p_distance, bool p_is_conormal) const;
inline bool _bvh_inside(FaceBVH *facebvhptr, int p_max_depth, int p_bvh_first, int p_face_idx) const; inline bool _bvh_inside(FaceBVH *r_facebvhptr, int p_max_depth, int p_bvh_first, int p_face_idx) const;
inline int _create_bvh(FaceBVH *facebvhptr, FaceBVH **facebvhptrptr, int p_from, int p_size, int p_depth, int &r_max_depth, int &r_max_alloc); inline int _create_bvh(FaceBVH *r_facebvhptr, FaceBVH **r_facebvhptrptr, int p_from, int p_size, int p_depth, int &r_max_depth, int &r_max_alloc);
void add_face(const Vector3 p_points[3], const Vector2 p_uvs[3], bool p_smooth, bool p_invert, const Ref<Material> &p_material, bool p_from_b); void add_face(const Vector3 p_points[3], const Vector2 p_uvs[3], bool p_smooth, bool p_invert, const Ref<Material> &p_material, bool p_from_b);
void mark_inside_faces(); void mark_inside_faces();

4
modules/gltf/editor/editor_scene_importer_blend.cpp
View File

@ -466,8 +466,8 @@ bool EditorFileSystemImportFormatSupportQueryBlend::query() {
} }
bool found = false; bool found = false;
for (const String &path : mdfind_paths) { for (const String &found_path : mdfind_paths) {
found = _autodetect_path(path.path_join("Contents/MacOS")); found = _autodetect_path(found_path.path_join("Contents/MacOS"));
if (found) { if (found) {
break; break;
} }

6
modules/text_server_adv/SCsub
View File

@ -520,7 +520,11 @@ if env["builtin_icu4c"]:
module_obj = [] module_obj = []
if env["builtin_msdfgen"] and msdfgen_enabled: if env["builtin_msdfgen"] and msdfgen_enabled:
env_text_server_adv.Prepend(CPPPATH=["#thirdparty/msdfgen"]) # Treat msdfgen headers as system headers to avoid raising warnings. Not supported on MSVC.
if not env.msvc:
env_text_server_adv.Append(CPPFLAGS=["-isystem", Dir("#thirdparty/msdfgen").path])
else:
env_text_server_adv.Prepend(CPPPATH=["#thirdparty/msdfgen"])
if env["builtin_freetype"] and freetype_enabled: if env["builtin_freetype"] and freetype_enabled:
env_text_server_adv.Append(CPPDEFINES=["FT_CONFIG_OPTION_USE_BROTLI"]) env_text_server_adv.Append(CPPDEFINES=["FT_CONFIG_OPTION_USE_BROTLI"])

6
modules/text_server_fb/SCsub
View File

@ -12,7 +12,11 @@ if "svg" in env.module_list:
env_text_server_fb.Prepend(CPPPATH=["#thirdparty/thorvg/inc", "#thirdparty/thorvg/src/lib"]) env_text_server_fb.Prepend(CPPPATH=["#thirdparty/thorvg/inc", "#thirdparty/thorvg/src/lib"])
if env["builtin_msdfgen"] and msdfgen_enabled: if env["builtin_msdfgen"] and msdfgen_enabled:
env_text_server_fb.Prepend(CPPPATH=["#thirdparty/msdfgen"]) # Treat msdfgen headers as system headers to avoid raising warnings. Not supported on MSVC.
if not env.msvc:
env_text_server_fb.Append(CPPFLAGS=["-isystem", Dir("#thirdparty/msdfgen").path])
else:
env_text_server_fb.Prepend(CPPPATH=["#thirdparty/msdfgen"])
if env["builtin_freetype"] and freetype_enabled: if env["builtin_freetype"] and freetype_enabled:
env_text_server_fb.Append(CPPDEFINES=["FT_CONFIG_OPTION_USE_BROTLI"]) env_text_server_fb.Append(CPPDEFINES=["FT_CONFIG_OPTION_USE_BROTLI"])

18
platform/ios/ios.mm
View File

@ -72,8 +72,8 @@ CHHapticEngine *iOS::get_haptic_engine_instance() API_AVAILABLE(ios(13)) {
void iOS::vibrate_haptic_engine(float p_duration_seconds) API_AVAILABLE(ios(13)) { void iOS::vibrate_haptic_engine(float p_duration_seconds) API_AVAILABLE(ios(13)) {
if (@available(iOS 13, *)) { // We need the @available check every time to make the compiler happy... if (@available(iOS 13, *)) { // We need the @available check every time to make the compiler happy...
if (supports_haptic_engine()) { if (supports_haptic_engine()) {
CHHapticEngine *haptic_engine = get_haptic_engine_instance(); CHHapticEngine *cur_haptic_engine = get_haptic_engine_instance();
if (haptic_engine) { if (cur_haptic_engine) {
NSDictionary *hapticDict = @{ NSDictionary *hapticDict = @{
CHHapticPatternKeyPattern : @[ CHHapticPatternKeyPattern : @[
@{CHHapticPatternKeyEvent : @{ @{CHHapticPatternKeyEvent : @{
@ -88,7 +88,7 @@ void iOS::vibrate_haptic_engine(float p_duration_seconds) API_AVAILABLE(ios(13))
NSError *error; NSError *error;
CHHapticPattern *pattern = [[CHHapticPattern alloc] initWithDictionary:hapticDict error:&error]; CHHapticPattern *pattern = [[CHHapticPattern alloc] initWithDictionary:hapticDict error:&error];
[[haptic_engine createPlayerWithPattern:pattern error:&error] startAtTime:0 error:&error]; [[cur_haptic_engine createPlayerWithPattern:pattern error:&error] startAtTime:0 error:&error];
NSLog(@"Could not vibrate using haptic engine: %@", error); NSLog(@"Could not vibrate using haptic engine: %@", error);
} }
@ -103,9 +103,9 @@ void iOS::vibrate_haptic_engine(float p_duration_seconds) API_AVAILABLE(ios(13))
void iOS::start_haptic_engine() { void iOS::start_haptic_engine() {
if (@available(iOS 13, *)) { if (@available(iOS 13, *)) {
if (supports_haptic_engine()) { if (supports_haptic_engine()) {
CHHapticEngine *haptic_engine = get_haptic_engine_instance(); CHHapticEngine *cur_haptic_engine = get_haptic_engine_instance();
if (haptic_engine) { if (cur_haptic_engine) {
[haptic_engine startWithCompletionHandler:^(NSError *returnedError) { [cur_haptic_engine startWithCompletionHandler:^(NSError *returnedError) {
if (returnedError) { if (returnedError) {
NSLog(@"Could not start haptic engine: %@", returnedError); NSLog(@"Could not start haptic engine: %@", returnedError);
} }
@ -122,9 +122,9 @@ void iOS::start_haptic_engine() {
void iOS::stop_haptic_engine() { void iOS::stop_haptic_engine() {
if (@available(iOS 13, *)) { if (@available(iOS 13, *)) {
if (supports_haptic_engine()) { if (supports_haptic_engine()) {
CHHapticEngine *haptic_engine = get_haptic_engine_instance(); CHHapticEngine *cur_haptic_engine = get_haptic_engine_instance();
if (haptic_engine) { if (cur_haptic_engine) {
[haptic_engine stopWithCompletionHandler:^(NSError *returnedError) { [cur_haptic_engine stopWithCompletionHandler:^(NSError *returnedError) {
if (returnedError) { if (returnedError) {
NSLog(@"Could not stop haptic engine: %@", returnedError); NSLog(@"Could not stop haptic engine: %@", returnedError);
} }

3
platform/linuxbsd/x11/detect_prime_x11.cpp
View File

@ -60,6 +60,9 @@
typedef GLXContext (*GLXCREATECONTEXTATTRIBSARBPROC)(Display *, GLXFBConfig, GLXContext, Bool, const int *); typedef GLXContext (*GLXCREATECONTEXTATTRIBSARBPROC)(Display *, GLXFBConfig, GLXContext, Bool, const int *);
// To prevent shadowing warnings
#undef glGetString
struct vendor { struct vendor {
const char *glxvendor = nullptr; const char *glxvendor = nullptr;
int priority = 0; int priority = 0;

22
platform/linuxbsd/x11/display_server_x11.cpp
View File

@ -2725,8 +2725,8 @@ void DisplayServerX11::cursor_set_custom_image(const Ref<Resource> &p_cursor, Cu
XcursorImageDestroy(cursor_image); XcursorImageDestroy(cursor_image);
} else { } else {
// Reset to default system cursor // Reset to default system cursor
if (img[p_shape]) { if (cursor_img[p_shape]) {
cursors[p_shape] = XcursorImageLoadCursor(x11_display, img[p_shape]); cursors[p_shape] = XcursorImageLoadCursor(x11_display, cursor_img[p_shape]);
} }
CursorShape c = current_cursor; CursorShape c = current_cursor;
@ -5360,7 +5360,7 @@ DisplayServerX11::DisplayServerX11(const String &p_rendering_driver, WindowMode
for (int i = 0; i < CURSOR_MAX; i++) { for (int i = 0; i < CURSOR_MAX; i++) {
cursors[i] = None; cursors[i] = None;
img[i] = nullptr; cursor_img[i] = nullptr;
} }
XInitThreads(); //always use threads XInitThreads(); //always use threads
@ -5717,8 +5717,8 @@ DisplayServerX11::DisplayServerX11(const String &p_rendering_driver, WindowMode
"question_arrow" "question_arrow"
}; };
img[i] = XcursorLibraryLoadImage(cursor_file[i], cursor_theme, cursor_size); cursor_img[i] = XcursorLibraryLoadImage(cursor_file[i], cursor_theme, cursor_size);
if (!img[i]) { if (!cursor_img[i]) {
const char *fallback = nullptr; const char *fallback = nullptr;
switch (i) { switch (i) {
@ -5756,7 +5756,7 @@ DisplayServerX11::DisplayServerX11(const String &p_rendering_driver, WindowMode
fallback = "bd_double_arrow"; fallback = "bd_double_arrow";
break; break;
case CURSOR_MOVE: case CURSOR_MOVE:
img[i] = img[CURSOR_DRAG]; cursor_img[i] = cursor_img[CURSOR_DRAG];
break; break;
case CURSOR_VSPLIT: case CURSOR_VSPLIT:
fallback = "sb_v_double_arrow"; fallback = "sb_v_double_arrow";
@ -5769,11 +5769,11 @@ DisplayServerX11::DisplayServerX11(const String &p_rendering_driver, WindowMode
break; break;
} }
if (fallback != nullptr) { if (fallback != nullptr) {
img[i] = XcursorLibraryLoadImage(fallback, cursor_theme, cursor_size); cursor_img[i] = XcursorLibraryLoadImage(fallback, cursor_theme, cursor_size);
} }
} }
if (img[i]) { if (cursor_img[i]) {
cursors[i] = XcursorImageLoadCursor(x11_display, img[i]); cursors[i] = XcursorImageLoadCursor(x11_display, cursor_img[i]);
} else { } else {
print_verbose("Failed loading custom cursor: " + String(cursor_file[i])); print_verbose("Failed loading custom cursor: " + String(cursor_file[i]));
} }
@ -5912,8 +5912,8 @@ DisplayServerX11::~DisplayServerX11() {
if (cursors[i] != None) { if (cursors[i] != None) {
XFreeCursor(x11_display, cursors[i]); XFreeCursor(x11_display, cursors[i]);
} }
if (img[i] != nullptr) { if (cursor_img[i] != nullptr) {
XcursorImageDestroy(img[i]); XcursorImageDestroy(cursor_img[i]);
} }
} }

2
platform/linuxbsd/x11/display_server_x11.h
View File

@ -306,7 +306,7 @@ class DisplayServerX11 : public DisplayServer {
const char *cursor_theme = nullptr; const char *cursor_theme = nullptr;
int cursor_size = 0; int cursor_size = 0;
XcursorImage *img[CURSOR_MAX]; XcursorImage *cursor_img[CURSOR_MAX];
Cursor cursors[CURSOR_MAX]; Cursor cursors[CURSOR_MAX];
Cursor null_cursor; Cursor null_cursor;
CursorShape current_cursor = CURSOR_ARROW; CursorShape current_cursor = CURSOR_ARROW;

3
platform/linuxbsd/x11/gl_manager_x11.cpp
View File

@ -44,6 +44,9 @@
typedef GLXContext (*GLXCREATECONTEXTATTRIBSARBPROC)(Display *, GLXFBConfig, GLXContext, Bool, const int *); typedef GLXContext (*GLXCREATECONTEXTATTRIBSARBPROC)(Display *, GLXFBConfig, GLXContext, Bool, const int *);
// To prevent shadowing warnings
#undef glXCreateContextAttribsARB
struct GLManager_X11_Private { struct GLManager_X11_Private {
::GLXContext glx_context; ::GLXContext glx_context;
}; };

10
platform/macos/display_server_macos.mm
View File

@ -1840,9 +1840,9 @@ Error DisplayServerMacOS::dialog_show(String p_title, String p_description, Vect
if (!p_callback.is_null()) { if (!p_callback.is_null()) {
Variant button = button_pressed; Variant button = button_pressed;
Variant *buttonp = &button; Variant *buttonp = &button;
Variant ret; Variant fun_ret;
Callable::CallError ce; Callable::CallError ce;
p_callback.callp((const Variant **)&buttonp, 1, ret, ce); p_callback.callp((const Variant **)&buttonp, 1, fun_ret, ce);
} }
return OK; return OK;
@ -1872,9 +1872,9 @@ Error DisplayServerMacOS::dialog_input_text(String p_title, String p_description
if (!p_callback.is_null()) { if (!p_callback.is_null()) {
Variant text = ret; Variant text = ret;
Variant *textp = &text; Variant *textp = &text;
Variant ret; Variant fun_ret;
Callable::CallError ce; Callable::CallError ce;
p_callback.callp((const Variant **)&textp, 1, ret, ce); p_callback.callp((const Variant **)&textp, 1, fun_ret, ce);
} }
return OK; return OK;
@ -1897,7 +1897,7 @@ void DisplayServerMacOS::mouse_set_mode(MouseMode p_mode) {
bool previously_shown = (mouse_mode == MOUSE_MODE_VISIBLE || mouse_mode == MOUSE_MODE_CONFINED); bool previously_shown = (mouse_mode == MOUSE_MODE_VISIBLE || mouse_mode == MOUSE_MODE_CONFINED);
if (show_cursor && !previously_shown) { if (show_cursor && !previously_shown) {
WindowID window_id = get_window_at_screen_position(mouse_get_position()); window_id = get_window_at_screen_position(mouse_get_position());
if (window_id != INVALID_WINDOW_ID) { if (window_id != INVALID_WINDOW_ID) {
send_window_event(windows[window_id], WINDOW_EVENT_MOUSE_ENTER); send_window_event(windows[window_id], WINDOW_EVENT_MOUSE_ENTER);
} }

14
platform/windows/os_windows.cpp
View File

@ -435,8 +435,6 @@ String OS_Windows::get_distribution_name() const {
} }
String OS_Windows::get_version() const { String OS_Windows::get_version() const {
typedef LONG NTSTATUS;
typedef NTSTATUS(WINAPI * RtlGetVersionPtr)(PRTL_OSVERSIONINFOW);
RtlGetVersionPtr version_ptr = (RtlGetVersionPtr)GetProcAddress(GetModuleHandle("ntdll.dll"), "RtlGetVersion"); RtlGetVersionPtr version_ptr = (RtlGetVersionPtr)GetProcAddress(GetModuleHandle("ntdll.dll"), "RtlGetVersion");
if (version_ptr != nullptr) { if (version_ptr != nullptr) {
RTL_OSVERSIONINFOW fow; RTL_OSVERSIONINFOW fow;
@ -554,9 +552,9 @@ OS::DateTime OS_Windows::get_datetime(bool p_utc) const {
//Get DST information from Windows, but only if p_utc is false. //Get DST information from Windows, but only if p_utc is false.
TIME_ZONE_INFORMATION info; TIME_ZONE_INFORMATION info;
bool daylight = false; bool is_daylight = false;
if (!p_utc && GetTimeZoneInformation(&info) == TIME_ZONE_ID_DAYLIGHT) { if (!p_utc && GetTimeZoneInformation(&info) == TIME_ZONE_ID_DAYLIGHT) {
daylight = true; is_daylight = true;
} }
DateTime dt; DateTime dt;
@ -567,20 +565,20 @@ OS::DateTime OS_Windows::get_datetime(bool p_utc) const {
dt.hour = systemtime.wHour; dt.hour = systemtime.wHour;
dt.minute = systemtime.wMinute; dt.minute = systemtime.wMinute;
dt.second = systemtime.wSecond; dt.second = systemtime.wSecond;
dt.dst = daylight; dt.dst = is_daylight;
return dt; return dt;
} }
OS::TimeZoneInfo OS_Windows::get_time_zone_info() const { OS::TimeZoneInfo OS_Windows::get_time_zone_info() const {
TIME_ZONE_INFORMATION info; TIME_ZONE_INFORMATION info;
bool daylight = false; bool is_daylight = false;
if (GetTimeZoneInformation(&info) == TIME_ZONE_ID_DAYLIGHT) { if (GetTimeZoneInformation(&info) == TIME_ZONE_ID_DAYLIGHT) {
daylight = true; is_daylight = true;
} }
// Daylight Bias needs to be added to the bias if DST is in effect, or else it will not properly update. // Daylight Bias needs to be added to the bias if DST is in effect, or else it will not properly update.
TimeZoneInfo ret; TimeZoneInfo ret;
if (daylight) { if (is_daylight) {
ret.name = info.DaylightName; ret.name = info.DaylightName;
ret.bias = info.Bias + info.DaylightBias; ret.bias = info.Bias + info.DaylightBias;
} else { } else {

16
scene/3d/lightmapper.h
View File

@ -71,15 +71,15 @@ public:
/*! Constructs a ray from origin, direction, and ray segment. Near /*! Constructs a ray from origin, direction, and ray segment. Near
* has to be smaller than far. */ * has to be smaller than far. */
_FORCE_INLINE_ Ray(const Vector3 &org, _FORCE_INLINE_ Ray(const Vector3 &p_org,
const Vector3 &dir, const Vector3 &p_dir,
float tnear = 0.0f, float p_tnear = 0.0f,
float tfar = INFINITY) : float p_tfar = INFINITY) :
org(org), org(p_org),
tnear(tnear), tnear(p_tnear),
dir(dir), dir(p_dir),
time(0.0f), time(0.0f),
tfar(tfar), tfar(p_tfar),
mask(-1), mask(-1),
u(0.0), u(0.0),
v(0.0), v(0.0),

56
scene/resources/audio_stream_wav.cpp
View File

@ -87,21 +87,21 @@ void AudioStreamPlaybackWAV::seek(double p_time) {
} }
template <class Depth, bool is_stereo, bool is_ima_adpcm> template <class Depth, bool is_stereo, bool is_ima_adpcm>
void AudioStreamPlaybackWAV::do_resample(const Depth *p_src, AudioFrame *p_dst, int64_t &offset, int32_t &increment, uint32_t amount, IMA_ADPCM_State *ima_adpcm) { void AudioStreamPlaybackWAV::do_resample(const Depth *p_src, AudioFrame *p_dst, int64_t &p_offset, int32_t &p_increment, uint32_t p_amount, IMA_ADPCM_State *p_ima_adpcm) {
// this function will be compiled branchless by any decent compiler // this function will be compiled branchless by any decent compiler
int32_t final, final_r, next, next_r; int32_t final, final_r, next, next_r;
while (amount) { while (p_amount) {
amount--; p_amount--;
int64_t pos = offset >> MIX_FRAC_BITS; int64_t pos = p_offset >> MIX_FRAC_BITS;
if (is_stereo && !is_ima_adpcm) { if (is_stereo && !is_ima_adpcm) {
pos <<= 1; pos <<= 1;
} }
if (is_ima_adpcm) { if (is_ima_adpcm) {
int64_t sample_pos = pos + ima_adpcm[0].window_ofs; int64_t sample_pos = pos + p_ima_adpcm[0].window_ofs;
while (sample_pos > ima_adpcm[0].last_nibble) { while (sample_pos > p_ima_adpcm[0].last_nibble) {
static const int16_t _ima_adpcm_step_table[89] = { static const int16_t _ima_adpcm_step_table[89] = {
7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 7, 8, 9, 10, 11, 12, 13, 14, 16, 17,
19, 21, 23, 25, 28, 31, 34, 37, 41, 45, 19, 21, 23, 25, 28, 31, 34, 37, 41, 45,
@ -122,20 +122,20 @@ void AudioStreamPlaybackWAV::do_resample(const Depth *p_src, AudioFrame *p_dst,
for (int i = 0; i < (is_stereo ? 2 : 1); i++) { for (int i = 0; i < (is_stereo ? 2 : 1); i++) {
int16_t nibble, diff, step; int16_t nibble, diff, step;
ima_adpcm[i].last_nibble++; p_ima_adpcm[i].last_nibble++;
const uint8_t *src_ptr = (const uint8_t *)base->data; const uint8_t *src_ptr = (const uint8_t *)base->data;
src_ptr += AudioStreamWAV::DATA_PAD; src_ptr += AudioStreamWAV::DATA_PAD;
uint8_t nbb = src_ptr[(ima_adpcm[i].last_nibble >> 1) * (is_stereo ? 2 : 1) + i]; uint8_t nbb = src_ptr[(p_ima_adpcm[i].last_nibble >> 1) * (is_stereo ? 2 : 1) + i];
nibble = (ima_adpcm[i].last_nibble & 1) ? (nbb >> 4) : (nbb & 0xF); nibble = (p_ima_adpcm[i].last_nibble & 1) ? (nbb >> 4) : (nbb & 0xF);
step = _ima_adpcm_step_table[ima_adpcm[i].step_index]; step = _ima_adpcm_step_table[p_ima_adpcm[i].step_index];
ima_adpcm[i].step_index += _ima_adpcm_index_table[nibble]; p_ima_adpcm[i].step_index += _ima_adpcm_index_table[nibble];
if (ima_adpcm[i].step_index < 0) { if (p_ima_adpcm[i].step_index < 0) {
ima_adpcm[i].step_index = 0; p_ima_adpcm[i].step_index = 0;
} }
if (ima_adpcm[i].step_index > 88) { if (p_ima_adpcm[i].step_index > 88) {
ima_adpcm[i].step_index = 88; p_ima_adpcm[i].step_index = 88;
} }
diff = step >> 3; diff = step >> 3;
@ -152,26 +152,26 @@ void AudioStreamPlaybackWAV::do_resample(const Depth *p_src, AudioFrame *p_dst,
diff = -diff; diff = -diff;
} }
ima_adpcm[i].predictor += diff; p_ima_adpcm[i].predictor += diff;
if (ima_adpcm[i].predictor < -0x8000) { if (p_ima_adpcm[i].predictor < -0x8000) {
ima_adpcm[i].predictor = -0x8000; p_ima_adpcm[i].predictor = -0x8000;
} else if (ima_adpcm[i].predictor > 0x7FFF) { } else if (p_ima_adpcm[i].predictor > 0x7FFF) {
ima_adpcm[i].predictor = 0x7FFF; p_ima_adpcm[i].predictor = 0x7FFF;
} }
/* store loop if there */ /* store loop if there */
if (ima_adpcm[i].last_nibble == ima_adpcm[i].loop_pos) { if (p_ima_adpcm[i].last_nibble == p_ima_adpcm[i].loop_pos) {
ima_adpcm[i].loop_step_index = ima_adpcm[i].step_index; p_ima_adpcm[i].loop_step_index = p_ima_adpcm[i].step_index;
ima_adpcm[i].loop_predictor = ima_adpcm[i].predictor; p_ima_adpcm[i].loop_predictor = p_ima_adpcm[i].predictor;
} }
//printf("%i - %i - pred %i\n",int(ima_adpcm[i].last_nibble),int(nibble),int(ima_adpcm[i].predictor)); //printf("%i - %i - pred %i\n",int(p_ima_adpcm[i].last_nibble),int(nibble),int(p_ima_adpcm[i].predictor));
} }
} }
final = ima_adpcm[0].predictor; final = p_ima_adpcm[0].predictor;
if (is_stereo) { if (is_stereo) {
final_r = ima_adpcm[1].predictor; final_r = p_ima_adpcm[1].predictor;
} }
} else { } else {
@ -201,7 +201,7 @@ void AudioStreamPlaybackWAV::do_resample(const Depth *p_src, AudioFrame *p_dst,
} }
} }
int32_t frac = int64_t(offset & MIX_FRAC_MASK); int32_t frac = int64_t(p_offset & MIX_FRAC_MASK);
final = final + ((next - final) * frac >> MIX_FRAC_BITS); final = final + ((next - final) * frac >> MIX_FRAC_BITS);
if (is_stereo) { if (is_stereo) {
@ -217,7 +217,7 @@ void AudioStreamPlaybackWAV::do_resample(const Depth *p_src, AudioFrame *p_dst,
p_dst->r = final_r / 32767.0; p_dst->r = final_r / 32767.0;
p_dst++; p_dst++;
offset += increment; p_offset += p_increment;
} }
} }

2
scene/resources/audio_stream_wav.h
View File

@ -61,7 +61,7 @@ class AudioStreamPlaybackWAV : public AudioStreamPlayback {
Ref<AudioStreamWAV> base; Ref<AudioStreamWAV> base;
template <class Depth, bool is_stereo, bool is_ima_adpcm> template <class Depth, bool is_stereo, bool is_ima_adpcm>
void do_resample(const Depth *p_src, AudioFrame *p_dst, int64_t &offset, int32_t &increment, uint32_t amount, IMA_ADPCM_State *ima_adpcm); void do_resample(const Depth *p_src, AudioFrame *p_dst, int64_t &p_offset, int32_t &p_increment, uint32_t p_amount, IMA_ADPCM_State *p_ima_adpcm);
public: public:
virtual void start(double p_from_pos = 0.0) override; virtual void start(double p_from_pos = 0.0) override;

36
servers/rendering/shader_compiler.cpp
View File

@ -436,7 +436,7 @@ String ShaderCompiler::_dump_node_code(const SL::Node *p_node, int p_level, Gene
String code; String code;
switch (p_node->type) { switch (p_node->type) {
case SL::Node::TYPE_SHADER: { case SL::Node::NODE_TYPE_SHADER: {
SL::ShaderNode *pnode = (SL::ShaderNode *)p_node; SL::ShaderNode *pnode = (SL::ShaderNode *)p_node;
for (int i = 0; i < pnode->render_modes.size(); i++) { for (int i = 0; i < pnode->render_modes.size(); i++) {
@ -781,11 +781,11 @@ String ShaderCompiler::_dump_node_code(const SL::Node *p_node, int p_level, Gene
//code+=dump_node_code(pnode->body,p_level); //code+=dump_node_code(pnode->body,p_level);
} break; } break;
case SL::Node::TYPE_STRUCT: { case SL::Node::NODE_TYPE_STRUCT: {
} break; } break;
case SL::Node::TYPE_FUNCTION: { case SL::Node::NODE_TYPE_FUNCTION: {
} break; } break;
case SL::Node::TYPE_BLOCK: { case SL::Node::NODE_TYPE_BLOCK: {
SL::BlockNode *bnode = (SL::BlockNode *)p_node; SL::BlockNode *bnode = (SL::BlockNode *)p_node;
//variables //variables
@ -796,7 +796,7 @@ String ShaderCompiler::_dump_node_code(const SL::Node *p_node, int p_level, Gene
for (int i = 0; i < bnode->statements.size(); i++) { for (int i = 0; i < bnode->statements.size(); i++) {
String scode = _dump_node_code(bnode->statements[i], p_level, r_gen_code, p_actions, p_default_actions, p_assigning); String scode = _dump_node_code(bnode->statements[i], p_level, r_gen_code, p_actions, p_default_actions, p_assigning);
if (bnode->statements[i]->type == SL::Node::TYPE_CONTROL_FLOW || bnode->single_statement) { if (bnode->statements[i]->type == SL::Node::NODE_TYPE_CONTROL_FLOW || bnode->single_statement) {
code += scode; //use directly code += scode; //use directly
if (bnode->use_comma_between_statements && i + 1 < bnode->statements.size()) { if (bnode->use_comma_between_statements && i + 1 < bnode->statements.size()) {
code += ","; code += ",";
@ -810,7 +810,7 @@ String ShaderCompiler::_dump_node_code(const SL::Node *p_node, int p_level, Gene
} }
} break; } break;
case SL::Node::TYPE_VARIABLE_DECLARATION: { case SL::Node::NODE_TYPE_VARIABLE_DECLARATION: {
SL::VariableDeclarationNode *vdnode = (SL::VariableDeclarationNode *)p_node; SL::VariableDeclarationNode *vdnode = (SL::VariableDeclarationNode *)p_node;
String declaration; String declaration;
@ -868,7 +868,7 @@ String ShaderCompiler::_dump_node_code(const SL::Node *p_node, int p_level, Gene
code += declaration; code += declaration;
} break; } break;
case SL::Node::TYPE_VARIABLE: { case SL::Node::NODE_TYPE_VARIABLE: {
SL::VariableNode *vnode = (SL::VariableNode *)p_node; SL::VariableNode *vnode = (SL::VariableNode *)p_node;
bool use_fragment_varying = false; bool use_fragment_varying = false;
@ -961,7 +961,7 @@ String ShaderCompiler::_dump_node_code(const SL::Node *p_node, int p_level, Gene
} }
} break; } break;
case SL::Node::TYPE_ARRAY_CONSTRUCT: { case SL::Node::NODE_TYPE_ARRAY_CONSTRUCT: {
SL::ArrayConstructNode *acnode = (SL::ArrayConstructNode *)p_node; SL::ArrayConstructNode *acnode = (SL::ArrayConstructNode *)p_node;
int sz = acnode->initializer.size(); int sz = acnode->initializer.size();
if (acnode->datatype == SL::TYPE_STRUCT) { if (acnode->datatype == SL::TYPE_STRUCT) {
@ -981,7 +981,7 @@ String ShaderCompiler::_dump_node_code(const SL::Node *p_node, int p_level, Gene
} }
code += ")"; code += ")";
} break; } break;
case SL::Node::TYPE_ARRAY: { case SL::Node::NODE_TYPE_ARRAY: {
SL::ArrayNode *anode = (SL::ArrayNode *)p_node; SL::ArrayNode *anode = (SL::ArrayNode *)p_node;
bool use_fragment_varying = false; bool use_fragment_varying = false;
@ -1072,7 +1072,7 @@ String ShaderCompiler::_dump_node_code(const SL::Node *p_node, int p_level, Gene
} }
} break; } break;
case SL::Node::TYPE_CONSTANT: { case SL::Node::NODE_TYPE_CONSTANT: {
SL::ConstantNode *cnode = (SL::ConstantNode *)p_node; SL::ConstantNode *cnode = (SL::ConstantNode *)p_node;
if (cnode->array_size == 0) { if (cnode->array_size == 0) {
@ -1099,7 +1099,7 @@ String ShaderCompiler::_dump_node_code(const SL::Node *p_node, int p_level, Gene
} }
} break; } break;
case SL::Node::TYPE_OPERATOR: { case SL::Node::NODE_TYPE_OPERATOR: {
SL::OperatorNode *onode = (SL::OperatorNode *)p_node; SL::OperatorNode *onode = (SL::OperatorNode *)p_node;
switch (onode->op) { switch (onode->op) {
@ -1130,7 +1130,7 @@ String ShaderCompiler::_dump_node_code(const SL::Node *p_node, int p_level, Gene
case SL::OP_CALL: case SL::OP_CALL:
case SL::OP_STRUCT: case SL::OP_STRUCT:
case SL::OP_CONSTRUCT: { case SL::OP_CONSTRUCT: {
ERR_FAIL_COND_V(onode->arguments[0]->type != SL::Node::TYPE_VARIABLE, String()); ERR_FAIL_COND_V(onode->arguments[0]->type != SL::Node::NODE_TYPE_VARIABLE, String());
const SL::VariableNode *vnode = static_cast<const SL::VariableNode *>(onode->arguments[0]); const SL::VariableNode *vnode = static_cast<const SL::VariableNode *>(onode->arguments[0]);
const SL::FunctionNode *func = nullptr; const SL::FunctionNode *func = nullptr;
const bool is_internal_func = internal_functions.has(vnode->name); const bool is_internal_func = internal_functions.has(vnode->name);
@ -1200,12 +1200,12 @@ String ShaderCompiler::_dump_node_code(const SL::Node *p_node, int p_level, Gene
bool done = false; bool done = false;
do { do {
switch (node->type) { switch (node->type) {
case SL::Node::TYPE_VARIABLE: { case SL::Node::NODE_TYPE_VARIABLE: {
name = static_cast<const SL::VariableNode *>(node)->name; name = static_cast<const SL::VariableNode *>(node)->name;
done = true; done = true;
found = true; found = true;
} break; } break;
case SL::Node::TYPE_MEMBER: { case SL::Node::NODE_TYPE_MEMBER: {
node = static_cast<const SL::MemberNode *>(node)->owner; node = static_cast<const SL::MemberNode *>(node)->owner;
} break; } break;
default: { default: {
@ -1227,12 +1227,12 @@ String ShaderCompiler::_dump_node_code(const SL::Node *p_node, int p_level, Gene
bool correct_texture_uniform = false; bool correct_texture_uniform = false;
switch (onode->arguments[i]->type) { switch (onode->arguments[i]->type) {
case SL::Node::TYPE_VARIABLE: { case SL::Node::NODE_TYPE_VARIABLE: {
const SL::VariableNode *varnode = static_cast<const SL::VariableNode *>(onode->arguments[i]); const SL::VariableNode *varnode = static_cast<const SL::VariableNode *>(onode->arguments[i]);
texture_uniform = varnode->name; texture_uniform = varnode->name;
correct_texture_uniform = true; correct_texture_uniform = true;
} break; } break;
case SL::Node::TYPE_ARRAY: { case SL::Node::NODE_TYPE_ARRAY: {
const SL::ArrayNode *anode = static_cast<const SL::ArrayNode *>(onode->arguments[i]); const SL::ArrayNode *anode = static_cast<const SL::ArrayNode *>(onode->arguments[i]);
texture_uniform = anode->name; texture_uniform = anode->name;
correct_texture_uniform = true; correct_texture_uniform = true;
@ -1361,7 +1361,7 @@ String ShaderCompiler::_dump_node_code(const SL::Node *p_node, int p_level, Gene
} }
} break; } break;
case SL::Node::TYPE_CONTROL_FLOW: { case SL::Node::NODE_TYPE_CONTROL_FLOW: {
SL::ControlFlowNode *cfnode = (SL::ControlFlowNode *)p_node; SL::ControlFlowNode *cfnode = (SL::ControlFlowNode *)p_node;
if (cfnode->flow_op == SL::FLOW_OP_IF) { if (cfnode->flow_op == SL::FLOW_OP_IF) {
code += _mktab(p_level) + "if (" + _dump_node_code(cfnode->expressions[0], p_level, r_gen_code, p_actions, p_default_actions, p_assigning) + ")\n"; code += _mktab(p_level) + "if (" + _dump_node_code(cfnode->expressions[0], p_level, r_gen_code, p_actions, p_default_actions, p_assigning) + ")\n";
@ -1413,7 +1413,7 @@ String ShaderCompiler::_dump_node_code(const SL::Node *p_node, int p_level, Gene
} }
} break; } break;
case SL::Node::TYPE_MEMBER: { case SL::Node::NODE_TYPE_MEMBER: {
SL::MemberNode *mnode = (SL::MemberNode *)p_node; SL::MemberNode *mnode = (SL::MemberNode *)p_node;
code = _dump_node_code(mnode->owner, p_level, r_gen_code, p_actions, p_default_actions, p_assigning) + "." + mnode->name; code = _dump_node_code(mnode->owner, p_level, r_gen_code, p_actions, p_default_actions, p_assigning) + "." + mnode->name;
if (mnode->index_expression != nullptr) { if (mnode->index_expression != nullptr) {

114
servers/rendering/shader_language.cpp
View File

@ -3063,7 +3063,7 @@ bool ShaderLanguage::_validate_function_call(BlockNode *p_block, const FunctionI
Vector<StringName> args2; Vector<StringName> args2;
Vector<int> args3; Vector<int> args3;
ERR_FAIL_COND_V(p_func->arguments[0]->type != Node::TYPE_VARIABLE, false); ERR_FAIL_COND_V(p_func->arguments[0]->type != Node::NODE_TYPE_VARIABLE, false);
StringName name = static_cast<VariableNode *>(p_func->arguments[0])->name.operator String(); StringName name = static_cast<VariableNode *>(p_func->arguments[0])->name.operator String();
@ -3117,14 +3117,14 @@ bool ShaderLanguage::_validate_function_call(BlockNode *p_block, const FunctionI
failed_builtin = true; failed_builtin = true;
bool fail = false; bool fail = false;
for (int i = 0; i < argcount; i++) { for (int i = 0; i < argcount; i++) {
if (p_func->arguments[i + 1]->type == Node::TYPE_ARRAY) { if (p_func->arguments[i + 1]->type == Node::NODE_TYPE_ARRAY) {
const ArrayNode *anode = static_cast<const ArrayNode *>(p_func->arguments[i + 1]); const ArrayNode *anode = static_cast<const ArrayNode *>(p_func->arguments[i + 1]);
if (anode->call_expression == nullptr && !anode->is_indexed()) { if (anode->call_expression == nullptr && !anode->is_indexed()) {
fail = true; fail = true;
break; break;
} }
} }
if (get_scalar_type(args[i]) == args[i] && p_func->arguments[i + 1]->type == Node::TYPE_CONSTANT && convert_constant(static_cast<ConstantNode *>(p_func->arguments[i + 1]), builtin_func_defs[idx].args[i])) { if (get_scalar_type(args[i]) == args[i] && p_func->arguments[i + 1]->type == Node::NODE_TYPE_CONSTANT && convert_constant(static_cast<ConstantNode *>(p_func->arguments[i + 1]), builtin_func_defs[idx].args[i])) {
//all good, but needs implicit conversion later //all good, but needs implicit conversion later
} else if (args[i] != builtin_func_defs[idx].args[i]) { } else if (args[i] != builtin_func_defs[idx].args[i]) {
fail = true; fail = true;
@ -3160,7 +3160,7 @@ bool ShaderLanguage::_validate_function_call(BlockNode *p_block, const FunctionI
int max = builtin_func_const_args[constarg_idx].max; int max = builtin_func_const_args[constarg_idx].max;
bool error = false; bool error = false;
if (p_func->arguments[arg]->type == Node::TYPE_VARIABLE) { if (p_func->arguments[arg]->type == Node::NODE_TYPE_VARIABLE) {
const VariableNode *vn = static_cast<VariableNode *>(p_func->arguments[arg]); const VariableNode *vn = static_cast<VariableNode *>(p_func->arguments[arg]);
bool is_const = false; bool is_const = false;
@ -3172,7 +3172,7 @@ bool ShaderLanguage::_validate_function_call(BlockNode *p_block, const FunctionI
error = true; error = true;
} }
} else { } else {
if (p_func->arguments[arg]->type == Node::TYPE_CONSTANT) { if (p_func->arguments[arg]->type == Node::NODE_TYPE_CONSTANT) {
const ConstantNode *cn = static_cast<ConstantNode *>(p_func->arguments[arg]); const ConstantNode *cn = static_cast<ConstantNode *>(p_func->arguments[arg]);
if (cn->get_datatype() == TYPE_INT && cn->values.size() == 1) { if (cn->get_datatype() == TYPE_INT && cn->values.size() == 1) {
@ -3207,17 +3207,17 @@ bool ShaderLanguage::_validate_function_call(BlockNode *p_block, const FunctionI
break; break;
} }
if (arg_idx < argcount) { if (arg_idx < argcount) {
if (p_func->arguments[arg_idx + 1]->type != Node::TYPE_VARIABLE && p_func->arguments[arg_idx + 1]->type != Node::TYPE_MEMBER && p_func->arguments[arg_idx + 1]->type != Node::TYPE_ARRAY) { if (p_func->arguments[arg_idx + 1]->type != Node::NODE_TYPE_VARIABLE && p_func->arguments[arg_idx + 1]->type != Node::NODE_TYPE_MEMBER && p_func->arguments[arg_idx + 1]->type != Node::NODE_TYPE_ARRAY) {
_set_error(vformat(RTR("Argument %d of function '%s' is not a variable, array, or member."), arg_idx + 1, String(name))); _set_error(vformat(RTR("Argument %d of function '%s' is not a variable, array, or member."), arg_idx + 1, String(name)));
return false; return false;
} }
if (p_func->arguments[arg_idx + 1]->type == Node::TYPE_ARRAY) { if (p_func->arguments[arg_idx + 1]->type == Node::NODE_TYPE_ARRAY) {
ArrayNode *mn = static_cast<ArrayNode *>(p_func->arguments[arg_idx + 1]); ArrayNode *mn = static_cast<ArrayNode *>(p_func->arguments[arg_idx + 1]);
if (mn->is_const) { if (mn->is_const) {
fail = true; fail = true;
} }
} else if (p_func->arguments[arg_idx + 1]->type == Node::TYPE_MEMBER) { } else if (p_func->arguments[arg_idx + 1]->type == Node::NODE_TYPE_MEMBER) {
MemberNode *mn = static_cast<MemberNode *>(p_func->arguments[arg_idx + 1]); MemberNode *mn = static_cast<MemberNode *>(p_func->arguments[arg_idx + 1]);
if (mn->basetype_const) { if (mn->basetype_const) {
fail = true; fail = true;
@ -3250,18 +3250,18 @@ bool ShaderLanguage::_validate_function_call(BlockNode *p_block, const FunctionI
} }
StringName var_name; StringName var_name;
if (p_func->arguments[arg_idx + 1]->type == Node::TYPE_ARRAY) { if (p_func->arguments[arg_idx + 1]->type == Node::NODE_TYPE_ARRAY) {
var_name = static_cast<const ArrayNode *>(p_func->arguments[arg_idx + 1])->name; var_name = static_cast<const ArrayNode *>(p_func->arguments[arg_idx + 1])->name;
} else if (p_func->arguments[arg_idx + 1]->type == Node::TYPE_MEMBER) { } else if (p_func->arguments[arg_idx + 1]->type == Node::NODE_TYPE_MEMBER) {
Node *n = static_cast<const MemberNode *>(p_func->arguments[arg_idx + 1])->owner; Node *n = static_cast<const MemberNode *>(p_func->arguments[arg_idx + 1])->owner;
while (n->type == Node::TYPE_MEMBER) { while (n->type == Node::NODE_TYPE_MEMBER) {
n = static_cast<const MemberNode *>(n)->owner; n = static_cast<const MemberNode *>(n)->owner;
} }
if (n->type != Node::TYPE_VARIABLE && n->type != Node::TYPE_ARRAY) { if (n->type != Node::NODE_TYPE_VARIABLE && n->type != Node::NODE_TYPE_ARRAY) {
_set_error(vformat(RTR("Argument %d of function '%s' is not a variable, array, or member."), arg_idx + 1, String(name))); _set_error(vformat(RTR("Argument %d of function '%s' is not a variable, array, or member."), arg_idx + 1, String(name)));
return false; return false;
} }
if (n->type == Node::TYPE_VARIABLE) { if (n->type == Node::NODE_TYPE_VARIABLE) {
var_name = static_cast<const VariableNode *>(n)->name; var_name = static_cast<const VariableNode *>(n)->name;
} else { // TYPE_ARRAY } else { // TYPE_ARRAY
var_name = static_cast<const ArrayNode *>(n)->name; var_name = static_cast<const ArrayNode *>(n)->name;
@ -3298,7 +3298,7 @@ bool ShaderLanguage::_validate_function_call(BlockNode *p_block, const FunctionI
} }
//implicitly convert values if possible //implicitly convert values if possible
for (int i = 0; i < argcount; i++) { for (int i = 0; i < argcount; i++) {
if (get_scalar_type(args[i]) != args[i] || args[i] == builtin_func_defs[idx].args[i] || p_func->arguments[i + 1]->type != Node::TYPE_CONSTANT) { if (get_scalar_type(args[i]) != args[i] || args[i] == builtin_func_defs[idx].args[i] || p_func->arguments[i + 1]->type != Node::NODE_TYPE_CONSTANT) {
//can't do implicit conversion here //can't do implicit conversion here
continue; continue;
} }
@ -3422,7 +3422,7 @@ bool ShaderLanguage::_validate_function_call(BlockNode *p_block, const FunctionI
bool fail = false; bool fail = false;
for (int j = 0; j < args.size(); j++) { for (int j = 0; j < args.size(); j++) {
if (get_scalar_type(args[j]) == args[j] && p_func->arguments[j + 1]->type == Node::TYPE_CONSTANT && args3[j] == 0 && convert_constant(static_cast<ConstantNode *>(p_func->arguments[j + 1]), pfunc->arguments[j].type)) { if (get_scalar_type(args[j]) == args[j] && p_func->arguments[j + 1]->type == Node::NODE_TYPE_CONSTANT && args3[j] == 0 && convert_constant(static_cast<ConstantNode *>(p_func->arguments[j + 1]), pfunc->arguments[j].type)) {
//all good, but it needs implicit conversion later //all good, but it needs implicit conversion later
} else if (args[j] != pfunc->arguments[j].type || (args[j] == TYPE_STRUCT && args2[j] != pfunc->arguments[j].type_str) || args3[j] != pfunc->arguments[j].array_size) { } else if (args[j] != pfunc->arguments[j].type || (args[j] == TYPE_STRUCT && args2[j] != pfunc->arguments[j].type_str) || args3[j] != pfunc->arguments[j].array_size) {
String func_arg_name; String func_arg_name;
@ -3457,7 +3457,7 @@ bool ShaderLanguage::_validate_function_call(BlockNode *p_block, const FunctionI
if (!fail) { if (!fail) {
//implicitly convert values if possible //implicitly convert values if possible
for (int k = 0; k < args.size(); k++) { for (int k = 0; k < args.size(); k++) {
if (get_scalar_type(args[k]) != args[k] || args[k] == pfunc->arguments[k].type || p_func->arguments[k + 1]->type != Node::TYPE_CONSTANT) { if (get_scalar_type(args[k]) != args[k] || args[k] == pfunc->arguments[k].type || p_func->arguments[k + 1]->type != Node::NODE_TYPE_CONSTANT) {
//can't do implicit conversion here //can't do implicit conversion here
continue; continue;
} }
@ -3565,7 +3565,7 @@ bool ShaderLanguage::_parse_function_arguments(BlockNode *p_block, const Functio
return false; return false;
} }
if (is_const_decl && arg->type == Node::TYPE_VARIABLE) { if (is_const_decl && arg->type == Node::NODE_TYPE_VARIABLE) {
const VariableNode *var = static_cast<const VariableNode *>(arg); const VariableNode *var = static_cast<const VariableNode *>(arg);
if (!var->is_const) { if (!var->is_const) {
_set_error(RTR("Expected constant expression.")); _set_error(RTR("Expected constant expression."));
@ -4531,7 +4531,7 @@ bool ShaderLanguage::_validate_varying_assign(ShaderNode::Varying &p_varying, St
bool ShaderLanguage::_check_node_constness(const Node *p_node) const { bool ShaderLanguage::_check_node_constness(const Node *p_node) const {
switch (p_node->type) { switch (p_node->type) {
case Node::TYPE_OPERATOR: { case Node::NODE_TYPE_OPERATOR: {
const OperatorNode *op_node = static_cast<const OperatorNode *>(p_node); const OperatorNode *op_node = static_cast<const OperatorNode *>(p_node);
for (int i = int(op_node->op == OP_CALL); i < op_node->arguments.size(); i++) { for (int i = int(op_node->op == OP_CALL); i < op_node->arguments.size(); i++) {
if (!_check_node_constness(op_node->arguments[i])) { if (!_check_node_constness(op_node->arguments[i])) {
@ -4539,15 +4539,15 @@ bool ShaderLanguage::_check_node_constness(const Node *p_node) const {
} }
} }
} break; } break;
case Node::TYPE_CONSTANT: case Node::NODE_TYPE_CONSTANT:
break; break;
case Node::TYPE_VARIABLE: { case Node::NODE_TYPE_VARIABLE: {
const VariableNode *var_node = static_cast<const VariableNode *>(p_node); const VariableNode *var_node = static_cast<const VariableNode *>(p_node);
if (!var_node->is_const) { if (!var_node->is_const) {
return false; return false;
} }
} break; } break;
case Node::TYPE_ARRAY: { case Node::NODE_TYPE_ARRAY: {
const ArrayNode *arr_node = static_cast<const ArrayNode *>(p_node); const ArrayNode *arr_node = static_cast<const ArrayNode *>(p_node);
if (!arr_node->is_const) { if (!arr_node->is_const) {
return false; return false;
@ -4560,7 +4560,7 @@ bool ShaderLanguage::_check_node_constness(const Node *p_node) const {
} }
bool ShaderLanguage::_validate_assign(Node *p_node, const FunctionInfo &p_function_info, String *r_message) { bool ShaderLanguage::_validate_assign(Node *p_node, const FunctionInfo &p_function_info, String *r_message) {
if (p_node->type == Node::TYPE_OPERATOR) { if (p_node->type == Node::NODE_TYPE_OPERATOR) {
OperatorNode *op = static_cast<OperatorNode *>(p_node); OperatorNode *op = static_cast<OperatorNode *>(p_node);
if (op->op == OP_INDEX) { if (op->op == OP_INDEX) {
@ -4577,7 +4577,7 @@ bool ShaderLanguage::_validate_assign(Node *p_node, const FunctionInfo &p_functi
return false; return false;
} }
} else if (p_node->type == Node::TYPE_MEMBER) { } else if (p_node->type == Node::NODE_TYPE_MEMBER) {
MemberNode *member = static_cast<MemberNode *>(p_node); MemberNode *member = static_cast<MemberNode *>(p_node);
if (member->has_swizzling_duplicates) { if (member->has_swizzling_duplicates) {
@ -4589,7 +4589,7 @@ bool ShaderLanguage::_validate_assign(Node *p_node, const FunctionInfo &p_functi
return _validate_assign(member->owner, p_function_info, r_message); return _validate_assign(member->owner, p_function_info, r_message);
} else if (p_node->type == Node::TYPE_VARIABLE) { } else if (p_node->type == Node::NODE_TYPE_VARIABLE) {
VariableNode *var = static_cast<VariableNode *>(p_node); VariableNode *var = static_cast<VariableNode *>(p_node);
if (shader->uniforms.has(var->name)) { if (shader->uniforms.has(var->name)) {
@ -4609,7 +4609,7 @@ bool ShaderLanguage::_validate_assign(Node *p_node, const FunctionInfo &p_functi
if (!(p_function_info.built_ins.has(var->name) && p_function_info.built_ins[var->name].constant)) { if (!(p_function_info.built_ins.has(var->name) && p_function_info.built_ins[var->name].constant)) {
return true; return true;
} }
} else if (p_node->type == Node::TYPE_ARRAY) { } else if (p_node->type == Node::NODE_TYPE_ARRAY) {
ArrayNode *arr = static_cast<ArrayNode *>(p_node); ArrayNode *arr = static_cast<ArrayNode *>(p_node);
if (shader->constants.has(arr->name) || arr->is_const) { if (shader->constants.has(arr->name) || arr->is_const) {
@ -4727,7 +4727,7 @@ Error ShaderLanguage::_parse_array_size(BlockNode *p_block, const FunctionInfo &
_set_tkpos(pos); _set_tkpos(pos);
Node *n = _parse_and_reduce_expression(p_block, p_function_info); Node *n = _parse_and_reduce_expression(p_block, p_function_info);
if (n) { if (n) {
if (n->type == Node::TYPE_VARIABLE) { if (n->type == Node::NODE_TYPE_VARIABLE) {
VariableNode *vn = static_cast<VariableNode *>(n); VariableNode *vn = static_cast<VariableNode *>(n);
if (vn) { if (vn) {
ConstantNode::Value v; ConstantNode::Value v;
@ -4750,7 +4750,7 @@ Error ShaderLanguage::_parse_array_size(BlockNode *p_block, const FunctionInfo &
} }
} }
} }
} else if (n->type == Node::TYPE_OPERATOR) { } else if (n->type == Node::NODE_TYPE_OPERATOR) {
_set_error(vformat(RTR("Array size expressions are not supported."))); _set_error(vformat(RTR("Array size expressions are not supported.")));
return ERR_PARSE_ERROR; return ERR_PARSE_ERROR;
} }
@ -5296,10 +5296,10 @@ ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, cons
ArgumentQualifier arg_qual = call_function->arguments[i].qualifier; ArgumentQualifier arg_qual = call_function->arguments[i].qualifier;
bool is_out_arg = arg_qual != ArgumentQualifier::ARGUMENT_QUALIFIER_IN; bool is_out_arg = arg_qual != ArgumentQualifier::ARGUMENT_QUALIFIER_IN;
if (n->type == Node::TYPE_VARIABLE || n->type == Node::TYPE_ARRAY) { if (n->type == Node::NODE_TYPE_VARIABLE || n->type == Node::NODE_TYPE_ARRAY) {
StringName varname; StringName varname;
if (n->type == Node::TYPE_VARIABLE) { if (n->type == Node::NODE_TYPE_VARIABLE) {
VariableNode *vn = static_cast<VariableNode *>(n); VariableNode *vn = static_cast<VariableNode *>(n);
varname = vn->name; varname = vn->name;
} else { // TYPE_ARRAY } else { // TYPE_ARRAY
@ -5347,23 +5347,23 @@ ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, cons
if (is_const_arg || is_out_arg) { if (is_const_arg || is_out_arg) {
StringName varname; StringName varname;
if (n->type == Node::TYPE_CONSTANT || n->type == Node::TYPE_OPERATOR || n->type == Node::TYPE_ARRAY_CONSTRUCT) { if (n->type == Node::NODE_TYPE_CONSTANT || n->type == Node::NODE_TYPE_OPERATOR || n->type == Node::NODE_TYPE_ARRAY_CONSTRUCT) {
if (!is_const_arg) { if (!is_const_arg) {
error = true; error = true;
} }
} else if (n->type == Node::TYPE_ARRAY) { } else if (n->type == Node::NODE_TYPE_ARRAY) {
ArrayNode *an = static_cast<ArrayNode *>(n); ArrayNode *an = static_cast<ArrayNode *>(n);
if (!is_const_arg && (an->call_expression != nullptr || an->is_const)) { if (!is_const_arg && (an->call_expression != nullptr || an->is_const)) {
error = true; error = true;
} }
varname = an->name; varname = an->name;
} else if (n->type == Node::TYPE_VARIABLE) { } else if (n->type == Node::NODE_TYPE_VARIABLE) {
VariableNode *vn = static_cast<VariableNode *>(n); VariableNode *vn = static_cast<VariableNode *>(n);
if (vn->is_const && !is_const_arg) { if (vn->is_const && !is_const_arg) {
error = true; error = true;
} }
varname = vn->name; varname = vn->name;
} else if (n->type == Node::TYPE_MEMBER) { } else if (n->type == Node::NODE_TYPE_MEMBER) {
MemberNode *mn = static_cast<MemberNode *>(n); MemberNode *mn = static_cast<MemberNode *>(n);
if (mn->basetype_const && is_out_arg) { if (mn->basetype_const && is_out_arg) {
error = true; error = true;
@ -5389,7 +5389,7 @@ ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, cons
} }
if (is_sampler_type(call_function->arguments[i].type)) { if (is_sampler_type(call_function->arguments[i].type)) {
//let's see where our argument comes from //let's see where our argument comes from
ERR_CONTINUE(n->type != Node::TYPE_VARIABLE); //bug? this should always be a variable ERR_CONTINUE(n->type != Node::NODE_TYPE_VARIABLE); //bug? this should always be a variable
VariableNode *vn = static_cast<VariableNode *>(n); VariableNode *vn = static_cast<VariableNode *>(n);
StringName varname = vn->name; StringName varname = vn->name;
if (shader->uniforms.has(varname)) { if (shader->uniforms.has(varname)) {
@ -5599,7 +5599,7 @@ ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, cons
return nullptr; return nullptr;
} }
if (index_expression->type == Node::TYPE_CONSTANT) { if (index_expression->type == Node::NODE_TYPE_CONSTANT) {
ConstantNode *cnode = static_cast<ConstantNode *>(index_expression); ConstantNode *cnode = static_cast<ConstantNode *>(index_expression);
if (cnode) { if (cnode) {
if (!cnode->values.is_empty()) { if (!cnode->values.is_empty()) {
@ -6064,7 +6064,7 @@ ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, cons
return nullptr; return nullptr;
} }
if (index_expression->type == Node::TYPE_CONSTANT) { if (index_expression->type == Node::NODE_TYPE_CONSTANT) {
ConstantNode *cnode = static_cast<ConstantNode *>(index_expression); ConstantNode *cnode = static_cast<ConstantNode *>(index_expression);
if (cnode) { if (cnode) {
if (!cnode->values.is_empty()) { if (!cnode->values.is_empty()) {
@ -6118,7 +6118,7 @@ ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, cons
String member_struct_name; String member_struct_name;
if (expr->get_array_size() > 0) { if (expr->get_array_size() > 0) {
if (index->type == Node::TYPE_CONSTANT) { if (index->type == Node::NODE_TYPE_CONSTANT) {
uint32_t index_constant = static_cast<ConstantNode *>(index)->values[0].uint; uint32_t index_constant = static_cast<ConstantNode *>(index)->values[0].uint;
if (index_constant >= (uint32_t)expr->get_array_size()) { if (index_constant >= (uint32_t)expr->get_array_size()) {
_set_error(vformat(RTR("Index [%d] out of range [%d..%d]."), index_constant, 0, expr->get_array_size() - 1)); _set_error(vformat(RTR("Index [%d] out of range [%d..%d]."), index_constant, 0, expr->get_array_size() - 1));
@ -6136,7 +6136,7 @@ ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, cons
case TYPE_IVEC2: case TYPE_IVEC2:
case TYPE_UVEC2: case TYPE_UVEC2:
case TYPE_MAT2: case TYPE_MAT2:
if (index->type == Node::TYPE_CONSTANT) { if (index->type == Node::NODE_TYPE_CONSTANT) {
uint32_t index_constant = static_cast<ConstantNode *>(index)->values[0].uint; uint32_t index_constant = static_cast<ConstantNode *>(index)->values[0].uint;
if (index_constant >= 2) { if (index_constant >= 2) {
_set_error(vformat(RTR("Index [%d] out of range [%d..%d]."), index_constant, 0, 1)); _set_error(vformat(RTR("Index [%d] out of range [%d..%d]."), index_constant, 0, 1));
@ -6170,7 +6170,7 @@ ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, cons
case TYPE_IVEC3: case TYPE_IVEC3:
case TYPE_UVEC3: case TYPE_UVEC3:
case TYPE_MAT3: case TYPE_MAT3:
if (index->type == Node::TYPE_CONSTANT) { if (index->type == Node::NODE_TYPE_CONSTANT) {
uint32_t index_constant = static_cast<ConstantNode *>(index)->values[0].uint; uint32_t index_constant = static_cast<ConstantNode *>(index)->values[0].uint;
if (index_constant >= 3) { if (index_constant >= 3) {
_set_error(vformat(RTR("Index [%d] out of range [%d..%d]."), index_constant, 0, 2)); _set_error(vformat(RTR("Index [%d] out of range [%d..%d]."), index_constant, 0, 2));
@ -6203,7 +6203,7 @@ ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, cons
case TYPE_IVEC4: case TYPE_IVEC4:
case TYPE_UVEC4: case TYPE_UVEC4:
case TYPE_MAT4: case TYPE_MAT4:
if (index->type == Node::TYPE_CONSTANT) { if (index->type == Node::NODE_TYPE_CONSTANT) {
uint32_t index_constant = static_cast<ConstantNode *>(index)->values[0].uint; uint32_t index_constant = static_cast<ConstantNode *>(index)->values[0].uint;
if (index_constant >= 4) { if (index_constant >= 4) {
_set_error(vformat(RTR("Index [%d] out of range [%d..%d]."), index_constant, 0, 3)); _set_error(vformat(RTR("Index [%d] out of range [%d..%d]."), index_constant, 0, 3));
@ -6702,7 +6702,7 @@ ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, cons
} }
ShaderLanguage::Node *ShaderLanguage::_reduce_expression(BlockNode *p_block, ShaderLanguage::Node *p_node) { ShaderLanguage::Node *ShaderLanguage::_reduce_expression(BlockNode *p_block, ShaderLanguage::Node *p_node) {
if (p_node->type != Node::TYPE_OPERATOR) { if (p_node->type != Node::NODE_TYPE_OPERATOR) {
return p_node; return p_node;
} }
@ -6710,7 +6710,7 @@ ShaderLanguage::Node *ShaderLanguage::_reduce_expression(BlockNode *p_block, Sha
OperatorNode *op = static_cast<OperatorNode *>(p_node); OperatorNode *op = static_cast<OperatorNode *>(p_node);
if (op->op == OP_CONSTRUCT) { if (op->op == OP_CONSTRUCT) {
ERR_FAIL_COND_V(op->arguments[0]->type != Node::TYPE_VARIABLE, p_node); ERR_FAIL_COND_V(op->arguments[0]->type != Node::NODE_TYPE_VARIABLE, p_node);
DataType type = op->get_datatype(); DataType type = op->get_datatype();
DataType base = get_scalar_type(type); DataType base = get_scalar_type(type);
@ -6720,7 +6720,7 @@ ShaderLanguage::Node *ShaderLanguage::_reduce_expression(BlockNode *p_block, Sha
for (int i = 1; i < op->arguments.size(); i++) { for (int i = 1; i < op->arguments.size(); i++) {
op->arguments.write[i] = _reduce_expression(p_block, op->arguments[i]); op->arguments.write[i] = _reduce_expression(p_block, op->arguments[i]);
if (op->arguments[i]->type == Node::TYPE_CONSTANT) { if (op->arguments[i]->type == Node::NODE_TYPE_CONSTANT) {
ConstantNode *cn = static_cast<ConstantNode *>(op->arguments[i]); ConstantNode *cn = static_cast<ConstantNode *>(op->arguments[i]);
if (get_scalar_type(cn->datatype) == base) { if (get_scalar_type(cn->datatype) == base) {
@ -6772,7 +6772,7 @@ ShaderLanguage::Node *ShaderLanguage::_reduce_expression(BlockNode *p_block, Sha
return cn; return cn;
} else if (op->op == OP_NEGATE) { } else if (op->op == OP_NEGATE) {
op->arguments.write[0] = _reduce_expression(p_block, op->arguments[0]); op->arguments.write[0] = _reduce_expression(p_block, op->arguments[0]);
if (op->arguments[0]->type == Node::TYPE_CONSTANT) { if (op->arguments[0]->type == Node::NODE_TYPE_CONSTANT) {
ConstantNode *cn = static_cast<ConstantNode *>(op->arguments[0]); ConstantNode *cn = static_cast<ConstantNode *>(op->arguments[0]);
DataType base = get_scalar_type(cn->datatype); DataType base = get_scalar_type(cn->datatype);
@ -7179,7 +7179,7 @@ Error ShaderLanguage::_parse_block(BlockNode *p_block, const FunctionInfo &p_fun
return ERR_PARSE_ERROR; return ERR_PARSE_ERROR;
} }
if (is_const && n->type == Node::TYPE_OPERATOR && static_cast<OperatorNode *>(n)->op == OP_CALL) { if (is_const && n->type == Node::NODE_TYPE_OPERATOR && static_cast<OperatorNode *>(n)->op == OP_CALL) {
_set_error(RTR("Expected a constant expression.")); _set_error(RTR("Expected a constant expression."));
return ERR_PARSE_ERROR; return ERR_PARSE_ERROR;
} }
@ -7235,7 +7235,7 @@ Error ShaderLanguage::_parse_block(BlockNode *p_block, const FunctionInfo &p_fun
if (!n) { if (!n) {
return ERR_PARSE_ERROR; return ERR_PARSE_ERROR;
} }
if (is_const && n->type == Node::TYPE_OPERATOR && static_cast<OperatorNode *>(n)->op == OP_CALL) { if (is_const && n->type == Node::NODE_TYPE_OPERATOR && static_cast<OperatorNode *>(n)->op == OP_CALL) {
OperatorNode *op = static_cast<OperatorNode *>(n); OperatorNode *op = static_cast<OperatorNode *>(n);
for (int i = 1; i < op->arguments.size(); i++) { for (int i = 1; i < op->arguments.size(); i++) {
if (!_check_node_constness(op->arguments[i])) { if (!_check_node_constness(op->arguments[i])) {
@ -7245,7 +7245,7 @@ Error ShaderLanguage::_parse_block(BlockNode *p_block, const FunctionInfo &p_fun
} }
} }
if (n->type == Node::TYPE_CONSTANT) { if (n->type == Node::NODE_TYPE_CONSTANT) {
ConstantNode *const_node = static_cast<ConstantNode *>(n); ConstantNode *const_node = static_cast<ConstantNode *>(n);
if (const_node && const_node->values.size() == 1) { if (const_node && const_node->values.size() == 1) {
var.value = const_node->values[0]; var.value = const_node->values[0];
@ -7412,7 +7412,7 @@ Error ShaderLanguage::_parse_block(BlockNode *p_block, const FunctionInfo &p_fun
ControlFlowNode *flow = static_cast<ControlFlowNode *>(switch_block->statements[i]); ControlFlowNode *flow = static_cast<ControlFlowNode *>(switch_block->statements[i]);
if (flow) { if (flow) {
if (flow->flow_op == FLOW_OP_CASE) { if (flow->flow_op == FLOW_OP_CASE) {
if (flow->expressions[0]->type == Node::TYPE_CONSTANT) { if (flow->expressions[0]->type == Node::NODE_TYPE_CONSTANT) {
ConstantNode *cn = static_cast<ConstantNode *>(flow->expressions[0]); ConstantNode *cn = static_cast<ConstantNode *>(flow->expressions[0]);
if (!cn || cn->values.is_empty()) { if (!cn || cn->values.is_empty()) {
return ERR_PARSE_ERROR; return ERR_PARSE_ERROR;
@ -7422,7 +7422,7 @@ Error ShaderLanguage::_parse_block(BlockNode *p_block, const FunctionInfo &p_fun
return ERR_PARSE_ERROR; return ERR_PARSE_ERROR;
} }
constants.insert(cn->values[0].sint); constants.insert(cn->values[0].sint);
} else if (flow->expressions[0]->type == Node::TYPE_VARIABLE) { } else if (flow->expressions[0]->type == Node::NODE_TYPE_VARIABLE) {
VariableNode *vn = static_cast<VariableNode *>(flow->expressions[0]); VariableNode *vn = static_cast<VariableNode *>(flow->expressions[0]);
if (!vn) { if (!vn) {
return ERR_PARSE_ERROR; return ERR_PARSE_ERROR;
@ -7852,9 +7852,9 @@ Error ShaderLanguage::_parse_block(BlockNode *p_block, const FunctionInfo &p_fun
if (!expr) { if (!expr) {
return ERR_PARSE_ERROR; return ERR_PARSE_ERROR;
} }
is_condition = expr->type == Node::TYPE_OPERATOR && expr->get_datatype() == TYPE_BOOL; is_condition = expr->type == Node::NODE_TYPE_OPERATOR && expr->get_datatype() == TYPE_BOOL;
if (expr->type == Node::TYPE_OPERATOR) { if (expr->type == Node::NODE_TYPE_OPERATOR) {
OperatorNode *op = static_cast<OperatorNode *>(expr); OperatorNode *op = static_cast<OperatorNode *>(expr);
if (op->op == OP_EMPTY) { if (op->op == OP_EMPTY) {
is_var_init = true; is_var_init = true;
@ -8916,7 +8916,7 @@ Error ShaderLanguage::_parse_shader(const HashMap<StringName, FunctionInfo> &p_f
if (!expr) { if (!expr) {
return ERR_PARSE_ERROR; return ERR_PARSE_ERROR;
} }
if (expr->type != Node::TYPE_CONSTANT) { if (expr->type != Node::NODE_TYPE_CONSTANT) {
_set_error(RTR("Expected constant expression after '='.")); _set_error(RTR("Expected constant expression after '='."));
return ERR_PARSE_ERROR; return ERR_PARSE_ERROR;
} }
@ -9276,7 +9276,7 @@ Error ShaderLanguage::_parse_shader(const HashMap<StringName, FunctionInfo> &p_f
return ERR_PARSE_ERROR; return ERR_PARSE_ERROR;
} }
if (n->type == Node::TYPE_OPERATOR && static_cast<OperatorNode *>(n)->op == OP_CALL) { if (n->type == Node::NODE_TYPE_OPERATOR && static_cast<OperatorNode *>(n)->op == OP_CALL) {
_set_error(RTR("Expected constant expression.")); _set_error(RTR("Expected constant expression."));
return ERR_PARSE_ERROR; return ERR_PARSE_ERROR;
} }
@ -9343,7 +9343,7 @@ Error ShaderLanguage::_parse_shader(const HashMap<StringName, FunctionInfo> &p_f
keyword_completion_context = CF_GLOBAL_SPACE; keyword_completion_context = CF_GLOBAL_SPACE;
} }
#endif // DEBUG_ENABLED #endif // DEBUG_ENABLED
if (expr->type == Node::TYPE_OPERATOR && static_cast<OperatorNode *>(expr)->op == OP_CALL) { if (expr->type == Node::NODE_TYPE_OPERATOR && static_cast<OperatorNode *>(expr)->op == OP_CALL) {
OperatorNode *op = static_cast<OperatorNode *>(expr); OperatorNode *op = static_cast<OperatorNode *>(expr);
for (int i = 1; i < op->arguments.size(); i++) { for (int i = 1; i < op->arguments.size(); i++) {
if (!_check_node_constness(op->arguments[i])) { if (!_check_node_constness(op->arguments[i])) {
@ -9756,7 +9756,7 @@ Error ShaderLanguage::_find_last_flow_op_in_op(ControlFlowNode *p_flow, FlowOper
bool found = false; bool found = false;
for (int i = p_flow->blocks.size() - 1; i >= 0; i--) { for (int i = p_flow->blocks.size() - 1; i >= 0; i--) {
if (p_flow->blocks[i]->type == Node::TYPE_BLOCK) { if (p_flow->blocks[i]->type == Node::NODE_TYPE_BLOCK) {
BlockNode *last_block = static_cast<BlockNode *>(p_flow->blocks[i]); BlockNode *last_block = static_cast<BlockNode *>(p_flow->blocks[i]);
if (_find_last_flow_op_in_block(last_block, p_op) == OK) { if (_find_last_flow_op_in_block(last_block, p_op) == OK) {
found = true; found = true;
@ -9774,7 +9774,7 @@ Error ShaderLanguage::_find_last_flow_op_in_block(BlockNode *p_block, FlowOperat
bool found = false; bool found = false;
for (int i = p_block->statements.size() - 1; i >= 0; i--) { for (int i = p_block->statements.size() - 1; i >= 0; i--) {
if (p_block->statements[i]->type == Node::TYPE_CONTROL_FLOW) { if (p_block->statements[i]->type == Node::NODE_TYPE_CONTROL_FLOW) {
ControlFlowNode *flow = static_cast<ControlFlowNode *>(p_block->statements[i]); ControlFlowNode *flow = static_cast<ControlFlowNode *>(p_block->statements[i]);
if (flow->flow_op == p_op) { if (flow->flow_op == p_op) {
found = true; found = true;
@ -9785,7 +9785,7 @@ Error ShaderLanguage::_find_last_flow_op_in_block(BlockNode *p_block, FlowOperat
break; break;
} }
} }
} else if (p_block->statements[i]->type == Node::TYPE_BLOCK) { } else if (p_block->statements[i]->type == Node::NODE_TYPE_BLOCK) {
BlockNode *block = static_cast<BlockNode *>(p_block->statements[i]); BlockNode *block = static_cast<BlockNode *>(p_block->statements[i]);
if (_find_last_flow_op_in_block(block, p_op) == OK) { if (_find_last_flow_op_in_block(block, p_op) == OK) {
found = true; found = true;

48
servers/rendering/shader_language.h
View File

@ -357,18 +357,18 @@ public:
Node *next = nullptr; Node *next = nullptr;
enum Type { enum Type {
TYPE_SHADER, NODE_TYPE_SHADER,
TYPE_FUNCTION, NODE_TYPE_FUNCTION,
TYPE_BLOCK, NODE_TYPE_BLOCK,
TYPE_VARIABLE, NODE_TYPE_VARIABLE,
TYPE_VARIABLE_DECLARATION, NODE_TYPE_VARIABLE_DECLARATION,
TYPE_CONSTANT, NODE_TYPE_CONSTANT,
TYPE_OPERATOR, NODE_TYPE_OPERATOR,
TYPE_CONTROL_FLOW, NODE_TYPE_CONTROL_FLOW,
TYPE_MEMBER, NODE_TYPE_MEMBER,
TYPE_ARRAY, NODE_TYPE_ARRAY,
TYPE_ARRAY_CONSTRUCT, NODE_TYPE_ARRAY_CONSTRUCT,
TYPE_STRUCT, NODE_TYPE_STRUCT,
}; };
Type type; Type type;
@ -407,7 +407,7 @@ public:
virtual bool is_indexed() const override { return op == OP_INDEX; } virtual bool is_indexed() const override { return op == OP_INDEX; }
OperatorNode() : OperatorNode() :
Node(TYPE_OPERATOR) {} Node(NODE_TYPE_OPERATOR) {}
}; };
struct VariableNode : public Node { struct VariableNode : public Node {
@ -421,7 +421,7 @@ public:
virtual String get_datatype_name() const override { return String(struct_name); } virtual String get_datatype_name() const override { return String(struct_name); }
VariableNode() : VariableNode() :
Node(TYPE_VARIABLE) {} Node(NODE_TYPE_VARIABLE) {}
}; };
struct VariableDeclarationNode : public Node { struct VariableDeclarationNode : public Node {
@ -442,7 +442,7 @@ public:
virtual DataType get_datatype() const override { return datatype; } virtual DataType get_datatype() const override { return datatype; }
VariableDeclarationNode() : VariableDeclarationNode() :
Node(TYPE_VARIABLE_DECLARATION) {} Node(NODE_TYPE_VARIABLE_DECLARATION) {}
}; };
struct ArrayNode : public Node { struct ArrayNode : public Node {
@ -462,7 +462,7 @@ public:
virtual bool is_indexed() const override { return index_expression != nullptr; } virtual bool is_indexed() const override { return index_expression != nullptr; }
ArrayNode() : ArrayNode() :
Node(TYPE_ARRAY) {} Node(NODE_TYPE_ARRAY) {}
}; };
struct ArrayConstructNode : public Node { struct ArrayConstructNode : public Node {
@ -475,7 +475,7 @@ public:
virtual int get_array_size() const override { return initializer.size(); } virtual int get_array_size() const override { return initializer.size(); }
ArrayConstructNode() : ArrayConstructNode() :
Node(TYPE_ARRAY_CONSTRUCT) {} Node(NODE_TYPE_ARRAY_CONSTRUCT) {}
}; };
struct ConstantNode : public Node { struct ConstantNode : public Node {
@ -498,7 +498,7 @@ public:
virtual int get_array_size() const override { return array_size; } virtual int get_array_size() const override { return array_size; }
ConstantNode() : ConstantNode() :
Node(TYPE_CONSTANT) {} Node(NODE_TYPE_CONSTANT) {}
}; };
struct FunctionNode; struct FunctionNode;
@ -536,7 +536,7 @@ public:
bool use_comma_between_statements = false; bool use_comma_between_statements = false;
BlockNode() : BlockNode() :
Node(TYPE_BLOCK) {} Node(NODE_TYPE_BLOCK) {}
}; };
struct ControlFlowNode : public Node { struct ControlFlowNode : public Node {
@ -545,7 +545,7 @@ public:
Vector<BlockNode *> blocks; Vector<BlockNode *> blocks;
ControlFlowNode() : ControlFlowNode() :
Node(TYPE_CONTROL_FLOW) {} Node(NODE_TYPE_CONTROL_FLOW) {}
}; };
struct MemberNode : public Node { struct MemberNode : public Node {
@ -569,13 +569,13 @@ public:
virtual bool is_indexed() const override { return index_expression != nullptr || call_expression != nullptr; } virtual bool is_indexed() const override { return index_expression != nullptr || call_expression != nullptr; }
MemberNode() : MemberNode() :
Node(TYPE_MEMBER) {} Node(NODE_TYPE_MEMBER) {}
}; };
struct StructNode : public Node { struct StructNode : public Node {
List<MemberNode *> members; List<MemberNode *> members;
StructNode() : StructNode() :
Node(TYPE_STRUCT) {} Node(NODE_TYPE_STRUCT) {}
}; };
struct FunctionNode : public Node { struct FunctionNode : public Node {
@ -611,7 +611,7 @@ public:
virtual int get_array_size() const override { return return_array_size; } virtual int get_array_size() const override { return return_array_size; }
FunctionNode() : FunctionNode() :
Node(TYPE_FUNCTION) {} Node(NODE_TYPE_FUNCTION) {}
}; };
struct ShaderNode : public Node { struct ShaderNode : public Node {
@ -718,7 +718,7 @@ public:
Vector<Struct> vstructs; Vector<Struct> vstructs;
ShaderNode() : ShaderNode() :
Node(TYPE_SHADER) {} Node(NODE_TYPE_SHADER) {}
}; };
struct UniformOrderComparator { struct UniformOrderComparator {