void CleanData(MeshParams <WorldVertexDefinition> data)
{
data.ResetSize();
lock (m_freeDatasLock)
{
m_freeDatas.Add(data);
}
}
public override void Render(Vector3 pos, MatrixView <BlockData> neighbors, MeshParams <WorldVertexDefinition> meshParams)
{
var block = neighbors.GetCenter();
ShapeType shape = GetShapeTypeData(block.data);
Rotation rotation = GetRotationData(block.data);
if (m_data == null)
{
m_data = new BlockRendererData(id, m_material);
}
m_data.SetFaceUV(new Rect(0.25f, 0, 0.25f, 1)
, new Rect(0.5f, 0, 0.25f, 1)
, new Rect(0.0f, 0, 0.25f, 1));
m_data.rotation = rotation;
SetDrawFacesFromNeighbors(m_data, neighbors);
switch (shape)
{
case ShapeType.AntiTetrahedral:
BlockRenderer.DrawAntiTetrahedral(pos, meshParams, m_data);
break;
case ShapeType.Cubic:
BlockRenderer.DrawCubic(pos, meshParams, m_data);
break;
case ShapeType.HalfCubic:
BlockRenderer.DrawHalfCubic(pos, meshParams, m_data);
break;
case ShapeType.HorizontalHalfCubic:
BlockRenderer.DrawHorizontalHalfCubic(pos, meshParams, m_data);
break;
case ShapeType.SmallPyramid:
BlockRenderer.DrawSmallPyramid(pos, meshParams, m_data);
break;
case ShapeType.Tetrahedral:
BlockRenderer.DrawThetrahedral(pos, meshParams, m_data);
break;
default:
Debug.Assert(false);
break;
}
}
static void CloneCollisions(MeshParams <WorldVertexDefinition> meshParams, MeshParamData <WorldVertexDefinition> data, int nbVertex, int nbIndex)
{
var collisionData = meshParams.AllocateCollider(nbVertex, nbIndex);
for (int i = 0; i < nbVertex; i++)
{
collisionData.vertices[collisionData.verticesSize + i].pos = data.vertices[data.verticesSize + i].pos;
collisionData.vertices[collisionData.verticesSize + i].normal = data.vertices[data.verticesSize + i].normal;
}
for (int i = 0; i < nbIndex; i++)
{
collisionData.indexes[collisionData.indexesSize + i] = (ushort)(data.indexes[data.indexesSize + i] - data.verticesSize + collisionData.verticesSize);
}
collisionData.verticesSize += nbVertex;
collisionData.indexesSize += nbIndex;
}
void UpdateLayerCollider(MeshCollider obj, int index, MeshParams <WorldVertexDefinition> meshParams)
{
var data = meshParams.GetColliderMesh(index);
var mesh = obj.sharedMesh;
MeshEx.SetColliderMeshParams(mesh, data.verticesSize, data.indexesSize);
mesh.SetVertexBufferData(data.vertices, 0, 0, data.verticesSize);
mesh.SetIndexBufferData(data.indexes, 0, 0, data.indexesSize);
mesh.subMeshCount = 1;
mesh.SetSubMesh(0, new UnityEngine.Rendering.SubMeshDescriptor(0, data.indexesSize, MeshTopology.Triangles));
//full chunk layer
mesh.bounds = new Bounds(new Vector3(Chunk.chunkSize, Chunk.chunkSize, Chunk.chunkSize) / 2, new Vector3(Chunk.chunkSize, Chunk.chunkSize, Chunk.chunkSize));
}
void UpdateLayerObject(LayerObject obj, Material material, int index, MeshParams <WorldVertexDefinition> meshParams)
{
var data = meshParams.GetMesh(material, index);
obj.meshRenderer.material = material;
var mesh = obj.meshFilter.mesh;
MeshEx.SetWorldMeshParams(mesh, data.verticesSize, data.indexesSize);
mesh.SetVertexBufferData(data.vertices, 0, 0, data.verticesSize);
mesh.SetIndexBufferData(data.indexes, 0, 0, data.indexesSize);
mesh.subMeshCount = 1;
mesh.SetSubMesh(0, new UnityEngine.Rendering.SubMeshDescriptor(0, data.indexesSize, MeshTopology.Triangles));
//full chunk layer
mesh.bounds = new Bounds(new Vector3(Chunk.chunkSize, Chunk.chunkSize, Chunk.chunkSize) / 2, new Vector3(Chunk.chunkSize, Chunk.chunkSize, Chunk.chunkSize));
}
public Octree(Vector3 minPoint, Vector3 maxPoint, float minimumSize, MeshParams meshParams)
{
m_MinimumSize = minimumSize;
Root = null;
for (int triangleID = 0; triangleID < meshParams.Triangles.Length; triangleID += 3)
{
int vertexId1 = meshParams.Triangles[triangleID];
int vertexId2 = meshParams.Triangles[triangleID + 1];
int vertexId3 = meshParams.Triangles[triangleID + 2];
Vector3[] triangleVertices = new Vector3[3]
{
meshParams.VerticesWS[vertexId1],
meshParams.VerticesWS[vertexId2],
meshParams.VerticesWS[vertexId3]
};
Vector3 triangleNormal = meshParams.TrianglesNormals[triangleID / 3];
Vector2 uv = Vector2.zero;
Color color = Color.white;
// Get mesh properties (color, uv) from first vertex in triangle and set to voxel.
if (meshParams.UVs.Length > 0)
{
uv = meshParams.UVs[vertexId1];
}
if (meshParams.Colors.Length > 0)
{
color = meshParams.Colors[vertexId1];
}
Vector3[] nodeVertices = Root != null ? Root.Vertices : GetNodeVertices(minPoint, maxPoint);
if (MathHelper.CheckAABBAndTriangleIntersection(minPoint, maxPoint, triangleVertices,
nodeVertices, triangleNormal))
{
ProcessRegion(ref Root, nodeVertices, minPoint, maxPoint, triangleVertices, triangleNormal, uv, color);
}
}
}
public override void Render(Chunk c, int x, int y, int z, MeshParams <WorldVertexDefinition> meshParams)
{
var layer = c.GetLayer(y);
if (layer == null)
{
return;
}
var world = c.world;
int minX, minY, minZ;
world.BlockPosInChunkToPos(Chunk.chunkSize - 1, Chunk.chunkSize - 1, c.x - 1, c.z - 1, out minX, out minZ);
minY = c.LayerToHeight(y - 1, Chunk.chunkSize - 1);
world.GetLocalMatrix(minX, minY, minZ, m_matrix);
m_view.mat = m_matrix;
for (int i = 0; i < Chunk.chunkSize; i++)
{
for (int j = 0; j < Chunk.chunkSize; j++)
{
for (int k = 0; k < Chunk.chunkSize; k++)
{
m_view.SetPos(i + 1, j + 1, k + 1);
int centerID = m_matrix.Get(i + 1, j + 1, k + 1).id;
if (centerID == 0)
{
continue;
}
Vector3 pos = new Vector3(i, j, k);
BlockTypeList.instance.Get(centerID).Render(pos, m_view, meshParams);
}
}
}
}
public abstract void Render(Chunk c, int x, int y, int z, MeshParams <WorldVertexDefinition> meshParams);
public override void Render(Vector3 pos, MatrixView <BlockData> neighbors, MeshParams <WorldVertexDefinition> meshParams)
{
//do nothing here, it's an empty block
}
public static void DrawCubic(Vector3 pos, MeshParams <WorldVertexDefinition> meshParams, BlockRendererData blockData)
{
var data = meshParams.Allocate(24, 36, blockData.material);
int vertexIndex = 0;
int nb = 0;
if (blockData.GetFaceDraw(BlockFace.Left))
{
var rect = blockData.GetFaceUV(BlockFaceEx.Rotate(BlockFace.Left, blockData.rotation));
data.vertices[data.verticesSize + vertexIndex].pos = new Vector3(0, 0, 0) + pos;
data.vertices[data.verticesSize + vertexIndex].uv = new Vector2(rect.x + rect.width, rect.y);
data.vertices[data.verticesSize + vertexIndex + 1].pos = new Vector3(0, 0, 1) + pos;
data.vertices[data.verticesSize + vertexIndex + 1].uv = new Vector2(rect.x, rect.y);
data.vertices[data.verticesSize + vertexIndex + 2].pos = new Vector3(0, 1, 1) + pos;
data.vertices[data.verticesSize + vertexIndex + 2].uv = new Vector2(rect.x, rect.y + rect.height);
data.vertices[data.verticesSize + vertexIndex + 3].pos = new Vector3(0, 1, 0) + pos;
data.vertices[data.verticesSize + vertexIndex + 3].uv = new Vector2(rect.x + rect.width, rect.y + rect.height);
vertexIndex += 4;
nb++;
}
if (blockData.GetFaceDraw(BlockFace.Up))
{
var rect = blockData.GetFaceUV(BlockFace.Up);
data.vertices[data.verticesSize + vertexIndex].pos = new Vector3(0, 1, 0) + pos;
data.vertices[data.verticesSize + vertexIndex].uv = new Vector2(rect.x, rect.y);
data.vertices[data.verticesSize + vertexIndex + 1].pos = new Vector3(0, 1, 1) + pos;
data.vertices[data.verticesSize + vertexIndex + 1].uv = new Vector2(rect.x, rect.y + rect.height);
data.vertices[data.verticesSize + vertexIndex + 2].pos = new Vector3(1, 1, 1) + pos;
data.vertices[data.verticesSize + vertexIndex + 2].uv = new Vector2(rect.x + rect.width, rect.y + rect.height);
data.vertices[data.verticesSize + vertexIndex + 3].pos = new Vector3(1, 1, 0) + pos;
data.vertices[data.verticesSize + vertexIndex + 3].uv = new Vector2(rect.x + rect.width, rect.y);
RotateUV(data, data.verticesSize + vertexIndex, 4, (int)blockData.rotation);
vertexIndex += 4;
nb++;
}
if (blockData.GetFaceDraw(BlockFace.Front))
{
var rect = blockData.GetFaceUV(BlockFaceEx.Rotate(BlockFace.Front, blockData.rotation));
data.vertices[data.verticesSize + vertexIndex].pos = new Vector3(0, 0, 1) + pos;
data.vertices[data.verticesSize + vertexIndex].uv = new Vector2(rect.x + rect.width, rect.y);
data.vertices[data.verticesSize + vertexIndex + 1].pos = new Vector3(1, 0, 1) + pos;
data.vertices[data.verticesSize + vertexIndex + 1].uv = new Vector2(rect.x, rect.y);
data.vertices[data.verticesSize + vertexIndex + 2].pos = new Vector3(1, 1, 1) + pos;
data.vertices[data.verticesSize + vertexIndex + 2].uv = new Vector2(rect.x, rect.y + rect.height);
data.vertices[data.verticesSize + vertexIndex + 3].pos = new Vector3(0, 1, 1) + pos;
data.vertices[data.verticesSize + vertexIndex + 3].uv = new Vector2(rect.x + rect.width, rect.y + rect.height);
vertexIndex += 4;
nb++;
}
if (blockData.GetFaceDraw(BlockFace.Down))
{
var rect = blockData.GetFaceUV(BlockFace.Down);
data.vertices[data.verticesSize + vertexIndex].pos = new Vector3(1, 0, 0) + pos;
data.vertices[data.verticesSize + vertexIndex].uv = new Vector2(rect.x + rect.width, rect.y);
data.vertices[data.verticesSize + vertexIndex + 1].pos = new Vector3(1, 0, 1) + pos;
data.vertices[data.verticesSize + vertexIndex + 1].uv = new Vector2(rect.x + rect.width, rect.y + rect.height);
data.vertices[data.verticesSize + vertexIndex + 2].pos = new Vector3(0, 0, 1) + pos;
data.vertices[data.verticesSize + vertexIndex + 2].uv = new Vector2(rect.x, rect.y + rect.height);
data.vertices[data.verticesSize + vertexIndex + 3].pos = new Vector3(0, 0, 0) + pos;
data.vertices[data.verticesSize + vertexIndex + 3].uv = new Vector2(rect.x, rect.y);
RotateUV(data, data.verticesSize + vertexIndex, 4, (int)blockData.rotation);
vertexIndex += 4;
nb++;
}
if (blockData.GetFaceDraw(BlockFace.Right))
{
var rect = blockData.GetFaceUV(BlockFaceEx.Rotate(BlockFace.Right, blockData.rotation));
data.vertices[data.verticesSize + vertexIndex].pos = new Vector3(1, 1, 0) + pos;
data.vertices[data.verticesSize + vertexIndex].uv = new Vector2(rect.x, rect.y + rect.height);
data.vertices[data.verticesSize + vertexIndex + 1].pos = new Vector3(1, 1, 1) + pos;
data.vertices[data.verticesSize + vertexIndex + 1].uv = new Vector2(rect.x + rect.width, rect.y + rect.height);
data.vertices[data.verticesSize + vertexIndex + 2].pos = new Vector3(1, 0, 1) + pos;
data.vertices[data.verticesSize + vertexIndex + 2].uv = new Vector2(rect.x + rect.width, rect.y);
data.vertices[data.verticesSize + vertexIndex + 3].pos = new Vector3(1, 0, 0) + pos;
data.vertices[data.verticesSize + vertexIndex + 3].uv = new Vector2(rect.x, rect.y);
vertexIndex += 4;
nb++;
}
if (blockData.GetFaceDraw(BlockFace.Back))
{
var rect = blockData.GetFaceUV(BlockFaceEx.Rotate(BlockFace.Back, blockData.rotation));
data.vertices[data.verticesSize + vertexIndex].pos = new Vector3(0, 1, 0) + pos;
data.vertices[data.verticesSize + vertexIndex].uv = new Vector2(rect.x, rect.y + rect.height);
data.vertices[data.verticesSize + vertexIndex + 1].pos = new Vector3(1, 1, 0) + pos;
data.vertices[data.verticesSize + vertexIndex + 1].uv = new Vector2(rect.x + rect.width, rect.y + rect.height);
data.vertices[data.verticesSize + vertexIndex + 2].pos = new Vector3(1, 0, 0) + pos;
data.vertices[data.verticesSize + vertexIndex + 2].uv = new Vector2(rect.x + rect.width, rect.y);
data.vertices[data.verticesSize + vertexIndex + 3].pos = new Vector3(0, 0, 0) + pos;
data.vertices[data.verticesSize + vertexIndex + 3].uv = new Vector2(rect.x, rect.y);
vertexIndex += 4;
nb++;
}
SetColor(data, data.verticesSize, vertexIndex, new Color32(255, 255, 255, 0));
SetQuadsIndexs(data, data.verticesSize, data.indexesSize, nb);
BakeNormals(data, data.indexesSize, nb * 2);
BakeTangents(data, data.indexesSize, nb * 2);
if (blockData.collision)
{
CloneCollisions(meshParams, data, vertexIndex, nb * 6);
}
data.verticesSize += vertexIndex;
data.indexesSize += nb * 6;
}
public static void DrawSmallPyramid(Vector3 pos, MeshParams <WorldVertexDefinition> meshParams, BlockRendererData blockData)
{
}
public static void DrawThetrahedral(Vector3 pos, MeshParams <WorldVertexDefinition> meshParams, BlockRendererData blockData)
{
//4 triangles
// each triangle have 3 vertex and 3 index
var data = meshParams.Allocate(12, 12, blockData.material);
var rot = blockData.rotation;
int vertexIndex = 0;
int nb = 0;
if (blockData.GetFaceDraw(BlockFace.Down))
{
var rect = blockData.GetFaceUV(BlockFace.Down);
data.vertices[data.verticesSize + vertexIndex].pos = new Vector3(1, 0, 0) + pos;
data.vertices[data.verticesSize + vertexIndex].uv = new Vector2(rect.x + rect.width, rect.y);
data.vertices[data.verticesSize + vertexIndex + 1].pos = new Vector3(1, 0, 1) + pos;
data.vertices[data.verticesSize + vertexIndex + 1].uv = new Vector2(rect.x + rect.width, rect.y + rect.height);
data.vertices[data.verticesSize + vertexIndex + 2].pos = new Vector3(0, 0, 0) + pos;
data.vertices[data.verticesSize + vertexIndex + 2].uv = new Vector2(rect.x, rect.y);
vertexIndex += 3;
nb++;
}
if (blockData.GetFaceDraw(BlockFaceEx.Rotate(BlockFace.Back, rot)))
{
var rect = blockData.GetFaceUV(BlockFace.Back);
data.vertices[data.verticesSize + vertexIndex].pos = new Vector3(0, 0, 0) + pos;
data.vertices[data.verticesSize + vertexIndex].uv = new Vector2(rect.x, rect.y);
data.vertices[data.verticesSize + vertexIndex + 1].pos = new Vector3(1, 1, 0) + pos;
data.vertices[data.verticesSize + vertexIndex + 1].uv = new Vector2(rect.x + rect.width, rect.y + rect.height);
data.vertices[data.verticesSize + vertexIndex + 2].pos = new Vector3(1, 0, 0) + pos;
data.vertices[data.verticesSize + vertexIndex + 2].uv = new Vector2(rect.x + rect.width, rect.y);
vertexIndex += 3;
nb++;
}
if (blockData.GetFaceDraw(BlockFaceEx.Rotate(BlockFace.Right, rot)))
{
var rect = blockData.GetFaceUV(BlockFace.Right);
data.vertices[data.verticesSize + vertexIndex].pos = new Vector3(1, 0, 0) + pos;
data.vertices[data.verticesSize + vertexIndex].uv = new Vector2(rect.x, rect.y);
data.vertices[data.verticesSize + vertexIndex + 1].pos = new Vector3(1, 1, 0) + pos;
data.vertices[data.verticesSize + vertexIndex + 1].uv = new Vector2(rect.x, rect.y + rect.height);
data.vertices[data.verticesSize + vertexIndex + 2].pos = new Vector3(1, 0, 1) + pos;
data.vertices[data.verticesSize + vertexIndex + 2].uv = new Vector2(rect.x + rect.width, rect.y);
vertexIndex += 3;
nb++;
}
//top face is drawn in all cases
{
var rect = blockData.GetFaceUV(BlockFace.Up);
data.vertices[data.verticesSize + vertexIndex].pos = new Vector3(0, 0, 0) + pos;
data.vertices[data.verticesSize + vertexIndex].uv = new Vector2(rect.x, rect.y);
data.vertices[data.verticesSize + vertexIndex + 1].pos = new Vector3(1, 0, 1) + pos;
data.vertices[data.verticesSize + vertexIndex + 1].uv = new Vector2(rect.x + rect.width, rect.y + rect.height);
data.vertices[data.verticesSize + vertexIndex + 2].pos = new Vector3(1, 1, 0) + pos;
data.vertices[data.verticesSize + vertexIndex + 2].uv = new Vector2(rect.x + rect.width, rect.y);
vertexIndex += 3;
nb++;
}
SetColor(data, data.verticesSize, vertexIndex, new Color32(255, 255, 255, 0));
SetTrianglesIndexs(data, data.verticesSize, data.indexesSize, nb);
RotatePos(data, data.verticesSize, vertexIndex, pos, rot);
BakeNormals(data, data.indexesSize, nb);
BakeTangents(data, data.indexesSize, nb);
if (blockData.collision)
{
CloneCollisions(meshParams, data, vertexIndex, nb * 3);
}
data.verticesSize += vertexIndex;
data.indexesSize += nb * 3;
}
public static void DrawHorizontalHalfCubic(Vector3 pos, MeshParams <WorldVertexDefinition> meshParams, BlockRendererData blockData)
{
//3 square and 2 triangles
// each square have 4 vertex and 6 index
// each triangle have 3 vertex and 3 index
var data = meshParams.Allocate(18, 24, blockData.material);
var rot = blockData.rotation;
int vertexIndex = 0;
int nbSquare = 0;
int nbTriangle = 0;
if (blockData.GetFaceDraw(BlockFaceEx.Rotate(BlockFace.Right, rot)))
{
var rect = blockData.GetFaceUV(BlockFace.Right);
data.vertices[data.verticesSize + vertexIndex].pos = new Vector3(1, 1, 0) + pos;
data.vertices[data.verticesSize + vertexIndex].uv = new Vector2(rect.x, rect.y + rect.height);
data.vertices[data.verticesSize + vertexIndex + 1].pos = new Vector3(1, 1, 1) + pos;
data.vertices[data.verticesSize + vertexIndex + 1].uv = new Vector2(rect.x + rect.width, rect.y + rect.height);
data.vertices[data.verticesSize + vertexIndex + 2].pos = new Vector3(1, 0, 1) + pos;
data.vertices[data.verticesSize + vertexIndex + 2].uv = new Vector2(rect.x + rect.width, rect.y);
data.vertices[data.verticesSize + vertexIndex + 3].pos = new Vector3(1, 0, 0) + pos;
data.vertices[data.verticesSize + vertexIndex + 3].uv = new Vector2(rect.x, rect.y);
vertexIndex += 4;
nbSquare++;
}
if (blockData.GetFaceDraw(BlockFaceEx.Rotate(BlockFace.Back, rot)))
{
var rect = blockData.GetFaceUV(BlockFace.Back);
data.vertices[data.verticesSize + vertexIndex].pos = new Vector3(0, 1, 0) + pos;
data.vertices[data.verticesSize + vertexIndex].uv = new Vector2(rect.x, rect.y + rect.height);
data.vertices[data.verticesSize + vertexIndex + 1].pos = new Vector3(1, 1, 0) + pos;
data.vertices[data.verticesSize + vertexIndex + 1].uv = new Vector2(rect.x + rect.width, rect.y + rect.height);
data.vertices[data.verticesSize + vertexIndex + 2].pos = new Vector3(1, 0, 0) + pos;
data.vertices[data.verticesSize + vertexIndex + 2].uv = new Vector2(rect.x + rect.width, rect.y);
data.vertices[data.verticesSize + vertexIndex + 3].pos = new Vector3(0, 0, 0) + pos;
data.vertices[data.verticesSize + vertexIndex + 3].uv = new Vector2(rect.x, rect.y);
vertexIndex += 4;
nbSquare++;
}
//diagonal face is drawn in all cases
{
var rect = blockData.GetFaceUV(BlockFace.Front);
data.vertices[data.verticesSize + vertexIndex].pos = new Vector3(0, 1, 0) + pos;
data.vertices[data.verticesSize + vertexIndex].uv = new Vector2(rect.x, rect.y + rect.height);
data.vertices[data.verticesSize + vertexIndex + 1].pos = new Vector3(0, 0, 0) + pos;
data.vertices[data.verticesSize + vertexIndex + 1].uv = new Vector2(rect.x, rect.y);
data.vertices[data.verticesSize + vertexIndex + 2].pos = new Vector3(1, 0, 1) + pos;
data.vertices[data.verticesSize + vertexIndex + 2].uv = new Vector2(rect.x + rect.width, rect.y);
data.vertices[data.verticesSize + vertexIndex + 3].pos = new Vector3(1, 1, 1) + pos;
data.vertices[data.verticesSize + vertexIndex + 3].uv = new Vector2(rect.x + rect.width, rect.y + rect.height);
vertexIndex += 4;
nbSquare++;
}
if (blockData.GetFaceDraw(BlockFace.Down))
{
var rect = blockData.GetFaceUV(BlockFace.Down);
data.vertices[data.verticesSize + vertexIndex].pos = new Vector3(1, 0, 0) + pos;
data.vertices[data.verticesSize + vertexIndex].uv = new Vector2(rect.x + rect.width, rect.y);
data.vertices[data.verticesSize + vertexIndex + 1].pos = new Vector3(1, 0, 1) + pos;
data.vertices[data.verticesSize + vertexIndex + 1].uv = new Vector2(rect.x + rect.width, rect.y + rect.height);
data.vertices[data.verticesSize + vertexIndex + 2].pos = new Vector3(0, 0, 0) + pos;
data.vertices[data.verticesSize + vertexIndex + 2].uv = new Vector2(rect.x, rect.y);
vertexIndex += 3;
nbTriangle++;
}
if (blockData.GetFaceDraw(BlockFace.Up))
{
var rect = blockData.GetFaceUV(BlockFace.Up);
data.vertices[data.verticesSize + vertexIndex].pos = new Vector3(1, 1, 0) + pos;
data.vertices[data.verticesSize + vertexIndex].uv = new Vector2(rect.x + rect.width, rect.y);
data.vertices[data.verticesSize + vertexIndex + 1].pos = new Vector3(0, 1, 0) + pos;
data.vertices[data.verticesSize + vertexIndex + 1].uv = new Vector2(rect.x, rect.y);
data.vertices[data.verticesSize + vertexIndex + 2].pos = new Vector3(1, 1, 1) + pos;
data.vertices[data.verticesSize + vertexIndex + 2].uv = new Vector2(rect.x + rect.width, rect.y + rect.height);
vertexIndex += 3;
nbTriangle++;
}
SetColor(data, data.verticesSize, vertexIndex, new Color32(255, 255, 255, 0));
SetQuadsIndexs(data, data.verticesSize, data.indexesSize, nbSquare);
SetTrianglesIndexs(data, data.verticesSize + 4 * nbSquare, data.indexesSize + 6 * nbSquare, nbTriangle);
RotatePos(data, data.verticesSize, vertexIndex, pos, rot);
BakeNormals(data, data.indexesSize, nbSquare * 2 + nbTriangle);
BakeTangents(data, data.indexesSize, nbSquare * 2 + nbTriangle);
if (blockData.collision)
{
CloneCollisions(meshParams, data, vertexIndex, nbSquare * 6 + nbTriangle * 3);
}
data.verticesSize += vertexIndex;
data.indexesSize += nbSquare * 6 + nbTriangle * 3;
}
public abstract void Render(Vector3 pos, MatrixView <BlockData> neighbors, MeshParams <WorldVertexDefinition> meshParams);
void StartNextTask()
{
//create next task
MeshParams <WorldVertexDefinition> data = null;
lock (m_freeDatasLock)
{
if (m_freeDatas.Count > 0)
{
data = m_freeDatas[0];
m_freeDatas.RemoveAt(0);
}
}
if (data == null)
{
return;
}
int nextJobID = GetNearestJobIndex();
lock (m_waitingJobsLock)
{
Job job = null;
if (nextJobID >= 0)
{
job = m_waitingJobs[nextJobID];
m_waitingJobs.RemoveAt(nextJobID);
}
if (job == null)
{
lock (m_freeDatasLock)
{
m_freeDatas.Add(data);
}
return;
}
data.ResetSize();
job.data = data;
lock (m_doingJobStatusLock)
{
lock (m_doingJobLock)
{
Debug.Assert(m_doingJob == null);
m_doingJob = job;
m_doingJobStatus.CloneJob(m_doingJob);
}
}
}
DoJob();
//move task to ended task
lock (m_doingJobLock)
{
lock (m_doingJobStatusLock)
{
m_doingJobStatus.working = false;
m_doingJob.aborted = m_doingJobStatus.aborted;
}
lock (m_endedJobsLock)
{
if (m_doingJob.aborted)
{
CleanData(m_doingJob.data);
}
else
{
m_endedJobs.Add(m_doingJob);
}
m_doingJob = null;
}
}
}
