/*************************************************************************/ /* mesh.cpp */ /*************************************************************************/ /* This file is part of: */ /* GODOT ENGINE */ /* http://www.godotengine.org */ /*************************************************************************/ /* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ /* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ /* */ /* Permission is hereby granted, free of charge, to any person obtaining */ /* a copy of this software and associated documentation files (the */ /* "Software"), to deal in the Software without restriction, including */ /* without limitation the rights to use, copy, modify, merge, publish, */ /* distribute, sublicense, and/or sell copies of the Software, and to */ /* permit persons to whom the Software is furnished to do so, subject to */ /* the following conditions: */ /* */ /* The above copyright notice and this permission notice shall be */ /* included in all copies or substantial portions of the Software. */ /* */ /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /*************************************************************************/ #include "mesh.h" #include "scene/resources/concave_polygon_shape.h" #include "scene/resources/convex_polygon_shape.h" #include "surface_tool.h" static const char *_array_name[] = { "vertex_array", "normal_array", "tangent_array", "color_array", "tex_uv_array", "tex_uv2_array", "bone_array", "weights_array", "index_array", NULL }; static const Mesh::ArrayType _array_types[] = { Mesh::ARRAY_VERTEX, Mesh::ARRAY_NORMAL, Mesh::ARRAY_TANGENT, Mesh::ARRAY_COLOR, Mesh::ARRAY_TEX_UV, Mesh::ARRAY_TEX_UV2, Mesh::ARRAY_BONES, Mesh::ARRAY_WEIGHTS, Mesh::ARRAY_INDEX }; /* compatibility */ static const int _format_translate[] = { Mesh::ARRAY_FORMAT_VERTEX, Mesh::ARRAY_FORMAT_NORMAL, Mesh::ARRAY_FORMAT_TANGENT, Mesh::ARRAY_FORMAT_COLOR, Mesh::ARRAY_FORMAT_TEX_UV, Mesh::ARRAY_FORMAT_TEX_UV2, Mesh::ARRAY_FORMAT_BONES, Mesh::ARRAY_FORMAT_WEIGHTS, Mesh::ARRAY_FORMAT_INDEX, }; bool Mesh::_set(const StringName &p_name, const Variant &p_value) { String sname = p_name; if (p_name == "blend_shape/names") { PoolVector<String> sk = p_value; int sz = sk.size(); PoolVector<String>::Read r = sk.read(); for (int i = 0; i < sz; i++) add_blend_shape(r[i]); return true; } if (p_name == "blend_shape/mode") { set_blend_shape_mode(BlendShapeMode(int(p_value))); return true; } if (sname.begins_with("surface_")) { int sl = sname.find("/"); if (sl == -1) return false; int idx = sname.substr(8, sl - 8).to_int() - 1; String what = sname.get_slicec('/', 1); if (what == "material") surface_set_material(idx, p_value); else if (what == "name") surface_set_name(idx, p_value); return true; } if (sname == "custom_aabb/custom_aabb") { set_custom_aabb(p_value); return true; } if (!sname.begins_with("surfaces")) return false; int idx = sname.get_slicec('/', 1).to_int(); String what = sname.get_slicec('/', 2); if (idx == surfaces.size()) { //create Dictionary d = p_value; ERR_FAIL_COND_V(!d.has("primitive"), false); if (d.has("arrays")) { //old format ERR_FAIL_COND_V(!d.has("morph_arrays"), false); add_surface_from_arrays(PrimitiveType(int(d["primitive"])), d["arrays"], d["morph_arrays"]); } else if (d.has("array_data")) { PoolVector<uint8_t> array_data = d["array_data"]; PoolVector<uint8_t> array_index_data; if (d.has("array_index_data")) array_index_data = d["array_index_data"]; ERR_FAIL_COND_V(!d.has("format"), false); uint32_t format = d["format"]; ERR_FAIL_COND_V(!d.has("primitive"), false); uint32_t primitive = d["primitive"]; ERR_FAIL_COND_V(!d.has("vertex_count"), false); int vertex_count = d["vertex_count"]; int index_count = 0; if (d.has("index_count")) index_count = d["index_count"]; Vector<PoolVector<uint8_t> > blend_shapes; if (d.has("blend_shape_data")) { Array blend_shape_data = d["blend_shape_data"]; for (int i = 0; i < blend_shape_data.size(); i++) { PoolVector<uint8_t> shape = blend_shape_data[i]; blend_shapes.push_back(shape); } } ERR_FAIL_COND_V(!d.has("aabb"), false); Rect3 aabb = d["aabb"]; Vector<Rect3> bone_aabb; if (d.has("bone_aabb")) { Array baabb = d["bone_aabb"]; bone_aabb.resize(baabb.size()); for (int i = 0; i < baabb.size(); i++) { bone_aabb[i] = baabb[i]; } } add_surface(format, PrimitiveType(primitive), array_data, vertex_count, array_index_data, index_count, aabb, blend_shapes, bone_aabb); } else { ERR_FAIL_V(false); } if (d.has("material")) { surface_set_material(idx, d["material"]); } if (d.has("name")) { surface_set_name(idx, d["name"]); } return true; } return false; } bool Mesh::_get(const StringName &p_name, Variant &r_ret) const { if (_is_generated()) return false; String sname = p_name; if (p_name == "blend_shape/names") { PoolVector<String> sk; for (int i = 0; i < blend_shapes.size(); i++) sk.push_back(blend_shapes[i]); r_ret = sk; return true; } else if (p_name == "blend_shape/mode") { r_ret = get_blend_shape_mode(); return true; } else if (sname.begins_with("surface_")) { int sl = sname.find("/"); if (sl == -1) return false; int idx = sname.substr(8, sl - 8).to_int() - 1; String what = sname.get_slicec('/', 1); if (what == "material") r_ret = surface_get_material(idx); else if (what == "name") r_ret = surface_get_name(idx); return true; } else if (sname == "custom_aabb/custom_aabb") { r_ret = custom_aabb; return true; } else if (!sname.begins_with("surfaces")) return false; int idx = sname.get_slicec('/', 1).to_int(); ERR_FAIL_INDEX_V(idx, surfaces.size(), false); Dictionary d; d["array_data"] = VS::get_singleton()->mesh_surface_get_array(mesh, idx); d["vertex_count"] = VS::get_singleton()->mesh_surface_get_array_len(mesh, idx); d["array_index_data"] = VS::get_singleton()->mesh_surface_get_index_array(mesh, idx); d["index_count"] = VS::get_singleton()->mesh_surface_get_array_index_len(mesh, idx); d["primitive"] = VS::get_singleton()->mesh_surface_get_primitive_type(mesh, idx); d["format"] = VS::get_singleton()->mesh_surface_get_format(mesh, idx); d["aabb"] = VS::get_singleton()->mesh_surface_get_aabb(mesh, idx); Vector<Rect3> skel_aabb = VS::get_singleton()->mesh_surface_get_skeleton_aabb(mesh, idx); Array arr; for (int i = 0; i < skel_aabb.size(); i++) { arr[i] = skel_aabb[i]; } d["skeleton_aabb"] = arr; Vector<PoolVector<uint8_t> > blend_shape_data = VS::get_singleton()->mesh_surface_get_blend_shapes(mesh, idx); Array md; for (int i = 0; i < blend_shape_data.size(); i++) { md.push_back(blend_shape_data[i]); } d["blend_shape_data"] = md; Ref<Material> m = surface_get_material(idx); if (m.is_valid()) d["material"] = m; String n = surface_get_name(idx); if (n != "") d["name"] = n; r_ret = d; return true; } void Mesh::_get_property_list(List<PropertyInfo> *p_list) const { if (_is_generated()) return; if (blend_shapes.size()) { p_list->push_back(PropertyInfo(Variant::POOL_STRING_ARRAY, "blend_shape/names", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR)); p_list->push_back(PropertyInfo(Variant::INT, "blend_shape/mode", PROPERTY_HINT_ENUM, "Normalized,Relative")); } for (int i = 0; i < surfaces.size(); i++) { p_list->push_back(PropertyInfo(Variant::DICTIONARY, "surfaces/" + itos(i), PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR)); p_list->push_back(PropertyInfo(Variant::STRING, "surface_" + itos(i + 1) + "/name", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_EDITOR)); p_list->push_back(PropertyInfo(Variant::OBJECT, "surface_" + itos(i + 1) + "/material", PROPERTY_HINT_RESOURCE_TYPE, "Material", PROPERTY_USAGE_EDITOR)); } p_list->push_back(PropertyInfo(Variant::RECT3, "custom_aabb/custom_aabb")); } void Mesh::_recompute_aabb() { // regenerate AABB aabb = Rect3(); for (int i = 0; i < surfaces.size(); i++) { if (i == 0) aabb = surfaces[i].aabb; else aabb.merge_with(surfaces[i].aabb); } } void Mesh::add_surface(uint32_t p_format, PrimitiveType p_primitive, const PoolVector<uint8_t> &p_array, int p_vertex_count, const PoolVector<uint8_t> &p_index_array, int p_index_count, const Rect3 &p_aabb, const Vector<PoolVector<uint8_t> > &p_blend_shapes, const Vector<Rect3> &p_bone_aabbs) { Surface s; s.aabb = p_aabb; surfaces.push_back(s); VisualServer::get_singleton()->mesh_add_surface(mesh, p_format, (VS::PrimitiveType)p_primitive, p_array, p_vertex_count, p_index_array, p_index_count, p_aabb, p_blend_shapes, p_bone_aabbs); } void Mesh::add_surface_from_arrays(PrimitiveType p_primitive, const Array &p_arrays, const Array &p_blend_shapes, uint32_t p_flags) { ERR_FAIL_COND(p_arrays.size() != ARRAY_MAX); Surface s; VisualServer::get_singleton()->mesh_add_surface_from_arrays(mesh, (VisualServer::PrimitiveType)p_primitive, p_arrays, p_blend_shapes, p_flags); surfaces.push_back(s); /* make aABB? */ { PoolVector<Vector3> vertices = p_arrays[ARRAY_VERTEX]; int len = vertices.size(); ERR_FAIL_COND(len == 0); PoolVector<Vector3>::Read r = vertices.read(); const Vector3 *vtx = r.ptr(); // check AABB Rect3 aabb; for (int i = 0; i < len; i++) { if (i == 0) aabb.pos = vtx[i]; else aabb.expand_to(vtx[i]); } surfaces[surfaces.size() - 1].aabb = aabb; _recompute_aabb(); } triangle_mesh = Ref<TriangleMesh>(); _change_notify(); emit_changed(); } Array Mesh::surface_get_arrays(int p_surface) const { ERR_FAIL_INDEX_V(p_surface, surfaces.size(), Array()); return VisualServer::get_singleton()->mesh_surface_get_arrays(mesh, p_surface); } Array Mesh::surface_get_blend_shape_arrays(int p_surface) const { ERR_FAIL_INDEX_V(p_surface, surfaces.size(), Array()); return Array(); } int Mesh::get_surface_count() const { return surfaces.size(); } void Mesh::add_blend_shape(const StringName &p_name) { if (surfaces.size()) { ERR_EXPLAIN("Can't add a shape key count if surfaces are already created."); ERR_FAIL_COND(surfaces.size()); } StringName name = p_name; if (blend_shapes.find(name) != -1) { int count = 2; do { name = String(p_name) + " " + itos(count); count++; } while (blend_shapes.find(name) != -1); } blend_shapes.push_back(name); VS::get_singleton()->mesh_set_blend_shape_count(mesh, blend_shapes.size()); } int Mesh::get_blend_shape_count() const { return blend_shapes.size(); } StringName Mesh::get_blend_shape_name(int p_index) const { ERR_FAIL_INDEX_V(p_index, blend_shapes.size(), StringName()); return blend_shapes[p_index]; } void Mesh::clear_blend_shapes() { if (surfaces.size()) { ERR_EXPLAIN("Can't set shape key count if surfaces are already created."); ERR_FAIL_COND(surfaces.size()); } blend_shapes.clear(); } void Mesh::set_blend_shape_mode(BlendShapeMode p_mode) { blend_shape_mode = p_mode; VS::get_singleton()->mesh_set_blend_shape_mode(mesh, (VS::BlendShapeMode)p_mode); } Mesh::BlendShapeMode Mesh::get_blend_shape_mode() const { return blend_shape_mode; } void Mesh::surface_remove(int p_idx) { ERR_FAIL_INDEX(p_idx, surfaces.size()); VisualServer::get_singleton()->mesh_remove_surface(mesh, p_idx); surfaces.remove(p_idx); triangle_mesh = Ref<TriangleMesh>(); _recompute_aabb(); _change_notify(); emit_changed(); } int Mesh::surface_get_array_len(int p_idx) const { ERR_FAIL_INDEX_V(p_idx, surfaces.size(), -1); return VisualServer::get_singleton()->mesh_surface_get_array_len(mesh, p_idx); } int Mesh::surface_get_array_index_len(int p_idx) const { ERR_FAIL_INDEX_V(p_idx, surfaces.size(), -1); return VisualServer::get_singleton()->mesh_surface_get_array_index_len(mesh, p_idx); } uint32_t Mesh::surface_get_format(int p_idx) const { ERR_FAIL_INDEX_V(p_idx, surfaces.size(), 0); return VisualServer::get_singleton()->mesh_surface_get_format(mesh, p_idx); } Mesh::PrimitiveType Mesh::surface_get_primitive_type(int p_idx) const { ERR_FAIL_INDEX_V(p_idx, surfaces.size(), PRIMITIVE_LINES); return (PrimitiveType)VisualServer::get_singleton()->mesh_surface_get_primitive_type(mesh, p_idx); } void Mesh::surface_set_material(int p_idx, const Ref<Material> &p_material) { ERR_FAIL_INDEX(p_idx, surfaces.size()); if (surfaces[p_idx].material == p_material) return; surfaces[p_idx].material = p_material; VisualServer::get_singleton()->mesh_surface_set_material(mesh, p_idx, p_material.is_null() ? RID() : p_material->get_rid()); _change_notify("material"); } void Mesh::surface_set_name(int p_idx, const String &p_name) { ERR_FAIL_INDEX(p_idx, surfaces.size()); surfaces[p_idx].name = p_name; } String Mesh::surface_get_name(int p_idx) const { ERR_FAIL_INDEX_V(p_idx, surfaces.size(), String()); return surfaces[p_idx].name; } void Mesh::surface_set_custom_aabb(int p_idx, const Rect3 &p_aabb) { ERR_FAIL_INDEX(p_idx, surfaces.size()); surfaces[p_idx].aabb = p_aabb; // set custom aabb too? } Ref<Material> Mesh::surface_get_material(int p_idx) const { ERR_FAIL_INDEX_V(p_idx, surfaces.size(), Ref<Material>()); return surfaces[p_idx].material; } void Mesh::add_surface_from_mesh_data(const Geometry::MeshData &p_mesh_data) { VisualServer::get_singleton()->mesh_add_surface_from_mesh_data(mesh, p_mesh_data); Rect3 aabb; for (int i = 0; i < p_mesh_data.vertices.size(); i++) { if (i == 0) aabb.pos = p_mesh_data.vertices[i]; else aabb.expand_to(p_mesh_data.vertices[i]); } Surface s; s.aabb = aabb; if (surfaces.size() == 0) aabb = s.aabb; else aabb.merge_with(s.aabb); triangle_mesh = Ref<TriangleMesh>(); surfaces.push_back(s); _change_notify(); emit_changed(); } RID Mesh::get_rid() const { return mesh; } Rect3 Mesh::get_aabb() const { return aabb; } void Mesh::set_custom_aabb(const Rect3 &p_custom) { custom_aabb = p_custom; VS::get_singleton()->mesh_set_custom_aabb(mesh, custom_aabb); } Rect3 Mesh::get_custom_aabb() const { return custom_aabb; } PoolVector<Face3> Mesh::get_faces() const { Ref<TriangleMesh> tm = generate_triangle_mesh(); if (tm.is_valid()) return tm->get_faces(); return PoolVector<Face3>(); /* for (int i=0;i<surfaces.size();i++) { if (VisualServer::get_singleton()->mesh_surface_get_primitive_type( mesh, i ) != VisualServer::PRIMITIVE_TRIANGLES ) continue; PoolVector<int> indices; PoolVector<Vector3> vertices; vertices=VisualServer::get_singleton()->mesh_surface_get_array(mesh, i,VisualServer::ARRAY_VERTEX); int len=VisualServer::get_singleton()->mesh_surface_get_array_index_len(mesh, i); bool has_indices; if (len>0) { indices=VisualServer::get_singleton()->mesh_surface_get_array(mesh, i,VisualServer::ARRAY_INDEX); has_indices=true; } else { len=vertices.size(); has_indices=false; } if (len<=0) continue; PoolVector<int>::Read indicesr = indices.read(); const int *indicesptr = indicesr.ptr(); PoolVector<Vector3>::Read verticesr = vertices.read(); const Vector3 *verticesptr = verticesr.ptr(); int old_faces=faces.size(); int new_faces=old_faces+(len/3); faces.resize(new_faces); PoolVector<Face3>::Write facesw = faces.write(); Face3 *facesptr=facesw.ptr(); for (int i=0;i<len/3;i++) { Face3 face; for (int j=0;j<3;j++) { int idx=i*3+j; face.vertex[j] = has_indices ? verticesptr[ indicesptr[ idx ] ] : verticesptr[idx]; } facesptr[i+old_faces]=face; } } */ } 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; } 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 Mesh::center_geometry() { /* Vector3 ofs = aabb.pos+aabb.size*0.5; for(int i=0;i<get_surface_count();i++) { PoolVector<Vector3> geom = surface_get_array(i,ARRAY_VERTEX); int gc =geom.size(); PoolVector<Vector3>::Write w = geom.write(); surfaces[i].aabb.pos-=ofs; for(int i=0;i<gc;i++) { w[i]-=ofs; } w = PoolVector<Vector3>::Write(); surface_set_array(i,ARRAY_VERTEX,geom); } aabb.pos-=ofs; */ } void Mesh::regen_normalmaps() { Vector<Ref<SurfaceTool> > surfs; for (int i = 0; i < get_surface_count(); i++) { Ref<SurfaceTool> st = memnew(SurfaceTool); st->create_from(Ref<Mesh>(this), i); surfs.push_back(st); } while (get_surface_count()) { surface_remove(0); } for (int i = 0; i < surfs.size(); i++) { surfs[i]->generate_tangents(); surfs[i]->commit(Ref<Mesh>(this)); } } Ref<TriangleMesh> Mesh::generate_triangle_mesh() const { if (triangle_mesh.is_valid()) return triangle_mesh; int facecount = 0; for (int i = 0; i < get_surface_count(); i++) { if (surface_get_primitive_type(i) != PRIMITIVE_TRIANGLES) continue; if (surface_get_format(i) & ARRAY_FORMAT_INDEX) { facecount += surface_get_array_index_len(i); } else { facecount += surface_get_array_len(i); } } if (facecount == 0 || (facecount % 3) != 0) return triangle_mesh; PoolVector<Vector3> faces; faces.resize(facecount); PoolVector<Vector3>::Write facesw = faces.write(); int widx = 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); int vc = surface_get_array_len(i); PoolVector<Vector3> vertices = a[ARRAY_VERTEX]; PoolVector<Vector3>::Read vr = vertices.read(); if (surface_get_format(i) & ARRAY_FORMAT_INDEX) { int ic = surface_get_array_index_len(i); PoolVector<int> indices = a[ARRAY_INDEX]; PoolVector<int>::Read ir = indices.read(); for (int i = 0; i < ic; i++) { int index = ir[i]; facesw[widx++] = vr[index]; } } else { for (int i = 0; i < vc; i++) facesw[widx++] = vr[i]; } } facesw = PoolVector<Vector3>::Write(); triangle_mesh = Ref<TriangleMesh>(memnew(TriangleMesh)); triangle_mesh->create(faces); return triangle_mesh; } 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); int vcount = 0; if (i == 0) { arrays = a; PoolVector<Vector3> v = a[ARRAY_VERTEX]; index_accum += v.size(); } else { 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; } } } } { 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<Mesh>()); 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<Mesh> newmesh = memnew(Mesh); newmesh->add_surface_from_arrays(PRIMITIVE_TRIANGLES, arrays); return newmesh; } void Mesh::_bind_methods() { ClassDB::bind_method(D_METHOD("add_blend_shape", "name"), &Mesh::add_blend_shape); ClassDB::bind_method(D_METHOD("get_blend_shape_count"), &Mesh::get_blend_shape_count); ClassDB::bind_method(D_METHOD("get_blend_shape_name", "index"), &Mesh::get_blend_shape_name); ClassDB::bind_method(D_METHOD("clear_blend_shapes"), &Mesh::clear_blend_shapes); ClassDB::bind_method(D_METHOD("set_blend_shape_mode", "mode"), &Mesh::set_blend_shape_mode); ClassDB::bind_method(D_METHOD("get_blend_shape_mode"), &Mesh::get_blend_shape_mode); ClassDB::bind_method(D_METHOD("add_surface_from_arrays", "primitive", "arrays", "blend_shapes", "compress_flags"), &Mesh::add_surface_from_arrays, DEFVAL(Array()), DEFVAL(ARRAY_COMPRESS_DEFAULT)); ClassDB::bind_method(D_METHOD("get_surface_count"), &Mesh::get_surface_count); ClassDB::bind_method(D_METHOD("surface_remove", "surf_idx"), &Mesh::surface_remove); ClassDB::bind_method(D_METHOD("surface_get_array_len", "surf_idx"), &Mesh::surface_get_array_len); ClassDB::bind_method(D_METHOD("surface_get_array_index_len", "surf_idx"), &Mesh::surface_get_array_index_len); ClassDB::bind_method(D_METHOD("surface_get_format", "surf_idx"), &Mesh::surface_get_format); ClassDB::bind_method(D_METHOD("surface_get_primitive_type", "surf_idx"), &Mesh::surface_get_primitive_type); ClassDB::bind_method(D_METHOD("surface_set_material", "surf_idx", "material:Material"), &Mesh::surface_set_material); ClassDB::bind_method(D_METHOD("surface_get_material:Material", "surf_idx"), &Mesh::surface_get_material); ClassDB::bind_method(D_METHOD("surface_set_name", "surf_idx", "name"), &Mesh::surface_set_name); ClassDB::bind_method(D_METHOD("surface_get_name", "surf_idx"), &Mesh::surface_get_name); ClassDB::bind_method(D_METHOD("center_geometry"), &Mesh::center_geometry); ClassDB::set_method_flags(get_class_static(), _scs_create("center_geometry"), METHOD_FLAGS_DEFAULT | METHOD_FLAG_EDITOR); ClassDB::bind_method(D_METHOD("regen_normalmaps"), &Mesh::regen_normalmaps); ClassDB::set_method_flags(get_class_static(), _scs_create("regen_normalmaps"), METHOD_FLAGS_DEFAULT | METHOD_FLAG_EDITOR); ClassDB::bind_method(D_METHOD("set_custom_aabb", "aabb"), &Mesh::set_custom_aabb); ClassDB::bind_method(D_METHOD("get_custom_aabb"), &Mesh::get_custom_aabb); BIND_CONSTANT(NO_INDEX_ARRAY); BIND_CONSTANT(ARRAY_WEIGHTS_SIZE); BIND_CONSTANT(ARRAY_VERTEX); BIND_CONSTANT(ARRAY_NORMAL); BIND_CONSTANT(ARRAY_TANGENT); BIND_CONSTANT(ARRAY_COLOR); BIND_CONSTANT(ARRAY_TEX_UV); BIND_CONSTANT(ARRAY_TEX_UV2); BIND_CONSTANT(ARRAY_BONES); BIND_CONSTANT(ARRAY_WEIGHTS); BIND_CONSTANT(ARRAY_INDEX); BIND_CONSTANT(ARRAY_FORMAT_VERTEX); BIND_CONSTANT(ARRAY_FORMAT_NORMAL); BIND_CONSTANT(ARRAY_FORMAT_TANGENT); BIND_CONSTANT(ARRAY_FORMAT_COLOR); BIND_CONSTANT(ARRAY_FORMAT_TEX_UV); BIND_CONSTANT(ARRAY_FORMAT_TEX_UV2); BIND_CONSTANT(ARRAY_FORMAT_BONES); BIND_CONSTANT(ARRAY_FORMAT_WEIGHTS); BIND_CONSTANT(ARRAY_FORMAT_INDEX); BIND_CONSTANT(PRIMITIVE_POINTS); BIND_CONSTANT(PRIMITIVE_LINES); BIND_CONSTANT(PRIMITIVE_LINE_STRIP); BIND_CONSTANT(PRIMITIVE_LINE_LOOP); BIND_CONSTANT(PRIMITIVE_TRIANGLES); BIND_CONSTANT(PRIMITIVE_TRIANGLE_STRIP); BIND_CONSTANT(PRIMITIVE_TRIANGLE_FAN); } Mesh::Mesh() { mesh = VisualServer::get_singleton()->mesh_create(); blend_shape_mode = BLEND_SHAPE_MODE_RELATIVE; } Mesh::~Mesh() { VisualServer::get_singleton()->free(mesh); } //////////////////////// void QuadMesh::_bind_methods() { ClassDB::bind_method(D_METHOD("set_material", "material:Material"), &QuadMesh::set_material); ClassDB::bind_method(D_METHOD("get_material:Material"), &QuadMesh::get_material); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "material", PROPERTY_HINT_RESOURCE_TYPE, "Material"), "set_material", "get_material"); } void QuadMesh::set_material(const Ref<Material> &p_material) { surface_set_material(0, p_material); } Ref<Material> QuadMesh::get_material() const { return surface_get_material(0); } QuadMesh::QuadMesh() { PoolVector<Vector3> faces; PoolVector<Vector3> normals; PoolVector<float> tangents; PoolVector<Vector2> uvs; faces.resize(4); normals.resize(4); tangents.resize(4 * 4); uvs.resize(4); for (int i = 0; i < 4; i++) { static const Vector3 quad_faces[4] = { Vector3(-1, -1, 0), Vector3(-1, 1, 0), Vector3(1, 1, 0), Vector3(1, -1, 0), }; faces.set(i, quad_faces[i]); normals.set(i, Vector3(0, 0, 1)); tangents.set(i * 4 + 0, 1.0); tangents.set(i * 4 + 1, 0.0); tangents.set(i * 4 + 2, 0.0); tangents.set(i * 4 + 3, 1.0); static const Vector2 quad_uv[4] = { Vector2(0, 1), Vector2(0, 0), Vector2(1, 0), Vector2(1, 1), }; uvs.set(i, quad_uv[i]); } Array arr; arr.resize(ARRAY_MAX); arr[ARRAY_VERTEX] = faces; arr[ARRAY_NORMAL] = normals; arr[ARRAY_TANGENT] = tangents; arr[ARRAY_TEX_UV] = uvs; add_surface_from_arrays(PRIMITIVE_TRIANGLE_FAN, arr); }