public void BindPoses()
{
UnityEngine.Mesh resultMesh = _resultMesh.Unity3dObject as UnityEngine.Mesh;
Assert.AreEqual(resultMesh.bindposes.Length, mesh.BindposesLength);
for (int i = 0; i < mesh.BindposesLength; i++)
{
Matrix4x4 resultMatrix = resultMesh.bindposes[i];
Matrix16 matrix = mesh.GetBindposes(i);
Assert.AreEqual(resultMatrix.m00, matrix.M00);
Assert.AreEqual(resultMatrix.m01, matrix.M01);
Assert.AreEqual(resultMatrix.m02, matrix.M02);
Assert.AreEqual(resultMatrix.m03, matrix.M03);
Assert.AreEqual(resultMatrix.m10, matrix.M10);
Assert.AreEqual(resultMatrix.m11, matrix.M11);
Assert.AreEqual(resultMatrix.m12, matrix.M12);
Assert.AreEqual(resultMatrix.m13, matrix.M13);
Assert.AreEqual(resultMatrix.m20, matrix.M20);
Assert.AreEqual(resultMatrix.m21, matrix.M21);
Assert.AreEqual(resultMatrix.m22, matrix.M22);
Assert.AreEqual(resultMatrix.m23, matrix.M23);
Assert.AreEqual(resultMatrix.m30, matrix.M30);
Assert.AreEqual(resultMatrix.m31, matrix.M31);
Assert.AreEqual(resultMatrix.m32, matrix.M32);
Assert.AreEqual(resultMatrix.m33, matrix.M33);
}
}
public void BindPoses()
{
UnityEngine.Mesh originMesh = smr.sharedMesh;
Assert.AreEqual(originMesh.bindposes.Length, mesh.BindposesLength);
for (int i = 0; i < mesh.BindposesLength; i++)
{
Matrix4x4 originMatrix = originMesh.bindposes [i];
Matrix16 matrix = mesh.GetBindposes(i);
Assert.AreEqual(originMatrix.m00, matrix.M00);
Assert.AreEqual(originMatrix.m01, matrix.M01);
Assert.AreEqual(originMatrix.m02, matrix.M02);
Assert.AreEqual(originMatrix.m03, matrix.M03);
Assert.AreEqual(originMatrix.m10, matrix.M10);
Assert.AreEqual(originMatrix.m11, matrix.M11);
Assert.AreEqual(originMatrix.m12, matrix.M12);
Assert.AreEqual(originMatrix.m13, matrix.M13);
Assert.AreEqual(originMatrix.m20, matrix.M20);
Assert.AreEqual(originMatrix.m21, matrix.M21);
Assert.AreEqual(originMatrix.m22, matrix.M22);
Assert.AreEqual(originMatrix.m23, matrix.M23);
Assert.AreEqual(originMatrix.m30, matrix.M30);
Assert.AreEqual(originMatrix.m31, matrix.M31);
Assert.AreEqual(originMatrix.m32, matrix.M32);
Assert.AreEqual(originMatrix.m33, matrix.M33);
}
}
public ResourceObject Parse(ByteBuffer bb)
{
Schema.Mesh fbMesh = Schema.Mesh.GetRootAsMesh(bb);
UnityEngine.Mesh mesh = new UnityEngine.Mesh();
Vec3 v3 = new Vec3();
Vec2 v2 = new Vec2();
Vec4 v4 = new Vec4();
Vector3[] inVertices = new Vector3[fbMesh.VerticesLength];
for (int i = 0; i < fbMesh.VerticesLength; i++)
{
Vec3 v = fbMesh.GetVertices(v3, i);
inVertices[i] = new Vector3(v.X, v.Y, v.Z);
}
mesh.vertices = inVertices;
if (fbMesh.UvLength > 0)
{
Vector2[] uvs = new Vector2[fbMesh.UvLength];
for (int i = 0; i < fbMesh.UvLength; i++)
{
Vec2 v = fbMesh.GetUv(v2, i);
uvs[i] = new Vector2(v.X, v.Y);
}
mesh.uv = uvs;
}
if (fbMesh.Uv2Length > 0)
{
Vector2[] uvs = new Vector2[fbMesh.Uv2Length];
for (int i = 0; i < fbMesh.Uv2Length; i++)
{
Vec2 v = fbMesh.GetUv2(v2, i);
uvs[i] = new Vector2(v.X, v.Y);
}
mesh.uv2 = uvs;
}
if (fbMesh.Uv3Length > 0)
{
Vector2[] uvs = new Vector2[fbMesh.Uv3Length];
for (int i = 0; i < fbMesh.Uv3Length; i++)
{
Vec2 v = fbMesh.GetUv3(v2, i);
uvs[i] = new Vector2(v.X, v.Y);
}
mesh.uv3 = uvs;
}
if (fbMesh.Uv4Length > 0)
{
Vector2[] uvs = new Vector2[fbMesh.Uv4Length];
for (int i = 0; i < fbMesh.Uv4Length; i++)
{
Vec2 v = fbMesh.GetUv4(v2, i);
uvs[i] = new Vector2(v.X, v.Y);
}
mesh.uv4 = uvs;
}
if (fbMesh.NormalsLength > 0)
{
Vector3[] normals = new Vector3[fbMesh.NormalsLength];
for (int i = 0; i < fbMesh.NormalsLength; i++)
{
Vec3 v = fbMesh.GetNormals(v3, i);
normals[i] = new Vector3(v.X, v.Y, v.Z);
}
mesh.normals = normals;
}
if (fbMesh.TangentsLength > 0)
{
Vector4[] tangents = new Vector4[fbMesh.TangentsLength];
for (int i = 0; i < fbMesh.TangentsLength; i++)
{
Vec4 v = fbMesh.GetTangents(v4, i);
tangents[i] = new Vector4(v.X, v.Y, v.Z, v.W);
}
mesh.tangents = tangents;
}
if (fbMesh.ColorsLength > 0)
{
Schema.Color cobj = new Schema.Color();
UnityEngine.Color[] colors = new UnityEngine.Color[fbMesh.ColorsLength];
for (int i = 0; i < fbMesh.ColorsLength; i++)
{
Schema.Color c = fbMesh.GetColors(cobj, i);
colors[i] = new UnityEngine.Color(c.R, c.G, c.B, c.A);
}
mesh.colors = colors;
}
if (fbMesh.Colors32Length > 0)
{
Schema.Color32 cobj = new Schema.Color32();
UnityEngine.Color32[] colors = new UnityEngine.Color32[fbMesh.Colors32Length];
for (int i = 0; i < fbMesh.Colors32Length; i++)
{
Schema.Color32 c = fbMesh.GetColors32(cobj, i);
colors[i] = new UnityEngine.Color32(c.R, c.G, c.B, c.A);
}
mesh.colors32 = colors;
}
if (fbMesh.BoneWeightsLength > 0)
{
Schema.BoneWeight bwobj = new Schema.BoneWeight();
UnityEngine.BoneWeight[] boneWeights = new UnityEngine.BoneWeight[fbMesh.BoneWeightsLength];
for (int i = 0; i < fbMesh.BoneWeightsLength; i++)
{
Schema.BoneWeight _bw = fbMesh.GetBoneWeights(bwobj, i);
UnityEngine.BoneWeight bw = new UnityEngine.BoneWeight();
bw.boneIndex0 = _bw.BoneIndex0;
bw.boneIndex1 = _bw.BoneIndex1;
bw.boneIndex2 = _bw.BoneIndex2;
bw.boneIndex3 = _bw.BoneIndex3;
bw.weight0 = _bw.Weight0;
bw.weight1 = _bw.Weight1;
bw.weight2 = _bw.Weight2;
bw.weight3 = _bw.Weight3;
boneWeights[i] = bw;
}
mesh.boneWeights = boneWeights;
}
int[] triangles = new int[fbMesh.TrianglesLength];
for (int i = 0; i < fbMesh.TrianglesLength; i++)
{
triangles[i] = fbMesh.GetTriangles(i);
}
mesh.triangles = triangles;
if (fbMesh.SubmeshesLength > 1)
{
for (int i = 0; i < fbMesh.SubmeshesLength; i++)
{
Schema.SubMesh sb = fbMesh.GetSubmeshes(i);
int[] indices = new int[sb.NumOfTriangles];
for (int j = 0; j < sb.NumOfTriangles; j++)
{
indices[j] = fbMesh.GetTriangles((int)sb.StartTriangle + j);
}
mesh.SetIndices(indices, (UnityEngine.MeshTopology)sb.MeshTopology, i);
}
}
if (fbMesh.BindposesLength > 0)
{
Matrix16 matrixObj = new Matrix16();
Matrix4x4[] matrices = new Matrix4x4[fbMesh.BindposesLength];
for (int i = 0; i < fbMesh.BindposesLength; i++)
{
Matrix16 _matrix = fbMesh.GetBindposes(matrixObj, i);
Matrix4x4 matrix = new Matrix4x4();
matrix.m00 = _matrix.M00;
matrix.m01 = _matrix.M01;
matrix.m02 = _matrix.M02;
matrix.m03 = _matrix.M03;
matrix.m10 = _matrix.M10;
matrix.m11 = _matrix.M11;
matrix.m12 = _matrix.M12;
matrix.m13 = _matrix.M13;
matrix.m20 = _matrix.M20;
matrix.m21 = _matrix.M21;
matrix.m22 = _matrix.M22;
matrix.m23 = _matrix.M23;
matrix.m30 = _matrix.M30;
matrix.m31 = _matrix.M31;
matrix.m32 = _matrix.M32;
matrix.m33 = _matrix.M33;
matrices[i] = matrix;
}
mesh.bindposes = matrices;
}
Bound _b = fbMesh.GetBound(new Bound());
Vec3 _min = _b.GetMin(v3);
Vector3 min = new Vector3(_min.X, _min.Y, _min.Z);
Vec3 _max = _b.GetMax(v3);
Vector3 max = new Vector3(_max.X, _max.Y, _max.Z);
Bounds b = new Bounds(min, max);
mesh.bounds = b;
string[] joints = new string[fbMesh.JointsLength];
for (int i = 0; i < fbMesh.JointsLength; i++)
{
joints[i] = fbMesh.GetJoints(i);
}
return(new ResourceObjectMesh(mesh, joints));
}
public static ByteBuffer Save(UnityEngine.Mesh mesh, UnityEngine.Transform[] bones)
{
FlatBufferBuilder builder = new FlatBufferBuilder(InitBufferSize);
// 创建顶点成分
MeshComponent[] components =
{
// vertices
new MeshComponent(
() => { return(true); },
() => { Schema.Mesh.StartVerticesVector(builder, mesh.vertexCount); },
(i) => { Vec3.CreateVec3(builder, mesh.vertices[i].x, mesh.vertices[i].y, mesh.vertices[i].z);},
(vo) => { Schema.Mesh.AddVertices(builder, vo); }
),
// uv
new MeshComponent(
() => { return((mesh.uv != null) && (mesh.uv.Length > 0)); },
() => { Schema.Mesh.StartUvVector(builder, mesh.vertexCount); },
(i) => { Vec2.CreateVec2(builder, mesh.uv[i].x, mesh.uv[i].y); },
(vo) => { Schema.Mesh.AddUv(builder, vo); }
),
// uv2
new MeshComponent(
() => { return((mesh.uv2 != null) && (mesh.uv2.Length > 0)); },
() => { Schema.Mesh.StartUv2Vector(builder, mesh.vertexCount); },
(i) => { Vec2.CreateVec2(builder, mesh.uv2[i].x, mesh.uv2[i].y); },
(vo) => { Schema.Mesh.AddUv2(builder, vo); }
),
// uv3
new MeshComponent(
() => { return((mesh.uv3 != null) && (mesh.uv3.Length > 0)); },
() => { Schema.Mesh.StartUv3Vector(builder, mesh.vertexCount); },
(i) => { Vec2.CreateVec2(builder, mesh.uv3[i].x, mesh.uv3[i].y); },
(vo) => { Schema.Mesh.AddUv3(builder, vo); }
),
// uv4
new MeshComponent(
() => { return((mesh.uv4 != null) && (mesh.uv4.Length > 0)); },
() => { Schema.Mesh.StartUv4Vector(builder, mesh.vertexCount); },
(i) => { Vec2.CreateVec2(builder, mesh.uv4[i].x, mesh.uv4[i].y); },
(vo) => { Schema.Mesh.AddUv4(builder, vo); }
),
// normals
new MeshComponent(
() => { return((mesh.normals != null) && (mesh.normals.Length > 0)); },
() => { Schema.Mesh.StartNormalsVector(builder, mesh.vertexCount); },
(i) => { Vec3.CreateVec3(builder, mesh.normals[i].x, mesh.normals[i].y, mesh.normals[i].z);},
(vo) => { Schema.Mesh.AddNormals(builder, vo); }
),
// tangents
new MeshComponent(
() => { return((mesh.tangents != null) && (mesh.tangents.Length > 0)); },
() => { Schema.Mesh.StartTangentsVector(builder, mesh.vertexCount); },
(i) => { Vec4.CreateVec4(builder, mesh.tangents[i].x, mesh.tangents[i].y, mesh.tangents[i].z, mesh.tangents[i].w);},
(vo) => { Schema.Mesh.AddTangents(builder, vo); }
),
// colors
new MeshComponent(
() => { return((mesh.colors != null) && (mesh.colors.Length > 0)); },
() => { Schema.Mesh.StartColorsVector(builder, mesh.vertexCount); },
(i) => { Schema.Color.CreateColor(builder, mesh.colors[i].a, mesh.colors[i].b, mesh.colors[i].g, mesh.colors[i].r);},
(vo) => { Schema.Mesh.AddColors(builder, vo); }
),
// colors32
new MeshComponent(
() => { return((mesh.colors32 != null) && (mesh.colors.Length > 0)); },
() => { Schema.Mesh.StartColors32Vector(builder, mesh.vertexCount); },
(i) => { Schema.Color32.CreateColor32(builder, mesh.colors32[i].a, mesh.colors32[i].b, mesh.colors32[i].g, mesh.colors32[i].r);},
(vo) => { Schema.Mesh.AddColors32(builder, vo); }
),
// BoneWeigths
new MeshComponent(
() => { return((mesh.boneWeights != null) && (mesh.boneWeights.Length > 0)); },
() => { Schema.Mesh.StartBoneWeightsVector(builder, mesh.vertexCount); },
(i) => { Schema.BoneWeight.CreateBoneWeight(builder,
mesh.boneWeights[i].boneIndex0, mesh.boneWeights[i].boneIndex1, mesh.boneWeights[i].boneIndex2, mesh.boneWeights[i].boneIndex3,
mesh.boneWeights[i].weight0, mesh.boneWeights[i].weight1, mesh.boneWeights[i].weight2, mesh.boneWeights[i].weight3
); },
(vo) => { Schema.Mesh.AddBoneWeights(builder, vo); }
)
};
int componentCount = components.Length;
VectorOffset[] vectorOffsets = new VectorOffset[componentCount];
for (int c = 0; c < componentCount; c++)
{
if (components[c].funcExist())
{
components[c].actStart();
for (int i = mesh.vertexCount - 1; i >= 0; i--) // 添加时顺序颠倒。
{
components[c].actElem(i); // 结构vector不需要AddOffset
}
vectorOffsets[c] = builder.EndVector();
}
}
// 创建 Submesh
Offset <SubMesh>[] offSubmeshes = new Offset <SubMesh> [mesh.subMeshCount];
uint offset = 0;
for (int i = 0; i < mesh.subMeshCount; i++)
{
int[] _is = mesh.GetIndices(i);
offSubmeshes[i] = SubMesh.CreateSubMesh(builder, offset, (uint)_is.Length, (Schema.MeshTopology)mesh.GetTopology(i));
offset += (uint)_is.Length;
}
// 网格所涉及到的骨骼
StringOffset[] offJoints = new StringOffset[bones.Length];
for (int i = 0; i < bones.Length; i++)
{
offJoints[i] = builder.CreateString(bones[i].name);
}
// BindPoses
Schema.Mesh.StartBindposesVector(builder, mesh.bindposes.Length);
for (int i = mesh.bindposes.Length - 1; i >= 0; i--)
{
Matrix4x4 m = mesh.bindposes[i];
Matrix16.CreateMatrix16(builder,
m.m00, m.m01, m.m02, m.m03,
m.m10, m.m11, m.m12, m.m13,
m.m20, m.m21, m.m22, m.m23,
m.m30, m.m31, m.m32, m.m33
);
}
VectorOffset vecBindPoses = builder.EndVector();
// 三角面索引数据 标量数组可以直接添加。
VectorOffset vecTrangles = Schema.Mesh.CreateTrianglesVector(builder, mesh.triangles);
// Submesh 数据
VectorOffset vecSubmeshes = Schema.Mesh.CreateSubmeshesVector(builder, offSubmeshes);
// 涉及到的骨骼
VectorOffset vecJoints = Schema.Mesh.CreateJointsVector(builder, offJoints);
// 放入Mesh
Schema.Mesh.StartMesh(builder);
// 顶点数据
for (int c = 0; c < componentCount; c++)
{
if (components[c].funcExist())
{
components[c].actAdd(vectorOffsets[c]);
}
}
Schema.Mesh.AddTriangles(builder, vecTrangles);
Schema.Mesh.AddSubmeshes(builder, vecSubmeshes);
Schema.Mesh.AddJoints(builder, vecJoints);
Schema.Mesh.AddBindposes(builder, vecBindPoses);
// 边界
Vector3 min = mesh.bounds.min;
Vector3 max = mesh.bounds.max;
Schema.Mesh.AddBound(builder, Schema.Bound.CreateBound(builder, min.x, min.y, min.z, max.x, max.y, max.z));
Offset <Schema.Mesh> offMesh = Schema.Mesh.EndMesh(builder);
builder.Finish(offMesh.Value);
return(builder.DataBuffer);
}
