private void INLINE_CombineMeshes(ref List <int> indexes, ref Mesh visibleMesh, ref Mesh colliderMesh)
{
int count = indexes.Count;
if (count > 0)
{
CombineInstance[] visibleCI = new CombineInstance[count], colliderCI = new CombineInstance[count];
Mesh m;
BlockpartVisualizeInfo bvi;
Matrix4x4 mtr;
for (int i = 0; i < count; i++)
{
bvi = blockVisualizersList[indexes[i]];
m = MeshMaster.GetMesh(bvi.meshType, bvi.materialID);
visibleCI[i].mesh = m;
visibleCI[i].transform = bvi.GetPositionMatrix();
mtr = bvi.GetPositionMatrix();
visibleCI[i].transform = mtr;
colliderCI[i].mesh = bvi.meshType == MeshType.Quad ? m : MeshMaster.GetMeshColliderLink(bvi.meshType);
colliderCI[i].transform = mtr;
}
visibleMesh.CombineMeshes(visibleCI, true); // все подмеши используют один материал
colliderMesh.CombineMeshes(colliderCI);
}
}
public bool IsFaceTransparent(byte faceIndex)
{
if ((existingPlanesMask & (1 << faceIndex)) != 0)
{
if (planes == null || !planes.ContainsKey(faceIndex))
{
return(false); // дефолтные квады
}
else
{
if (planes[faceIndex].isQuad)
{
return(false);
}
else
{
return(MeshMaster.IsMeshTransparent(planes[faceIndex].meshType));
}
}
}
else
{
return(true);
}
}
public Plane CreatePlane(byte faceIndex, int i_materialID, bool redrawCall)
{
Plane p = null;
if (planes == null)
{
planes = new Dictionary <byte, Plane>();
}
else
{
if (planes.ContainsKey(faceIndex))
{
p = planes[faceIndex];
p.ChangeMaterial(i_materialID, redrawCall);
return(p);
}
}
var pos = myBlock.pos;
if (faceIndex == Block.UP_FACE_INDEX && pos.y == Chunk.chunkSize - 1)
{
p = MeshMaster.GetRooftop(this, Random.value < 0.14f, !isNatural);
}
else
{
p = new Plane(this, Plane.defaultMeshType, i_materialID, faceIndex, 0);
}
planes.Add(faceIndex, p);
if (redrawCall)
{
myBlock.myChunk.RefreshBlockVisualising(myBlock, faceIndex);
}
return(p);
}
public Plane CreatePlane(byte faceIndex, bool redrawCall)
{
if (planes == null)
{
planes = new Dictionary <byte, Plane>();
}
else
{
if (planes.ContainsKey(faceIndex))
{
return(planes[faceIndex]);
}
}
var pos = myBlock.pos;
Plane p;
if (faceIndex < 4)
{
MeshType mtype = MeshType.Quad;
var f = Random.value;
if (f < 0.8f)
{
if (f < 0.4f)
{
mtype = MeshType.StorageEntrance;
}
else
{
mtype = MeshType.StorageSide;
}
}
else
{
mtype = MeshType.DoubleWindows;
}
var mp = new MultimaterialPlane(this, mtype, faceIndex, 0);
mp.SetActivationStatus(isActive);
p = mp;
}
else
{
if (faceIndex == Block.UP_FACE_INDEX && pos.y == Chunk.chunkSize - 1)
{
p = MeshMaster.GetRooftop(this, Random.value < 0.1f, true);
}
else
{
p = new Plane(this, MeshType.Quad, PoolMaster.MATERIAL_ADVANCED_COVERING_ID, faceIndex, 0);
}
}
//
planes.Add(faceIndex, p);
if (redrawCall)
{
myBlock.myChunk.RefreshBlockVisualising(myBlock, faceIndex);
}
return(p);
}
private void PrepareModel()
{
model = MeshMaster.InstantiateAdvancedMesh(meshType);
model.transform.parent = myChunk.GetRenderersHolderTransform(faceIndex);
model.transform.localPosition = GetCenterPosition();
model.transform.localRotation = Quaternion.Euler(GetEulerRotationForBlockpart() + Vector3.forward * 90f * meshRotation);
model.AddComponent <StructurePointer>().SetStructureLink((Structure)host, faceIndex);
if (!isActive)
{
PoolMaster.SwitchMaterialToOffline(model.GetComponentInChildren <Renderer>());
}
model.SetActive(isVisible);
}
public Plane CreatePlane(byte faceIndex, bool redrawCall)
{
if (planes == null)
{
planes = new Dictionary <byte, Plane>();
}
else
{
if (planes.ContainsKey(faceIndex))
{
return(planes[faceIndex]);
}
}
var pos = myBlock.pos;
MeshType mtype = MeshType.Quad;
int mid;
bool isSideMesh = faceIndex < 4;
if (isSideMesh)
{
mtype = MeshType.FoundationSide;
mid = PoolMaster.FIXED_UV_BASIC;
}
else
{
if (faceIndex == Block.UP_FACE_INDEX && pos.y == Chunk.chunkSize - 1)
{
var px = MeshMaster.GetRooftop(this, Random.value < 0.1f, true);
planes.Add(faceIndex, px);
if (redrawCall)
{
myBlock.myChunk.RefreshBlockVisualising(myBlock, faceIndex);
}
return(px);
}
else
{
mtype = MeshType.Quad;
mid = PoolMaster.MATERIAL_ADVANCED_COVERING_ID;
}
}
//
var p = new Plane(this, mtype, mid, faceIndex, 0);
planes.Add(faceIndex, p);
if (redrawCall)
{
myBlock.myChunk.RefreshBlockVisualising(myBlock, faceIndex);
}
return(p);
}
public void SetStructureLink(Structure s, byte i_faceIndex)
{
source = s;
var mc = GetComponent <MeshCollider>();
if (mc == null)
{
Destroy(this);
return;
}
else
{
mc.sharedMesh = MeshMaster.GetMeshSourceLink(MeshType.Quad);
faceIndex = i_faceIndex;
}
}
public static Mesh SetMaterialByID(ref MeshFilter mf, ref MeshRenderer mr, int materialID, byte i_illumination)
{
Mesh m = mf.mesh;
MeshMaster.SetMeshUVs(ref m, materialID);
mf.sharedMesh = m;
if (useIlluminationSystem)
{
mr.sharedMaterial = GetMaterial(materialID, i_illumination);
}
else
{
mr.sharedMaterial = GetMaterial(materialID);
}
return(m);
}
//returns true if plane exists and opaque
public bool InitializePlane(byte faceIndex)
{
if ((existingPlanesMask & (1 << faceIndex)) == 0)
{
return(false);
}
else
{
if (planes != null && planes.ContainsKey(faceIndex))
{
if (!planes[faceIndex].isVisible)
{
planes[faceIndex].SetVisibility(true);
}
return(!MeshMaster.IsMeshTransparent(planes[faceIndex].meshType));
}
else
{
var p = CreatePlane(faceIndex, materialID, false);
return(!MeshMaster.IsMeshTransparent(p.meshType));
}
}
}
public Plane CreatePlane(byte faceIndex, bool redrawCall)
{
if (planes == null)
{
planes = new Dictionary <byte, Plane>();
}
else
{
if (planes.ContainsKey(faceIndex))
{
return(planes[faceIndex]);
}
}
var pos = myBlock.pos;
Plane p;
if (faceIndex < 4)
{
var mtype = (ID == FARM_BLOCK_ID ? MeshType.FarmSide : MeshType.LumbermillSide);
var f = Random.value;
if (f < 0.25f)
{
mtype = (ID == FARM_BLOCK_ID ? MeshType.FarmFace : MeshType.LumbermillFace);
}
else
{
if (f > 0.8f)
{
mtype = f > 0.9f ? MeshType.IndustryHeater0 : MeshType.IndustryHeater1;
}
else
{
if (f > 0.7f)
{
if (f > 0.75f)
{
mtype = MeshType.BigWindow;
}
else
{
mtype = MeshType.SmallWindows;
}
}
}
}
var mp = new MultimaterialPlane(this, mtype, faceIndex, 0);
mp.SetActivationStatus(isActive);
p = mp;
}
else
{
if (faceIndex == Block.UP_FACE_INDEX && pos.y == Chunk.chunkSize - 1)
{
p = MeshMaster.GetRooftop(this, Random.value < 0.1f, true);
}
else
{
p = new Plane(this, MeshType.Quad, PoolMaster.MATERIAL_ADVANCED_COVERING_ID, faceIndex, 0);
}
}
//
planes.Add(faceIndex, p);
if (redrawCall)
{
myBlock.myChunk.RefreshBlockVisualising(myBlock, faceIndex);
}
return(p);
}
private static GameObject ConstructGeneratedMesh(GeneratedMeshPartInfo[,,] dataArray, int materialID)
{
Vector3 scale = Vector3.one;
var ci = new CombineInstance[RefineGeneratedMesh(ref dataArray)];
int i = 0, xsize = dataArray.GetLength(0), ysize = dataArray.GetLength(1), zsize = dataArray.GetLength(2);
float xhalf = xsize / 2f, zhalf = zsize / 2f;
Quaternion[] rotations = new Quaternion[6]
{
Quaternion.identity, Quaternion.Euler(0f, 90f, 0f), Quaternion.Euler(0f, 180f, 0f),
Quaternion.Euler(0f, 270f, 0f), Quaternion.Euler(90f, 0f, 0f), Quaternion.Euler(-90f, 0f, 0f)
};
Vector3[] correctionVectors = new Vector3[6]
{
Vector3.forward * 0.5f *scale.z, Vector3.right * 0.5f *scale.x, Vector3.back * 0.5f *scale.z,
Vector3.left * 0.5f *scale.x, Vector3.up * 0.5f *scale.y, Vector3.down * 0.5f *scale.y
};
for (int x = 0; x < xsize; x++)
{
for (int y = 0; y < ysize; y++)
{
for (int z = 0; z < zsize; z++)
{
var gmi = dataArray[x, y, z];
if (gmi.fwdFaceType != MeshType.NoMesh)
{
ci[i].mesh = MeshMaster.GetMesh(gmi.fwdFaceType, materialID);
ci[i].transform = Matrix4x4.TRS((new Vector3(x - xhalf, y - ysize, z - zhalf) + correctionVectors[0]), rotations[0], scale);
i++;
}
if (gmi.rightFaceType != MeshType.NoMesh)
{
ci[i].mesh = MeshMaster.GetMesh(gmi.rightFaceType, materialID);
ci[i].transform = Matrix4x4.TRS((new Vector3(x - xhalf, y - ysize, z - zhalf) + correctionVectors[1]), rotations[1], scale);
i++;
}
if (gmi.backFaceType != MeshType.NoMesh)
{
ci[i].mesh = MeshMaster.GetMesh(gmi.backFaceType, materialID);
ci[i].transform = Matrix4x4.TRS((new Vector3(x - xhalf, y - ysize, z - zhalf) + correctionVectors[2]), rotations[2], scale);
i++;
}
if (gmi.leftFaceType != MeshType.NoMesh)
{
ci[i].mesh = MeshMaster.GetMesh(gmi.leftFaceType, materialID);
ci[i].transform = Matrix4x4.TRS((new Vector3(x - xhalf, y - ysize, z - zhalf) + correctionVectors[3]), rotations[3], scale);
i++;
}
if (gmi.upFaceType != MeshType.NoMesh)
{
ci[i].mesh = MeshMaster.GetMesh(gmi.upFaceType, materialID);
ci[i].transform = Matrix4x4.TRS((new Vector3(x - xhalf, y - ysize, z - zhalf) + correctionVectors[4]), rotations[5], scale);
i++;
}
if (gmi.downFaceType != MeshType.NoMesh)
{
ci[i].mesh = MeshMaster.GetMesh(gmi.downFaceType, materialID);
ci[i].transform = Matrix4x4.TRS((new Vector3(x - xhalf, y - ysize, z - zhalf) + correctionVectors[5]), rotations[5], scale);
i++;
}
if (gmi.innerFaceType != MeshType.NoMesh)
{
ci[i].mesh = MeshMaster.GetMesh(gmi.innerFaceType, materialID);
ci[i].transform = Matrix4x4.TRS((new Vector3(x - xhalf, y - ysize, z - zhalf)),
(gmi.fwdFaceType == MeshType.NoMesh) ? rotations[0] : (gmi.rightFaceType == MeshType.NoMesh ? rotations[1] : (
gmi.backFaceType == MeshType.NoMesh ? rotations[2] : rotations[3]
)),
scale);
i++;
}
}
}
}
GameObject g = new GameObject("peak model");
var mf = g.AddComponent <MeshFilter>();
var m = new Mesh();
m.CombineMeshes(ci, true);
mf.sharedMesh = m;
var mr = g.AddComponent <MeshRenderer>();
mr.sharedMaterial = PoolMaster.GetMaterial(materialID);
if (PoolMaster.shadowCasting)
{
mr.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.On;
mr.receiveShadows = true;
}
else
{
mr.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
mr.receiveShadows = false;
}
mr.lightProbeUsage = UnityEngine.Rendering.LightProbeUsage.Off;
mr.reflectionProbeUsage = UnityEngine.Rendering.ReflectionProbeUsage.Off;
return(g);
}
private void RedrawRenderer(MeshVisualizeInfo mvi)
{
GameObject g;
renderers.TryGetValue(mvi, out g);
if (g != null)
{
int n = blockVisualizersList.Count;
if (n > 0)
{
var indexes = new List <int>();
for (int i = 0; i < n; i++)
{
if (blockVisualizersList[i].meshInfo == mvi)
{
indexes.Add(i);
}
}
n = indexes.Count;
if (n > 0)
{
CombineInstance[] cir = new CombineInstance[n], cic = new CombineInstance[n];
BlockpartVisualizeInfo bvi;
Mesh cm;
Matrix4x4 mtr;
for (int i = 0; i < n; i++)
{
bvi = blockVisualizersList[indexes[i]];
cm = MeshMaster.GetMesh(bvi.meshType, bvi.materialID);
cir[i].mesh = cm;
mtr = bvi.GetPositionMatrix();
cir[i].transform = mtr;
cic[i].mesh = bvi.meshType == MeshType.Quad ? cm : MeshMaster.GetMeshColliderLink(bvi.meshType);
cic[i].transform = mtr;
}
cm = new Mesh();
cm.CombineMeshes(cir);
g.GetComponent <MeshFilter>().sharedMesh = cm;
cm = new Mesh();
cm.CombineMeshes(cic);
g.GetComponent <MeshCollider>().sharedMesh = cm;
if (PoolMaster.useIlluminationSystem)
{
g.GetComponent <MeshRenderer>().sharedMaterial = PoolMaster.GetMaterial(mvi.materialType, mvi.illumination);
}
else
{
g.GetComponent <MeshRenderer>().sharedMaterial = PoolMaster.GetMaterial(mvi.materialType);
}
}
else
{
renderers.Remove(mvi);
Destroy(g);
}
}
}
else
{
CreateBlockpartsRenderer(mvi);
}
}
private void CreateBlockpartsRenderer(MeshVisualizeInfo mvi)
{
if (renderers.ContainsKey(mvi))
{
return;
}
var processingIndexes = new List <int>();
for (int i = 0; i < blockVisualizersList.Count; i++)
{
if (blockVisualizersList[i].meshInfo == mvi)
{
processingIndexes.Add(i);
}
}
int pcount = processingIndexes.Count;
if (pcount > 0)
{
var ci = new CombineInstance[pcount];
Mesh m;
BlockpartVisualizeInfo cdata;
for (int j = 0; j < pcount; j++)
{
cdata = blockVisualizersList[processingIndexes[j]];
m = MeshMaster.GetMesh(cdata.meshType, cdata.materialID);
ci[j].mesh = m;
ci[j].transform = cdata.GetPositionMatrix();
}
GameObject g = new GameObject();
m = new Mesh();
m.CombineMeshes(ci, true); // все подмеши используют один материал
//удаление копий вершин на стыках - отменено из-за uv
var mf = g.AddComponent <MeshFilter>();
mf.sharedMesh = m;
var mr = g.AddComponent <MeshRenderer>();
mr.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
mr.receiveShadows = PoolMaster.shadowCasting;
mr.lightProbeUsage = UnityEngine.Rendering.LightProbeUsage.Off;
mr.reflectionProbeUsage = UnityEngine.Rendering.ReflectionProbeUsage.Off;
if (!PoolMaster.useIlluminationSystem)
{
mr.sharedMaterial = PoolMaster.GetMaterial(mvi.materialType);
}
else
{
mr.sharedMaterial = PoolMaster.GetMaterial(mvi.materialType, mvi.illumination);
}
g.transform.parent = renderersHolders[mvi.faceIndex].transform;
g.AddComponent <MeshCollider>().sharedMesh = m;
g.tag = BLOCK_COLLIDER_TAG;
renderers.Add(mvi, g);
}
}
public Plane CreatePlane(byte faceIndex, bool redrawCall)
{
if (planes == null)
{
planes = new Dictionary <byte, Plane>();
}
else
{
if (planes.ContainsKey(faceIndex))
{
return(planes[faceIndex]);
}
}
var pos = myBlock.pos;
Plane p;
if (faceIndex < 4)
{
var mtype = MeshType.Housing_0;
float f = Random.value;
if (f < 0.75f)
{
if (f > 0.5f)
{
mtype = MeshType.Housing_0;
}
else
{
if (f < 0.25f)
{
mtype = MeshType.Housing_1;
}
else
{
mtype = MeshType.Housing_2;
}
}
}
else
{
if (f > 0.92f)
{
mtype = MeshType.SimpleHeater_0;
}
else
{
if (f > 0.83f)
{
mtype = MeshType.BigWindow;
}
else
{
mtype = MeshType.SmallWindows;
}
}
}
var mp = new MultimaterialPlane(this, mtype, faceIndex, 0);
mp.SetActivationStatus(isActive);
p = mp;
}
else
{
if (faceIndex == Block.UP_FACE_INDEX && pos.y == Chunk.chunkSize - 1)
{
p = MeshMaster.GetRooftop(this, Random.value < 0.1f, true);
}
else
{
p = new Plane(this, MeshType.Quad, PoolMaster.MATERIAL_ADVANCED_COVERING_ID, faceIndex, 0);
}
}
//
planes.Add(faceIndex, p);
if (redrawCall)
{
myBlock.myChunk.RefreshBlockVisualising(myBlock, faceIndex);
}
return(p);
}
