public void Read(ref List <LevelSubMesh> value)
{
int count;
Stream.ReadInt32(out count);
if (value != null)
{
value.Clear();
}
else
{
value = new List <LevelSubMesh>();
}
value.Capacity = count;
for (var i = 0; i < count; i++)
{
LevelSubMesh t = new LevelSubMesh();
Read(ref t);
value.Add(t);
}
}
void SerializeMesh(GameObject go, LevelObject lo, bool rejectStatic = true)
{
MeshFilter mf = go.GetComponent <MeshFilter>();
MeshRenderer mr = go.GetComponent <MeshRenderer>();
bool isBatchStatic = GameObjectUtility.AreStaticEditorFlagsSet(go, StaticEditorFlags.BatchingStatic);
bool isLightmapStatic = GameObjectUtility.AreStaticEditorFlagsSet(go, StaticEditorFlags.LightmapStatic);
bool shouldBailDueToRejectingStatics = rejectStatic && isBatchStatic;
if (mf == null || mf.sharedMesh == null || shouldBailDueToRejectingStatics)
{
lo.mesh = new LevelMesh();
return;
}
var m = mf.sharedMesh;
var lm = new LevelMesh();
var mNormals = m.normals;
var mUV1 = m.uv;
var mUV2 = m.uv2;
var mTangent = m.tangents;
bool hasNormal = mNormals != null && mNormals.Length > 0;
bool hasUV1 = mUV1 != null && mUV1.Length > 0;
bool hasUV2 = mUV2 != null && mUV2.Length > 0;
bool hasTangent = mTangent != null && mTangent.Length > 0;
if (hasNormal)
{
lm.Flags |= LevelMesh.MeshFlags.Normal;
}
if (hasUV1)
{
lm.Flags |= LevelMesh.MeshFlags.UV1;
}
if (hasUV2)
{
lm.Flags |= LevelMesh.MeshFlags.UV2;
}
if (hasTangent)
{
lm.Flags |= LevelMesh.MeshFlags.Tangent;
}
Profiler.BeginSample("Write Verts");
// TODO: We should reuse the stuff above.
// Vertex order is: pos, norm, uv0, [uv1]
var uv1 = new List <Vector2>();
var uv2 = new List <Vector2>();
var tangent = new List <Vector4>();
if (hasUV1)
{
m.GetUVs(0, uv1);
}
if (hasUV2)
{
m.GetUVs(1, uv2);
}
if (hasTangent)
{
m.GetTangents(tangent);
}
Profiler.BeginSample("Copy Verts");
var vertByteSize =
3 * 4 + // Position
(hasNormal ? 3 * 4 : 0) + // Normal
(hasUV1 ? 2 * 4 : 0) + // UV1
(hasUV2 ? 2 * 4 : 0) + // UV2
(hasTangent ? 4 * 4 : 0) // Tangent
;
var bytes = new byte[vertByteSize * m.vertexCount];
var stagingFloats = new float[m.vertexCount * 4];
Debug.Assert(m.vertexCount == m.vertices.Length);
// Copy vertex data as contiguous runs by field.
var offset = 0;
offset = MemoryMapUtility.MapVector3ToBytes(m.vertexCount, bytes, 0, stagingFloats, m.vertices);
if (hasNormal)
{
Debug.AssertFormat(m.vertices.Length == m.normals.Length, "vertices[{0}] != normals[{1}]", m.vertices.Length, m.normals.Length);
offset += MemoryMapUtility.MapVector3ToBytes(m.vertexCount, bytes, offset, stagingFloats, m.normals);
}
if (hasUV1)
{
offset += MemoryMapUtility.MapVector2ToBytes(m.vertexCount, bytes, offset, stagingFloats, m.uv);
}
if (hasUV2)
{
offset += MemoryMapUtility.MapVector2ToBytes(m.vertexCount, bytes, offset, stagingFloats, m.uv2);
}
if (hasTangent)
{
offset += MemoryMapUtility.MapVector4ToBytes(m.vertexCount, bytes, offset, stagingFloats, m.tangents);
}
lm.verts.Stream = new MemoryStream(bytes, 0, offset, false, true);
lm.vertexCount = m.vertexCount;
lm.bounds = m.bounds;
Profiler.EndSample();
Profiler.EndSample();
Profiler.BeginSample("Write Indices");
var indices = m.triangles;
lm.indexCount = indices.Length;
var indexSizeInBytes = indices.Length * 2;
bytes = new byte[indexSizeInBytes];
var shortIdx = new ushort[indices.Length];
for (var i = 0; i < indices.Length; i++)
{
shortIdx[i] = (ushort)indices[i];
}
Buffer.BlockCopy(shortIdx, 0, bytes, 0, indexSizeInBytes);
lm.indices.Stream = new MemoryStream(bytes, 0, indexSizeInBytes, false, true);
Profiler.EndSample();
for (var i = 0; i < m.subMeshCount; i++)
{
var lsm = new LevelSubMesh();
lsm.start = (int)m.GetIndexStart(i);
lsm.count = (int)m.GetIndexCount(i);
lm.subMeshes.Add(lsm);
}
if (go.GetComponent <MeshCollider>() && go.GetComponent <MeshCollider>().enabled)
{
lo.SetMeshCollider();
}
if (mr && mr.enabled)
{
lo.SetMeshRenderer();
// Lightmap settings.
lm.lightmapIndex = mr.lightmapIndex;
lm.lightmapScaleOffset = mr.lightmapScaleOffset;
// Encode materials.
foreach (var mrM in mr.sharedMaterials)
{
lm.materials.Add(mapComp.ResolveMaterialName(mrM.name));
}
}
lo.mesh = lm;
}