void NV_Handler(SurfExtractReqMC req)
{
int nMesh = req.Ret.FillMesh(null);
if (nMesh == 0)
{
req._chunkData.AttachChunkGo(null);
return;
}
Material defMat = null;
GameObject go = new GameObject();
MeshFilter mf = go.AddComponent <MeshFilter>();
MeshCollider mc = go.AddComponent <MeshCollider>();
MeshRenderer mr = go.AddComponent <MeshRenderer>();
mc.sharedMesh = null;
mr.sharedMaterial = defMat;
nMesh = req.Ret.FillMesh(mf.mesh);
go.name = "chunk_" + req.Signature;
while (nMesh > 0)
{
GameObject goChild = new GameObject();
MeshFilter mfChild = goChild.AddComponent <MeshFilter>();
MeshCollider mcChild = goChild.AddComponent <MeshCollider>();
MeshRenderer mrChild = goChild.AddComponent <MeshRenderer>();
mcChild.sharedMesh = null;
mrChild.sharedMaterial = defMat;
nMesh = req.Ret.FillMesh(mfChild.mesh);
goChild.transform.parent = go.transform;
goChild.transform.localPosition = Vector3.zero;
goChild.name = "chunk_sub";
}
}
public static SurfExtractReqMC Get(VFVoxelChunkData chunk, Action <SurfExtractReqMC> finHandler)
{
SurfExtractReqMC req = Get(chunk);
req._customFinHandler = finHandler;
return(req);
}
public void Exec()
{
reqToProceed = null;
lock (_reqList)
reqToProceed = PickReqToProceed();
if (reqToProceed == null)
{
return;
}
swMarchingCubes.setInputChunkData(_chunkDataToProceed);
swMarchingCubes.Rebuild();
SurfExtractReqMC req = reqToProceed as SurfExtractReqMC;
int chunkTotalVerts = swMarchingCubes.VertexList.Count;
if (chunkTotalVerts > 0)
{
req.FillOutData(swMarchingCubes.VertexList, swMarchingCubes.Norm01List, swMarchingCubes.Norm2tList, 0, chunkTotalVerts);
}
lock (_reqFinishedList)
_reqFinishedList.Add(reqToProceed);
_chunkDataToProceed = null;
}
public void ChunkProcPostGenMesh(IVxSurfExtractReq ireq)
{
SurfExtractReqMC req = ireq as SurfExtractReqMC;
VFVoxelChunkGo vfGo = VFVoxelChunkGo.CreateChunkGo(req);
req._chunk.AttachChunkGo(vfGo, req);
#if !ScopedCollider
if (vfGo != null)
{
bChunkColliderRebuilding = true;
vfGo._mc.sharedMesh = null;
vfGo._mc.sharedMesh = vfGo._mf.mesh;
foreach (Transform subGo in vfGo.transform)
{
VFVoxelChunkGo vfGoSub = subGo.GetComponent <VFVoxelChunkGo>();
if (vfGoSub != null)
{
vfGoSub._mc.sharedMesh = null;
vfGoSub._mc.sharedMesh = vfGoSub._mf.mesh;
}
}
bChunkColliderRebuilding = false;
}
#endif
}
public void AddToBuildList() // Can be called from the main thread
{
if (IsHollow)
{
FinHollowUpdate(); return;
}
BuildStep = BuildStep_StartGoCreating;
_helperProc.SurfExtractor.AddSurfExtractReq(SurfExtractReqMC.Get(this, VertsThreshold));
}
// The above functions can be invoked in other thread
// The below function will be invoked in main thread.
public void AttachChunkGo(VFVoxelChunkGo vfGo, SurfExtractReqMC req = null)
{
if (vfGo != null)
{
float fScale = (1 << _chunkPosLod.w);
#if UNITY_EDITOR
vfGo.name = PatheaScript.Util.GetChunkName(_chunkPosLod);
#endif
vfGo.transform.localScale = new Vector3(fScale, fScale, fScale);
vfGo.transform.position = Pos;
vfGo.Data = this;
vfGo.OriginalChunkGo = null;
if (null != _goChunk && _goChunk.name.Equals(vfGo.name))
{
if (_goChunk.OriginalChunkGo != null)
{
vfGo.OriginalChunkGo = _goChunk.OriginalChunkGo;
_goChunk.OriginalChunkGo = null;
}
else if (_goChunk.Mc.sharedMesh != null)
{
vfGo.OriginalChunkGo = _goChunk;
_goChunk.Mr.enabled = false;
_goChunk = null;
}
}
else if (_node != null && SigOfType == VFVoxelTerrain.self.ChunkSig)
{
_node.OnMeshCreated();
}
}
if (null != _goChunk)
{
VFGoPool <VFVoxelChunkGo> .FreeGo(_goChunk);
}
_goChunk = vfGo;
_bNoVerts = vfGo == null;
if (_node != null && req != null)
{
if (!req.IsInvalid)
{
#if BegEndUpdateNodeDataInSameThread
lock (s_lstReqsToEndUpdateNodeData)
{
s_lstReqsToEndUpdateNodeData.Add(new EndUpdateReq(req));
}
#else
EndUpdateNodeData();
#endif
}
return;
}
BuildStep = BuildStep_NotInBuild;
}
public void ChunkProcPostGenMesh(IVxSurfExtractReq ireq)
{
SurfExtractReqMC req = ireq as SurfExtractReqMC;
VFVoxelChunkGo vfGo = VFVoxelChunkGo.CreateChunkGo(req, _waterMat, s_layer);
if (vfGo != null)
{
vfGo.transform.parent = gameObject.transform;
}
req._chunk.AttachChunkGo(vfGo, req);
}
void ProcGenSeaSurface(SurfExtractReqMC req)
{
_tmpSeaSurfaceVerts.Clone(_seaSurfaceVerts [req._chunk.LOD]); // To avoid outputdata(_seaSurfaceVerts) from clearing
req.AddOutData(_tmpSeaSurfaceVerts);
VFVoxelChunkGo vfGo = VFVoxelChunkGo.CreateChunkGo(req, _waterMat, s_layer);
vfGo.transform.parent = gameObject.transform;
req._chunkData = _tmpSurfChunkData4Req;
req._chunk.AttachChunkGo(vfGo, req);
}
public static SurfExtractReqMC Get(VFVoxelChunkData chunk, int nVertsPerMesh = SurfExtractorsMan.c_vertsCnt4Pool)
{
//SurfExtractReqMC req = new SurfExtractReqMC ();
SurfExtractReqMC req = s_reqPool.Get();
req._chunk = chunk;
req._chunkData = chunk.DataVT;
req._chunkSig = chunk.SigOfChnk;
req._chunkStamp = chunk.StampOfUpdating;
req._customFinHandler = null;
req._nVertsPerMesh = nVertsPerMesh;
return(req);
}
public static void Free(SurfExtractReqMC req)
{
int n = req._outDatas.Count;
if (n > 0)
{
// If mesh data not been filled
for (int i = 0; i < n; i++)
{
MCOutputData.Free(req._outDatas [i]);
}
req._outDatas.Clear();
}
s_reqPool.Free(req);
}
// Delegates
public void OnWaterDataLoad(VFVoxelChunkData chunkData, byte[] chunkDataVT, bool bFromPool)
{
if (chunkDataVT.Length != VFVoxel.c_VTSize || chunkDataVT[0] != c_iSurfaceVol)
{
// not surface chunk
chunkData.OnDataLoaded(chunkDataVT, bFromPool);
return;
}
// surface chunk
int step = 1 << chunkData.LOD;
if (c_fWaterLvl >= ((chunkData.ChunkPosLod.y + step) << VoxelTerrainConstants._shift))
{
chunkData.OnDataLoaded(VFVoxelChunkData.S_ChunkDataWaterSolid);
return;
}
if (_seaSurfaceVerts[chunkData.LOD] == null)
{
float fy = (c_fWaterLvl - (chunkData.ChunkPosLod.y << VoxelTerrainConstants._shift)) / step;
Vector3[] pos = new Vector3[4] {
new Vector3(0.0f, fy, 0.0f),
new Vector3(0.0f, fy, 32.0f),
new Vector3(32.0f, fy, 0.0f),
new Vector3(32.0f, fy, 32.0f),
};
Vector2[] norm01 = new Vector2[4] {
new Vector2(), new Vector2(), new Vector2(), new Vector2(),
};
Vector2[] norm2t = new Vector2[4] {
new Vector2(), new Vector2(), new Vector2(), new Vector2(),
};
int[] indice = new int[6] {
0, 1, 2, 1, 3, 2
};
MCOutputData chunkMeshData = new MCOutputData(pos, norm01, norm2t, indice);
_seaSurfaceVerts[chunkData.LOD] = chunkMeshData;
}
lock (_seaSurfaceChunkReqs)
{
_seaSurfaceChunkReqs.Add(SurfExtractReqMC.Get(chunkData, ProcGenSeaSurface));
}
// if surface chunk data not the following format, we should set it to this
//chunkDataVT[0] = c_iSurfaceVol;
//chunkDataVT[1] = c_iSeaWaterType;
chunkData.SetDataVT(chunkDataVT);
}
public void Exec()
{
lock (_reqList)
PickReqToProceed();
int nNumChunks = oclMarchingCube.numChunks;
if (nNumChunks == 0)
{
return;
}
IEnumerator e = oclMarchingCube.computeIsosurfaceAsyn();
while (e.MoveNext())
{
;
}
Vector3[] posArray = oclMarchingCube.hPosArray.Target as Vector3[];
Vector2[] srcNorm01Array = oclMarchingCube.hNorm01Array.Target as Vector2[];
Vector2[] srcNorm2tArray = oclMarchingCube.hNorm2tArray.Target as Vector2[];
for (int i = 0; i < nNumChunks; i++)
{
SurfExtractReqMC req = _reqInProcessList[i] as SurfExtractReqMC;
int prevChunkVerts = oclScanLaucher.ofsData[i];
int chunkTotalVerts = i == nNumChunks - 1 ? (oclScanLaucher.sumData[0] - prevChunkVerts) : (oclScanLaucher.ofsData[i + 1] - prevChunkVerts);
if (chunkTotalVerts > 0)
{
req.FillOutData(posArray, srcNorm01Array, srcNorm2tArray, prevChunkVerts, chunkTotalVerts);
}
}
lock (_reqFinishedList)
_reqFinishedList.AddRange(_reqInProcessList);
_reqInProcessList.Clear();
}
public EndUpdateReq(SurfExtractReqMC req)
{
_chunk = req._chunk;
_sig = req._chunkSig;
_stamp = req._chunkStamp;
}
public void ChunkProcPostGenMesh(IVxSurfExtractReq ireq)
{
if (m_MeshMgr == null)
{
return;
}
SurfExtractReqMC req = ireq as SurfExtractReqMC;
if (req.IsInvalid)
{
Debug.Log("[VCSystem] RemoveChunkInSet" + req._chunk.ChunkPosLod
+ ":" + req._chunkStamp + "|" + req._chunk.StampOfUpdating);
return;
}
IntVector3 pos = SNChunkPosToChunkPos(new IntVector3(req._chunk.ChunkPosLod.x, req._chunk.ChunkPosLod.y, req._chunk.ChunkPosLod.z));
int mesh_cnt = req.FillMesh(null);
m_MeshMgr.Clamp(pos, mesh_cnt);
int index = 0;
while (mesh_cnt > 0)
{
GameObject targetgo = m_MeshMgr.QueryAtIndex(pos, index);
if (targetgo == null)
{
targetgo = new GameObject();
// mf
targetgo.AddComponent <MeshFilter>();
// mr
MeshRenderer mr = targetgo.AddComponent <MeshRenderer>();
mr.material = m_MeshMgr.m_MeshMat;
mr.receiveShadows = true;
mr.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.On;
// mc
// MeshCollider mc = targetgo.AddComponent<MeshCollider>();
//mc.sharedMesh = null;
// pp
if (!m_ForEditor)
{
VCParticlePlayer pp = targetgo.AddComponent <VCParticlePlayer>();
pp.FunctionTag = VCParticlePlayer.ftDamaged;
pp.LocalPosition = Vector3.zero;
}
m_MeshMgr.Set(pos, index, targetgo);
}
else
{
// MeshCollider mc = targetgo.GetComponent<MeshCollider>();
// mc.sharedMesh = null;
}
MeshFilter targetmf = targetgo.GetComponent <MeshFilter>();
Mesh mesh = targetmf.mesh;
mesh.Clear();
mesh_cnt = req.FillMesh(mesh);
// Customize mesh for VCSystem
int vert_cnt = mesh.vertexCount;
Color32[] colors = new Color32[vert_cnt];
Vector3[] normals = new Vector3[vert_cnt];
Vector3[] vertices = mesh.vertices;
for (int i = 0; i < vert_cnt; ++i)
{
colors[i] = VCIsoData.BLANK_COLOR;
}
for (int i = 0; i < vertices.Length; i += 3)
{
Vector3 normal = Vector3.Cross(vertices[i] - vertices[i + 1], vertices[i] - vertices[i + 2]).normalized;
normals[i] = normal;
normals[i + 1] = normal;
normals[i + 2] = normal;
}
mesh.normals = normals;
mesh.colors32 = colors;
m_MeshMgr.UpdateMeshColor(targetmf);
PostGenerate(targetmf);
++index;
}
}
