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

Merge pull request #32397 from akien-mga/3.1 

Assorted cherry-picks from the master branch for Godot 3.1.2
This commit is contained in:
Rémi Verschelde 2019-09-28 07:37:25 +02:00 committed by GitHub
parent 9bd5501a22 5acb21dd7b
commit 8f3fea2058
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
20 changed files with 314 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
drivers/gles2/rasterizer_storage_gles2.cpp
View File

@ -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);

6
editor/editor_file_system.cpp
View File

@ -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;

2
editor/editor_file_system.h
View File

@ -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);

4
main/main.cpp
View File

@ -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.

190
modules/bmp/image_loader_bmp.cpp
View File

@ -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();
}

26
modules/bmp/image_loader_bmp.h
View File

@ -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:

34
modules/gdnative/videodecoder/video_stream_gdnative.cpp
View File

@ -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;
}
}
}

2
modules/gdscript/gdscript.cpp
View File

@ -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();

2
modules/gdscript/gdscript_editor.cpp
View File

@ -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;

1
platform/x11/context_gl_x11.cpp
View File

@ -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);

49
scene/2d/cpu_particles_2d.cpp
View File

@ -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) {

2
scene/2d/cpu_particles_2d.h
View File

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

5
scene/2d/parallax_layer.cpp
View File

@ -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;
}
}

56
scene/3d/cpu_particles.cpp
View File

@ -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);

4
scene/3d/cpu_particles.h
View File

@ -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;

4
scene/gui/popup_menu.cpp
View File

@ -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();

2
scene/gui/tab_container.cpp
View File

@ -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 {

4
scene/register_scene_types.cpp
View File

@ -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();

9
scene/resources/curve.cpp
View File

@ -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;
}

2
scene/resources/dynamic_font.cpp
View File

@ -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");