feat: updated engine
This commit is contained in:
parent
cbe99774ff
commit
f4cf6b3999
6607 changed files with 910135 additions and 430025 deletions
|
|
@ -30,6 +30,7 @@
|
|||
|
||||
#include "surface_tool.h"
|
||||
|
||||
#include "core/object/class_db.h"
|
||||
#include "core/templates/a_hash_map.h"
|
||||
|
||||
#define EQ_VERTEX_DIST 0.00001
|
||||
|
|
@ -42,6 +43,7 @@ SurfaceTool::SimplifyScaleFunc SurfaceTool::simplify_scale_func = nullptr;
|
|||
SurfaceTool::GenerateRemapFunc SurfaceTool::generate_remap_func = nullptr;
|
||||
SurfaceTool::RemapVertexFunc SurfaceTool::remap_vertex_func = nullptr;
|
||||
SurfaceTool::RemapIndexFunc SurfaceTool::remap_index_func = nullptr;
|
||||
SurfaceTool::GenerateTangentsFunc SurfaceTool::generate_tangents_func = nullptr;
|
||||
|
||||
void SurfaceTool::strip_mesh_arrays(PackedVector3Array &r_vertices, PackedInt32Array &r_indices) {
|
||||
ERR_FAIL_COND_MSG(!generate_remap_func || !remap_vertex_func || !remap_index_func, "Meshoptimizer library is not initialized.");
|
||||
|
|
@ -95,10 +97,6 @@ bool SurfaceTool::Vertex::operator==(const Vertex &p_vertex) const {
|
|||
return false;
|
||||
}
|
||||
|
||||
if (binormal != p_vertex.binormal) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (tangent != p_vertex.tangent) {
|
||||
return false;
|
||||
}
|
||||
|
|
@ -123,7 +121,7 @@ bool SurfaceTool::Vertex::operator==(const Vertex &p_vertex) const {
|
|||
}
|
||||
}
|
||||
|
||||
for (int i = 0; i < RS::ARRAY_CUSTOM_COUNT; i++) {
|
||||
for (int i = 0; i < RSE::ARRAY_CUSTOM_COUNT; i++) {
|
||||
if (custom[i] != p_vertex.custom[i]) {
|
||||
return false;
|
||||
}
|
||||
|
|
@ -234,11 +232,10 @@ void SurfaceTool::add_vertex(const Vector3 &p_vertex) {
|
|||
vtx.uv2 = last_uv2;
|
||||
vtx.weights = last_weights;
|
||||
vtx.bones = last_bones;
|
||||
vtx.tangent = last_tangent.normal;
|
||||
vtx.binormal = last_normal.cross(last_tangent.normal).normalized() * last_tangent.d;
|
||||
vtx.tangent = last_tangent;
|
||||
vtx.smooth_group = last_smooth_group;
|
||||
|
||||
for (int i = 0; i < RS::ARRAY_CUSTOM_COUNT; i++) {
|
||||
for (int i = 0; i < RSE::ARRAY_CUSTOM_COUNT; i++) {
|
||||
vtx.custom[i] = last_custom[i];
|
||||
}
|
||||
|
||||
|
|
@ -316,7 +313,7 @@ void SurfaceTool::set_tangent(const Plane &p_tangent) {
|
|||
ERR_FAIL_COND(!first && !(format & Mesh::ARRAY_FORMAT_TANGENT));
|
||||
|
||||
format |= Mesh::ARRAY_FORMAT_TANGENT;
|
||||
last_tangent = p_tangent;
|
||||
last_tangent = Vector4(p_tangent.normal.x, p_tangent.normal.y, p_tangent.normal.z, p_tangent.d);
|
||||
}
|
||||
|
||||
void SurfaceTool::set_uv(const Vector2 &p_uv) {
|
||||
|
|
@ -336,10 +333,10 @@ void SurfaceTool::set_uv2(const Vector2 &p_uv2) {
|
|||
}
|
||||
|
||||
void SurfaceTool::set_custom(int p_channel_index, const Color &p_custom) {
|
||||
ERR_FAIL_INDEX(p_channel_index, RS::ARRAY_CUSTOM_COUNT);
|
||||
ERR_FAIL_INDEX(p_channel_index, RSE::ARRAY_CUSTOM_COUNT);
|
||||
ERR_FAIL_COND(!begun);
|
||||
ERR_FAIL_COND(last_custom_format[p_channel_index] == CUSTOM_MAX);
|
||||
static const uint32_t mask[RS::ARRAY_CUSTOM_COUNT] = { Mesh::ARRAY_FORMAT_CUSTOM0, Mesh::ARRAY_FORMAT_CUSTOM1, Mesh::ARRAY_FORMAT_CUSTOM2, Mesh::ARRAY_FORMAT_CUSTOM3 };
|
||||
static const uint32_t mask[RSE::ARRAY_CUSTOM_COUNT] = { Mesh::ARRAY_FORMAT_CUSTOM0, Mesh::ARRAY_FORMAT_CUSTOM1, Mesh::ARRAY_FORMAT_CUSTOM2, Mesh::ARRAY_FORMAT_CUSTOM3 };
|
||||
ERR_FAIL_COND(!first && !(format & mask[p_channel_index]));
|
||||
|
||||
if (first) {
|
||||
|
|
@ -383,19 +380,19 @@ void SurfaceTool::add_triangle_fan(const Vector<Vector3> &p_vertices, const Vect
|
|||
ERR_FAIL_COND(primitive != Mesh::PRIMITIVE_TRIANGLES);
|
||||
ERR_FAIL_COND(p_vertices.size() < 3);
|
||||
|
||||
#define ADD_POINT(n) \
|
||||
{ \
|
||||
if (p_colors.size() > n) \
|
||||
set_color(p_colors[n]); \
|
||||
if (p_uvs.size() > n) \
|
||||
set_uv(p_uvs[n]); \
|
||||
if (p_uv2s.size() > n) \
|
||||
set_uv2(p_uv2s[n]); \
|
||||
if (p_normals.size() > n) \
|
||||
set_normal(p_normals[n]); \
|
||||
if (p_tangents.size() > n) \
|
||||
#define ADD_POINT(n) \
|
||||
{ \
|
||||
if (p_colors.size() > n) \
|
||||
set_color(p_colors[n]); \
|
||||
if (p_uvs.size() > n) \
|
||||
set_uv(p_uvs[n]); \
|
||||
if (p_uv2s.size() > n) \
|
||||
set_uv2(p_uv2s[n]); \
|
||||
if (p_normals.size() > n) \
|
||||
set_normal(p_normals[n]); \
|
||||
if (p_tangents.size() > n) \
|
||||
set_tangent(p_tangents[n]); \
|
||||
add_vertex(p_vertices[n]); \
|
||||
add_vertex(p_vertices[n]); \
|
||||
}
|
||||
|
||||
for (int i = 0; i < p_vertices.size() - 2; i++) {
|
||||
|
|
@ -482,10 +479,7 @@ Array SurfaceTool::commit_to_arrays() {
|
|||
w[idx * 4 + 0] = v.tangent.x;
|
||||
w[idx * 4 + 1] = v.tangent.y;
|
||||
w[idx * 4 + 2] = v.tangent.z;
|
||||
|
||||
//float d = v.tangent.dot(v.binormal,v.normal);
|
||||
float d = v.binormal.dot(v.normal.cross(v.tangent));
|
||||
w[idx * 4 + 3] = d < 0 ? -1 : 1;
|
||||
w[idx * 4 + 3] = v.tangent.w;
|
||||
}
|
||||
|
||||
a[i] = array;
|
||||
|
|
@ -727,9 +721,9 @@ Ref<ArrayMesh> SurfaceTool::commit(const Ref<ArrayMesh> &p_existing, uint64_t p_
|
|||
|
||||
Array a = commit_to_arrays();
|
||||
|
||||
uint64_t compress_flags = (p_compress_flags >> RS::ARRAY_COMPRESS_FLAGS_BASE) << RS::ARRAY_COMPRESS_FLAGS_BASE;
|
||||
static const uint64_t shift[RS::ARRAY_CUSTOM_COUNT] = { Mesh::ARRAY_FORMAT_CUSTOM0_SHIFT, Mesh::ARRAY_FORMAT_CUSTOM1_SHIFT, Mesh::ARRAY_FORMAT_CUSTOM2_SHIFT, Mesh::ARRAY_FORMAT_CUSTOM3_SHIFT };
|
||||
for (int i = 0; i < RS::ARRAY_CUSTOM_COUNT; i++) {
|
||||
uint64_t compress_flags = (p_compress_flags >> RSE::ARRAY_COMPRESS_FLAGS_BASE) << RSE::ARRAY_COMPRESS_FLAGS_BASE;
|
||||
static const uint64_t shift[RSE::ARRAY_CUSTOM_COUNT] = { Mesh::ARRAY_FORMAT_CUSTOM0_SHIFT, Mesh::ARRAY_FORMAT_CUSTOM1_SHIFT, Mesh::ARRAY_FORMAT_CUSTOM2_SHIFT, Mesh::ARRAY_FORMAT_CUSTOM3_SHIFT };
|
||||
for (int i = 0; i < RSE::ARRAY_CUSTOM_COUNT; i++) {
|
||||
if (last_custom_format[i] != CUSTOM_MAX) {
|
||||
compress_flags |= uint64_t(last_custom_format[i]) << shift[i];
|
||||
}
|
||||
|
|
@ -776,7 +770,7 @@ void SurfaceTool::deindex() {
|
|||
return; //nothing to deindex
|
||||
}
|
||||
|
||||
LocalVector<Vertex> old_vertex_array = vertex_array;
|
||||
LocalVector<Vertex> old_vertex_array(vertex_array);
|
||||
vertex_array.clear();
|
||||
for (const int &index : index_array) {
|
||||
ERR_FAIL_COND(uint32_t(index) >= old_vertex_array.size());
|
||||
|
|
@ -790,27 +784,27 @@ void SurfaceTool::_create_list(const Ref<Mesh> &p_existing, int p_surface, Local
|
|||
ERR_FAIL_COND_MSG(p_existing.is_null(), "First argument in SurfaceTool::_create_list() must be a valid object of type Mesh");
|
||||
|
||||
Array arr = p_existing->surface_get_arrays(p_surface);
|
||||
ERR_FAIL_COND(arr.size() != RS::ARRAY_MAX);
|
||||
ERR_FAIL_COND(arr.size() != RSE::ARRAY_MAX);
|
||||
_create_list_from_arrays(arr, r_vertex, r_index, lformat);
|
||||
}
|
||||
|
||||
const uint32_t SurfaceTool::custom_mask[RS::ARRAY_CUSTOM_COUNT] = { Mesh::ARRAY_FORMAT_CUSTOM0, Mesh::ARRAY_FORMAT_CUSTOM1, Mesh::ARRAY_FORMAT_CUSTOM2, Mesh::ARRAY_FORMAT_CUSTOM3 };
|
||||
const uint32_t SurfaceTool::custom_shift[RS::ARRAY_CUSTOM_COUNT] = { Mesh::ARRAY_FORMAT_CUSTOM0_SHIFT, Mesh::ARRAY_FORMAT_CUSTOM1_SHIFT, Mesh::ARRAY_FORMAT_CUSTOM2_SHIFT, Mesh::ARRAY_FORMAT_CUSTOM3_SHIFT };
|
||||
const uint32_t SurfaceTool::custom_mask[RSE::ARRAY_CUSTOM_COUNT] = { Mesh::ARRAY_FORMAT_CUSTOM0, Mesh::ARRAY_FORMAT_CUSTOM1, Mesh::ARRAY_FORMAT_CUSTOM2, Mesh::ARRAY_FORMAT_CUSTOM3 };
|
||||
const uint32_t SurfaceTool::custom_shift[RSE::ARRAY_CUSTOM_COUNT] = { Mesh::ARRAY_FORMAT_CUSTOM0_SHIFT, Mesh::ARRAY_FORMAT_CUSTOM1_SHIFT, Mesh::ARRAY_FORMAT_CUSTOM2_SHIFT, Mesh::ARRAY_FORMAT_CUSTOM3_SHIFT };
|
||||
|
||||
void SurfaceTool::create_vertex_array_from_arrays(const Array &p_arrays, LocalVector<SurfaceTool::Vertex> &ret, uint64_t *r_format) {
|
||||
ERR_FAIL_INDEX(RS::ARRAY_WEIGHTS, p_arrays.size());
|
||||
ERR_FAIL_INDEX(RSE::ARRAY_WEIGHTS, p_arrays.size());
|
||||
|
||||
ret.clear();
|
||||
|
||||
Vector<Vector3> varr = p_arrays[RS::ARRAY_VERTEX];
|
||||
Vector<Vector3> narr = p_arrays[RS::ARRAY_NORMAL];
|
||||
Vector<float> tarr = p_arrays[RS::ARRAY_TANGENT];
|
||||
Vector<Color> carr = p_arrays[RS::ARRAY_COLOR];
|
||||
Vector<Vector2> uvarr = p_arrays[RS::ARRAY_TEX_UV];
|
||||
Vector<Vector2> uv2arr = p_arrays[RS::ARRAY_TEX_UV2];
|
||||
Vector<int> barr = p_arrays[RS::ARRAY_BONES];
|
||||
Vector<float> warr = p_arrays[RS::ARRAY_WEIGHTS];
|
||||
Vector<float> custom_float[RS::ARRAY_CUSTOM_COUNT];
|
||||
Vector<Vector3> varr = p_arrays[RSE::ARRAY_VERTEX];
|
||||
Vector<Vector3> narr = p_arrays[RSE::ARRAY_NORMAL];
|
||||
Vector<float> tarr = p_arrays[RSE::ARRAY_TANGENT];
|
||||
Vector<Color> carr = p_arrays[RSE::ARRAY_COLOR];
|
||||
Vector<Vector2> uvarr = p_arrays[RSE::ARRAY_TEX_UV];
|
||||
Vector<Vector2> uv2arr = p_arrays[RSE::ARRAY_TEX_UV2];
|
||||
Vector<int> barr = p_arrays[RSE::ARRAY_BONES];
|
||||
Vector<float> warr = p_arrays[RSE::ARRAY_WEIGHTS];
|
||||
Vector<float> custom_float[RSE::ARRAY_CUSTOM_COUNT];
|
||||
|
||||
int vc = varr.size();
|
||||
if (vc == 0) {
|
||||
|
|
@ -822,43 +816,43 @@ void SurfaceTool::create_vertex_array_from_arrays(const Array &p_arrays, LocalVe
|
|||
|
||||
uint64_t lformat = 0;
|
||||
if (varr.size()) {
|
||||
lformat |= RS::ARRAY_FORMAT_VERTEX;
|
||||
lformat |= RSE::ARRAY_FORMAT_VERTEX;
|
||||
}
|
||||
if (narr.size()) {
|
||||
lformat |= RS::ARRAY_FORMAT_NORMAL;
|
||||
lformat |= RSE::ARRAY_FORMAT_NORMAL;
|
||||
}
|
||||
if (tarr.size()) {
|
||||
lformat |= RS::ARRAY_FORMAT_TANGENT;
|
||||
lformat |= RSE::ARRAY_FORMAT_TANGENT;
|
||||
}
|
||||
if (carr.size()) {
|
||||
lformat |= RS::ARRAY_FORMAT_COLOR;
|
||||
lformat |= RSE::ARRAY_FORMAT_COLOR;
|
||||
}
|
||||
if (uvarr.size()) {
|
||||
lformat |= RS::ARRAY_FORMAT_TEX_UV;
|
||||
lformat |= RSE::ARRAY_FORMAT_TEX_UV;
|
||||
}
|
||||
if (uv2arr.size()) {
|
||||
lformat |= RS::ARRAY_FORMAT_TEX_UV2;
|
||||
lformat |= RSE::ARRAY_FORMAT_TEX_UV2;
|
||||
}
|
||||
int wcount = 0;
|
||||
if (barr.size() && warr.size()) {
|
||||
lformat |= RS::ARRAY_FORMAT_BONES;
|
||||
lformat |= RS::ARRAY_FORMAT_WEIGHTS;
|
||||
lformat |= RSE::ARRAY_FORMAT_BONES;
|
||||
lformat |= RSE::ARRAY_FORMAT_WEIGHTS;
|
||||
|
||||
wcount = barr.size() / varr.size();
|
||||
if (wcount == 8) {
|
||||
lformat |= RS::ARRAY_FLAG_USE_8_BONE_WEIGHTS;
|
||||
lformat |= RSE::ARRAY_FLAG_USE_8_BONE_WEIGHTS;
|
||||
}
|
||||
}
|
||||
|
||||
if (warr.size()) {
|
||||
lformat |= RS::ARRAY_FORMAT_WEIGHTS;
|
||||
lformat |= RSE::ARRAY_FORMAT_WEIGHTS;
|
||||
}
|
||||
|
||||
for (int i = 0; i < RS::ARRAY_CUSTOM_COUNT; i++) {
|
||||
ERR_CONTINUE_MSG(p_arrays[RS::ARRAY_CUSTOM0 + i].get_type() == Variant::PACKED_BYTE_ARRAY, "Extracting Byte/Half formats is not supported");
|
||||
if (p_arrays[RS::ARRAY_CUSTOM0 + i].get_type() == Variant::PACKED_FLOAT32_ARRAY) {
|
||||
for (int i = 0; i < RSE::ARRAY_CUSTOM_COUNT; i++) {
|
||||
ERR_CONTINUE_MSG(p_arrays[RSE::ARRAY_CUSTOM0 + i].get_type() == Variant::PACKED_BYTE_ARRAY, "Extracting Byte/Half formats is not supported");
|
||||
if (p_arrays[RSE::ARRAY_CUSTOM0 + i].get_type() == Variant::PACKED_FLOAT32_ARRAY) {
|
||||
lformat |= custom_mask[i];
|
||||
custom_float[i] = p_arrays[RS::ARRAY_CUSTOM0 + i];
|
||||
custom_float[i] = p_arrays[RSE::ARRAY_CUSTOM0 + i];
|
||||
int fmt = custom_float[i].size() / varr.size();
|
||||
if (fmt == 1) {
|
||||
lformat |= CUSTOM_R_FLOAT << custom_shift[i];
|
||||
|
|
@ -874,27 +868,25 @@ void SurfaceTool::create_vertex_array_from_arrays(const Array &p_arrays, LocalVe
|
|||
|
||||
for (int i = 0; i < vc; i++) {
|
||||
Vertex v;
|
||||
if (lformat & RS::ARRAY_FORMAT_VERTEX) {
|
||||
if (lformat & RSE::ARRAY_FORMAT_VERTEX) {
|
||||
v.vertex = varr[i];
|
||||
}
|
||||
if (lformat & RS::ARRAY_FORMAT_NORMAL) {
|
||||
if (lformat & RSE::ARRAY_FORMAT_NORMAL) {
|
||||
v.normal = narr[i];
|
||||
}
|
||||
if (lformat & RS::ARRAY_FORMAT_TANGENT) {
|
||||
v.tangent = Vector3(tarr[i * 4 + 0], tarr[i * 4 + 1], tarr[i * 4 + 2]);
|
||||
float d = tarr[i * 4 + 3];
|
||||
v.binormal = v.normal.cross(v.tangent).normalized() * d;
|
||||
if (lformat & RSE::ARRAY_FORMAT_TANGENT) {
|
||||
v.tangent = Vector4(tarr[i * 4 + 0], tarr[i * 4 + 1], tarr[i * 4 + 2], tarr[i * 4 + 3]);
|
||||
}
|
||||
if (lformat & RS::ARRAY_FORMAT_COLOR) {
|
||||
if (lformat & RSE::ARRAY_FORMAT_COLOR) {
|
||||
v.color = carr[i];
|
||||
}
|
||||
if (lformat & RS::ARRAY_FORMAT_TEX_UV) {
|
||||
if (lformat & RSE::ARRAY_FORMAT_TEX_UV) {
|
||||
v.uv = uvarr[i];
|
||||
}
|
||||
if (lformat & RS::ARRAY_FORMAT_TEX_UV2) {
|
||||
if (lformat & RSE::ARRAY_FORMAT_TEX_UV2) {
|
||||
v.uv2 = uv2arr[i];
|
||||
}
|
||||
if (lformat & RS::ARRAY_FORMAT_BONES) {
|
||||
if (lformat & RSE::ARRAY_FORMAT_BONES) {
|
||||
Vector<int> b;
|
||||
b.resize(wcount);
|
||||
for (int j = 0; j < wcount; j++) {
|
||||
|
|
@ -902,7 +894,7 @@ void SurfaceTool::create_vertex_array_from_arrays(const Array &p_arrays, LocalVe
|
|||
}
|
||||
v.bones = b;
|
||||
}
|
||||
if (lformat & RS::ARRAY_FORMAT_WEIGHTS) {
|
||||
if (lformat & RSE::ARRAY_FORMAT_WEIGHTS) {
|
||||
Vector<float> w;
|
||||
w.resize(wcount);
|
||||
for (int j = 0; j < wcount; j++) {
|
||||
|
|
@ -911,7 +903,7 @@ void SurfaceTool::create_vertex_array_from_arrays(const Array &p_arrays, LocalVe
|
|||
v.weights = w;
|
||||
}
|
||||
|
||||
for (int j = 0; j < RS::ARRAY_CUSTOM_COUNT; j++) {
|
||||
for (int j = 0; j < RSE::ARRAY_CUSTOM_COUNT; j++) {
|
||||
if (lformat & custom_mask[j]) {
|
||||
int cc = custom_float[j].size() / varr.size();
|
||||
for (int k = 0; k < cc; k++) {
|
||||
|
|
@ -935,10 +927,10 @@ void SurfaceTool::_create_list_from_arrays(Array arr, LocalVector<Vertex> *r_ver
|
|||
//indices
|
||||
r_index->clear();
|
||||
|
||||
Vector<int> idx = arr[RS::ARRAY_INDEX];
|
||||
Vector<int> idx = arr[RSE::ARRAY_INDEX];
|
||||
int is = idx.size();
|
||||
if (is) {
|
||||
lformat |= RS::ARRAY_FORMAT_INDEX;
|
||||
lformat |= RSE::ARRAY_FORMAT_INDEX;
|
||||
const int *iarr = idx.ptr();
|
||||
for (int i = 0; i < is; i++) {
|
||||
r_index->push_back(iarr[i]);
|
||||
|
|
@ -951,9 +943,9 @@ void SurfaceTool::create_from_arrays(const Array &p_arrays, Mesh::PrimitiveType
|
|||
primitive = p_primitive_type;
|
||||
_create_list_from_arrays(p_arrays, &vertex_array, &index_array, format);
|
||||
|
||||
for (int j = 0; j < RS::ARRAY_CUSTOM_COUNT; j++) {
|
||||
for (int j = 0; j < RSE::ARRAY_CUSTOM_COUNT; j++) {
|
||||
if (format & custom_mask[j]) {
|
||||
last_custom_format[j] = (CustomFormat)((format >> custom_shift[j]) & RS::ARRAY_FORMAT_CUSTOM_MASK);
|
||||
last_custom_format[j] = (CustomFormat)((format >> custom_shift[j]) & RSE::ARRAY_FORMAT_CUSTOM_MASK);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -970,9 +962,9 @@ void SurfaceTool::create_from(const Ref<Mesh> &p_existing, int p_surface) {
|
|||
_create_list(p_existing, p_surface, &vertex_array, &index_array, format);
|
||||
material = p_existing->surface_get_material(p_surface);
|
||||
|
||||
for (int j = 0; j < RS::ARRAY_CUSTOM_COUNT; j++) {
|
||||
for (int j = 0; j < RSE::ARRAY_CUSTOM_COUNT; j++) {
|
||||
if (format & custom_mask[j]) {
|
||||
last_custom_format[j] = (CustomFormat)((format >> custom_shift[j]) & RS::ARRAY_FORMAT_CUSTOM_MASK);
|
||||
last_custom_format[j] = (CustomFormat)((format >> custom_shift[j]) & RSE::ARRAY_FORMAT_CUSTOM_MASK);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -995,24 +987,24 @@ void SurfaceTool::create_from_blend_shape(const Ref<Mesh> &p_existing, int p_sur
|
|||
ERR_FAIL_COND(shape_idx == -1);
|
||||
ERR_FAIL_COND(shape_idx >= arr.size());
|
||||
Array blendshape_mesh_arrays = arr[shape_idx];
|
||||
ERR_FAIL_COND(blendshape_mesh_arrays.size() != RS::ARRAY_MAX);
|
||||
ERR_FAIL_COND(blendshape_mesh_arrays.size() != RSE::ARRAY_MAX);
|
||||
|
||||
Array source_mesh_arrays = p_existing->surface_get_arrays(p_surface);
|
||||
ERR_FAIL_COND(source_mesh_arrays.size() != RS::ARRAY_MAX);
|
||||
ERR_FAIL_COND(source_mesh_arrays.size() != RSE::ARRAY_MAX);
|
||||
|
||||
// Copy BlendShape vertex data over while keeping e.g. bones, weights, index from existing mesh intact.
|
||||
source_mesh_arrays[RS::ARRAY_VERTEX] = blendshape_mesh_arrays[RS::ARRAY_VERTEX];
|
||||
source_mesh_arrays[RS::ARRAY_NORMAL] = blendshape_mesh_arrays[RS::ARRAY_NORMAL];
|
||||
source_mesh_arrays[RS::ARRAY_TANGENT] = blendshape_mesh_arrays[RS::ARRAY_TANGENT];
|
||||
source_mesh_arrays[RSE::ARRAY_VERTEX] = blendshape_mesh_arrays[RSE::ARRAY_VERTEX];
|
||||
source_mesh_arrays[RSE::ARRAY_NORMAL] = blendshape_mesh_arrays[RSE::ARRAY_NORMAL];
|
||||
source_mesh_arrays[RSE::ARRAY_TANGENT] = blendshape_mesh_arrays[RSE::ARRAY_TANGENT];
|
||||
|
||||
_create_list_from_arrays(source_mesh_arrays, &vertex_array, &index_array, format);
|
||||
|
||||
material = p_existing->surface_get_material(p_surface);
|
||||
format = p_existing->surface_get_format(p_surface);
|
||||
|
||||
for (int j = 0; j < RS::ARRAY_CUSTOM_COUNT; j++) {
|
||||
for (int j = 0; j < RSE::ARRAY_CUSTOM_COUNT; j++) {
|
||||
if (format & custom_mask[j]) {
|
||||
last_custom_format[j] = (CustomFormat)((format >> custom_shift[j]) & RS::ARRAY_FORMAT_CUSTOM_MASK);
|
||||
last_custom_format[j] = (CustomFormat)((format >> custom_shift[j]) & RSE::ARRAY_FORMAT_CUSTOM_MASK);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1031,22 +1023,23 @@ void SurfaceTool::append_from(const Ref<Mesh> &p_existing, int p_surface, const
|
|||
_create_list(p_existing, p_surface, &nvertices, &nindices, nformat);
|
||||
format |= nformat;
|
||||
|
||||
for (int j = 0; j < RS::ARRAY_CUSTOM_COUNT; j++) {
|
||||
for (int j = 0; j < RSE::ARRAY_CUSTOM_COUNT; j++) {
|
||||
if (format & custom_mask[j]) {
|
||||
CustomFormat new_format = (CustomFormat)((format >> custom_shift[j]) & RS::ARRAY_FORMAT_CUSTOM_MASK);
|
||||
CustomFormat new_format = (CustomFormat)((format >> custom_shift[j]) & RSE::ARRAY_FORMAT_CUSTOM_MASK);
|
||||
last_custom_format[j] = new_format;
|
||||
}
|
||||
}
|
||||
int vfrom = vertex_array.size();
|
||||
float flip = p_xform.basis.determinant() < 0 ? -1.0f : 1.0f;
|
||||
|
||||
for (Vertex &v : nvertices) {
|
||||
v.vertex = p_xform.xform(v.vertex);
|
||||
if (nformat & RS::ARRAY_FORMAT_NORMAL) {
|
||||
if (nformat & RSE::ARRAY_FORMAT_NORMAL) {
|
||||
v.normal = p_xform.basis.xform(v.normal);
|
||||
}
|
||||
if (nformat & RS::ARRAY_FORMAT_TANGENT) {
|
||||
v.tangent = p_xform.basis.xform(v.tangent);
|
||||
v.binormal = p_xform.basis.xform(v.binormal);
|
||||
if (nformat & RSE::ARRAY_FORMAT_TANGENT) {
|
||||
Vector3 tangent = p_xform.basis.xform(Vector3(v.tangent.x, v.tangent.y, v.tangent.z));
|
||||
v.tangent = Vector4(tangent.x, tangent.y, tangent.z, v.tangent.w * flip);
|
||||
}
|
||||
|
||||
vertex_array.push_back(v);
|
||||
|
|
@ -1061,125 +1054,105 @@ void SurfaceTool::append_from(const Ref<Mesh> &p_existing, int p_surface, const
|
|||
}
|
||||
}
|
||||
|
||||
//mikktspace callbacks
|
||||
namespace {
|
||||
struct TangentGenerationContextUserData {
|
||||
LocalVector<SurfaceTool::Vertex> *vertices;
|
||||
LocalVector<int> *indices;
|
||||
struct TangentVertex {
|
||||
float position[3];
|
||||
float normal[3];
|
||||
float uv[2];
|
||||
};
|
||||
} // namespace
|
||||
|
||||
int SurfaceTool::mikktGetNumFaces(const SMikkTSpaceContext *pContext) {
|
||||
TangentGenerationContextUserData &triangle_data = *reinterpret_cast<TangentGenerationContextUserData *>(pContext->m_pUserData);
|
||||
|
||||
if (triangle_data.indices->size() > 0) {
|
||||
return triangle_data.indices->size() / 3;
|
||||
} else {
|
||||
return triangle_data.vertices->size() / 3;
|
||||
static void _propagate_tangents_or_split(LocalVector<SurfaceTool::Vertex> &r_vertex_array, LocalVector<int> &r_index_array, const float *p_tangents, bool p_split) {
|
||||
// Seed each vertex with one of its corner tangents; the loop below fixes any mismatches.
|
||||
for (size_t i = 0; i < r_index_array.size(); i++) {
|
||||
Vector4 tangent(p_tangents[i * 4 + 0], p_tangents[i * 4 + 1], p_tangents[i * 4 + 2], p_tangents[i * 4 + 3]);
|
||||
r_vertex_array[r_index_array[i]].tangent = Vector4(p_tangents[i * 4 + 0], p_tangents[i * 4 + 1], p_tangents[i * 4 + 2], p_tangents[i * 4 + 3]);
|
||||
}
|
||||
}
|
||||
|
||||
int SurfaceTool::mikktGetNumVerticesOfFace(const SMikkTSpaceContext *pContext, const int iFace) {
|
||||
return 3; //always 3
|
||||
}
|
||||
if (!p_split) {
|
||||
return;
|
||||
}
|
||||
|
||||
void SurfaceTool::mikktGetPosition(const SMikkTSpaceContext *pContext, float fvPosOut[], const int iFace, const int iVert) {
|
||||
TangentGenerationContextUserData &triangle_data = *reinterpret_cast<TangentGenerationContextUserData *>(pContext->m_pUserData);
|
||||
Vector3 v;
|
||||
if (triangle_data.indices->size() > 0) {
|
||||
uint32_t index = triangle_data.indices->operator[](iFace * 3 + iVert);
|
||||
if (index < triangle_data.vertices->size()) {
|
||||
v = triangle_data.vertices->operator[](index).vertex;
|
||||
LocalVector<uint32_t> splits;
|
||||
splits.resize(r_vertex_array.size());
|
||||
memset(splits.ptr(), -1, splits.size() * sizeof(uint32_t)); // ~0u means "no split copy"
|
||||
|
||||
for (size_t i = 0; i < r_index_array.size(); i++) {
|
||||
// Walk the chain of split copies looking for a vertex whose tangent matches.
|
||||
Vector4 tangent(p_tangents[i * 4 + 0], p_tangents[i * 4 + 1], p_tangents[i * 4 + 2], p_tangents[i * 4 + 3]);
|
||||
uint32_t v = r_index_array[i];
|
||||
while (v != ~0u && r_vertex_array[v].tangent != tangent) {
|
||||
v = splits[v];
|
||||
}
|
||||
} else {
|
||||
v = triangle_data.vertices->operator[](iFace * 3 + iVert).vertex;
|
||||
}
|
||||
|
||||
fvPosOut[0] = v.x;
|
||||
fvPosOut[1] = v.y;
|
||||
fvPosOut[2] = v.z;
|
||||
}
|
||||
|
||||
void SurfaceTool::mikktGetNormal(const SMikkTSpaceContext *pContext, float fvNormOut[], const int iFace, const int iVert) {
|
||||
TangentGenerationContextUserData &triangle_data = *reinterpret_cast<TangentGenerationContextUserData *>(pContext->m_pUserData);
|
||||
Vector3 v;
|
||||
if (triangle_data.indices->size() > 0) {
|
||||
uint32_t index = triangle_data.indices->operator[](iFace * 3 + iVert);
|
||||
if (index < triangle_data.vertices->size()) {
|
||||
v = triangle_data.vertices->operator[](index).normal;
|
||||
// No match in chain: append a new split copy with the target tangent and chain it.
|
||||
if (v == ~0u) {
|
||||
v = r_vertex_array.size();
|
||||
r_vertex_array.push_back(r_vertex_array[r_index_array[i]]);
|
||||
r_vertex_array[v].tangent = tangent;
|
||||
splits.push_back(splits[r_index_array[i]]);
|
||||
splits[r_index_array[i]] = v;
|
||||
}
|
||||
} else {
|
||||
v = triangle_data.vertices->operator[](iFace * 3 + iVert).normal;
|
||||
}
|
||||
|
||||
fvNormOut[0] = v.x;
|
||||
fvNormOut[1] = v.y;
|
||||
fvNormOut[2] = v.z;
|
||||
}
|
||||
|
||||
void SurfaceTool::mikktGetTexCoord(const SMikkTSpaceContext *pContext, float fvTexcOut[], const int iFace, const int iVert) {
|
||||
TangentGenerationContextUserData &triangle_data = *reinterpret_cast<TangentGenerationContextUserData *>(pContext->m_pUserData);
|
||||
Vector2 v;
|
||||
if (triangle_data.indices->size() > 0) {
|
||||
uint32_t index = triangle_data.indices->operator[](iFace * 3 + iVert);
|
||||
if (index < triangle_data.vertices->size()) {
|
||||
v = triangle_data.vertices->operator[](index).uv;
|
||||
}
|
||||
} else {
|
||||
v = triangle_data.vertices->operator[](iFace * 3 + iVert).uv;
|
||||
}
|
||||
|
||||
fvTexcOut[0] = v.x;
|
||||
fvTexcOut[1] = v.y;
|
||||
}
|
||||
|
||||
void SurfaceTool::mikktSetTSpaceDefault(const SMikkTSpaceContext *pContext, const float fvTangent[], const float fvBiTangent[], const float fMagS, const float fMagT,
|
||||
const tbool bIsOrientationPreserving, const int iFace, const int iVert) {
|
||||
TangentGenerationContextUserData &triangle_data = *reinterpret_cast<TangentGenerationContextUserData *>(pContext->m_pUserData);
|
||||
Vertex *vtx = nullptr;
|
||||
if (triangle_data.indices->size() > 0) {
|
||||
uint32_t index = triangle_data.indices->operator[](iFace * 3 + iVert);
|
||||
if (index < triangle_data.vertices->size()) {
|
||||
vtx = &triangle_data.vertices->operator[](index);
|
||||
}
|
||||
} else {
|
||||
vtx = &triangle_data.vertices->operator[](iFace * 3 + iVert);
|
||||
}
|
||||
|
||||
if (vtx != nullptr) {
|
||||
vtx->tangent = Vector3(fvTangent[0], fvTangent[1], fvTangent[2]);
|
||||
vtx->binormal = Vector3(-fvBiTangent[0], -fvBiTangent[1], -fvBiTangent[2]); // for some reason these are reversed, something with the coordinate system in Godot
|
||||
r_index_array[i] = int(v);
|
||||
}
|
||||
}
|
||||
|
||||
void SurfaceTool::generate_tangents() {
|
||||
void SurfaceTool::_generate_tangents_bind() {
|
||||
generate_tangents(/*split*/ false);
|
||||
}
|
||||
|
||||
void SurfaceTool::generate_tangents(bool p_split) {
|
||||
ERR_FAIL_COND_MSG(!generate_tangents_func, "Meshoptimizer library is not initialized.");
|
||||
ERR_FAIL_COND_MSG(!(format & Mesh::ARRAY_FORMAT_TEX_UV), "UVs are required to generate tangents.");
|
||||
ERR_FAIL_COND(!(format & Mesh::ARRAY_FORMAT_NORMAL));
|
||||
ERR_FAIL_COND(primitive != Mesh::PRIMITIVE_TRIANGLES);
|
||||
|
||||
SMikkTSpaceInterface mkif;
|
||||
mkif.m_getNormal = mikktGetNormal;
|
||||
mkif.m_getNumFaces = mikktGetNumFaces;
|
||||
mkif.m_getNumVerticesOfFace = mikktGetNumVerticesOfFace;
|
||||
mkif.m_getPosition = mikktGetPosition;
|
||||
mkif.m_getTexCoord = mikktGetTexCoord;
|
||||
mkif.m_setTSpace = mikktSetTSpaceDefault;
|
||||
mkif.m_setTSpaceBasic = nullptr;
|
||||
|
||||
SMikkTSpaceContext msc;
|
||||
msc.m_pInterface = &mkif;
|
||||
|
||||
TangentGenerationContextUserData triangle_data;
|
||||
triangle_data.vertices = &vertex_array;
|
||||
for (Vertex &vertex : vertex_array) {
|
||||
vertex.binormal = Vector3();
|
||||
vertex.tangent = Vector3();
|
||||
if (vertex_array.is_empty()) {
|
||||
format |= Mesh::ARRAY_FORMAT_TANGENT;
|
||||
return;
|
||||
}
|
||||
triangle_data.indices = &index_array;
|
||||
msc.m_pUserData = &triangle_data;
|
||||
|
||||
bool res = genTangSpaceDefault(&msc);
|
||||
size_t corner_count = index_array.size() > 0 ? index_array.size() : vertex_array.size();
|
||||
ERR_FAIL_COND(corner_count % 3 != 0);
|
||||
|
||||
// We can't operate on SurfaceTool::Vertex directly because in double-precision builds, vectors use double components
|
||||
// So we convert the inputs to single precision floats before generating tangents.
|
||||
LocalVector<TangentVertex> tangent_vertices;
|
||||
tangent_vertices.resize(vertex_array.size());
|
||||
|
||||
for (size_t i = 0; i < vertex_array.size(); i++) {
|
||||
const Vertex &vertex = vertex_array[i];
|
||||
TangentVertex &tangent_vertex = tangent_vertices[i];
|
||||
|
||||
tangent_vertex.position[0] = vertex.vertex.x;
|
||||
tangent_vertex.position[1] = vertex.vertex.y;
|
||||
tangent_vertex.position[2] = vertex.vertex.z;
|
||||
tangent_vertex.normal[0] = vertex.normal.x;
|
||||
tangent_vertex.normal[1] = vertex.normal.y;
|
||||
tangent_vertex.normal[2] = vertex.normal.z;
|
||||
tangent_vertex.uv[0] = vertex.uv.x;
|
||||
tangent_vertex.uv[1] = vertex.uv.y;
|
||||
}
|
||||
|
||||
const TangentVertex *vertices = tangent_vertices.ptr();
|
||||
|
||||
LocalVector<float> tangents;
|
||||
tangents.resize(corner_count * 4);
|
||||
|
||||
generate_tangents_func(tangents.ptr(),
|
||||
index_array.size() > 0 ? reinterpret_cast<const unsigned int *>(index_array.ptr()) : nullptr, corner_count,
|
||||
vertices->position, tangent_vertices.size(), sizeof(TangentVertex),
|
||||
vertices->normal, sizeof(TangentVertex),
|
||||
vertices->uv, sizeof(TangentVertex), 0);
|
||||
|
||||
if (index_array.size() > 0) {
|
||||
_propagate_tangents_or_split(vertex_array, index_array, tangents.ptr(), p_split);
|
||||
} else {
|
||||
for (size_t i = 0; i < corner_count; i++) {
|
||||
Vector4 tangent(tangents[i * 4 + 0], tangents[i * 4 + 1], tangents[i * 4 + 2], tangents[i * 4 + 3]);
|
||||
vertex_array[i].tangent = tangent;
|
||||
}
|
||||
}
|
||||
|
||||
ERR_FAIL_COND(!res);
|
||||
format |= Mesh::ARRAY_FORMAT_TANGENT;
|
||||
}
|
||||
|
||||
|
|
@ -1255,7 +1228,7 @@ void SurfaceTool::clear() {
|
|||
vertex_array.clear();
|
||||
material.unref();
|
||||
last_smooth_group = 0;
|
||||
for (int i = 0; i < RS::ARRAY_CUSTOM_COUNT; i++) {
|
||||
for (int i = 0; i < RSE::ARRAY_CUSTOM_COUNT; i++) {
|
||||
last_custom_format[i] = CUSTOM_MAX;
|
||||
}
|
||||
skin_weights = SKIN_4_WEIGHTS;
|
||||
|
|
@ -1270,7 +1243,7 @@ SurfaceTool::SkinWeightCount SurfaceTool::get_skin_weight_count() const {
|
|||
}
|
||||
|
||||
void SurfaceTool::set_custom_format(int p_channel_index, CustomFormat p_format) {
|
||||
ERR_FAIL_INDEX(p_channel_index, RS::ARRAY_CUSTOM_COUNT);
|
||||
ERR_FAIL_INDEX(p_channel_index, RSE::ARRAY_CUSTOM_COUNT);
|
||||
ERR_FAIL_COND(!begun);
|
||||
ERR_FAIL_INDEX(p_format, CUSTOM_MAX + 1);
|
||||
last_custom_format[p_channel_index] = p_format;
|
||||
|
|
@ -1280,7 +1253,7 @@ Mesh::PrimitiveType SurfaceTool::get_primitive_type() const {
|
|||
return primitive;
|
||||
}
|
||||
SurfaceTool::CustomFormat SurfaceTool::get_custom_format(int p_channel_index) const {
|
||||
ERR_FAIL_INDEX_V(p_channel_index, RS::ARRAY_CUSTOM_COUNT, CUSTOM_MAX);
|
||||
ERR_FAIL_INDEX_V(p_channel_index, RSE::ARRAY_CUSTOM_COUNT, CUSTOM_MAX);
|
||||
return last_custom_format[p_channel_index];
|
||||
}
|
||||
void SurfaceTool::optimize_indices_for_cache() {
|
||||
|
|
@ -1289,7 +1262,7 @@ void SurfaceTool::optimize_indices_for_cache() {
|
|||
ERR_FAIL_COND(primitive != Mesh::PRIMITIVE_TRIANGLES);
|
||||
ERR_FAIL_COND(index_array.size() % 3 != 0);
|
||||
|
||||
LocalVector old_index_array = index_array;
|
||||
LocalVector<int> old_index_array(index_array);
|
||||
memset(index_array.ptr(), 0, index_array.size() * sizeof(int));
|
||||
optimize_vertex_cache_func((unsigned int *)index_array.ptr(), (unsigned int *)old_index_array.ptr(), old_index_array.size(), vertex_array.size());
|
||||
}
|
||||
|
|
@ -1365,7 +1338,7 @@ void SurfaceTool::_bind_methods() {
|
|||
ClassDB::bind_method(D_METHOD("index"), &SurfaceTool::index);
|
||||
ClassDB::bind_method(D_METHOD("deindex"), &SurfaceTool::deindex);
|
||||
ClassDB::bind_method(D_METHOD("generate_normals", "flip"), &SurfaceTool::generate_normals, DEFVAL(false));
|
||||
ClassDB::bind_method(D_METHOD("generate_tangents"), &SurfaceTool::generate_tangents);
|
||||
ClassDB::bind_method(D_METHOD("generate_tangents"), &SurfaceTool::_generate_tangents_bind);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("optimize_indices_for_cache"), &SurfaceTool::optimize_indices_for_cache);
|
||||
|
||||
|
|
@ -1398,7 +1371,7 @@ void SurfaceTool::_bind_methods() {
|
|||
}
|
||||
|
||||
SurfaceTool::SurfaceTool() {
|
||||
for (int i = 0; i < RS::ARRAY_CUSTOM_COUNT; i++) {
|
||||
for (int i = 0; i < RSE::ARRAY_CUSTOM_COUNT; i++) {
|
||||
last_custom_format[i] = CUSTOM_MAX;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue