void _update(uint64_t p_frame) { if (p_frame == last_frame) return; last_frame = p_frame; if (!changed) return; for (Map<Camera *, CameraData>::Element *E = cameras.front(); E; E = E->next()) { pass++; Camera *c = E->key(); Vector<Plane> planes = c->get_frustum(); int culled = octree.cull_convex(planes, cull.ptrw(), cull.size()); VisibilityNotifier **ptr = cull.ptrw(); List<VisibilityNotifier *> added; List<VisibilityNotifier *> removed; for (int i = 0; i < culled; i++) { //notifiers in frustum Map<VisibilityNotifier *, uint64_t>::Element *H = E->get().notifiers.find(ptr[i]); if (!H) { E->get().notifiers.insert(ptr[i], pass); added.push_back(ptr[i]); } else { H->get() = pass; } } for (Map<VisibilityNotifier *, uint64_t>::Element *F = E->get().notifiers.front(); F; F = F->next()) { if (F->get() != pass) removed.push_back(F->key()); } while (!added.empty()) { added.front()->get()->_enter_camera(E->key()); added.pop_front(); } while (!removed.empty()) { E->get().notifiers.erase(removed.front()->get()); removed.front()->get()->_exit_camera(E->key()); removed.pop_front(); } } changed = false; }
Error ResourceImporterImage::import(const String &p_source_file, const String &p_save_path, const Map<StringName, Variant> &p_options, List<String> *r_platform_variants, List<String> *r_gen_files) { FileAccess *f = FileAccess::open(p_source_file, FileAccess::READ); if (!f) { ERR_FAIL_COND_V(!f, ERR_CANT_OPEN); } size_t len = f->get_len(); Vector<uint8_t> data; data.resize(len); f->get_buffer(data.ptrw(), len); memdelete(f); f = FileAccess::open(p_save_path + ".image", FileAccess::WRITE); //save the header GDIM const uint8_t header[4] = { 'G', 'D', 'I', 'M' }; f->store_buffer(header, 4); //SAVE the extension (so it can be recognized by the loader later f->store_pascal_string(p_source_file.get_extension().to_lower()); //SAVE the actual image f->store_buffer(data.ptr(), len); memdelete(f); return OK; }
Vector<uint8_t> FileAccess::get_file_as_array(const String &p_path) { FileAccess *f = FileAccess::open(p_path, READ); ERR_FAIL_COND_V(!f, Vector<uint8_t>()); Vector<uint8_t> data; data.resize(f->get_len()); f->get_buffer(data.ptrw(), data.size()); memdelete(f); return data; }
void FileAccessEncrypted::close() { if (!file) return; if (writing) { Vector<uint8_t> compressed; size_t len = data.size(); if (len % 16) { len += 16 - (len % 16); } MD5_CTX md5; MD5Init(&md5); MD5Update(&md5, (uint8_t *)data.ptr(), data.size()); MD5Final(&md5); compressed.resize(len); zeromem(compressed.ptrw(), len); for (int i = 0; i < data.size(); i++) { compressed.write[i] = data[i]; } aes256_context ctx; aes256_init(&ctx, key.ptrw()); for (size_t i = 0; i < len; i += 16) { aes256_encrypt_ecb(&ctx, &compressed.write[i]); } aes256_done(&ctx); file->store_32(COMP_MAGIC); file->store_32(mode); file->store_buffer(md5.digest, 16); file->store_64(data.size()); file->store_buffer(compressed.ptr(), compressed.size()); file->close(); memdelete(file); file = NULL; data.clear(); } else { file->close(); memdelete(file); data.clear(); file = NULL; } }
bool GodotSharpExport::_add_file(const String &p_src_path, const String &p_dst_path, bool p_remap) { FileAccessRef f = FileAccess::open(p_src_path, FileAccess::READ); ERR_FAIL_COND_V(!f, false); Vector<uint8_t> data; data.resize(f->get_len()); f->get_buffer(data.ptrw(), data.size()); add_file(p_dst_path, data, p_remap); return true; }
void FileAccessCompressed::close() { if (!f) return; if (writing) { //save block table and all compressed blocks CharString mgc = magic.utf8(); f->store_buffer((const uint8_t *)mgc.get_data(), mgc.length()); //write header 4 f->store_32(cmode); //write compression mode 4 f->store_32(block_size); //write block size 4 f->store_32(write_max); //max amount of data written 4 int bc = (write_max / block_size) + 1; for (int i = 0; i < bc; i++) { f->store_32(0); //compressed sizes, will update later } Vector<int> block_sizes; for (int i = 0; i < bc; i++) { int bl = i == (bc - 1) ? write_max % block_size : block_size; uint8_t *bp = &write_ptr[i * block_size]; Vector<uint8_t> cblock; cblock.resize(Compression::get_max_compressed_buffer_size(bl, cmode)); int s = Compression::compress(cblock.ptrw(), bp, bl, cmode); f->store_buffer(cblock.ptr(), s); block_sizes.push_back(s); } f->seek(16); //ok write block sizes for (int i = 0; i < bc; i++) f->store_32(block_sizes[i]); f->seek_end(); f->store_buffer((const uint8_t *)mgc.get_data(), mgc.length()); //magic at the end too buffer.clear(); } else { comp_buffer.clear(); buffer.clear(); read_blocks.clear(); } memdelete(f); f = NULL; }
Error DocData::load_compressed(const uint8_t *p_data, int p_compressed_size, int p_uncompressed_size) { Vector<uint8_t> data; data.resize(p_uncompressed_size); Compression::decompress(data.ptrw(), p_uncompressed_size, p_data, p_compressed_size, Compression::MODE_DEFLATE); class_list.clear(); Ref<XMLParser> parser = memnew(XMLParser); Error err = parser->open_buffer(data); if (err) return err; _load(parser); return OK; }
MainLoop *test() { print_line("this is test io"); DirAccess *da = DirAccess::create(DirAccess::ACCESS_FILESYSTEM); da->change_dir("."); print_line("Opening current dir " + da->get_current_dir()); String entry; da->list_dir_begin(); while ((entry = da->get_next()) != "") { print_line("entry " + entry + " is dir: " + Variant(da->current_is_dir())); }; da->list_dir_end(); RES texture = ResourceLoader::load("test_data/rock.png"); ERR_FAIL_COND_V(texture.is_null(), NULL); ResourceSaver::save("test_data/rock.xml", texture); print_line("localize paths"); print_line(ProjectSettings::get_singleton()->localize_path("algo.xml")); print_line(ProjectSettings::get_singleton()->localize_path("c:\\windows\\algo.xml")); print_line(ProjectSettings::get_singleton()->localize_path(ProjectSettings::get_singleton()->get_resource_path() + "/something/something.xml")); print_line(ProjectSettings::get_singleton()->localize_path("somedir/algo.xml")); { FileAccess *z = FileAccess::open("test_data/archive.zip", FileAccess::READ); int len = z->get_len(); Vector<uint8_t> zip; zip.resize(len); z->get_buffer(zip.ptrw(), len); z->close(); memdelete(z); FileAccessMemory::register_file("a_package", zip); FileAccess::make_default<FileAccessMemory>(FileAccess::ACCESS_RESOURCES); FileAccess::make_default<FileAccessMemory>(FileAccess::ACCESS_FILESYSTEM); FileAccess::make_default<FileAccessMemory>(FileAccess::ACCESS_USERDATA); print_line("archive test"); }; print_line("test done"); return memnew(TestMainLoop); }
bool grow() { if (vector.resize(next_power_of_2(1 + written)) != OK) { return false; } if (buffer == stack_buffer) { // first chunk? for (int i = 0; i < written; i++) { vector.write[i] = stack_buffer[i]; } } buffer = vector.ptrw(); capacity = vector.size(); ERR_FAIL_COND_V(written >= capacity, false); return true; }
void ExportTemplateManager::_install_from_file(const String &p_file, bool p_use_progress) { FileAccess *fa = NULL; zlib_filefunc_def io = zipio_create_io_from_file(&fa); unzFile pkg = unzOpen2(p_file.utf8().get_data(), &io); if (!pkg) { EditorNode::get_singleton()->show_warning(TTR("Can't open export templates zip.")); return; } int ret = unzGoToFirstFile(pkg); int fc = 0; //count them and find version String version; while (ret == UNZ_OK) { unz_file_info info; char fname[16384]; ret = unzGetCurrentFileInfo(pkg, &info, fname, 16384, NULL, 0, NULL, 0); String file = fname; if (file.ends_with("version.txt")) { Vector<uint8_t> data; data.resize(info.uncompressed_size); //read unzOpenCurrentFile(pkg); ret = unzReadCurrentFile(pkg, data.ptrw(), data.size()); unzCloseCurrentFile(pkg); String data_str; data_str.parse_utf8((const char *)data.ptr(), data.size()); data_str = data_str.strip_edges(); // Version number should be of the form major.minor[.patch].status[.module_config] // so it can in theory have 3 or more slices. if (data_str.get_slice_count(".") < 3) { EditorNode::get_singleton()->show_warning(vformat(TTR("Invalid version.txt format inside templates: %s."), data_str)); unzClose(pkg); return; } version = data_str; } if (file.get_file().size() != 0) { fc++; } ret = unzGoToNextFile(pkg); } if (version == String()) { EditorNode::get_singleton()->show_warning(TTR("No version.txt found inside templates.")); unzClose(pkg); return; } String template_path = EditorSettings::get_singleton()->get_templates_dir().plus_file(version); DirAccess *d = DirAccess::create(DirAccess::ACCESS_FILESYSTEM); Error err = d->make_dir_recursive(template_path); if (err != OK) { EditorNode::get_singleton()->show_warning(TTR("Error creating path for templates:") + "\n" + template_path); unzClose(pkg); return; } memdelete(d); ret = unzGoToFirstFile(pkg); EditorProgress *p = NULL; if (p_use_progress) { p = memnew(EditorProgress("ltask", TTR("Extracting Export Templates"), fc)); } fc = 0; while (ret == UNZ_OK) { //get filename unz_file_info info; char fname[16384]; unzGetCurrentFileInfo(pkg, &info, fname, 16384, NULL, 0, NULL, 0); String file = String(fname).get_file(); if (file.size() == 0) { ret = unzGoToNextFile(pkg); continue; } Vector<uint8_t> data; data.resize(info.uncompressed_size); //read unzOpenCurrentFile(pkg); unzReadCurrentFile(pkg, data.ptrw(), data.size()); unzCloseCurrentFile(pkg); if (p) { p->step(TTR("Importing:") + " " + file, fc); } FileAccess *f = FileAccess::open(template_path.plus_file(file), FileAccess::WRITE); if (!f) { ret = unzGoToNextFile(pkg); fc++; ERR_CONTINUE(!f); } f->store_buffer(data.ptr(), data.size()); memdelete(f); ret = unzGoToNextFile(pkg); fc++; } if (p) { memdelete(p); } unzClose(pkg); _update_template_list(); }
void FileAccessNetworkClient::_thread_func() { client->set_no_delay(true); while (!quit) { DEBUG_PRINT("SEM WAIT - " + itos(sem->get())); Error err = sem->wait(); if (err != OK) ERR_PRINT("sem->wait() failed"); DEBUG_TIME("sem_unlock"); //DEBUG_PRINT("semwait returned "+itos(werr)); DEBUG_PRINT("MUTEX LOCK " + itos(lockcount)); lock_mutex(); DEBUG_PRINT("MUTEX PASS"); blockrequest_mutex->lock(); while (block_requests.size()) { put_32(block_requests.front()->get().id); put_32(FileAccessNetwork::COMMAND_READ_BLOCK); put_64(block_requests.front()->get().offset); put_32(block_requests.front()->get().size); block_requests.pop_front(); } blockrequest_mutex->unlock(); DEBUG_PRINT("THREAD ITER"); DEBUG_TIME("sem_read"); int id = get_32(); int response = get_32(); DEBUG_PRINT("GET RESPONSE: " + itos(response)); FileAccessNetwork *fa = NULL; if (response != FileAccessNetwork::RESPONSE_DATA) { if (!accesses.has(id)) { unlock_mutex(); ERR_FAIL_COND(!accesses.has(id)); } } if (accesses.has(id)) fa = accesses[id]; switch (response) { case FileAccessNetwork::RESPONSE_OPEN: { DEBUG_TIME("sem_open"); int status = get_32(); if (status != OK) { fa->_respond(0, Error(status)); } else { uint64_t len = get_64(); fa->_respond(len, Error(status)); } fa->sem->post(); } break; case FileAccessNetwork::RESPONSE_DATA: { int64_t offset = get_64(); uint32_t len = get_32(); Vector<uint8_t> block; block.resize(len); client->get_data(block.ptrw(), len); if (fa) //may have been queued fa->_set_block(offset, block); } break; case FileAccessNetwork::RESPONSE_FILE_EXISTS: { int status = get_32(); fa->exists_modtime = status != 0; fa->sem->post(); } break; case FileAccessNetwork::RESPONSE_GET_MODTIME: { uint64_t status = get_64(); fa->exists_modtime = status; fa->sem->post(); } break; } unlock_mutex(); } }
String RegEx::sub(const String &p_subject, const String &p_replacement, bool p_all, int p_offset, int p_end) const { ERR_FAIL_COND_V(!is_valid(), String()); // safety_zone is the number of chars we allocate in addition to the number of chars expected in order to // guard against the PCRE API writing one additional \0 at the end. PCRE's API docs are unclear on whether // PCRE understands outlength in pcre2_substitute() as counting an implicit additional terminating char or // not. always allocating one char more than telling PCRE has us on the safe side. const int safety_zone = 1; PCRE2_SIZE olength = p_subject.length() + 1; // space for output string and one terminating \0 character Vector<CharType> output; output.resize(olength + safety_zone); uint32_t flags = PCRE2_SUBSTITUTE_OVERFLOW_LENGTH; if (p_all) flags |= PCRE2_SUBSTITUTE_GLOBAL; PCRE2_SIZE length = p_subject.length(); if (p_end >= 0 && (uint32_t)p_end < length) length = p_end; if (sizeof(CharType) == 2) { pcre2_code_16 *c = (pcre2_code_16 *)code; pcre2_general_context_16 *gctx = (pcre2_general_context_16 *)general_ctx; pcre2_match_context_16 *mctx = pcre2_match_context_create_16(gctx); PCRE2_SPTR16 s = (PCRE2_SPTR16)p_subject.c_str(); PCRE2_SPTR16 r = (PCRE2_SPTR16)p_replacement.c_str(); PCRE2_UCHAR16 *o = (PCRE2_UCHAR16 *)output.ptrw(); pcre2_match_data_16 *match = pcre2_match_data_create_from_pattern_16(c, gctx); int res = pcre2_substitute_16(c, s, length, p_offset, flags, match, mctx, r, p_replacement.length(), o, &olength); if (res == PCRE2_ERROR_NOMEMORY) { output.resize(olength + safety_zone); o = (PCRE2_UCHAR16 *)output.ptrw(); res = pcre2_substitute_16(c, s, length, p_offset, flags, match, mctx, r, p_replacement.length(), o, &olength); } pcre2_match_data_free_16(match); pcre2_match_context_free_16(mctx); if (res < 0) return String(); } else { pcre2_code_32 *c = (pcre2_code_32 *)code; pcre2_general_context_32 *gctx = (pcre2_general_context_32 *)general_ctx; pcre2_match_context_32 *mctx = pcre2_match_context_create_32(gctx); PCRE2_SPTR32 s = (PCRE2_SPTR32)p_subject.c_str(); PCRE2_SPTR32 r = (PCRE2_SPTR32)p_replacement.c_str(); PCRE2_UCHAR32 *o = (PCRE2_UCHAR32 *)output.ptrw(); pcre2_match_data_32 *match = pcre2_match_data_create_from_pattern_32(c, gctx); int res = pcre2_substitute_32(c, s, length, p_offset, flags, match, mctx, r, p_replacement.length(), o, &olength); if (res == PCRE2_ERROR_NOMEMORY) { output.resize(olength + safety_zone); o = (PCRE2_UCHAR32 *)output.ptrw(); res = pcre2_substitute_32(c, s, length, p_offset, flags, match, mctx, r, p_replacement.length(), o, &olength); } pcre2_match_data_free_32(match); pcre2_match_context_free_32(mctx); if (res < 0) return String(); } return String(output.ptr(), olength); }
Array PhysicsDirectSpaceState::_intersect_shape(const Ref<PhysicsShapeQueryParameters> &p_shape_query, int p_max_results) { Vector<ShapeResult> sr; sr.resize(p_max_results); int rc = intersect_shape(p_shape_query->shape, p_shape_query->transform, p_shape_query->margin, sr.ptrw(), sr.size(), p_shape_query->exclude, p_shape_query->collision_mask); Array ret; ret.resize(rc); for (int i = 0; i < rc; i++) { Dictionary d; d["rid"] = sr[i].rid; d["collider_id"] = sr[i].collider_id; d["collider"] = sr[i].collider; d["shape"] = sr[i].shape; ret[i] = d; } return ret; }
Array PhysicsDirectSpaceState::_collide_shape(const Ref<PhysicsShapeQueryParameters> &p_shape_query, int p_max_results) { Vector<Vector3> ret; ret.resize(p_max_results * 2); int rc = 0; bool res = collide_shape(p_shape_query->shape, p_shape_query->transform, p_shape_query->margin, ret.ptrw(), p_max_results, rc, p_shape_query->exclude, p_shape_query->collision_mask); if (!res) return Array(); Array r; r.resize(rc * 2); for (int i = 0; i < rc * 2; i++) r[i] = ret[i]; return r; }
void Polygon2D::_notification(int p_what) { switch (p_what) { case NOTIFICATION_DRAW: { if (polygon.size() < 3) return; Skeleton2D *skeleton_node = NULL; if (has_node(skeleton)) { skeleton_node = Object::cast_to<Skeleton2D>(get_node(skeleton)); } ObjectID new_skeleton_id = 0; if (skeleton_node) { VS::get_singleton()->canvas_item_attach_skeleton(get_canvas_item(), skeleton_node->get_skeleton()); new_skeleton_id = skeleton_node->get_instance_id(); } else { VS::get_singleton()->canvas_item_attach_skeleton(get_canvas_item(), RID()); } if (new_skeleton_id != current_skeleton_id) { Object *old_skeleton = ObjectDB::get_instance(current_skeleton_id); if (old_skeleton) { old_skeleton->disconnect("bone_setup_changed", this, "_skeleton_bone_setup_changed"); } if (skeleton_node) { skeleton_node->connect("bone_setup_changed", this, "_skeleton_bone_setup_changed"); } current_skeleton_id = new_skeleton_id; } Vector<Vector2> points; Vector<Vector2> uvs; Vector<int> bones; Vector<float> weights; int len = polygon.size(); if ((invert || polygons.size() == 0) && internal_vertices > 0) { //if no polygons are around, internal vertices must not be drawn, else let them be len -= internal_vertices; } if (len <= 0) { return; } points.resize(len); { PoolVector<Vector2>::Read polyr = polygon.read(); for (int i = 0; i < len; i++) { points.write[i] = polyr[i] + offset; } } if (invert) { Rect2 bounds; int highest_idx = -1; float highest_y = -1e20; float sum = 0; for (int i = 0; i < len; i++) { if (i == 0) bounds.position = points[i]; else bounds.expand_to(points[i]); if (points[i].y > highest_y) { highest_idx = i; highest_y = points[i].y; } int ni = (i + 1) % len; sum += (points[ni].x - points[i].x) * (points[ni].y + points[i].y); } bounds = bounds.grow(invert_border); Vector2 ep[7] = { Vector2(points[highest_idx].x, points[highest_idx].y + invert_border), Vector2(bounds.position + bounds.size), Vector2(bounds.position + Vector2(bounds.size.x, 0)), Vector2(bounds.position), Vector2(bounds.position + Vector2(0, bounds.size.y)), Vector2(points[highest_idx].x - CMP_EPSILON, points[highest_idx].y + invert_border), Vector2(points[highest_idx].x - CMP_EPSILON, points[highest_idx].y), }; if (sum > 0) { SWAP(ep[1], ep[4]); SWAP(ep[2], ep[3]); SWAP(ep[5], ep[0]); SWAP(ep[6], points.write[highest_idx]); } points.resize(points.size() + 7); for (int i = points.size() - 1; i >= highest_idx + 7; i--) { points.write[i] = points[i - 7]; } for (int i = 0; i < 7; i++) { points.write[highest_idx + i + 1] = ep[i]; } len = points.size(); } if (texture.is_valid()) { Transform2D texmat(tex_rot, tex_ofs); texmat.scale(tex_scale); Size2 tex_size = texture->get_size(); uvs.resize(len); if (points.size() == uv.size()) { PoolVector<Vector2>::Read uvr = uv.read(); for (int i = 0; i < len; i++) { uvs.write[i] = texmat.xform(uvr[i]) / tex_size; } } else { for (int i = 0; i < len; i++) { uvs.write[i] = texmat.xform(points[i]) / tex_size; } } } if (skeleton_node && !invert && bone_weights.size()) { //a skeleton is set! fill indices and weights int vc = len; bones.resize(vc * 4); weights.resize(vc * 4); int *bonesw = bones.ptrw(); float *weightsw = weights.ptrw(); for (int i = 0; i < vc * 4; i++) { bonesw[i] = 0; weightsw[i] = 0; } for (int i = 0; i < bone_weights.size(); i++) { if (bone_weights[i].weights.size() != points.size()) { continue; //different number of vertices, sorry not using. } if (!skeleton_node->has_node(bone_weights[i].path)) { continue; //node does not exist } Bone2D *bone = Object::cast_to<Bone2D>(skeleton_node->get_node(bone_weights[i].path)); if (!bone) { continue; } int bone_index = bone->get_index_in_skeleton(); PoolVector<float>::Read r = bone_weights[i].weights.read(); for (int j = 0; j < vc; j++) { if (r[j] == 0.0) continue; //weight is unpainted, skip //find an index with a weight for (int k = 0; k < 4; k++) { if (weightsw[j * 4 + k] < r[j]) { //this is less than this weight, insert weight! for (int l = 3; l > k; l--) { weightsw[j * 4 + l] = weightsw[j * 4 + l - 1]; bonesw[j * 4 + l] = bonesw[j * 4 + l - 1]; } weightsw[j * 4 + k] = r[j]; bonesw[j * 4 + k] = bone_index; break; } } } } //normalize the weights for (int i = 0; i < vc; i++) { float tw = 0; for (int j = 0; j < 4; j++) { tw += weightsw[i * 4 + j]; } if (tw == 0) continue; //unpainted, do nothing //normalize for (int j = 0; j < 4; j++) { weightsw[i * 4 + j] /= tw; } } } Vector<Color> colors; if (vertex_colors.size() == points.size()) { colors.resize(len); PoolVector<Color>::Read color_r = vertex_colors.read(); for (int i = 0; i < len; i++) { colors.write[i] = color_r[i]; } } else { colors.push_back(color); } // Vector<int> indices = Geometry::triangulate_polygon(points); // VS::get_singleton()->canvas_item_add_triangle_array(get_canvas_item(), indices, points, colors, uvs, texture.is_valid() ? texture->get_rid() : RID()); if (invert || polygons.size() == 0) { Vector<int> indices = Geometry::triangulate_polygon(points); VS::get_singleton()->canvas_item_add_triangle_array(get_canvas_item(), indices, points, colors, uvs, bones, weights, texture.is_valid() ? texture->get_rid() : RID()); } else { //draw individual polygons Vector<int> total_indices; for (int i = 0; i < polygons.size(); i++) { PoolVector<int> src_indices = polygons[i]; int ic = src_indices.size(); if (ic < 3) continue; PoolVector<int>::Read r = src_indices.read(); Vector<Vector2> tmp_points; tmp_points.resize(ic); for (int j = 0; j < ic; j++) { int idx = r[j]; ERR_CONTINUE(idx < 0 || idx >= points.size()); tmp_points.write[j] = points[r[j]]; } Vector<int> indices = Geometry::triangulate_polygon(tmp_points); int ic2 = indices.size(); const int *r2 = indices.ptr(); int bic = total_indices.size(); total_indices.resize(bic + ic2); int *w2 = total_indices.ptrw(); for (int j = 0; j < ic2; j++) { w2[j + bic] = r[r2[j]]; } } if (total_indices.size()) { VS::get_singleton()->canvas_item_add_triangle_array(get_canvas_item(), total_indices, points, colors, uvs, bones, weights, texture.is_valid() ? texture->get_rid() : RID()); } #if 0 //use splits Vector<int> loop; int sc = splits.size(); PoolVector<int>::Read r = splits.read(); print_line("has splits, amount " + itos(splits.size())); Vector<Vector<int> > loops; // find a point that can be used to begin, must not be in a split, and have to the left and right the same one // like this one -> x---o // \ / \ . // o---o int base_point = -1; { int current_point = -1; int base_point_prev_split = -1; for (int i = 0; i < points.size(); i++) { //find if this point is in a split int split_index = -1; bool has_prev_split = false; int min_dist_to_end = 0x7FFFFFFF; for (int j = 0; j < sc; j += 2) { int split_pos = -1; int split_end = -1; if (r[j + 0] == i) { //found split in first point split_pos = r[j + 0]; split_end = r[j + 1]; } else if (r[j + 1] == i) { //found split in second point split_pos = r[j + 1]; split_end = r[j + 0]; } if (split_pos == split_end) { continue; //either nothing found or begin == end, this not a split in either case } if (j == base_point_prev_split) { has_prev_split = true; } //compute distance from split pos to split end in current traversal direction int dist_to_end = split_end > split_pos ? split_end - split_pos : (last - split_pos + split_end); if (dist_to_end < min_dist_to_end) { //always keep the valid split with the least distance to the loop min_dist_to_end = dist_to_end; split_index = j; } } if (split_index == -1) { current_point = i; //no split here, we are testing this point } else if (has_prev_split) { base_point = current_point; // there is a split and it contains the previous visited split, success break; } else { //invalidate current point and keep split current_point = -1; base_point_prev_split = split_index; } } } print_line("found base point: " + itos(base_point)); if (base_point != -1) { int point = base_point; int last = base_point; //go through all the points, find splits do { int split; int last_dist_to_end = -1; //maximum valid distance to end do { loop.push_back(point); //push current point split = -1; int end = -1; int max_dist_to_end = 0; //find if this point is in a split for (int j = 0; j < sc; j += 2) { int split_pos = -1; int split_end = -1; if (r[j + 0] == point) { //match first split index split_pos = r[j + 0]; split_end = r[j + 1]; } else if (r[j + 1] == point) { //match second split index split_pos = r[j + 1]; split_end = r[j + 0]; } if (split_pos == split_end) { continue; //either nothing found or begin == end, this not a split in either case } //compute distance from split pos to split end int dist_to_end = split_end > split_pos ? split_end - split_pos : (points.size() - split_pos + split_end); if (last_dist_to_end != -1 && dist_to_end >= last_dist_to_end) { //distance must be shorter than in last iteration, means we've tested this before so ignore continue; } else if (dist_to_end > max_dist_to_end) { //always keep the valid point with the most distance (as long as it's valid) max_dist_to_end = dist_to_end; split = split_pos; end = split_end; } } if (split != -1) { //found a split! int from = end; //add points until last is reached while (true) { //find if point is in a split loop.push_back(from); if (from == last) { break; } from++; if (from >= points.size()) { //wrap if reached end from = 0; } if (from == loop[0]) { break; //end because we reached split source } } loops.push_back(loop); //done with this loop loop.clear(); last_dist_to_end = max_dist_to_end; last = end; //algorithm can safely finish in this split point } } while (split != -1); } while (point != last); } if (loop.size() >=2 ) { //points remained //points remain loop.push_back(last); //no splits found, use last loops.push_back(loop); } print_line("total loops: " + itos(loops.size())); if (loops.size()) { //loops found Vector<int> indices; for (int i = 0; i < loops.size(); i++) { Vector<int> loop = loops[i]; Vector<Vector2> vertices; vertices.resize(loop.size()); for (int j = 0; j < vertices.size(); j++) { vertices.write[j] = points[loop[j]]; } Vector<int> sub_indices = Geometry::triangulate_polygon(vertices); int from = indices.size(); indices.resize(from + sub_indices.size()); for (int j = 0; j < sub_indices.size(); j++) { indices.write[from + j] = loop[sub_indices[j]]; } } VS::get_singleton()->canvas_item_add_triangle_array(get_canvas_item(), indices, points, colors, uvs, bones, weights, texture.is_valid() ? texture->get_rid() : RID()); } #endif } } break; } }
void EditorAssetInstaller::ok_pressed() { FileAccess *src_f = NULL; zlib_filefunc_def io = zipio_create_io_from_file(&src_f); unzFile pkg = unzOpen2(package_path.utf8().get_data(), &io); if (!pkg) { error->set_text(TTR("Error opening package file, not in zip format.")); return; } int ret = unzGoToFirstFile(pkg); Vector<String> failed_files; ProgressDialog::get_singleton()->add_task("uncompress", TTR("Uncompressing Assets"), status_map.size()); int idx = 0; while (ret == UNZ_OK) { //get filename unz_file_info info; char fname[16384]; ret = unzGetCurrentFileInfo(pkg, &info, fname, 16384, NULL, 0, NULL, 0); String name = fname; if (status_map.has(name) && status_map[name]->is_checked(0)) { String path = status_map[name]->get_metadata(0); if (path == String()) { // a dir String dirpath; TreeItem *t = status_map[name]; while (t) { dirpath = t->get_text(0) + dirpath; t = t->get_parent(); } if (dirpath.ends_with("/")) { dirpath = dirpath.substr(0, dirpath.length() - 1); } DirAccess *da = DirAccess::create(DirAccess::ACCESS_RESOURCES); da->make_dir(dirpath); memdelete(da); } else { Vector<uint8_t> data; data.resize(info.uncompressed_size); //read unzOpenCurrentFile(pkg); unzReadCurrentFile(pkg, data.ptrw(), data.size()); unzCloseCurrentFile(pkg); FileAccess *f = FileAccess::open(path, FileAccess::WRITE); if (f) { f->store_buffer(data.ptr(), data.size()); memdelete(f); } else { failed_files.push_back(path); } ProgressDialog::get_singleton()->task_step("uncompress", path, idx); } } idx++; ret = unzGoToNextFile(pkg); } ProgressDialog::get_singleton()->end_task("uncompress"); unzClose(pkg); if (failed_files.size()) { String msg = "The following files failed extraction from package:\n\n"; for (int i = 0; i < failed_files.size(); i++) { if (i > 15) { msg += "\nAnd " + itos(failed_files.size() - i) + " more files."; break; } msg += failed_files[i]; } if (EditorNode::get_singleton() != NULL) EditorNode::get_singleton()->show_warning(msg); } else { if (EditorNode::get_singleton() != NULL) EditorNode::get_singleton()->show_warning(TTR("Package Installed Successfully!"), TTR("Success!")); } EditorFileSystem::get_singleton()->scan_changes(); }
MainLoop *test(TestType p_type) { List<String> cmdlargs = OS::get_singleton()->get_cmdline_args(); if (cmdlargs.empty()) { //try editor! return NULL; } String test = cmdlargs.back()->get(); FileAccess *fa = FileAccess::open(test, FileAccess::READ); if (!fa) { ERR_EXPLAIN("Could not open file: " + test); ERR_FAIL_V(NULL); } Vector<uint8_t> buf; int flen = fa->get_len(); buf.resize(fa->get_len() + 1); fa->get_buffer(buf.ptrw(), flen); buf.write[flen] = 0; String code; code.parse_utf8((const char *)&buf[0]); Vector<String> lines; int last = 0; for (int i = 0; i <= code.length(); i++) { if (code[i] == '\n' || code[i] == 0) { lines.push_back(code.substr(last, i - last)); last = i + 1; } } if (p_type == TEST_TOKENIZER) { GDScriptTokenizerText tk; tk.set_code(code); int line = -1; while (tk.get_token() != GDScriptTokenizer::TK_EOF) { String text; if (tk.get_token() == GDScriptTokenizer::TK_IDENTIFIER) text = "'" + tk.get_token_identifier() + "' (identifier)"; else if (tk.get_token() == GDScriptTokenizer::TK_CONSTANT) { Variant c = tk.get_token_constant(); if (c.get_type() == Variant::STRING) text = "\"" + String(c) + "\""; else text = c; text = text + " (" + Variant::get_type_name(c.get_type()) + " constant)"; } else if (tk.get_token() == GDScriptTokenizer::TK_ERROR) text = "ERROR: " + tk.get_token_error(); else if (tk.get_token() == GDScriptTokenizer::TK_NEWLINE) text = "newline (" + itos(tk.get_token_line()) + ") + indent: " + itos(tk.get_token_line_indent()); else if (tk.get_token() == GDScriptTokenizer::TK_BUILT_IN_FUNC) text = "'" + String(GDScriptFunctions::get_func_name(tk.get_token_built_in_func())) + "' (built-in function)"; else text = tk.get_token_name(tk.get_token()); if (tk.get_token_line() != line) { int from = line + 1; line = tk.get_token_line(); for (int i = from; i <= line; i++) { int l = i - 1; if (l >= 0 && l < lines.size()) { print_line("\n" + itos(i) + ": " + lines[l] + "\n"); } } } print_line("\t(" + itos(tk.get_token_column()) + "): " + text); tk.advance(); } } if (p_type == TEST_PARSER) { GDScriptParser parser; Error err = parser.parse(code); if (err) { print_line("Parse Error:\n" + itos(parser.get_error_line()) + ":" + itos(parser.get_error_column()) + ":" + parser.get_error()); memdelete(fa); return NULL; } const GDScriptParser::Node *root = parser.get_parse_tree(); ERR_FAIL_COND_V(root->type != GDScriptParser::Node::TYPE_CLASS, NULL); const GDScriptParser::ClassNode *cnode = static_cast<const GDScriptParser::ClassNode *>(root); _parser_show_class(cnode, 0, lines); } if (p_type == TEST_COMPILER) { GDScriptParser parser; Error err = parser.parse(code); if (err) { print_line("Parse Error:\n" + itos(parser.get_error_line()) + ":" + itos(parser.get_error_column()) + ":" + parser.get_error()); memdelete(fa); return NULL; } GDScript *script = memnew(GDScript); GDScriptCompiler gdc; err = gdc.compile(&parser, script); if (err) { print_line("Compile Error:\n" + itos(gdc.get_error_line()) + ":" + itos(gdc.get_error_column()) + ":" + gdc.get_error()); memdelete(script); return NULL; } Ref<GDScript> gds = Ref<GDScript>(script); Ref<GDScript> current = gds; while (current.is_valid()) { print_line("** CLASS **"); _disassemble_class(current, lines); current = current->get_base(); } } else if (p_type == TEST_BYTECODE) { Vector<uint8_t> buf = GDScriptTokenizerBuffer::parse_code_string(code); String dst = test.get_basename() + ".gdc"; FileAccess *fw = FileAccess::open(dst, FileAccess::WRITE); fw->store_buffer(buf.ptr(), buf.size()); memdelete(fw); } memdelete(fa); return NULL; }