public void ChunkProcPostGenMesh(IVxSurfExtractReq ireq)
{
SurfExtractReqB45 req = ireq as SurfExtractReqB45;
Block45ChunkGo b45Go = Block45ChunkGo.CreateChunkGo(req);
req._chunkData.AttachChunkGo(b45Go);
}
public static Block45ChunkGo CreateChunkGo(IVxSurfExtractReq req, Transform parent = null)
{
if (req.FillMesh(null) == 0)
{
return(null);
}
Block45ChunkGo b45Go = VFGoPool <Block45ChunkGo> .GetGo();
req.FillMesh(b45Go._mf.mesh);
// set material
SurfExtractReqB45 b45ret = req as SurfExtractReqB45;
if (b45ret != null)
{
List <Material> tmpMatList = new List <Material>();
for (int i = 0; i < b45ret.matCnt; i++)
{
tmpMatList.Add(_defMats[b45ret.materialMap[i]]);
}
b45Go._mr.sharedMaterials = tmpMatList.ToArray();
}
if (parent != null)
{
b45Go.transform.parent = parent;
}
b45Go.gameObject.SetActive(true);
return(b45Go);
}
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
}
IVxSurfExtractReq PickReqToProceed()
{
if (_reqList.Count == 0)
{
return(null);
}
// Remove those out of date.
foreach (var entry in _reqList.Where(kvp => kvp.Value.IsInvalid).ToList())
{
_reqList.Remove(entry.Key);
}
// TODO : mod code for b45
// Add to process
for (int curlod = 0; curlod <= LODOctreeMan.MaxLod; curlod++)
{
foreach (KeyValuePair <int, IVxSurfExtractReq> pair in _reqList)
{
if (pair.Value.Priority == curlod)
{
IVxSurfExtractReq req = pair.Value;
Array.Copy(req.VolumeData, _chunkDataBuffer, _chunkDataBuffer.Length);
_chunkDataToProceed = _chunkDataBuffer;
_reqList.Remove(pair.Key);
return(req);
}
}
}
return(null);
}
void PickReqToProceed()
{
if (_reqList.Count == 0)
{
return;
}
// Remove those out of date.
foreach (var entry in _reqList.Where(kvp => kvp.Value.IsInvalid).ToList())
{
//SurfExtractReqMC r = (SurfExtractReqMC)entry.Value;
//Debug.LogError("[RemoveChunkInReq]"+r._chunk.ChunkPosLod+":"
// +r._chunkSig+"|"+r._chunk.SigOfChnk+";"
// +r._chunkStamp+"|"+r._chunk.StampOfUpdating);
_reqList.Remove(entry.Key);
}
// Add to processList
_tmpReqList.Clear();
for (int curlod = 0; curlod <= LODOctreeMan.MaxLod && _tmpReqList.Count < oclMarchingCube.MAX_CHUNKS - 1; curlod++)
{
_tmpReqList.AddRange(_reqList.Where(kvp => kvp.Value.Priority == curlod));
}
int n = 0, nMax = _tmpReqList.Count;
while (oclMarchingCube.numChunks < oclMarchingCube.MAX_CHUNKS - 1 && n < nMax)
{
IVxSurfExtractReq req = _tmpReqList[n].Value;
_reqInProcessList.Add(req);
oclMarchingCube.AddChunkVolumeData(req.VolumeData);
_reqList.Remove(_tmpReqList[n].Key);
n++;
}
return;
}
IVxSurfExtractReq PickReqToProceed()
{
if (_reqList.Count == 0)
{
return(null);
}
// Remove those out of date.
foreach (var entry in _reqList.Where(kvp => kvp.Value.IsInvalid).ToList())
{
//Debug.Log("RemoveChunkInReq"+((SurfExtractReqMC)entry.Value)._chunkData.ChunkPosLod+":"
// +((SurfExtractReqMC)entry.Value)._chunkStamp+"|"
// +((SurfExtractReqMC)entry.Value)._chunkData.StampOfChnkUpdating);
_reqList.Remove(entry.Key);
}
// Add to process
for (int curlod = 0; curlod <= LODOctreeMan.MaxLod; curlod++)
{
foreach (KeyValuePair <int, IVxSurfExtractReq> pair in _reqList)
{
if (pair.Value.Priority == curlod)
{
IVxSurfExtractReq req = pair.Value;
Array.Copy(req.VolumeData, _chunkDataBuffer, _chunkDataBuffer.Length);
_chunkDataToProceed = _chunkDataBuffer;
_reqList.Remove(pair.Key);
return(req);
}
}
}
return(null);
}
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 bool AddSurfExtractReq(IVxSurfExtractReq req)
{
lock (_reqList){
_reqList[req.Signature] = req;
}
return(true);
}
void ChunkProcPostGenMesh(IVxSurfExtractReq ireq)
{
if (this == null)
{
return;
}
SurfExtractReqB45 req = ireq as SurfExtractReqB45;
Block45ChunkGo b45Go = Block45ChunkGo.CreateChunkGo(req, transform);
req._chunkData.AttachChunkGo(b45Go);
}
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);
}
public IVxSurfExtractReq Contains(VFVoxelChunkData chunk)
{
lock (_reqList){
List <IVxSurfExtractReq> rs = _reqList.Values.ToList();
IVxSurfExtractReq ret = rs.Find(r => ((SurfExtractReqMC)r)._chunk == chunk);
if (ret == null)
{
ret = rs.Find(r => ((SurfExtractReqMC)r)._chunk.ChunkPosLod.Equals(chunk.ChunkPosLod));
if (ret == null)
{
_reqList.TryGetValue(chunk.SigOfChnk, out ret);
}
}
return(ret);
}
}
public static VFVoxelChunkGo CreateChunkGo(IVxSurfExtractReq req, Material mat = null, int layer = 0)
{
if (req.FillMesh(null) == 0)
{
return(null);
}
VFVoxelChunkGo vfGo = VFGoPool <VFVoxelChunkGo> .GetGo();
int nMesh = req.FillMesh(vfGo.Mf.sharedMesh);
vfGo._bPrimal = true;
if (mat != null)
{
vfGo.Mr.sharedMaterial = mat;
}
if (layer != 0)
{
vfGo.gameObject.layer = layer;
}
vfGo.gameObject.SetActive(true);
while (nMesh > 0)
{
VFVoxelChunkGo subGo = VFGoPool <VFVoxelChunkGo> .GetGo();
nMesh = req.FillMesh(subGo.Mf.sharedMesh);
subGo.transform.parent = vfGo.transform;
subGo.transform.localScale = Vector3.one;
subGo.transform.localPosition = Vector3.zero;
if (mat != null)
{
subGo.Mr.sharedMaterial = mat;
}
if (layer != 0)
{
subGo.gameObject.layer = layer;
}
subGo.gameObject.SetActive(true);
}
return(vfGo);
}
public void Exec()
{
reqToProceed = null;
lock (_reqList)
reqToProceed = PickReqToProceed();
if (reqToProceed == null)
{
return;
}
swBlock45.setInputChunkData(_chunkDataToProceed);
swBlock45.Rebuild();
SurfExtractReqB45 req = reqToProceed as SurfExtractReqB45;
//usedMaterialIndicesList.Add(swBlock45.getMaterialMap());
int chunkTotalVerts = swBlock45.verts.Count;
if (chunkTotalVerts > 0)
{
int chunkVertsCntThreshold = reqToProceed.MeshSplitThreshold;
if (chunkTotalVerts <= chunkVertsCntThreshold)
{
req.verts = swBlock45.verts.ToArray();
req.uvs = swBlock45.uvs.ToArray();
req.matCnt = swBlock45.matCnt;
req.materialMap = swBlock45.materialMap;
foreach (List <int> indice in swBlock45.subMeshIndices)
{
req.subMeshIndices.Add(indice.ToArray());
}
}
else
{
Debug.LogError("[SurfB45_CPU]:Out Of chunkVertsCntThreshold.");
}
}
lock (_reqFinishedList)
_reqFinishedList.Add(reqToProceed);
_chunkDataToProceed = null;
}
public void SetTransGo(IVxSurfExtractReq req, int faceMask)
{
if (TransvoxelGo != null)
{
VFGoPool <VFTransVoxelGo> .FreeGo(TransvoxelGo);
TransvoxelGo = null;
}
if (faceMask != 0)
{
VFTransVoxelGo go = VFGoPool <VFTransVoxelGo> .GetGo();
req.FillMesh(go._mf.sharedMesh);
go._faceMask = faceMask;
go.transform.parent = transform;
//go.transform.localScale = Vector3.one;
go.transform.localPosition = Vector3.zero;
go.gameObject.SetActive(true);
TransvoxelGo = go;
}
}
//private bool bNeedUpdateTrans = false;
public int OnFin()
{
#if !B45_THREADING
if (_reqList.Count > 0 && !Pause)
{
Exec();
}
#endif
if (Monitor.TryEnter(_reqFinishedList))
{
for (int i = 0; i < _reqFinishedList.Count; i++)
{
IVxSurfExtractReq req = _reqFinishedList [i];
req.OnReqFinished();
}
_reqFinishedList.Clear();
Monitor.Exit(_reqFinishedList);
}
return(_reqFinishedList.Count);
}
public bool AddSurfExtractReq(IVxSurfExtractReq req)
{
return(true);
}
public bool AddSurfExtractReq(IVxSurfExtractReq req)
{
_reqList[req.Signature] = (SurfExtractReqTrans)req;
return(true);
}
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;
}
}
private void Recover()
{
//if(reqToProceed != null) AddSurfExtractReq(reqToProceed);
reqToProceed = null;
}
