public void SendFrame(MeshChunks meshChunks)
{
//VertexC4ubV3s[] sVertices = Array.ConvertAll(meshChunks.lVertices.ToArray(), x => x.toVertexC4ubV3s());
VertexC4ubV3f[] sVertices = meshChunks.lVertices.ToArray();
int nVerticesToSend = meshChunks.lVertices.Count;
int nTrianglesToSend = meshChunks.lTriangles.Count / 3;
int nChunks = meshChunks.trianglesChunkSizes.Count();
byte[] colorsArray = new byte[sizeof(byte) * 3 * nVerticesToSend];
float[] verticesArray = new float[sizeof(float) * 3 * nVerticesToSend];
int[] triangles = meshChunks.lTriangles.ToArray();
int pos1 = 0;
int pos2 = 0;
for (int i = 0; i < nVerticesToSend; i++)
{
colorsArray[pos1++] = sVertices[i].R;
colorsArray[pos1++] = sVertices[i].G;
colorsArray[pos1++] = sVertices[i].B;
verticesArray[pos2++] = sVertices[i].X;
verticesArray[pos2++] = sVertices[i].Y;
verticesArray[pos2++] = sVertices[i].Z;
}
byte[] colorsBuffer = new byte[sizeof(byte) * 3 * nVerticesToSend];
Buffer.BlockCopy(colorsArray, 0, colorsBuffer, 0, sizeof(byte) * 3 * nVerticesToSend);
byte[] verticesBuffer = new byte[sizeof(float) * 3 * nVerticesToSend];
Buffer.BlockCopy(verticesArray, 0, verticesBuffer, 0, sizeof(float) * 3 * nVerticesToSend);
byte[] trianglesBuffer = new byte[sizeof(int) * 3 * nTrianglesToSend];
Buffer.BlockCopy(triangles, 0, trianglesBuffer, 0, sizeof(int) * 3 * nTrianglesToSend);
byte[] chunksVerticesSizesBuffer = new byte[sizeof(int) * nChunks];
Buffer.BlockCopy(meshChunks.verticesChunkSizes.ToArray(), 0, chunksVerticesSizesBuffer, 0, sizeof(int) * nChunks);
byte[] chunksTrianglesSizesBuffer = new byte[sizeof(int) * nChunks];
Buffer.BlockCopy(meshChunks.trianglesChunkSizes.ToArray(), 0, chunksTrianglesSizesBuffer, 0, sizeof(int) * nChunks);
try
{
WriteInt(nVerticesToSend);
WriteInt(nTrianglesToSend);
WriteInt(nChunks);
oSocket.GetStream().Write(chunksVerticesSizesBuffer, 0, chunksVerticesSizesBuffer.Length);
oSocket.GetStream().Write(chunksTrianglesSizesBuffer, 0, chunksTrianglesSizesBuffer.Length);
oSocket.GetStream().Write(verticesBuffer, 0, verticesBuffer.Length);
oSocket.GetStream().Write(colorsBuffer, 0, colorsBuffer.Length);
oSocket.GetStream().Write(trianglesBuffer, 0, trianglesBuffer.Length);
}
catch (Exception)
{
}
}
private MeshChunks formVerticesChunks(List <VertexC4ubV3f> lVertices)
{
int chunkSizeLimit = 65000 - 3;
MeshChunks ret = new MeshChunks();
int nVertices = lVertices.Count();
List <int> trianglesInChunks = new List <int>();
List <int> verticesInChunks = new List <int>();
int currentVertex = 0;
while (currentVertex < nVertices)
{
int size = Math.Min(chunkSizeLimit, nVertices - currentVertex);
verticesInChunks.Add(size);
trianglesInChunks.Add(0);
currentVertex += size;
}
ret.lTriangles = new List <int>();
ret.lVertices = new List <VertexC4ubV3f>(lVertices);
ret.trianglesChunkSizes = trianglesInChunks;
ret.verticesChunkSizes = verticesInChunks;
return(ret);
}
private void ReceivingWorker()
{
System.Timers.Timer checkConnectionTimer = new System.Timers.Timer();
checkConnectionTimer.Interval = 1000;
checkConnectionTimer.Elapsed += delegate(object sender, System.Timers.ElapsedEventArgs e)
{
lock (oClientSocketLock)
{
for (int i = 0; i < lClientSockets.Count; i++)
{
if (!lClientSockets[i].SocketConnected())
{
lClientSockets.RemoveAt(i);
i--;
}
}
}
};
checkConnectionTimer.Start();
while (bServerRunning)
{
lock (oClientSocketLock)
{
for (int i = 0; i < lClientSockets.Count; i++)
{
byte[] buffer = lClientSockets[i].Receive(1);
while (buffer.Length != 0)
{
if (buffer[0] == 0)
{
List <VertexC4ubV3f> lVerticesClonedLocal;
List <int> lTrianglesClonedLocal;
lock (meshCopyLock)
{
lVerticesClonedLocal = new List <VertexC4ubV3f>(lVerticesCloned);
lTrianglesClonedLocal = new List <int>(lTrianglesCloned);
}
if (lTrianglesClonedLocal.Count > 0)
{
MeshChunks meshChunks = formMeshChunks(lVerticesClonedLocal, lTrianglesClonedLocal);
Stopwatch sw = new Stopwatch();
sw.Start();
lClientSockets[i].SendFrame(meshChunks);
sw.Stop();
Console.WriteLine("Sending elapsed={0}", sw.ElapsedMilliseconds);
}
else if (lVerticesClonedLocal.Count > 0)
{
MeshChunks meshChunks = formVerticesChunks(lVerticesClonedLocal);
lClientSockets[i].SendFrame(meshChunks);
}
}
buffer = lClientSockets[i].Receive(1);
}
}
}
Thread.Sleep(10);
}
checkConnectionTimer.Stop();
}
private MeshChunks formMeshChunks(List <VertexC4ubV3f> lVertices, List <int> lTriangles)
{
int chunkSizeLimit = 65000 - 3;
MeshChunks ret = new MeshChunks();
int nVertices = lVertices.Count();
int nTriangles = lTriangles.Count() / 3;
List <int> trianglesInChunks = new List <int>();
List <int> verticesInChunks = new List <int>();
int[] chunkIndex = new int[nVertices];
int[] verticesMap = new int[nVertices];
VertexC4ubV3f[] newVertices = new VertexC4ubV3f[nTriangles * 3];
int[] newTriangles = new int[nTriangles * 3];
int trianglesChunkStart = 0;
int currentChunkIndex = 0;
int currentVertex = 0;
for (int v = 0; v < nVertices; v++)
{
chunkIndex[v] = -1;
}
int verticesInCurrentChunk = 0;
Stopwatch sw = new Stopwatch();
sw.Start();
for (int t = 0; t < nTriangles * 3; t++)
{
int val = lTriangles[t];
if (chunkIndex[val] != currentChunkIndex)
{
newVertices[currentVertex] = lVertices[val];
verticesMap[val] = verticesInCurrentChunk;
chunkIndex[val] = currentChunkIndex;
currentVertex++;
newTriangles[t] = verticesInCurrentChunk;
verticesInCurrentChunk++;
}
else
{
newTriangles[t] = verticesMap[val];
}
if (verticesInCurrentChunk >= chunkSizeLimit && (((t + 1) % 3) == 0))
{
currentChunkIndex++;
verticesInChunks.Add(verticesInCurrentChunk);
trianglesInChunks.Add((t - trianglesChunkStart) / 3);
verticesInCurrentChunk = 0;
trianglesChunkStart = t;
}
}
if (verticesInCurrentChunk != 0)
{
verticesInChunks.Add(verticesInCurrentChunk);
trianglesInChunks.Add((nTriangles * 3 - trianglesChunkStart) / 3);
}
ret.lTriangles = new List <int>(newTriangles);
ret.lVertices = new List <VertexC4ubV3f>(SubArray(newVertices, 0, currentVertex));
ret.trianglesChunkSizes = trianglesInChunks;
ret.verticesChunkSizes = verticesInChunks;
sw.Stop();
Console.WriteLine("Forming elapsed={0}", sw.ElapsedMilliseconds);
return(ret);
}
