unity and native osx bundles and frameworks build from the same project now
This commit is contained in:
Joseph Henry
@@ -0,0 +1,627 @@
|
||||
|
||||
using System;
|
||||
using System.IO;
|
||||
using System.Collections.Generic;
|
||||
using System.Runtime.InteropServices;
|
||||
|
||||
using UnityEngine;
|
||||
|
||||
namespace UnityExtension
|
||||
{
|
||||
public static class MeshExt
|
||||
{
|
||||
//------------------------------------------------------------------------------------------------------------
|
||||
public static void RecalculateTangents(this Mesh lMesh)
|
||||
{
|
||||
//speed up math by copying the mesh arrays
|
||||
int[] triangles = lMesh.triangles;
|
||||
Vector3[] vertices = lMesh.vertices;
|
||||
Vector2[] uv = lMesh.uv;
|
||||
Vector3[] normals = lMesh.normals;
|
||||
|
||||
//variable definitions
|
||||
int triangleCount = triangles.Length;
|
||||
int vertexCount = vertices.Length;
|
||||
|
||||
Vector3[] tan1 = new Vector3[vertexCount];
|
||||
Vector3[] tan2 = new Vector3[vertexCount];
|
||||
|
||||
Vector4[] tangents = new Vector4[vertexCount];
|
||||
|
||||
for (long a = 0; a < triangleCount; a += 3)
|
||||
{
|
||||
long i1 = triangles[a + 0];
|
||||
long i2 = triangles[a + 1];
|
||||
long i3 = triangles[a + 2];
|
||||
|
||||
Vector3 v1 = vertices[i1];
|
||||
Vector3 v2 = vertices[i2];
|
||||
Vector3 v3 = vertices[i3];
|
||||
|
||||
Vector2 w1 = uv[i1];
|
||||
Vector2 w2 = uv[i2];
|
||||
Vector2 w3 = uv[i3];
|
||||
|
||||
float x1 = v2.x - v1.x;
|
||||
float x2 = v3.x - v1.x;
|
||||
float y1 = v2.y - v1.y;
|
||||
float y2 = v3.y - v1.y;
|
||||
float z1 = v2.z - v1.z;
|
||||
float z2 = v3.z - v1.z;
|
||||
|
||||
float s1 = w2.x - w1.x;
|
||||
float s2 = w3.x - w1.x;
|
||||
float t1 = w2.y - w1.y;
|
||||
float t2 = w3.y - w1.y;
|
||||
|
||||
float r = 1.0f / (s1 * t2 - s2 * t1);
|
||||
|
||||
Vector3 sdir = new Vector3((t2 * x1 - t1 * x2) * r, (t2 * y1 - t1 * y2) * r, (t2 * z1 - t1 * z2) * r);
|
||||
Vector3 tdir = new Vector3((s1 * x2 - s2 * x1) * r, (s1 * y2 - s2 * y1) * r, (s1 * z2 - s2 * z1) * r);
|
||||
|
||||
tan1[i1] += sdir;
|
||||
tan1[i2] += sdir;
|
||||
tan1[i3] += sdir;
|
||||
|
||||
tan2[i1] += tdir;
|
||||
tan2[i2] += tdir;
|
||||
tan2[i3] += tdir;
|
||||
}
|
||||
|
||||
|
||||
for (long a = 0; a < vertexCount; ++a)
|
||||
{
|
||||
Vector3 n = normals[a];
|
||||
Vector3 t = tan1[a];
|
||||
|
||||
//Vector3 tmp = (t - n * Vector3.Dot(n, t)).normalized;
|
||||
//tangents[a] = new Vector4(tmp.x, tmp.y, tmp.z);
|
||||
Vector3.OrthoNormalize(ref n, ref t);
|
||||
tangents[a].x = t.x;
|
||||
tangents[a].y = t.y;
|
||||
tangents[a].z = t.z;
|
||||
|
||||
tangents[a].w = (Vector3.Dot(Vector3.Cross(n, t), tan2[a]) < 0.0f) ? -1.0f : 1.0f;
|
||||
}
|
||||
|
||||
lMesh.tangents = tangents;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------------------
|
||||
public static void LoadOBJ(this Mesh lMesh, OBJData lData)
|
||||
{
|
||||
List<Vector3> lVertices = new List<Vector3>();
|
||||
List<Vector3> lNormals = new List<Vector3>();
|
||||
List<Vector2> lUVs = new List<Vector2>();
|
||||
List<int>[] lIndices = new List<int>[lData.m_Groups.Count];
|
||||
Dictionary<OBJFaceVertex, int> lVertexIndexRemap = new Dictionary<OBJFaceVertex, int>();
|
||||
bool lHasNormals = lData.m_Normals.Count > 0;
|
||||
bool lHasUVs = lData.m_UVs.Count > 0;
|
||||
|
||||
lMesh.subMeshCount = lData.m_Groups.Count;
|
||||
for (int lGCount = 0; lGCount < lData.m_Groups.Count; ++lGCount)
|
||||
{
|
||||
OBJGroup lGroup = lData.m_Groups[lGCount];
|
||||
lIndices[lGCount] = new List<int>();
|
||||
|
||||
for (int lFCount = 0; lFCount < lGroup.Faces.Count; ++lFCount)
|
||||
{
|
||||
OBJFace lFace = lGroup.Faces[lFCount];
|
||||
|
||||
// Unity3d doesn't support non-triangle faces
|
||||
// so we do simple fan triangulation
|
||||
for (int lVCount = 1; lVCount < lFace.Count - 1; ++lVCount)
|
||||
{
|
||||
foreach (int i in new int[]{0, lVCount, lVCount + 1})
|
||||
{
|
||||
OBJFaceVertex lFaceVertex = lFace[i];
|
||||
int lVertexIndex = -1;
|
||||
|
||||
if (!lVertexIndexRemap.TryGetValue(lFaceVertex, out lVertexIndex)) {
|
||||
lVertexIndexRemap[lFaceVertex] = lVertices.Count;
|
||||
lVertexIndex = lVertices.Count;
|
||||
|
||||
lVertices.Add(lData.m_Vertices[lFaceVertex.m_VertexIndex]);
|
||||
if (lHasUVs)
|
||||
{
|
||||
lUVs.Add(lData.m_UVs[lFaceVertex.m_UVIndex]);
|
||||
}
|
||||
if (lHasNormals)
|
||||
{
|
||||
lNormals.Add(lData.m_Normals[lFaceVertex.m_NormalIndex]);
|
||||
}
|
||||
}
|
||||
|
||||
lIndices[lGCount].Add(lVertexIndex);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
lMesh.triangles = new int[]{ };
|
||||
lMesh.vertices = lVertices.ToArray();
|
||||
lMesh.uv = lUVs.ToArray();
|
||||
lMesh.normals = lNormals.ToArray();
|
||||
if (!lHasNormals)
|
||||
{
|
||||
lMesh.RecalculateNormals();
|
||||
}
|
||||
|
||||
lMesh.RecalculateTangents();
|
||||
|
||||
for (int lGCount = 0; lGCount < lData.m_Groups.Count; ++lGCount)
|
||||
{
|
||||
lMesh.SetTriangles(lIndices[lGCount].ToArray(), lGCount);
|
||||
}
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------------------
|
||||
public static OBJData EncodeOBJ(this Mesh lMesh)
|
||||
{
|
||||
OBJData lData = new OBJData
|
||||
{
|
||||
m_Vertices = new List<Vector3>(lMesh.vertices),
|
||||
m_UVs = new List<Vector2>(lMesh.uv),
|
||||
m_Normals = new List<Vector3>(lMesh.normals),
|
||||
m_UV2s = new List<Vector2>(lMesh.uv2),
|
||||
m_Colors = new List<Color>(lMesh.colors)
|
||||
};
|
||||
|
||||
int[] lIndices = null;
|
||||
OBJGroup lGroup = null;
|
||||
OBJFace lFace = null;
|
||||
OBJFaceVertex lFaceVertex = null;
|
||||
|
||||
for (int lMCount = 0; lMCount < lMesh.subMeshCount; ++lMCount)
|
||||
{
|
||||
lIndices = lMesh.GetTriangles(lMCount);
|
||||
lGroup = new OBJGroup(lMesh.name + "_" + lMCount.ToString());
|
||||
|
||||
for (int lCount = 0; lCount < lIndices.Length; lCount += 3)
|
||||
{
|
||||
lFace = new OBJFace();
|
||||
|
||||
lFaceVertex = new OBJFaceVertex();
|
||||
lFaceVertex.m_VertexIndex = lData.m_Vertices.Count > 0 ? lIndices[lCount] : -1;
|
||||
lFaceVertex.m_UVIndex = lData.m_UVs.Count > 0 ? lIndices[lCount] : -1;
|
||||
lFaceVertex.m_NormalIndex = lData.m_Normals.Count > 0 ? lIndices[lCount] : -1;
|
||||
lFaceVertex.m_UV2Index = lData.m_UV2s.Count > 0 ? lIndices[lCount] : -1;
|
||||
lFaceVertex.m_ColorIndex = lData.m_Colors.Count > 0 ? lIndices[lCount] : -1;
|
||||
lFace.AddVertex(lFaceVertex);
|
||||
|
||||
lFaceVertex = new OBJFaceVertex();
|
||||
lFaceVertex.m_VertexIndex = lData.m_Vertices.Count > 0 ? lIndices[lCount + 1] : -1;
|
||||
lFaceVertex.m_UVIndex = lData.m_UVs.Count > 0 ? lIndices[lCount + 1] : -1;
|
||||
lFaceVertex.m_NormalIndex = lData.m_Normals.Count > 0 ? lIndices[lCount + 1] : -1;
|
||||
lFaceVertex.m_UV2Index = lData.m_UV2s.Count > 0 ? lIndices[lCount + 1] : -1;
|
||||
lFaceVertex.m_ColorIndex = lData.m_Colors.Count > 0 ? lIndices[lCount + 1] : -1;
|
||||
lFace.AddVertex(lFaceVertex);
|
||||
|
||||
lFaceVertex = new OBJFaceVertex();
|
||||
lFaceVertex.m_VertexIndex = lData.m_Vertices.Count > 0 ? lIndices[lCount + 2] : -1;
|
||||
lFaceVertex.m_UVIndex = lData.m_UVs.Count > 0 ? lIndices[lCount + 2] : -1;
|
||||
lFaceVertex.m_NormalIndex = lData.m_Normals.Count > 0 ? lIndices[lCount + 2] : -1;
|
||||
lFaceVertex.m_UV2Index = lData.m_UV2s.Count > 0 ? lIndices[lCount + 2] : -1;
|
||||
lFaceVertex.m_ColorIndex = lData.m_Colors.Count > 0 ? lIndices[lCount + 2] : -1;
|
||||
lFace.AddVertex(lFaceVertex);
|
||||
|
||||
lGroup.AddFace(lFace);
|
||||
}
|
||||
|
||||
lData.m_Groups.Add(lGroup);
|
||||
}
|
||||
|
||||
return lData;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------------------
|
||||
internal const int MESH_BINARY_HEADER_SIZE = 20;
|
||||
internal const short MESH_BINARY_SIGNATURE = 0xF5;
|
||||
internal const short MESH_BINARY_VERSION = 1;
|
||||
|
||||
//------------------------------------------------------------------------------------------------------------
|
||||
public static bool LoadBinary(this Mesh lMesh, byte[] lData)
|
||||
{
|
||||
int lSizeOfVector2 = Marshal.SizeOf(typeof(Vector2));
|
||||
int lSizeOfVector3 = Marshal.SizeOf(typeof(Vector3));
|
||||
int lSizeOfVector4 = Marshal.SizeOf(typeof(Vector4));
|
||||
int lSizeOfMatrix4x4 = Marshal.SizeOf(typeof(Matrix4x4));
|
||||
int lSizeOfBoneWeight = Marshal.SizeOf(typeof(BoneWeight));
|
||||
int lSizeOfColor = Marshal.SizeOf(typeof(Color));
|
||||
|
||||
int lDataOffset = MESH_BINARY_HEADER_SIZE;
|
||||
int lDeltaOffset = 0;
|
||||
|
||||
if (lData == null ||
|
||||
lData.Length < MESH_BINARY_HEADER_SIZE)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
// Header
|
||||
short lSignature = BitConverter.ToInt16(lData, 0);
|
||||
short lVersion = BitConverter.ToInt16(lData, 2);
|
||||
|
||||
if (lSignature != MESH_BINARY_SIGNATURE ||
|
||||
lVersion != MESH_BINARY_VERSION)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
lMesh.Clear();
|
||||
|
||||
int lVertexCount = BitConverter.ToInt32(lData, 4);
|
||||
int lIndexCount = BitConverter.ToInt32(lData, 8);
|
||||
int lSubMeshCount = BitConverter.ToInt32(lData, 12);
|
||||
|
||||
byte lFlags = lData[16];
|
||||
|
||||
bool lUVFlag = (lFlags & 1) > 0;
|
||||
bool lUV1Flag = (lFlags & 2) > 0;
|
||||
bool lUV2Flag = (lFlags & 4) > 0;
|
||||
bool lNormalFlag = (lFlags & 8) > 0;
|
||||
bool lTangentFlag = (lFlags & 16) > 0;
|
||||
bool lColorFlag = (lFlags & 32) > 0;
|
||||
bool lBindPoseFlag = (lFlags & 64) > 0;
|
||||
bool lBoneWeightFlag = (lFlags & 128) > 0;
|
||||
|
||||
// Vertices
|
||||
Vector3[] lVertices = new Vector3[lVertexCount];
|
||||
lDeltaOffset = lVertices.Length * lSizeOfVector3;
|
||||
GCHandle lHandle = GCHandle.Alloc(lVertices, GCHandleType.Pinned);
|
||||
Marshal.Copy(lData, lDataOffset, lHandle.AddrOfPinnedObject(), lDeltaOffset);
|
||||
lHandle.Free();
|
||||
lDataOffset += lDeltaOffset;
|
||||
lMesh.vertices = lVertices;
|
||||
lVertices = null;
|
||||
|
||||
// UV Channel 0
|
||||
Vector2[] lUVs = null;
|
||||
if (lUVFlag == true)
|
||||
{
|
||||
lUVs = new Vector2[lVertexCount];
|
||||
lDeltaOffset = lUVs.Length * lSizeOfVector2;
|
||||
lHandle = GCHandle.Alloc(lUVs, GCHandleType.Pinned);
|
||||
Marshal.Copy(lData, lDataOffset, lHandle.AddrOfPinnedObject(), lDeltaOffset);
|
||||
lHandle.Free();
|
||||
lDataOffset += lDeltaOffset;
|
||||
lMesh.uv = lUVs;
|
||||
Debug.Log("UV Count : " + lUVs.Length);
|
||||
lUVs = null;
|
||||
}
|
||||
|
||||
// UV Channel 1
|
||||
if (lUV1Flag == true)
|
||||
{
|
||||
lUVs = new Vector2[lVertexCount];
|
||||
lDeltaOffset = lUVs.Length * lSizeOfVector2;
|
||||
lHandle = GCHandle.Alloc(lUVs, GCHandleType.Pinned);
|
||||
Marshal.Copy(lData, lDataOffset, lHandle.AddrOfPinnedObject(), lDeltaOffset);
|
||||
lHandle.Free();
|
||||
lDataOffset += lDeltaOffset;
|
||||
lMesh.uv2 = lUVs;
|
||||
Debug.Log("UV1 Count : " + lUVs.Length);
|
||||
lUVs = null;
|
||||
}
|
||||
|
||||
// UV Channel 2
|
||||
if (lUV2Flag == true)
|
||||
{
|
||||
lUVs = new Vector2[lVertexCount];
|
||||
lDeltaOffset = lUVs.Length * lSizeOfVector2;
|
||||
lHandle = GCHandle.Alloc(lUVs, GCHandleType.Pinned);
|
||||
Marshal.Copy(lData, lDataOffset, lHandle.AddrOfPinnedObject(), lDeltaOffset);
|
||||
lHandle.Free();
|
||||
lDataOffset += lDeltaOffset;
|
||||
lMesh.uv2 = lUVs;
|
||||
Debug.Log("UV2 Count : " + lUVs.Length);
|
||||
lUVs = null;
|
||||
}
|
||||
|
||||
// Normals
|
||||
if (lNormalFlag == true)
|
||||
{
|
||||
Vector3[] lNormals = new Vector3[lVertexCount];
|
||||
lDeltaOffset = lNormals.Length * lSizeOfVector3;
|
||||
lHandle = GCHandle.Alloc(lNormals, GCHandleType.Pinned);
|
||||
Marshal.Copy(lData, lDataOffset, lHandle.AddrOfPinnedObject(), lDeltaOffset);
|
||||
lHandle.Free();
|
||||
lDataOffset += lDeltaOffset;
|
||||
lMesh.normals = lNormals;
|
||||
Debug.Log("Normal Count : " + lNormals.Length);
|
||||
lNormals = null;
|
||||
}
|
||||
|
||||
// Tangents
|
||||
if (lTangentFlag == true)
|
||||
{
|
||||
Vector4[] lTangents = new Vector4[lVertexCount];
|
||||
lDeltaOffset = lTangents.Length * lSizeOfVector4;
|
||||
lHandle = GCHandle.Alloc(lTangents, GCHandleType.Pinned);
|
||||
Marshal.Copy(lData, lDataOffset, lHandle.AddrOfPinnedObject(), lDeltaOffset);
|
||||
lHandle.Free();
|
||||
lDataOffset += lDeltaOffset;
|
||||
lMesh.tangents = lTangents;
|
||||
Debug.Log("Tangents Count : " + lTangents.Length);
|
||||
lTangents = null;
|
||||
}
|
||||
|
||||
// Colors
|
||||
if (lColorFlag == true)
|
||||
{
|
||||
Color[] lColors = new Color[lVertexCount];
|
||||
lDeltaOffset = lColors.Length * lSizeOfColor;
|
||||
lHandle = GCHandle.Alloc(lColors, GCHandleType.Pinned);
|
||||
Marshal.Copy(lData, lDataOffset, lHandle.AddrOfPinnedObject(), lDeltaOffset);
|
||||
lHandle.Free();
|
||||
lDataOffset += lDeltaOffset;
|
||||
lMesh.colors = lColors;
|
||||
lColors = null;
|
||||
}
|
||||
|
||||
// Bind Poses
|
||||
if (lBindPoseFlag == true)
|
||||
{
|
||||
Matrix4x4[] lBindPoses = new Matrix4x4[lVertexCount];
|
||||
lDeltaOffset = lBindPoses.Length * lSizeOfMatrix4x4;
|
||||
lHandle = GCHandle.Alloc(lBindPoses, GCHandleType.Pinned);
|
||||
Marshal.Copy(lData, lDataOffset, lHandle.AddrOfPinnedObject(), lDeltaOffset);
|
||||
lHandle.Free();
|
||||
lDataOffset += lDeltaOffset;
|
||||
lMesh.bindposes = lBindPoses;
|
||||
lBindPoses = null;
|
||||
}
|
||||
|
||||
// Bone Weights
|
||||
if (lBoneWeightFlag == true)
|
||||
{
|
||||
BoneWeight[] lBoneWeight = new BoneWeight[lVertexCount];
|
||||
lDeltaOffset = lBoneWeight.Length * lSizeOfBoneWeight;
|
||||
lHandle = GCHandle.Alloc(lBoneWeight, GCHandleType.Pinned);
|
||||
Marshal.Copy(lData, lDataOffset, lHandle.AddrOfPinnedObject(), lDeltaOffset);
|
||||
lHandle.Free();
|
||||
lDataOffset += lDeltaOffset;
|
||||
lMesh.boneWeights = lBoneWeight;
|
||||
lBoneWeight = null;
|
||||
}
|
||||
|
||||
// Indices
|
||||
int[] lIndices = new int[lIndexCount];
|
||||
lDeltaOffset = lIndices.Length * sizeof(int);
|
||||
Buffer.BlockCopy(lData, lDataOffset, lIndices, 0, lDeltaOffset);
|
||||
lDataOffset += lDeltaOffset;
|
||||
lMesh.triangles = lIndices;
|
||||
lIndices = null;
|
||||
|
||||
// SubMesh Indices
|
||||
for (int lSubMeshIndex = 0; lSubMeshIndex < lSubMeshCount; ++lSubMeshIndex)
|
||||
{
|
||||
int lSubMeshIndexCount = BitConverter.ToInt32(lData, lDataOffset);
|
||||
lDataOffset += sizeof(int);
|
||||
|
||||
lIndices = new int[lSubMeshIndexCount];
|
||||
lDeltaOffset = lIndices.Length * sizeof(int);
|
||||
Buffer.BlockCopy(lData, lDataOffset, lIndices, 0, lDeltaOffset);
|
||||
lDataOffset += lDeltaOffset;
|
||||
|
||||
if (lIndices.Length > 0 &&
|
||||
lIndices.Length % 3 == 0)
|
||||
{
|
||||
lMesh.SetTriangles(lIndices, lSubMeshIndex);
|
||||
}
|
||||
|
||||
lIndices = null;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------------------------
|
||||
public static byte[] EncodeBinary(this Mesh lMesh)
|
||||
{
|
||||
// Currently no support for BlendShape
|
||||
|
||||
int lSizeOfVector2 = Marshal.SizeOf(typeof(Vector2));
|
||||
int lSizeOfVector3 = Marshal.SizeOf(typeof(Vector3));
|
||||
int lSizeOfVector4 = Marshal.SizeOf(typeof(Vector4));
|
||||
int lSizeOfMatrix4x4 = Marshal.SizeOf(typeof(Matrix4x4));
|
||||
int lSizeOfBoneWeight = Marshal.SizeOf(typeof(BoneWeight));
|
||||
int lSizeOfColor = Marshal.SizeOf(typeof(Color));
|
||||
|
||||
int lDataSize = MESH_BINARY_HEADER_SIZE;
|
||||
int lDeltaSize = 0;
|
||||
|
||||
bool lUVFlag = false, lUV1Flag = false, lUV2Flag = false,
|
||||
lNormalFlag = false, lTangentFlag = false, lColorFlag = false,
|
||||
lBindPoseFlag = false, lBoneWeightFlag = false;
|
||||
|
||||
byte[] lData = new byte[lDataSize];
|
||||
|
||||
// Vertices
|
||||
Vector3[] lVertices = lMesh.vertices;
|
||||
Int32Converter lVertexCount = lVertices.Length;
|
||||
lDeltaSize = lVertices.Length * lSizeOfVector3;
|
||||
Array.Resize(ref lData, lDataSize + lDeltaSize);
|
||||
GCHandle lHandle = GCHandle.Alloc(lVertices, GCHandleType.Pinned);
|
||||
Marshal.Copy(lHandle.AddrOfPinnedObject(), lData, lDataSize, lDeltaSize);
|
||||
lHandle.Free();
|
||||
lDataSize += lDeltaSize;
|
||||
lVertices = null;
|
||||
|
||||
// UV Channel 0
|
||||
Vector2[] lUVs = lMesh.uv;
|
||||
if (lUVs.Length > 0)
|
||||
{
|
||||
lUVFlag = true;
|
||||
lDeltaSize = lUVs.Length * lSizeOfVector2;
|
||||
Array.Resize(ref lData, lDataSize + lDeltaSize);
|
||||
lHandle = GCHandle.Alloc(lUVs, GCHandleType.Pinned);
|
||||
Marshal.Copy(lHandle.AddrOfPinnedObject(), lData, lDataSize, lDeltaSize);
|
||||
lHandle.Free();
|
||||
lDataSize += lDeltaSize;
|
||||
}
|
||||
lUVs = null;
|
||||
|
||||
// UV Channel 1
|
||||
lUVs = lMesh.uv2;
|
||||
if (lUVs.Length > 0)
|
||||
{
|
||||
lUV1Flag = true;
|
||||
lDeltaSize = lUVs.Length * lSizeOfVector2;
|
||||
Array.Resize(ref lData, lDataSize + lDeltaSize);
|
||||
lHandle = GCHandle.Alloc(lUVs, GCHandleType.Pinned);
|
||||
Marshal.Copy(lHandle.AddrOfPinnedObject(), lData, lDataSize, lDeltaSize);
|
||||
lHandle.Free();
|
||||
lDataSize += lDeltaSize;
|
||||
}
|
||||
lUVs = null;
|
||||
|
||||
// UV Channel 2
|
||||
lUVs = lMesh.uv2;
|
||||
if (lUVs.Length > 0)
|
||||
{
|
||||
lUV2Flag = true;
|
||||
lDeltaSize = lUVs.Length * lSizeOfVector2;
|
||||
Array.Resize(ref lData, lDataSize + lDeltaSize);
|
||||
lHandle = GCHandle.Alloc(lUVs, GCHandleType.Pinned);
|
||||
Marshal.Copy(lHandle.AddrOfPinnedObject(), lData, lDataSize, lDeltaSize);
|
||||
lHandle.Free();
|
||||
lDataSize += lDeltaSize;
|
||||
}
|
||||
lUVs = null;
|
||||
|
||||
// Normals
|
||||
Vector3[] lNormals = lMesh.normals;
|
||||
if (lNormals.Length > 0)
|
||||
{
|
||||
lNormalFlag = true;
|
||||
lDeltaSize = lNormals.Length * lSizeOfVector3;
|
||||
Array.Resize(ref lData, lDataSize + lDeltaSize);
|
||||
lHandle = GCHandle.Alloc(lNormals, GCHandleType.Pinned);
|
||||
Marshal.Copy(lHandle.AddrOfPinnedObject(), lData, lDataSize, lDeltaSize);
|
||||
lHandle.Free();
|
||||
lDataSize += lDeltaSize;
|
||||
}
|
||||
lNormals = null;
|
||||
|
||||
// Tangents
|
||||
Vector4[] lTangents = lMesh.tangents;
|
||||
if (lTangents.Length > 0)
|
||||
{
|
||||
lTangentFlag = true;
|
||||
lDeltaSize = lTangents.Length * lSizeOfVector4;
|
||||
Array.Resize(ref lData, lDataSize + lDeltaSize);
|
||||
lHandle = GCHandle.Alloc(lTangents, GCHandleType.Pinned);
|
||||
Marshal.Copy(lHandle.AddrOfPinnedObject(), lData, lDataSize, lDeltaSize);
|
||||
lHandle.Free();
|
||||
lDataSize += lDeltaSize;
|
||||
}
|
||||
lTangents = null;
|
||||
|
||||
// Colors
|
||||
Color[] lColors = lMesh.colors;
|
||||
if (lColors.Length > 0)
|
||||
{
|
||||
lColorFlag = true;
|
||||
lDeltaSize = lColors.Length * lSizeOfColor;
|
||||
Array.Resize(ref lData, lDataSize + lDeltaSize);
|
||||
lHandle = GCHandle.Alloc(lColors, GCHandleType.Pinned);
|
||||
Marshal.Copy(lHandle.AddrOfPinnedObject(), lData, lDataSize, lDeltaSize);
|
||||
lHandle.Free();
|
||||
lDataSize += lDeltaSize;
|
||||
}
|
||||
lColors = null;
|
||||
|
||||
// BindPoses
|
||||
Matrix4x4[] lBindPoses = lMesh.bindposes;
|
||||
if (lBindPoses.Length > 0)
|
||||
{
|
||||
lBindPoseFlag = true;
|
||||
lDeltaSize = lBindPoses.Length * lSizeOfMatrix4x4;
|
||||
Array.Resize(ref lData, lDataSize + lDeltaSize);
|
||||
lHandle = GCHandle.Alloc(lBindPoses, GCHandleType.Pinned);
|
||||
Marshal.Copy(lHandle.AddrOfPinnedObject(), lData, lDataSize, lDeltaSize);
|
||||
lHandle.Free();
|
||||
lDataSize += lDeltaSize;
|
||||
}
|
||||
lBindPoses = null;
|
||||
|
||||
// BoneWeight
|
||||
BoneWeight[] lBoneWeight = lMesh.boneWeights;
|
||||
if (lBoneWeight.Length > 0)
|
||||
{
|
||||
lBoneWeightFlag = true;
|
||||
lDeltaSize = lBoneWeight.Length * lSizeOfBoneWeight;
|
||||
Array.Resize(ref lData, lDataSize + lDeltaSize);
|
||||
lHandle = GCHandle.Alloc(lBoneWeight, GCHandleType.Pinned);
|
||||
Marshal.Copy(lHandle.AddrOfPinnedObject(), lData, lDataSize, lDeltaSize);
|
||||
lHandle.Free();
|
||||
lDataSize += lDeltaSize;
|
||||
}
|
||||
lBoneWeight = null;
|
||||
|
||||
// Indices
|
||||
int[] lIndices = lMesh.triangles;
|
||||
Int32Converter lIndexCount = lIndices.Length;
|
||||
lDeltaSize = lIndices.Length * sizeof(int);
|
||||
Array.Resize(ref lData, lDataSize + lDeltaSize);
|
||||
Buffer.BlockCopy(lIndices, 0, lData, lDataSize, lDeltaSize);
|
||||
lDataSize += lDeltaSize;
|
||||
lIndices = null;
|
||||
|
||||
// SubMesh Indices
|
||||
Int32Converter lSubMeshCount = lMesh.subMeshCount;
|
||||
for (int lSubMeshIndex = 0; lSubMeshIndex < lSubMeshCount; ++lSubMeshIndex)
|
||||
{
|
||||
lIndices = lMesh.GetTriangles(lSubMeshIndex);
|
||||
|
||||
Int32Converter lSubMeshIndexCount = lIndices.Length;
|
||||
|
||||
lDeltaSize = sizeof(int) + (lIndices.Length * sizeof(int));
|
||||
Array.Resize(ref lData, lDataSize + lDeltaSize);
|
||||
|
||||
lData[lDataSize + 0] = lSubMeshIndexCount.Byte1;
|
||||
lData[lDataSize + 1] = lSubMeshIndexCount.Byte2;
|
||||
lData[lDataSize + 2] = lSubMeshIndexCount.Byte3;
|
||||
lData[lDataSize + 3] = lSubMeshIndexCount.Byte4;
|
||||
|
||||
Buffer.BlockCopy(lIndices, 0, lData, lDataSize, lDeltaSize - sizeof(int));
|
||||
lDataSize += lDeltaSize;
|
||||
}
|
||||
|
||||
// Header
|
||||
lData[0] = (byte)(MESH_BINARY_SIGNATURE & 0xFF);
|
||||
lData[1] = (byte)((MESH_BINARY_SIGNATURE >> 8) & 0xFF);
|
||||
|
||||
lData[2] = (byte)(MESH_BINARY_VERSION & 0xFF);
|
||||
lData[3] = (byte)((MESH_BINARY_VERSION >> 8) & 0xFF);
|
||||
|
||||
lData[4] = lVertexCount.Byte1;
|
||||
lData[5] = lVertexCount.Byte2;
|
||||
lData[6] = lVertexCount.Byte3;
|
||||
lData[7] = lVertexCount.Byte4;
|
||||
|
||||
lData[8] = lIndexCount.Byte1;
|
||||
lData[9] = lIndexCount.Byte2;
|
||||
lData[10] = lIndexCount.Byte3;
|
||||
lData[11] = lIndexCount.Byte4;
|
||||
|
||||
lData[12] = lSubMeshCount.Byte1;
|
||||
lData[13] = lSubMeshCount.Byte2;
|
||||
lData[14] = lSubMeshCount.Byte3;
|
||||
lData[15] = lSubMeshCount.Byte4;
|
||||
|
||||
lData[16] = (byte)(
|
||||
(lUVFlag ? 1 : 0) |
|
||||
(lUV1Flag ? 2 : 0) |
|
||||
(lUV2Flag ? 4 : 0) |
|
||||
(lNormalFlag ? 8 : 0) |
|
||||
(lTangentFlag ? 16 : 0) |
|
||||
(lColorFlag ? 32 : 0) |
|
||||
(lBindPoseFlag ? 64 : 0) |
|
||||
(lBoneWeightFlag ? 128 : 0));
|
||||
|
||||
return lData;
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user