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;
}
Ref<Shape> Mesh::create_convex_shape() const {
PoolVector<Vector3> vertices;
for (int i = 0; i < get_surface_count(); i++) {
Array a = surface_get_arrays(i);
PoolVector<Vector3> v = a[ARRAY_VERTEX];
vertices.append_array(v);
}
Ref<ConvexPolygonShape> shape = memnew(ConvexPolygonShape);
shape->set_points(vertices);
return shape;
}
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(!p_url.begins_with("/"), ERR_INVALID_PARAMETER);
ERR_FAIL_COND_V(status != STATUS_CONNECTED, ERR_INVALID_PARAMETER);
ERR_FAIL_COND_V(connection.is_null(), ERR_INVALID_DATA);
String request = String(_methods[p_method]) + " " + p_url + " HTTP/1.1\r\n";
if ((ssl && conn_port == PORT_HTTPS) || (!ssl && conn_port == PORT_HTTP)) {
// 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;
bool add_uagent = true;
bool add_accept = true;
for (int i = 0; i < p_headers.size(); i++) {
request += p_headers[i] + "\r\n";
if (add_clen && p_headers[i].findn("Content-Length:") == 0) {
add_clen = false;
}
if (add_uagent && p_headers[i].findn("User-Agent:") == 0) {
add_uagent = false;
}
if (add_accept && p_headers[i].findn("Accept:") == 0) {
add_accept = false;
}
}
if (add_clen) {
request += "Content-Length: " + itos(p_body.size()) + "\r\n";
// Should it add utf8 encoding?
}
if (add_uagent) {
request += "User-Agent: GodotEngine/" + String(VERSION_FULL_BUILD) + " (" + OS::get_singleton()->get_name() + ")\r\n";
}
if (add_accept) {
request += "Accept: */*\r\n";
}
request += "\r\n";
CharString cs = request.utf8();
PoolVector<uint8_t> data;
data.resize(cs.length());
{
PoolVector<uint8_t>::Write data_write = data.write();
for (int i = 0; i < cs.length(); i++) {
data_write[i] = 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;
}
Ref<Mesh> Mesh::create_outline(float p_margin) const {
Array arrays;
int index_accum = 0;
for (int i = 0; i < get_surface_count(); i++) {
if (surface_get_primitive_type(i) != PRIMITIVE_TRIANGLES)
continue;
Array a = surface_get_arrays(i);
if (i == 0) {
arrays = a;
PoolVector<Vector3> v = a[ARRAY_VERTEX];
index_accum += v.size();
} else {
int vcount = 0;
for (int j = 0; j < arrays.size(); j++) {
if (arrays[j].get_type() == Variant::NIL || a[j].get_type() == Variant::NIL) {
//mismatch, do not use
arrays[j] = Variant();
continue;
}
switch (j) {
case ARRAY_VERTEX:
case ARRAY_NORMAL: {
PoolVector<Vector3> dst = arrays[j];
PoolVector<Vector3> src = a[j];
if (j == ARRAY_VERTEX)
vcount = src.size();
if (dst.size() == 0 || src.size() == 0) {
arrays[j] = Variant();
continue;
}
dst.append_array(src);
arrays[j] = dst;
} break;
case ARRAY_TANGENT:
case ARRAY_BONES:
case ARRAY_WEIGHTS: {
PoolVector<real_t> dst = arrays[j];
PoolVector<real_t> src = a[j];
if (dst.size() == 0 || src.size() == 0) {
arrays[j] = Variant();
continue;
}
dst.append_array(src);
arrays[j] = dst;
} break;
case ARRAY_COLOR: {
PoolVector<Color> dst = arrays[j];
PoolVector<Color> src = a[j];
if (dst.size() == 0 || src.size() == 0) {
arrays[j] = Variant();
continue;
}
dst.append_array(src);
arrays[j] = dst;
} break;
case ARRAY_TEX_UV:
case ARRAY_TEX_UV2: {
PoolVector<Vector2> dst = arrays[j];
PoolVector<Vector2> src = a[j];
if (dst.size() == 0 || src.size() == 0) {
arrays[j] = Variant();
continue;
}
dst.append_array(src);
arrays[j] = dst;
} break;
case ARRAY_INDEX: {
PoolVector<int> dst = arrays[j];
PoolVector<int> src = a[j];
if (dst.size() == 0 || src.size() == 0) {
arrays[j] = Variant();
continue;
}
{
int ss = src.size();
PoolVector<int>::Write w = src.write();
for (int k = 0; k < ss; k++) {
w[k] += index_accum;
}
}
dst.append_array(src);
arrays[j] = dst;
index_accum += vcount;
} break;
}
}
}
}
ERR_FAIL_COND_V(arrays.size() != ARRAY_MAX, Ref<ArrayMesh>());
{
PoolVector<int>::Write ir;
PoolVector<int> indices = arrays[ARRAY_INDEX];
bool has_indices = false;
PoolVector<Vector3> vertices = arrays[ARRAY_VERTEX];
int vc = vertices.size();
ERR_FAIL_COND_V(!vc, Ref<ArrayMesh>());
PoolVector<Vector3>::Write r = vertices.write();
if (indices.size()) {
vc = indices.size();
ir = indices.write();
has_indices = true;
}
Map<Vector3, Vector3> normal_accum;
//fill normals with triangle normals
for (int i = 0; i < vc; i += 3) {
Vector3 t[3];
if (has_indices) {
t[0] = r[ir[i + 0]];
t[1] = r[ir[i + 1]];
t[2] = r[ir[i + 2]];
} else {
t[0] = r[i + 0];
t[1] = r[i + 1];
t[2] = r[i + 2];
}
Vector3 n = Plane(t[0], t[1], t[2]).normal;
for (int j = 0; j < 3; j++) {
Map<Vector3, Vector3>::Element *E = normal_accum.find(t[j]);
if (!E) {
normal_accum[t[j]] = n;
} else {
float d = n.dot(E->get());
if (d < 1.0)
E->get() += n * (1.0 - d);
//E->get()+=n;
}
}
}
//normalize
for (Map<Vector3, Vector3>::Element *E = normal_accum.front(); E; E = E->next()) {
E->get().normalize();
}
//displace normals
int vc2 = vertices.size();
for (int i = 0; i < vc2; i++) {
Vector3 t = r[i];
Map<Vector3, Vector3>::Element *E = normal_accum.find(t);
ERR_CONTINUE(!E);
t += E->get() * p_margin;
r[i] = t;
}
r = PoolVector<Vector3>::Write();
arrays[ARRAY_VERTEX] = vertices;
if (!has_indices) {
PoolVector<int> new_indices;
new_indices.resize(vertices.size());
PoolVector<int>::Write iw = new_indices.write();
for (int j = 0; j < vc2; j += 3) {
iw[j] = j;
iw[j + 1] = j + 2;
iw[j + 2] = j + 1;
}
iw = PoolVector<int>::Write();
arrays[ARRAY_INDEX] = new_indices;
} else {
for (int j = 0; j < vc; j += 3) {
SWAP(ir[j + 1], ir[j + 2]);
}
ir = PoolVector<int>::Write();
arrays[ARRAY_INDEX] = indices;
}
}
Ref<ArrayMesh> newmesh = memnew(ArrayMesh);
newmesh->add_surface_from_arrays(PRIMITIVE_TRIANGLES, arrays);
return newmesh;
}
void GDAPI godot_pool_byte_array_append_array(godot_pool_byte_array *p_self, const godot_pool_byte_array *p_array) {
PoolVector<uint8_t> *self = (PoolVector<uint8_t> *)p_self;
PoolVector<uint8_t> *array = (PoolVector<uint8_t> *)p_array;
self->append_array(*array);
}
void GDAPI godot_pool_color_array_append_array(godot_pool_color_array *p_self, const godot_pool_color_array *p_array) {
PoolVector<Color> *self = (PoolVector<Color> *)p_self;
PoolVector<Color> *array = (PoolVector<Color> *)p_array;
self->append_array(*array);
}
void GDAPI godot_pool_string_array_append_array(godot_pool_string_array *p_self, const godot_pool_string_array *p_array) {
PoolVector<String> *self = (PoolVector<String> *)p_self;
PoolVector<String> *array = (PoolVector<String> *)p_array;
self->append_array(*array);
}
void GDAPI godot_pool_real_array_append_array(godot_pool_real_array *p_self, const godot_pool_real_array *p_array) {
PoolVector<godot_real> *self = (PoolVector<godot_real> *)p_self;
PoolVector<godot_real> *array = (PoolVector<godot_real> *)p_array;
self->append_array(*array);
}
