Array StreamPeer::_get_partial_data(int p_bytes) { Array ret; PoolVector<uint8_t> data; data.resize(p_bytes); if (data.size() != p_bytes) { ret.push_back(ERR_OUT_OF_MEMORY); ret.push_back(PoolVector<uint8_t>()); return ret; } PoolVector<uint8_t>::Write w = data.write(); int received; Error err = get_partial_data(&w[0], p_bytes, received); w = PoolVector<uint8_t>::Write(); if (err != OK) { data.resize(0); } else if (received != data.size()) { data.resize(received); } ret.push_back(err); ret.push_back(data); return ret; }
RES ResourceFormatLoaderDynamicFont::load(const String &p_path, const String &p_original_path, Error *r_error) { if (r_error) *r_error = ERR_FILE_CANT_OPEN; FileAccess *f = FileAccess::open(p_path, FileAccess::READ); ERR_FAIL_COND_V(!f, RES()); PoolVector<uint8_t> data; data.resize(f->get_len()); ERR_FAIL_COND_V(data.size() == 0, RES()); { PoolVector<uint8_t>::Write w = data.write(); f->get_buffer(w.ptr(), data.size()); } Ref<DynamicFontData> dfd; dfd.instance(); dfd->set_font_data(data); if (r_error) *r_error = OK; return dfd; }
void VisualServerCanvas::canvas_occluder_polygon_set_shape(RID p_occluder_polygon, const PoolVector<Vector2> &p_shape, bool p_closed) { if (p_shape.size() < 3) { canvas_occluder_polygon_set_shape_as_lines(p_occluder_polygon, p_shape); return; } PoolVector<Vector2> lines; int lc = p_shape.size() * 2; lines.resize(lc - (p_closed ? 0 : 2)); { PoolVector<Vector2>::Write w = lines.write(); PoolVector<Vector2>::Read r = p_shape.read(); int max = lc / 2; if (!p_closed) { max--; } for (int i = 0; i < max; i++) { Vector2 a = r[i]; Vector2 b = r[(i + 1) % (lc / 2)]; w[i * 2 + 0] = a; w[i * 2 + 1] = b; } } canvas_occluder_polygon_set_shape_as_lines(p_occluder_polygon, lines); }
void NavigationMesh::create_from_mesh(const Ref<Mesh>& p_mesh) { vertices=PoolVector<Vector3>(); clear_polygons(); for(int i=0;i<p_mesh->get_surface_count();i++) { if (p_mesh->surface_get_primitive_type(i)!=Mesh::PRIMITIVE_TRIANGLES) continue; Array arr = p_mesh->surface_get_arrays(i); PoolVector<Vector3> varr = arr[Mesh::ARRAY_VERTEX]; PoolVector<int> iarr = arr[Mesh::ARRAY_INDEX]; if (varr.size()==0 || iarr.size()==0) continue; int from = vertices.size(); vertices.append_array(varr); int rlen = iarr.size(); PoolVector<int>::Read r = iarr.read(); for(int j=0;j<rlen;j+=3) { Vector<int> vi; vi.resize(3); vi[0]=r[j+0]+from; vi[1]=r[j+1]+from; vi[2]=r[j+2]+from; add_polygon(vi); } } }
Error HTTPClient::request_raw(Method p_method, const String &p_url, const Vector<String> &p_headers, const PoolVector<uint8_t> &p_body) { ERR_FAIL_INDEX_V(p_method, METHOD_MAX, ERR_INVALID_PARAMETER); ERR_FAIL_COND_V(status != STATUS_CONNECTED, ERR_INVALID_PARAMETER); ERR_FAIL_COND_V(connection.is_null(), ERR_INVALID_DATA); static const char *_methods[METHOD_MAX] = { "GET", "HEAD", "POST", "PUT", "DELETE", "OPTIONS", "TRACE", "CONNECT" }; String request = String(_methods[p_method]) + " " + p_url + " HTTP/1.1\r\n"; if ((ssl && conn_port == 443) || (!ssl && conn_port == 80)) { // don't append the standard ports request += "Host: " + conn_host + "\r\n"; } else { request += "Host: " + conn_host + ":" + itos(conn_port) + "\r\n"; } bool add_clen = p_body.size() > 0; for (int i = 0; i < p_headers.size(); i++) { request += p_headers[i] + "\r\n"; if (add_clen && p_headers[i].find("Content-Length:") == 0) { add_clen = false; } } if (add_clen) { request += "Content-Length: " + itos(p_body.size()) + "\r\n"; //should it add utf8 encoding? not sure } request += "\r\n"; CharString cs = request.utf8(); PoolVector<uint8_t> data; //Maybe this goes faster somehow? for (int i = 0; i < cs.length(); i++) { data.append(cs[i]); } data.append_array(p_body); PoolVector<uint8_t>::Read r = data.read(); Error err = connection->put_data(&r[0], data.size()); if (err) { close(); status = STATUS_CONNECTION_ERROR; return err; } status = STATUS_REQUESTING; return OK; }
Error MultiplayerAPI::send_bytes(PoolVector<uint8_t> p_data, int p_to) { ERR_FAIL_COND_V(p_data.size() < 1, ERR_INVALID_DATA); ERR_FAIL_COND_V(!network_peer.is_valid(), ERR_UNCONFIGURED); ERR_FAIL_COND_V(network_peer->get_connection_status() != NetworkedMultiplayerPeer::CONNECTION_CONNECTED, ERR_UNCONFIGURED); MAKE_ROOM(p_data.size() + 1); PoolVector<uint8_t>::Read r = p_data.read(); packet_cache[0] = NETWORK_COMMAND_RAW; memcpy(&packet_cache[1], &r[0], p_data.size()); network_peer->set_target_peer(p_to); return network_peer->put_packet(packet_cache.ptr(), p_data.size() + 1); }
void PolygonPathFinder::_set_data(const Dictionary &p_data) { ERR_FAIL_COND(!p_data.has("points")); ERR_FAIL_COND(!p_data.has("connections")); ERR_FAIL_COND(!p_data.has("segments")); ERR_FAIL_COND(!p_data.has("bounds")); PoolVector<Vector2> p = p_data["points"]; Array c = p_data["connections"]; ERR_FAIL_COND(c.size() != p.size()); if (c.size()) return; int pc = p.size(); points.resize(pc + 2); PoolVector<Vector2>::Read pr = p.read(); for (int i = 0; i < pc; i++) { points.write[i].pos = pr[i]; PoolVector<int> con = c[i]; PoolVector<int>::Read cr = con.read(); int cc = con.size(); for (int j = 0; j < cc; j++) { points.write[i].connections.insert(cr[j]); } } if (p_data.has("penalties")) { PoolVector<float> penalties = p_data["penalties"]; if (penalties.size() == pc) { PoolVector<float>::Read pr = penalties.read(); for (int i = 0; i < pc; i++) { points.write[i].penalty = pr[i]; } } } PoolVector<int> segs = p_data["segments"]; int sc = segs.size(); ERR_FAIL_COND(sc & 1); PoolVector<int>::Read sr = segs.read(); for (int i = 0; i < sc; i += 2) { Edge e(sr[i], sr[i + 1]); edges.insert(e); } bounds = p_data["bounds"]; }
static int _get_number_from_token(PoolVector<uint8_t>& r_token) { int len = r_token.size(); PoolVector<uint8_t>::Read r = r_token.read(); return String::to_int((const char*)r.ptr(),len); }
Vector<Vector3> ConcavePolygonShape::_gen_debug_mesh_lines() { Set<DrawEdge> edges; PoolVector<Vector3> data = get_faces(); int datalen = data.size(); ERR_FAIL_COND_V((datalen % 3) != 0, Vector<Vector3>()); PoolVector<Vector3>::Read r = data.read(); for (int i = 0; i < datalen; i += 3) { for (int j = 0; j < 3; j++) { DrawEdge de(r[i + j], r[i + ((j + 1) % 3)]); edges.insert(de); } } Vector<Vector3> points; points.resize(edges.size() * 2); int idx = 0; for (Set<DrawEdge>::Element *E = edges.front(); E; E = E->next()) { points.write[idx + 0] = E->get().a; points.write[idx + 1] = E->get().b; idx += 2; } return points; }
/** PrimitiveMesh */ void PrimitiveMesh::_update() const { Array arr; arr.resize(VS::ARRAY_MAX); _create_mesh_array(arr); PoolVector<Vector3> points = arr[VS::ARRAY_VERTEX]; aabb = AABB(); int pc = points.size(); ERR_FAIL_COND(pc == 0); { PoolVector<Vector3>::Read r = points.read(); for (int i = 0; i < pc; i++) { if (i == 0) aabb.position = r[i]; else aabb.expand_to(r[i]); } } // in with the new VisualServer::get_singleton()->mesh_clear(mesh); VisualServer::get_singleton()->mesh_add_surface_from_arrays(mesh, (VisualServer::PrimitiveType)primitive_type, arr); VisualServer::get_singleton()->mesh_surface_set_material(mesh, 0, material.is_null() ? RID() : material->get_rid()); pending_request = false; _clear_triangle_mesh(); }
Ref<Texture> EditorPackedScenePreviewPlugin::_gen_from_imd(Ref<ResourceImportMetadata> p_imd) { if (p_imd.is_null()) { return Ref<Texture>(); } if (!p_imd->has_option("thumbnail")) return Ref<Texture>(); Variant tn = p_imd->get_option("thumbnail"); //print_line(Variant::get_type_name(tn.get_type())); PoolVector<uint8_t> thumbnail = tn; int len = thumbnail.size(); if (len==0) return Ref<Texture>(); PoolVector<uint8_t>::Read r = thumbnail.read(); Image img(r.ptr(),len); if (img.empty()) return Ref<Texture>(); Ref<ImageTexture> ptex = Ref<ImageTexture>( memnew( ImageTexture )); ptex->create_from_image(img,0); return ptex; }
Error StreamPeer::_put_data(const PoolVector<uint8_t> &p_data) { int len = p_data.size(); if (len == 0) return OK; PoolVector<uint8_t>::Read r = p_data.read(); return put_data(&r[0], len); }
static Ref<Image> _lossless_unpack_png(const PoolVector<uint8_t> &p_data) { int len = p_data.size(); ERR_FAIL_COND_V(len < 4, Ref<Image>()); PoolVector<uint8_t>::Read r = p_data.read(); ERR_FAIL_COND_V(r[0] != 'P' || r[1] != 'N' || r[2] != 'G' || r[3] != ' ', Ref<Image>()); return _load_mem_png(&r[4], len - 4); }
Error HTTPClient::request_raw(Method p_method, const String &p_url, const Vector<String> &p_headers, const PoolVector<uint8_t> &p_body) { Error err = prepare_request(p_method, p_url, p_headers); if (err != OK) return err; PoolByteArray::Read read = p_body.read(); godot_xhr_send_data(xhr_id, read.ptr(), p_body.size()); return OK; }
Error PacketPeer::put_packet_buffer(const PoolVector<uint8_t> &p_buffer) { int len = p_buffer.size(); if (len == 0) return OK; PoolVector<uint8_t>::Read r = p_buffer.read(); return put_packet(&r[0], len); }
Error MultiplayerAPI::send_bytes(PoolVector<uint8_t> p_data, int p_to, NetworkedMultiplayerPeer::TransferMode p_mode) { ERR_EXPLAIN("Trying to send an empty raw packet."); ERR_FAIL_COND_V(p_data.size() < 1, ERR_INVALID_DATA); ERR_EXPLAIN("Trying to send a raw packet while no network peer is active."); ERR_FAIL_COND_V(!network_peer.is_valid(), ERR_UNCONFIGURED); ERR_EXPLAIN("Trying to send a raw packet via a network peer which is not connected."); ERR_FAIL_COND_V(network_peer->get_connection_status() != NetworkedMultiplayerPeer::CONNECTION_CONNECTED, ERR_UNCONFIGURED); MAKE_ROOM(p_data.size() + 1); PoolVector<uint8_t>::Read r = p_data.read(); packet_cache.write[0] = NETWORK_COMMAND_RAW; memcpy(&packet_cache.write[1], &r[0], p_data.size()); network_peer->set_target_peer(p_to); network_peer->set_transfer_mode(p_mode); return network_peer->put_packet(packet_cache.ptr(), p_data.size() + 1); }
bool test_abc() { ABCX abcx; PoolVector<int> path = abcx.get_id_path(ABCX::A, ABCX::C); bool ok = path.size() == 3; int i = 0; ok = ok && path[i++] == ABCX::A; ok = ok && path[i++] == ABCX::B; ok = ok && path[i++] == ABCX::C; return ok; }
Ref<Shape> Mesh::create_trimesh_shape() const { PoolVector<Face3> faces = get_faces(); if (faces.size() == 0) return Ref<Shape>(); PoolVector<Vector3> face_points; face_points.resize(faces.size() * 3); for (int i = 0; i < face_points.size(); i++) { Face3 f = faces.get(i / 3); face_points.set(i, f.vertex[i % 3]); } Ref<ConcavePolygonShape> shape = memnew(ConcavePolygonShape); shape->set_faces(face_points); return shape; }
void GDAPI godot_array_new_pool_real_array(godot_array *p_arr, const godot_pool_real_array *p_pra) { Array *a = (Array *)p_arr; PoolVector<godot_real> *pca = (PoolVector<godot_real> *)p_pra; memnew_placement(a, Array); a->resize(pca->size()); for (size_t i = 0; i < a->size(); i++) { Variant v = pca->operator[](i); a->operator[](i) = v; } }
void GDAPI godot_array_new_pool_string_array(godot_array *r_dest, const godot_pool_string_array *p_psa) { Array *dest = (Array *)r_dest; PoolVector<String> *pca = (PoolVector<String> *)p_psa; memnew_placement(dest, Array); dest->resize(pca->size()); for (int i = 0; i < dest->size(); i++) { Variant v = pca->operator[](i); dest->operator[](i) = v; } }
void ConcavePolygonShape2D::draw(const RID &p_to_rid, const Color &p_color) { PoolVector<Vector2> s = get_segments(); int len = s.size(); if (len == 0 || (len % 2) == 1) return; PoolVector<Vector2>::Read r = s.read(); for (int i = 0; i < len; i += 2) { VisualServer::get_singleton()->canvas_item_add_line(p_to_rid, r[i], r[i + 1], p_color, 2); } }
void Translation::_set_messages(const PoolVector<String> &p_messages) { int msg_count = p_messages.size(); ERR_FAIL_COND(msg_count % 2); PoolVector<String>::Read r = p_messages.read(); for (int i = 0; i < msg_count; i += 2) { add_message(r[i + 0], r[i + 1]); } }
void Shape::add_vertices_to_array(PoolVector<Vector3> &array, const Transform &p_xform) { Vector<Vector3> toadd = _gen_debug_mesh_lines(); if (toadd.size()) { int base = array.size(); array.resize(base + toadd.size()); PoolVector<Vector3>::Write w = array.write(); for (int i = 0; i < toadd.size(); i++) { w[i + base] = p_xform.xform(toadd[i]); } } }
void BitmapFont::_set_kernings(const PoolVector<int> &p_kernings) { int len = p_kernings.size(); ERR_FAIL_COND(len % 3); if (!len) return; PoolVector<int>::Read r = p_kernings.read(); for (int i = 0; i < len / 3; i++) { const int *data = &r[i * 3]; add_kerning_pair(data[0], data[1], data[2]); } }
void VisualServerCanvas::canvas_occluder_polygon_set_shape_as_lines(RID p_occluder_polygon, const PoolVector<Vector2> &p_shape) { LightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.get(p_occluder_polygon); ERR_FAIL_COND(!occluder_poly); ERR_FAIL_COND(p_shape.size() & 1); int lc = p_shape.size(); occluder_poly->aabb = Rect2(); { PoolVector<Vector2>::Read r = p_shape.read(); for (int i = 0; i < lc; i++) { if (i == 0) occluder_poly->aabb.pos = r[i]; else occluder_poly->aabb.expand_to(r[i]); } } VSG::storage->canvas_light_occluder_set_polylines(occluder_poly->occluder, p_shape); for (Set<RasterizerCanvas::LightOccluderInstance *>::Element *E = occluder_poly->owners.front(); E; E = E->next()) { E->get()->aabb_cache = occluder_poly->aabb; } }
void ResourceLoader::load_path_remaps() { if (!ProjectSettings::get_singleton()->has_setting("path_remap/remapped_paths")) return; PoolVector<String> remaps = ProjectSettings::get_singleton()->get("path_remap/remapped_paths"); int rc = remaps.size(); ERR_FAIL_COND(rc & 1); //must be even PoolVector<String>::Read r = remaps.read(); for (int i = 0; i < rc; i += 2) { path_remaps[r[i]] = r[i + 1]; } }
bool ConcavePolygonShape2D::_edit_is_selected_on_click(const Point2 &p_point, double p_tolerance) const { PoolVector<Vector2> s = get_segments(); int len = s.size(); if (len == 0 || (len % 2) == 1) return false; PoolVector<Vector2>::Read r = s.read(); for (int i = 0; i < len; i += 2) { Vector2 closest = Geometry::get_closest_point_to_segment_2d(p_point, &r[i]); if (p_point.distance_to(closest) < p_tolerance) return true; } return false; }
void BitmapFont::_set_chars(const PoolVector<int> &p_chars) { int len = p_chars.size(); //char 1 charsize 1 texture, 4 rect, 2 align, advance 1 ERR_FAIL_COND(len % 9); if (!len) return; //none to do int chars = len / 9; PoolVector<int>::Read r = p_chars.read(); for (int i = 0; i < chars; i++) { const int *data = &r[i * 9]; add_char(data[0], data[1], Rect2(data[2], data[3], data[4], data[5]), Size2(data[6], data[7]), data[8]); } }
void SpriteFramesEditor::_file_load_request(const PoolVector<String> &p_path, int p_at_pos) { ERR_FAIL_COND(!frames->has_animation(edited_anim)); List<Ref<Texture> > resources; for (int i = 0; i < p_path.size(); i++) { Ref<Texture> resource; resource = ResourceLoader::load(p_path[i]); if (resource.is_null()) { dialog->set_text(TTR("ERROR: Couldn't load frame resource!")); dialog->set_title(TTR("Error!")); //dialog->get_cancel()->set_text("Close"); dialog->get_ok()->set_text(TTR("Close")); dialog->popup_centered_minsize(); return; ///beh should show an error i guess } resources.push_back(resource); } if (resources.empty()) { //print_line("added frames!"); return; } undo_redo->create_action(TTR("Add Frame")); int fc = frames->get_frame_count(edited_anim); int count = 0; for (List<Ref<Texture> >::Element *E = resources.front(); E; E = E->next()) { undo_redo->add_do_method(frames, "add_frame", edited_anim, E->get(), p_at_pos == -1 ? -1 : p_at_pos + count); undo_redo->add_undo_method(frames, "remove_frame", edited_anim, p_at_pos == -1 ? fc : p_at_pos); count++; } undo_redo->add_do_method(this, "_update_library"); undo_redo->add_undo_method(this, "_update_library"); undo_redo->commit_action(); //print_line("added frames!"); }
void CPUParticlesEditor::_generate_emission_points() { /// hacer codigo aca PoolVector<Vector3> points; PoolVector<Vector3> normals; if (!_generate(points, normals)) { return; } if (normals.size() == 0) { node->set_emission_shape(CPUParticles::EMISSION_SHAPE_POINTS); node->set_emission_points(points); } else { node->set_emission_shape(CPUParticles::EMISSION_SHAPE_DIRECTED_POINTS); node->set_emission_points(points); node->set_emission_normals(normals); } }