public static void Restore(DMesh3 mesh, BinaryReader reader)
{
int version = reader.ReadInt32();
if (version != DMesh3Version)
{
throw new Exception("gSerialization.Restore: Incorrect DMesh3Version!");
}
MeshComponents components = (MeshComponents)reader.ReadInt32();
Restore(mesh.VerticesBuffer, reader);
Restore(mesh.TrianglesBuffer, reader);
Restore(mesh.EdgesBuffer, reader);
Restore(mesh.EdgesRefCounts.RawRefCounts, reader);
if ((components & MeshComponents.VertexNormals) != 0)
{
mesh.EnableVertexNormals(Vector3F.AxisY);
Restore(mesh.NormalsBuffer, reader);
}
else
{
mesh.DiscardVertexNormals();
}
if ((components & MeshComponents.VertexColors) != 0)
{
mesh.EnableVertexColors(Vector3F.One);
Restore(mesh.ColorsBuffer, reader);
}
else
{
mesh.DiscardVertexColors();
}
if ((components & MeshComponents.VertexUVs) != 0)
{
mesh.EnableVertexUVs(Vector2F.Zero);
Restore(mesh.UVBuffer, reader);
}
else
{
mesh.DiscardVertexUVs();
}
if ((components & MeshComponents.FaceGroups) != 0)
{
mesh.EnableTriangleGroups(0);
Restore(mesh.GroupsBuffer, reader);
}
else
{
mesh.DiscardTriangleGroups();
}
mesh.RebuildFromEdgeRefcounts();
}
public void CopyTo(DMesh3 SetMesh)
{
if (SetMesh.MaxVertexID < Mesh.MaxVertexID)
{
throw new Exception("MeshNormals.Set: SetMesh does not have enough vertices!");
}
if (!SetMesh.HasVertexNormals)
{
SetMesh.EnableVertexNormals(Vector3f.AxisY);
}
int NV = Mesh.MaxVertexID;
for (int vi = 0; vi < NV; ++vi)
{
if (Mesh.IsVertex(vi) && SetMesh.IsVertex(vi))
{
SetMesh.SetVertexNormal(vi, (Vector3f)Normals[vi]);
}
}
}
/// <summary>
/// copy vertex positions from sourceMesh.
/// [TODO] perhaps can refactor into a call to EditAndUpdateMesh() ?
/// </summary>
public void UpdateVertices(DMesh3 sourceMesh, bool bNormals = true, bool bColors = true)
{
if (sourceMesh.MaxVertexID != mesh.MaxVertexID)
{
throw new Exception("DMeshSO.UpdateVertexPositions: not enough positions provided!");
}
bNormals &= sourceMesh.HasVertexNormals;
if (bNormals && mesh.HasVertexNormals == false)
{
mesh.EnableVertexNormals(Vector3f.AxisY);
}
bColors &= sourceMesh.HasVertexColors;
if (bColors && mesh.HasVertexColors == false)
{
mesh.EnableVertexColors(Colorf.White);
}
lock (mesh_write_lock) {
foreach (int vid in mesh.VertexIndices())
{
Vector3d sourceV = sourceMesh.GetVertex(vid);
mesh.SetVertex(vid, sourceV);
if (bNormals)
{
Vector3f sourceN = sourceMesh.GetVertexNormal(vid);
mesh.SetVertexNormal(vid, sourceN);
}
if (bColors)
{
Vector3f sourceC = sourceMesh.GetVertexColor(vid);
mesh.SetVertexColor(vid, sourceC);
}
}
}
fast_mesh_update(bNormals, bColors);
post_mesh_modified();
}
public virtual DMesh3 RestoreDMesh(TypedAttribSet attributes)
{
bool is_compressed = false;
TypedAttribSet meshAttr = find_struct(attributes, IOStrings.BinaryDMeshStruct);
if (meshAttr == null)
{
meshAttr = find_struct(attributes, IOStrings.CompressedDMeshStruct);
is_compressed = true;
}
if (meshAttr == null)
{
throw new Exception("SOFactory.RestoreDMesh: DMesh binary or compressed struct not found!");
}
VectorArray3d v = null;
VectorArray3f n = null, c = null;
VectorArray2f uv = null;
VectorArray3i t = null;
int[] g = null;
IndexArray4i e = null;
short[] e_ref = null;
var storageMode = IOStrings.MeshStorageMode.EdgeRefCounts;
if (meshAttr.ContainsKey(IOStrings.AMeshStorageMode))
{
storageMode = (IOStrings.MeshStorageMode)(int) meshAttr[IOStrings.AMeshStorageMode];
}
if (is_compressed)
{
if (check_key_or_debug_print(meshAttr, IOStrings.AMeshVertices3Compressed))
{
v = meshAttr[IOStrings.AMeshVertices3Compressed] as VectorArray3d;
}
if (check_key_or_debug_print(meshAttr, IOStrings.AMeshNormals3Compressed))
{
n = meshAttr[IOStrings.AMeshNormals3Compressed] as VectorArray3f;
}
if (check_key_or_debug_print(meshAttr, IOStrings.AMeshColors3Compressed))
{
c = meshAttr[IOStrings.AMeshColors3Compressed] as VectorArray3f;
}
if (check_key_or_debug_print(meshAttr, IOStrings.AMeshUVs2Compressed))
{
uv = meshAttr[IOStrings.AMeshUVs2Compressed] as VectorArray2f;
}
if (check_key_or_debug_print(meshAttr, IOStrings.AMeshTrianglesCompressed))
{
t = meshAttr[IOStrings.AMeshTrianglesCompressed] as VectorArray3i;
}
if (check_key_or_debug_print(meshAttr, IOStrings.AMeshTriangleGroupsCompressed))
{
g = meshAttr[IOStrings.AMeshTriangleGroupsCompressed] as int[];
}
if (check_key_or_debug_print(meshAttr, IOStrings.AMeshEdgesCompressed))
{
e = meshAttr[IOStrings.AMeshEdgesCompressed] as IndexArray4i;
}
if (check_key_or_debug_print(meshAttr, IOStrings.AMeshEdgeRefCountsCompressed))
{
e_ref = meshAttr[IOStrings.AMeshEdgeRefCountsCompressed] as short[];
}
}
else
{
if (check_key_or_debug_print(meshAttr, IOStrings.AMeshVertices3Binary))
{
v = meshAttr[IOStrings.AMeshVertices3Binary] as VectorArray3d;
}
if (check_key_or_debug_print(meshAttr, IOStrings.AMeshNormals3Binary))
{
n = meshAttr[IOStrings.AMeshNormals3Binary] as VectorArray3f;
}
if (check_key_or_debug_print(meshAttr, IOStrings.AMeshColors3Binary))
{
c = meshAttr[IOStrings.AMeshColors3Binary] as VectorArray3f;
}
if (check_key_or_debug_print(meshAttr, IOStrings.AMeshUVs2Binary))
{
uv = meshAttr[IOStrings.AMeshUVs2Binary] as VectorArray2f;
}
if (check_key_or_debug_print(meshAttr, IOStrings.AMeshTrianglesBinary))
{
t = meshAttr[IOStrings.AMeshTrianglesBinary] as VectorArray3i;
}
if (check_key_or_debug_print(meshAttr, IOStrings.AMeshTriangleGroupsBinary))
{
g = meshAttr[IOStrings.AMeshTriangleGroupsBinary] as int[];
}
if (check_key_or_debug_print(meshAttr, IOStrings.AMeshEdgesBinary))
{
e = meshAttr[IOStrings.AMeshEdgesBinary] as IndexArray4i;
}
if (check_key_or_debug_print(meshAttr, IOStrings.AMeshEdgeRefCountsBinary))
{
e_ref = meshAttr[IOStrings.AMeshEdgeRefCountsBinary] as short[];
}
}
DMesh3 m = new DMesh3();
if (n != null)
{
m.EnableVertexNormals(Vector3f.Zero);
}
if (c != null)
{
m.EnableVertexColors(Vector3f.Zero);
}
if (uv != null)
{
m.EnableVertexUVs(Vector2f.Zero);
}
if (g != null)
{
m.EnableTriangleGroups(0);
}
if (storageMode == IOStrings.MeshStorageMode.EdgeRefCounts)
{
if (v == null || t == null || e == null || e_ref == null)
{
return(null);
}
m.VerticesBuffer = new DVector <double>(v);
if (n != null)
{
m.NormalsBuffer = new DVector <float>(n);
}
if (c != null)
{
m.ColorsBuffer = new DVector <float>(c);
}
if (uv != null)
{
m.UVBuffer = new DVector <float>(uv);
}
m.TrianglesBuffer = new DVector <int>(t);
if (g != null)
{
m.GroupsBuffer = new DVector <int>(g);
}
m.EdgesBuffer = new DVector <int>(e);
m.EdgesRefCounts = new RefCountVector(e_ref);
m.RebuildFromEdgeRefcounts();
}
else if (storageMode == IOStrings.MeshStorageMode.Minimal)
{
if (v == null || t == null)
{
return(null);
}
int NV = v.Count;
NewVertexInfo vinfo = new NewVertexInfo();
for (int k = 0; k < NV; ++k)
{
vinfo.v = v[k];
if (n != null)
{
vinfo.n = n[k];
}
if (c != null)
{
vinfo.c = c[k];
}
if (uv != null)
{
vinfo.uv = uv[k];
}
m.AppendVertex(ref vinfo);
}
int NT = t.Count;
for (int k = 0; k < NT; ++k)
{
Vector3i tri = t[k];
int setg = (g == null) ? -1 : g[k];
m.AppendTriangle(tri, setg);
}
}
else
{
throw new Exception("SOFactory.RestoreDMesh: unsupported mesh storage mode");
}
return(m);
}
// Ctor
public TerrainChunk(int _arrX, int _arrY, int terrainSize)
{
//this can be done here because it wont ever need to be modified.
List <int> inds = new List <int>();
#region Init
xPos = _arrX * (numXVerts - 1);
yPos = _arrY * (numXVerts - 1);
arrayX = _arrX;
arrayY = _arrY;
dMesh = new DMesh3(MeshComponents.VertexNormals | MeshComponents.VertexColors);
int indexTracker = 0;
for (int i = 0; i < numXVerts; i++)
{
for (int j = 0; j < numXVerts; j++)
{
Vector3d v = new Vector3d((float)i + xPos, 0, (float)j + yPos);
//vertices.Add(new BasicVertex(Convert.ToV3(v), new Vector3(0, 0, 0), new Vector3(0, 1, 0)));
dMesh.AppendVertex(new NewVertexInfo(v, new Vector3f(0, 1, 0)));
//fancy uv stuff.
float uvu, uvv;
uvu = ((1f / (numXVerts - 1)) * i);
uvv = 1 - ((1f / (numXVerts - 1)) * j);
Vertex vert = new Vertex()
{
x = (float)v.x,
y = (float)v.y,
z = (float)v.z,
u = uvu,
v = uvv,
n1 = 0.0f,
n2 = 1.0f,
n3 = 0.0f,
index = indexTracker
};
vertices.Add(vert);
vertNeedsCollisionUpdate.Add(false);
indexTracker++;
}
}
for (int j = 0; j < numXVerts - 1; j++)
{
for (int i = 0; i < numXVerts - 1; i++)
{
int i1, i2, i3, i4, i5, i6;
int row1 = i * numXVerts;
int row2 = (i + 1) * numXVerts;
i1 = row1 + j;
i2 = row1 + j + 1;
i3 = row2 + j;
i4 = row2 + j + 1;
i5 = row2 + j;
i6 = row1 + j + 1;
if (i == numXVerts - 1 && j == numXVerts - 1)
{
Console.Write(i4 + " " + i5 + " " + i6);
}
dMesh.AppendTriangle(i1, i2, i3);
dMesh.AppendTriangle(i4, i5, i6);
inds.Add(i1);
inds.Add(i2);
inds.Add(i3);
inds.Add(i4);
inds.Add(i5);
inds.Add(i6);
}
}
dMesh.EnableVertexNormals(new Vector3f(0, 1, 0));
dMeshAABB = new DMeshAABBTree3(dMesh);
dMeshAABB.Build();
#endregion
//
//
InitRendering(inds);
}
