Merge pull request #32397 from akien-mga/3.1

Assorted cherry-picks from the master branch for Godot 3.1.2

drivers/gles2/rasterizer_storage_gles2.cpp

@@ -3466,6 +3466,8 @@ RID RasterizerStorageGLES2::skeleton_create() {
 
 	Skeleton *skeleton = memnew(Skeleton);
 
+	glGenTextures(1, &skeleton->tex_id);
+
 	return skeleton_owner.make_rid(skeleton);
 }
 
@@ -3483,7 +3485,6 @@ void RasterizerStorageGLES2::skeleton_allocate(RID p_skeleton, int p_bones, bool
 	skeleton->use_2d = p_2d_skeleton;
 
 	if (config.float_texture_supported) {
-		glGenTextures(1, &skeleton->tex_id);
 
 		glActiveTexture(GL_TEXTURE0);
 		glBindTexture(GL_TEXTURE_2D, skeleton->tex_id);

editor/editor_file_system.cpp

@@ -837,7 +837,7 @@ void EditorFileSystem::_scan_fs_changes(EditorFileSystemDirectory *p_dir, const
 	bool updated_dir = false;
 	String cd = p_dir->get_path();
 
-	if (current_mtime != p_dir->modified_time || using_fat_32) {
+	if (current_mtime != p_dir->modified_time || using_fat32_or_exfat) {
 
 		updated_dir = true;
 		p_dir->modified_time = current_mtime;
@@ -1855,8 +1855,8 @@ EditorFileSystem::EditorFileSystem() {
 	if (da->change_dir("res://.import") != OK) {
 		da->make_dir("res://.import");
 	}
-	//this should probably also work on Unix and use the string it returns for FAT32
-	using_fat_32 = da->get_filesystem_type() == "FAT32";
+	// This should probably also work on Unix and use the string it returns for FAT32 or exFAT
+	using_fat32_or_exfat = (da->get_filesystem_type() == "FAT32" || da->get_filesystem_type() == "exFAT");
 	memdelete(da);
 
 	scan_total = 0;

editor/editor_file_system.h

@@ -234,7 +234,7 @@ class EditorFileSystem : public Node {
 
 	static Error _resource_import(const String &p_path);
 
-	bool using_fat_32; //workaround for projects in FAT32 filesystem (pendrives, most of the time)
+	bool using_fat32_or_exfat; // Workaround for projects in FAT32 or exFAT filesystem (pendrives, most of the time)
 
 protected:
 	void _notification(int p_what);

main/main.cpp

@@ -1876,7 +1876,9 @@ bool Main::iteration() {
 
 	uint64_t idle_begin = OS::get_singleton()->get_ticks_usec();
 
-	OS::get_singleton()->get_main_loop()->idle(step * time_scale);
+	if (OS::get_singleton()->get_main_loop()->idle(step * time_scale)) {
+		exit = true;
+	}
 	message_queue->flush();
 
 	VisualServer::get_singleton()->sync(); //sync if still drawing from previous frames.

modules/bmp/image_loader_bmp.cpp

@@ -33,6 +33,7 @@
 Error ImageLoaderBMP::convert_to_image(Ref<Image> p_image,
 		const uint8_t *p_buffer,
 		const uint8_t *p_color_buffer,
+		const uint32_t color_table_size,
 		const bmp_header_s &p_header) {
 
 	Error err = OK;
@@ -46,32 +47,84 @@ Error ImageLoaderBMP::convert_to_image(Ref<Image> p_image,
 		size_t height = (size_t)p_header.bmp_info_header.bmp_height;
 		size_t bits_per_pixel = (size_t)p_header.bmp_info_header.bmp_bit_count;
 
-		if (p_header.bmp_info_header.bmp_compression != 0) {
-			err = FAILED;
-		}
+		// Check whether we can load it
 
-		if (!(bits_per_pixel == 24 || bits_per_pixel == 32)) {
-			err = FAILED;
-		}
+		if (bits_per_pixel == 1) {
+			// Requires bit unpacking...
+			ERR_FAIL_COND_V(width % 8 != 0, ERR_UNAVAILABLE);
+			ERR_FAIL_COND_V(height % 8 != 0, ERR_UNAVAILABLE);
+
+		} else if (bits_per_pixel == 4) {
+			// Requires bit unpacking...
+			ERR_FAIL_COND_V(width % 2 != 0, ERR_UNAVAILABLE);
+			ERR_FAIL_COND_V(height % 2 != 0, ERR_UNAVAILABLE);
 
+		} else if (bits_per_pixel == 16) {
+
+			ERR_FAIL_V(ERR_UNAVAILABLE);
+		}
 		if (err == OK) {
 
-			uint32_t line_width = ((p_header.bmp_info_header.bmp_width *
-										   p_header.bmp_info_header.bmp_bit_count / 8) +
-										  3) &
-								  ~3;
+			// Image data (might be indexed)
+			PoolVector<uint8_t> data;
+			int data_len = 0;
 
-			PoolVector<uint8_t> image_data;
-			err = image_data.resize(width * height * 4);
+			if (bits_per_pixel <= 8) { // indexed
+				data_len = width * height;
+			} else { // color
+				data_len = width * height * 4;
+			}
+			ERR_FAIL_COND_V(data_len == 0, ERR_BUG);
+			err = data.resize(data_len);
 
-			PoolVector<uint8_t>::Write image_data_w = image_data.write();
-			uint8_t *write_buffer = image_data_w.ptr();
+			PoolVector<uint8_t>::Write data_w = data.write();
+			uint8_t *write_buffer = data_w.ptr();
 
+			const uint32_t width_bytes = width * bits_per_pixel / 8;
+			const uint32_t line_width = (width_bytes + 3) & ~3;
+
+			// The actual data traversal is determined by
+			// the data width in case of 8/4/1 bit images
+			const uint32_t w = bits_per_pixel >= 24 ? width : width_bytes;
 			const uint8_t *line = p_buffer + (line_width * (height - 1));
+
 			for (unsigned int i = 0; i < height; i++) {
 				const uint8_t *line_ptr = line;
-				for (unsigned int j = 0; j < width; j++) {
+
+				for (unsigned int j = 0; j < w; j++) {
 					switch (bits_per_pixel) {
+						case 1: {
+							uint8_t color_index = *line_ptr;
+
+							write_buffer[index + 0] = (color_index >> 7) & 1;
+							write_buffer[index + 1] = (color_index >> 6) & 1;
+							write_buffer[index + 2] = (color_index >> 5) & 1;
+							write_buffer[index + 3] = (color_index >> 4) & 1;
+							write_buffer[index + 4] = (color_index >> 3) & 1;
+							write_buffer[index + 5] = (color_index >> 2) & 1;
+							write_buffer[index + 6] = (color_index >> 1) & 1;
+							write_buffer[index + 7] = (color_index >> 0) & 1;
+
+							index += 8;
+							line_ptr += 1;
+						} break;
+						case 4: {
+							uint8_t color_index = *line_ptr;
+
+							write_buffer[index + 0] = (color_index >> 4) & 0x0f;
+							write_buffer[index + 1] = color_index & 0x0f;
+
+							index += 2;
+							line_ptr += 1;
+						} break;
+						case 8: {
+							uint8_t color_index = *line_ptr;
+
+							write_buffer[index] = color_index;
+
+							index += 1;
+							line_ptr += 1;
+						} break;
 						case 24: {
 							uint32_t color = *((uint32_t *)line_ptr);
 
@@ -79,6 +132,7 @@ Error ImageLoaderBMP::convert_to_image(Ref<Image> p_image,
 							write_buffer[index + 1] = (color >> 8) & 0xff;
 							write_buffer[index + 0] = (color >> 16) & 0xff;
 							write_buffer[index + 3] = 0xff;
+
 							index += 4;
 							line_ptr += 3;
 						} break;
@@ -89,6 +143,7 @@ Error ImageLoaderBMP::convert_to_image(Ref<Image> p_image,
 							write_buffer[index + 1] = (color >> 8) & 0xff;
 							write_buffer[index + 0] = (color >> 16) & 0xff;
 							write_buffer[index + 3] = color >> 24;
+
 							index += 4;
 							line_ptr += 4;
 						} break;
@@ -96,7 +151,51 @@ Error ImageLoaderBMP::convert_to_image(Ref<Image> p_image,
 				}
 				line -= line_width;
 			}
-			p_image->create(width, height, 0, Image::FORMAT_RGBA8, image_data);
+
+			if (p_color_buffer == NULL || color_table_size == 0) { // regular pixels
+
+				p_image->create(width, height, 0, Image::FORMAT_RGBA8, data);
+
+			} else { // data is in indexed format, extend it
+
+				// Palette data
+				PoolVector<uint8_t> palette_data;
+				palette_data.resize(color_table_size * 4);
+
+				PoolVector<uint8_t>::Write palette_data_w = palette_data.write();
+				uint8_t *pal = palette_data_w.ptr();
+
+				const uint8_t *cb = p_color_buffer;
+
+				for (unsigned int i = 0; i < color_table_size; ++i) {
+					uint32_t color = *((uint32_t *)cb);
+
+					pal[i * 4 + 0] = (color >> 16) & 0xff;
+					pal[i * 4 + 1] = (color >> 8) & 0xff;
+					pal[i * 4 + 2] = (color)&0xff;
+					pal[i * 4 + 3] = 0xff;
+
+					cb += 4;
+				}
+				// Extend palette to image
+				PoolVector<uint8_t> extended_data;
+				extended_data.resize(data.size() * 4);
+
+				PoolVector<uint8_t>::Write ex_w = extended_data.write();
+				uint8_t *dest = ex_w.ptr();
+
+				const int num_pixels = width * height;
+
+				for (int i = 0; i < num_pixels; i++) {
+					dest[0] = pal[write_buffer[i] * 4 + 0];
+					dest[1] = pal[write_buffer[i] * 4 + 1];
+					dest[2] = pal[write_buffer[i] * 4 + 2];
+					dest[3] = pal[write_buffer[i] * 4 + 3];
+
+					dest += 4;
+				}
+				p_image->create(width, height, 0, Image::FORMAT_RGBA8, extended_data);
+			}
 		}
 	}
 	return err;
@@ -108,7 +207,9 @@ Error ImageLoaderBMP::load_image(Ref<Image> p_image, FileAccess *f,
 	bmp_header_s bmp_header;
 	Error err = ERR_INVALID_DATA;
 
-	if (f->get_len() > sizeof(bmp_header)) {
+	// A valid bmp file should always at least have a
+	// file header and a minimal info header
+	if (f->get_len() > BITMAP_FILE_HEADER_SIZE + BITMAP_INFO_HEADER_MIN_SIZE) {
 		// File Header
 		bmp_header.bmp_file_header.bmp_signature = f->get_16();
 		if (bmp_header.bmp_file_header.bmp_signature == BITMAP_SIGNATURE) {
@@ -118,9 +219,14 @@ Error ImageLoaderBMP::load_image(Ref<Image> p_image, FileAccess *f,
 
 			// Info Header
 			bmp_header.bmp_info_header.bmp_header_size = f->get_32();
+			ERR_FAIL_COND_V(bmp_header.bmp_info_header.bmp_header_size < BITMAP_INFO_HEADER_MIN_SIZE, ERR_FILE_CORRUPT);
+
 			bmp_header.bmp_info_header.bmp_width = f->get_32();
 			bmp_header.bmp_info_header.bmp_height = f->get_32();
+
 			bmp_header.bmp_info_header.bmp_planes = f->get_16();
+			ERR_FAIL_COND_V(bmp_header.bmp_info_header.bmp_planes != 1, ERR_FILE_CORRUPT);
+
 			bmp_header.bmp_info_header.bmp_bit_count = f->get_16();
 			bmp_header.bmp_info_header.bmp_compression = f->get_32();
 			bmp_header.bmp_info_header.bmp_size_image = f->get_32();
@@ -129,35 +235,39 @@ Error ImageLoaderBMP::load_image(Ref<Image> p_image, FileAccess *f,
 			bmp_header.bmp_info_header.bmp_colors_used = f->get_32();
 			bmp_header.bmp_info_header.bmp_important_colors = f->get_32();
 
-			bmp_header.bmp_info_header.bmp_red_mask = f->get_32();
-			bmp_header.bmp_info_header.bmp_green_mask = f->get_32();
-			bmp_header.bmp_info_header.bmp_blue_mask = f->get_32();
-			bmp_header.bmp_info_header.bmp_alpha_mask = f->get_32();
-			bmp_header.bmp_info_header.bmp_cs_type = f->get_32();
-			for (int i = 0; i < 9; i++)
-				bmp_header.bmp_info_header.bmp_endpoints[i] = f->get_32();
-
-			bmp_header.bmp_info_header.bmp_gamma_red = f->get_32();
-			bmp_header.bmp_info_header.bmp_gamma_green = f->get_32();
-			bmp_header.bmp_info_header.bmp_gamma_blue = f->get_32();
-
-			f->seek(sizeof(bmp_header.bmp_file_header) +
-					bmp_header.bmp_info_header.bmp_header_size);
+			switch (bmp_header.bmp_info_header.bmp_compression) {
+				case BI_RLE8:
+				case BI_RLE4:
+				case BI_CMYKRLE8:
+				case BI_CMYKRLE4: {
+					// Stop parsing
+					ERR_EXPLAIN("Compressed BMP files are not supported: " + f->get_path());
+					f->close();
+					ERR_FAIL_V(ERR_UNAVAILABLE);
+				} break;
+			}
+			// Don't rely on sizeof(bmp_file_header) as structure padding
+			// adds 2 bytes offset leading to misaligned color table reading
+			uint32_t ct_offset = BITMAP_FILE_HEADER_SIZE +
+								 bmp_header.bmp_info_header.bmp_header_size;
+			f->seek(ct_offset);
 
 			uint32_t color_table_size = 0;
-			if (bmp_header.bmp_info_header.bmp_bit_count == 1)
-				color_table_size = 2;
-			else if (bmp_header.bmp_info_header.bmp_bit_count == 4)
-				color_table_size = 16;
-			else if (bmp_header.bmp_info_header.bmp_bit_count == 8)
-				color_table_size = 256;
+
+			// bmp_colors_used may report 0 despite having a color table
+			// for 4 and 1 bit images, so don't rely on this information
+			if (bmp_header.bmp_info_header.bmp_bit_count <= 8) {
+				// Support 256 colors max
+				color_table_size = 1 << bmp_header.bmp_info_header.bmp_bit_count;
+				ERR_FAIL_COND_V(color_table_size == 0, ERR_BUG);
+			}
 
 			PoolVector<uint8_t> bmp_color_table;
 			if (color_table_size > 0) {
+				// Color table is usually 4 bytes per color -> [B][G][R][0]
 				err = bmp_color_table.resize(color_table_size * 4);
 				PoolVector<uint8_t>::Write bmp_color_table_w = bmp_color_table.write();
-				f->get_buffer(bmp_color_table_w.ptr(),
-						bmp_header.bmp_info_header.bmp_colors_used * 4);
+				f->get_buffer(bmp_color_table_w.ptr(), color_table_size * 4);
 			}
 
 			f->seek(bmp_header.bmp_file_header.bmp_file_offset);
@@ -174,7 +284,7 @@ Error ImageLoaderBMP::load_image(Ref<Image> p_image, FileAccess *f,
 				PoolVector<uint8_t>::Read bmp_buffer_r = bmp_buffer.read();
 				PoolVector<uint8_t>::Read bmp_color_table_r = bmp_color_table.read();
 				err = convert_to_image(p_image, bmp_buffer_r.ptr(),
-						bmp_color_table_r.ptr(), bmp_header);
+						bmp_color_table_r.ptr(), color_table_size, bmp_header);
 			}
 			f->close();
 		}

modules/bmp/image_loader_bmp.h

@@ -37,6 +37,22 @@ class ImageLoaderBMP : public ImageFormatLoader {
 protected:
 	static const unsigned BITMAP_SIGNATURE = 0x4d42;
 
+	static const unsigned BITMAP_FILE_HEADER_SIZE = 14; // bmp_file_header_s
+	static const unsigned BITMAP_INFO_HEADER_MIN_SIZE = 40; // bmp_info_header_s
+
+	enum bmp_compression_s {
+		BI_RGB = 0x00,
+		BI_RLE8 = 0x01, // compressed
+		BI_RLE4 = 0x02, // compressed
+		BI_BITFIELDS = 0x03,
+		BI_JPEG = 0x04,
+		BI_PNG = 0x05,
+		BI_ALPHABITFIELDS = 0x06,
+		BI_CMYK = 0x0b,
+		BI_CMYKRLE8 = 0x0c, // compressed
+		BI_CMYKRLE4 = 0x0d // compressed
+	};
+
 	struct bmp_header_s {
 		struct bmp_file_header_s {
 			uint16_t bmp_signature;
@@ -57,21 +73,13 @@ protected:
 			uint32_t bmp_pixels_per_meter_y;
 			uint32_t bmp_colors_used;
 			uint32_t bmp_important_colors;
-			uint32_t bmp_red_mask;
-			uint32_t bmp_green_mask;
-			uint32_t bmp_blue_mask;
-			uint32_t bmp_alpha_mask;
-			uint32_t bmp_cs_type;
-			uint32_t bmp_endpoints[9];
-			uint32_t bmp_gamma_red;
-			uint32_t bmp_gamma_green;
-			uint32_t bmp_gamma_blue;
 		} bmp_info_header;
 	};
 
 	static Error convert_to_image(Ref<Image> p_image,
 			const uint8_t *p_buffer,
 			const uint8_t *p_color_buffer,
+			const uint32_t color_table_size,
 			const bmp_header_s &p_header);
 
 public:

modules/gdnative/videodecoder/video_stream_gdnative.cpp

@@ -146,23 +146,25 @@ void VideoStreamPlaybackGDNative::update(float p_delta) {
 	ERR_FAIL_COND(interface == NULL);
 	interface->update(data_struct, p_delta);
 
-	if (pcm_write_idx >= 0) {
-		// Previous remains
-		int mixed = mix_callback(mix_udata, pcm, samples_decoded);
-		if (mixed == samples_decoded) {
-			pcm_write_idx = -1;
-		} else {
-			samples_decoded -= mixed;
-			pcm_write_idx += mixed;
+	if (mix_callback) {
+		if (pcm_write_idx >= 0) {
+			// Previous remains
+			int mixed = mix_callback(mix_udata, pcm, samples_decoded);
+			if (mixed == samples_decoded) {
+				pcm_write_idx = -1;
+			} else {
+				samples_decoded -= mixed;
+				pcm_write_idx += mixed;
+			}
 		}
-	}
-	if (pcm_write_idx < 0) {
-		samples_decoded = interface->get_audioframe(data_struct, pcm, AUX_BUFFER_SIZE);
-		pcm_write_idx = mix_callback(mix_udata, pcm, samples_decoded);
-		if (pcm_write_idx == samples_decoded) {
-			pcm_write_idx = -1;
-		} else {
-			samples_decoded -= pcm_write_idx;
+		if (pcm_write_idx < 0) {
+			samples_decoded = interface->get_audioframe(data_struct, pcm, AUX_BUFFER_SIZE);
+			pcm_write_idx = mix_callback(mix_udata, pcm, samples_decoded);
+			if (pcm_write_idx == samples_decoded) {
+				pcm_write_idx = -1;
+			} else {
+				samples_decoded -= pcm_write_idx;
+			}
 		}
 	}
 

modules/gdscript/gdscript.cpp

@@ -226,7 +226,7 @@ void GDScript::get_script_method_list(List<MethodInfo> *p_list) const {
 
 	const GDScript *current = this;
 	while (current) {
-		for (const Map<StringName, GDScriptFunction *>::Element *E = member_functions.front(); E; E = E->next()) {
+		for (const Map<StringName, GDScriptFunction *>::Element *E = current->member_functions.front(); E; E = E->next()) {
 			GDScriptFunction *func = E->get();
 			MethodInfo mi;
 			mi.name = E->key();

modules/gdscript/gdscript_editor.cpp

@@ -1947,7 +1947,7 @@ static void _find_identifiers_in_base(const GDScriptCompletionContext &p_context
 					} else {
 						base_type.has_type = script->get_instance_base_type() != StringName();
 						base_type.kind = GDScriptParser::DataType::NATIVE;
-						base_type.script_type = script->get_instance_base_type();
+						base_type.native_type = script->get_instance_base_type();
 					}
 				} else {
 					return;

platform/x11/context_gl_x11.cpp

@@ -191,6 +191,7 @@ Error ContextGL_X11::initialize() {
 
 	swa.colormap = XCreateColormap(x11_display, RootWindow(x11_display, vi->screen), vi->visual, AllocNone);
 	x11_window = XCreateWindow(x11_display, RootWindow(x11_display, vi->screen), 0, 0, OS::get_singleton()->get_video_mode().width, OS::get_singleton()->get_video_mode().height, 0, vi->depth, InputOutput, vi->visual, valuemask, &swa);
+	XStoreName(x11_display, x11_window, "Godot Engine");
 
 	ERR_FAIL_COND_V(!x11_window, ERR_UNCONFIGURED);
 	set_class_hint(x11_display, x11_window);

scene/2d/cpu_particles_2d.cpp

@@ -84,7 +84,9 @@ void CPUParticles2D::set_randomness_ratio(float p_ratio) {
 void CPUParticles2D::set_use_local_coordinates(bool p_enable) {
 
 	local_coords = p_enable;
+	set_notify_transform(!p_enable);
 }
+
 void CPUParticles2D::set_speed_scale(float p_scale) {
 
 	speed_scale = p_scale;
@@ -864,11 +866,6 @@ void CPUParticles2D::_update_particle_data_buffer() {
 		PoolVector<Particle>::Read r = particles.read();
 		float *ptr = w.ptr();
 
-		Transform2D un_transform;
-		if (!local_coords) {
-			un_transform = get_global_transform().affine_inverse();
-		}
-
 		if (draw_order != DRAW_ORDER_INDEX) {
 			ow = particle_order.write();
 			order = ow.ptr();
@@ -890,7 +887,7 @@ void CPUParticles2D::_update_particle_data_buffer() {
 			Transform2D t = r[idx].transform;
 
 			if (!local_coords) {
-				t = un_transform * t;
+				t = inv_emission_transform * t;
 			}
 
 			if (r[idx].active) {
@@ -939,9 +936,13 @@ void CPUParticles2D::_set_redraw(bool p_redraw) {
 	if (redraw) {
 		VS::get_singleton()->connect("frame_pre_draw", this, "_update_render_thread");
 		VS::get_singleton()->canvas_item_set_update_when_visible(get_canvas_item(), true);
+
+		VS::get_singleton()->multimesh_set_visible_instances(multimesh, -1);
 	} else {
 		VS::get_singleton()->disconnect("frame_pre_draw", this, "_update_render_thread");
 		VS::get_singleton()->canvas_item_set_update_when_visible(get_canvas_item(), false);
+
+		VS::get_singleton()->multimesh_set_visible_instances(multimesh, 0);
 	}
 #ifndef NO_THREADS
 	update_mutex->unlock();
@@ -1059,6 +1060,42 @@ void CPUParticles2D::_notification(int p_what) {
 
 		_update_particle_data_buffer();
 	}
+
+	if (p_what == NOTIFICATION_TRANSFORM_CHANGED) {
+
+		inv_emission_transform = get_global_transform().affine_inverse();
+
+		if (!local_coords) {
+
+			int pc = particles.size();
+
+			PoolVector<float>::Write w = particle_data.write();
+			PoolVector<Particle>::Read r = particles.read();
+			float *ptr = w.ptr();
+
+			for (int i = 0; i < pc; i++) {
+
+				Transform2D t = inv_emission_transform * r[i].transform;
+
+				if (r[i].active) {
+
+					ptr[0] = t.elements[0][0];
+					ptr[1] = t.elements[1][0];
+					ptr[2] = 0;
+					ptr[3] = t.elements[2][0];
+					ptr[4] = t.elements[0][1];
+					ptr[5] = t.elements[1][1];
+					ptr[6] = 0;
+					ptr[7] = t.elements[2][1];
+
+				} else {
+					zeromem(ptr, sizeof(float) * 8);
+				}
+
+				ptr += 13;
+			}
+		}
+	}
 }
 
 void CPUParticles2D::convert_from_particles(Node *p_particles) {

scene/2d/cpu_particles_2d.h

@@ -142,6 +142,8 @@ private:
 	int fixed_fps;
 	bool fractional_delta;
 
+	Transform2D inv_emission_transform;
+
 	DrawOrder draw_order;
 
 	Ref<Texture> texture;

scene/2d/parallax_layer.cpp

@@ -105,6 +105,11 @@ void ParallaxLayer::_notification(int p_what) {
 			orig_scale = get_scale();
 			_update_mirroring();
 		} break;
+		case NOTIFICATION_EXIT_TREE: {
+
+			set_position(orig_offset);
+			set_scale(orig_scale);
+		} break;
 	}
 }
 

scene/3d/cpu_particles.cpp

@@ -909,11 +909,6 @@ void CPUParticles::_update_particle_data_buffer() {
 		PoolVector<Particle>::Read r = particles.read();
 		float *ptr = w.ptr();
 
-		Transform un_transform;
-		if (!local_coords) {
-			un_transform = get_global_transform().affine_inverse();
-		}
-
 		if (draw_order != DRAW_ORDER_INDEX) {
 			ow = particle_order.write();
 			order = ow.ptr();
@@ -931,7 +926,12 @@ void CPUParticles::_update_particle_data_buffer() {
 					Vector3 dir = c->get_global_transform().basis.get_axis(2); //far away to close
 
 					if (local_coords) {
-						dir = un_transform.basis.xform(dir).normalized();
+
+						// will look different from Particles in editor as this is based on the camera in the scenetree
+						// and not the editor camera
+						dir = inv_emission_transform.xform(dir).normalized();
+					} else {
+						dir = dir.normalized();
 					}
 
 					SortArray<int, SortAxis> sorter;
@@ -949,7 +949,7 @@ void CPUParticles::_update_particle_data_buffer() {
 			Transform t = r[idx].transform;
 
 			if (!local_coords) {
-				t = un_transform * t;
+				t = inv_emission_transform * t;
 			}
 
 			if (r[idx].active) {
@@ -1114,6 +1114,46 @@ void CPUParticles::_notification(int p_what) {
 			_update_particle_data_buffer();
 		}
 	}
+
+	if (p_what == NOTIFICATION_TRANSFORM_CHANGED) {
+
+		inv_emission_transform = get_global_transform().affine_inverse();
+
+		if (!local_coords) {
+
+			int pc = particles.size();
+
+			PoolVector<float>::Write w = particle_data.write();
+			PoolVector<Particle>::Read r = particles.read();
+			float *ptr = w.ptr();
+
+			for (int i = 0; i < pc; i++) {
+
+				Transform t = inv_emission_transform * r[i].transform;
+
+				if (r[i].active) {
+					ptr[0] = t.basis.elements[0][0];
+					ptr[1] = t.basis.elements[0][1];
+					ptr[2] = t.basis.elements[0][2];
+					ptr[3] = t.origin.x;
+					ptr[4] = t.basis.elements[1][0];
+					ptr[5] = t.basis.elements[1][1];
+					ptr[6] = t.basis.elements[1][2];
+					ptr[7] = t.origin.y;
+					ptr[8] = t.basis.elements[2][0];
+					ptr[9] = t.basis.elements[2][1];
+					ptr[10] = t.basis.elements[2][2];
+					ptr[11] = t.origin.z;
+				} else {
+					zeromem(ptr, sizeof(float) * 12);
+				}
+
+				ptr += 17;
+			}
+
+			can_update = true;
+		}
+	}
 }
 
 void CPUParticles::convert_from_particles(Node *p_particles) {
@@ -1391,6 +1431,8 @@ CPUParticles::CPUParticles() {
 	cycle = 0;
 	redraw = false;
 
+	set_notify_transform(true);
+
 	multimesh = VisualServer::get_singleton()->multimesh_create();
 	set_base(multimesh);
 

scene/3d/cpu_particles.h

@@ -116,7 +116,7 @@ private:
 		const Particle *particles;
 
 		bool operator()(int p_a, int p_b) const {
-			return particles[p_a].time < particles[p_b].time;
+			return particles[p_a].time > particles[p_b].time;
 		}
 	};
 
@@ -142,6 +142,8 @@ private:
 	int fixed_fps;
 	bool fractional_delta;
 
+	Transform inv_emission_transform;
+
 	volatile bool can_update;
 
 	DrawOrder draw_order;

scene/gui/popup_menu.cpp

@@ -594,7 +594,7 @@ void PopupMenu::add_item(const String &p_label, int p_ID, uint32_t p_accel) {
 	item.text = p_label;
 	item.xl_text = tr(p_label);
 	item.accel = p_accel;
-	item.ID = p_ID;
+	item.ID = p_ID == -1 ? items.size() : p_ID;
 	items.push_back(item);
 	update();
 	minimum_size_changed();
@@ -632,7 +632,7 @@ void PopupMenu::add_check_item(const String &p_label, int p_ID, uint32_t p_accel
 	item.text = p_label;
 	item.xl_text = tr(p_label);
 	item.accel = p_accel;
-	item.ID = p_ID;
+	item.ID = p_ID == -1 ? items.size() : p_ID;
 	item.checkable_type = Item::CHECKABLE_TYPE_CHECK_BOX;
 	items.push_back(item);
 	update();

scene/gui/tab_container.cpp

@@ -719,6 +719,7 @@ void TabContainer::set_tab_title(int p_tab, const String &p_title) {
 	Control *child = _get_tab(p_tab);
 	ERR_FAIL_COND(!child);
 	child->set_meta("_tab_name", p_title);
+	update();
 }
 
 String TabContainer::get_tab_title(int p_tab) const {
@@ -736,6 +737,7 @@ void TabContainer::set_tab_icon(int p_tab, const Ref<Texture> &p_icon) {
 	Control *child = _get_tab(p_tab);
 	ERR_FAIL_COND(!child);
 	child->set_meta("_tab_icon", p_icon);
+	update();
 }
 Ref<Texture> TabContainer::get_tab_icon(int p_tab) const {
 

scene/register_scene_types.cpp

@@ -762,7 +762,11 @@ void unregister_scene_types() {
 	ResourceLoader::remove_resource_format_loader(resource_loader_bmfont);
 	resource_loader_bmfont.unref();
 
+	//SpatialMaterial is not initialised when 3D is disabled, so it shouldn't be cleaned up either
+#ifndef _3D_DISABLED
 	SpatialMaterial::finish_shaders();
+#endif // _3D_DISABLED
+
 	ParticlesMaterial::finish_shaders();
 	CanvasItemMaterial::finish_shaders();
 	SceneStringNames::free();

scene/resources/curve.cpp

@@ -782,7 +782,8 @@ Vector2 Curve2D::interpolate_baked(float p_offset, bool p_cubic) const {
 	if (idx >= bpc - 1) {
 		return r[bpc - 1];
 	} else if (idx == bpc - 2) {
-		frac /= Math::fmod(baked_max_ofs, bake_interval);
+		if (frac > 0)
+			frac /= Math::fmod(baked_max_ofs, bake_interval);
 	} else {
 		frac /= bake_interval;
 	}
@@ -1352,7 +1353,8 @@ Vector3 Curve3D::interpolate_baked(float p_offset, bool p_cubic) const {
 	if (idx >= bpc - 1) {
 		return r[bpc - 1];
 	} else if (idx == bpc - 2) {
-		frac /= Math::fmod(baked_max_ofs, bake_interval);
+		if (frac > 0)
+			frac /= Math::fmod(baked_max_ofs, bake_interval);
 	} else {
 		frac /= bake_interval;
 	}
@@ -1396,7 +1398,8 @@ float Curve3D::interpolate_baked_tilt(float p_offset) const {
 	if (idx >= bpc - 1) {
 		return r[bpc - 1];
 	} else if (idx == bpc - 2) {
-		frac /= Math::fmod(baked_max_ofs, bake_interval);
+		if (frac > 0)
+			frac /= Math::fmod(baked_max_ofs, bake_interval);
 	} else {
 		frac /= bake_interval;
 	}

scene/resources/dynamic_font.cpp

@@ -1008,7 +1008,7 @@ void DynamicFont::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_fallback_count"), &DynamicFont::get_fallback_count);
 
 	ADD_GROUP("Settings", "");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "size"), "set_size", "get_size");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "size", PROPERTY_HINT_RANGE, "1,255,1"), "set_size", "get_size");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "outline_size", PROPERTY_HINT_RANGE, "0,255,1"), "set_outline_size", "get_outline_size");
 	ADD_PROPERTY(PropertyInfo(Variant::COLOR, "outline_color"), "set_outline_color", "get_outline_color");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "use_mipmaps"), "set_use_mipmaps", "get_use_mipmaps");