void CreateRailLandAsset(){
#if UNITY_EDITOR
AssetDatabase.DeleteAsset(pathFolder+"/Rail");
AssetDatabase.CreateFolder(pathFolder, "Rail");
GameObject railPacked = new GameObject("RailPacked");
int mX = xMinEffectiveBoard;
while(mX <= xMaxEffectiveBoard){
GameObject nRail = Instantiate(rail, Vector3.zero, Quaternion.identity)as GameObject;
nRail.transform.position = new Vector3(mX, 0, 0);
nRail.transform.SetParent(railPacked.transform);
mX++;
}
mX = xMinBoard;
while(mX < xMinEffectiveBoard){
GameObject nRail = Instantiate(deepRail, Vector3.zero, Quaternion.identity) as GameObject;
nRail.transform.position = new Vector3(mX, 0,0);
nRail.transform.SetParent(railPacked.transform);
mX++;
}
mX = xMaxEffectiveBoard+1;
while(mX <= xMaxBoard){
GameObject nRail = Instantiate(deepRail, Vector3.zero, Quaternion.identity) as GameObject;
nRail.transform.position = new Vector3(mX, 0,0);
nRail.transform.SetParent(railPacked.transform);
mX++;
}
railPacked.tag = "Rail";
MeshCombine.CreatePrefab(railPacked, pathFolder, "Rail", "Rail");
Destroy(railPacked);
#endif
}
void OnSceneGUI()
{
MeshCombine mc = target as MeshCombine;
if (Handles.Button(mc.transform.position + Vector3.up * 5, Quaternion.LookRotation(Vector3.up), 1, 1, Handles.CylinderHandleCap))
{
mc.CombineMeshes();
}
}
public override void OnInspectorGUI()
{
DrawDefaultInspector();
MeshCombine mc = target as MeshCombine;
if (GUILayout.Button("Combine Meshes Basic"))
{
mc.CombineMeshesBas();
}
if (GUILayout.Button("Combine Meshes Advance"))
{
mc.CombineMeshesAdv();
}
}
protected void Test()
{
if (isInit == true)
{
return;
}
isInit = true;
MeshCombine combine = new MeshCombine();
combine.Combine(this.gameObject.AddComponent <MeshRenderer>(),
this.gameObject.GetComponentsInChildren <MeshRenderer>(),
new string[] { "_MainTex", "_BumpMap" },
new Material(Shader.Find("Mobile/Bumped Diffuse")),
1024,
512,
true);
}
void CreateGrassLandAsset(){
#if UNITY_EDITOR
AssetDatabase.DeleteAsset(pathFolder+"/Grass");
AssetDatabase.CreateFolder(pathFolder, "Grass");
GameObject grassPacked = new GameObject("GrassPacked");
int xGrass = xMinEffectiveBoard;
while(xGrass <= xMaxEffectiveBoard){
GameObject nGrass = Instantiate(grass, Vector3.zero, Quaternion.identity)as GameObject;
nGrass.transform.position = new Vector3(xGrass, 0, 0);
nGrass.transform.SetParent(grassPacked.transform);
xGrass++;
}
xGrass = xMinBoard;
while(xGrass < xMinEffectiveBoard){
GameObject nDGrass = Instantiate(deepGrass, Vector3.zero, Quaternion.identity) as GameObject;
nDGrass.transform.position = new Vector3(xGrass, 0,0);
nDGrass.transform.SetParent(grassPacked.transform);
if(tree.Length == 0){
Debug.LogError("Tree Array is Null, make sure you have assign it");
EditorApplication.isPaused = true;
}
else{
GameObject nTree = Instantiate(tree[UnityEngine.Random.Range(0, tree.Length)],new Vector3(xGrass, 0,0), Quaternion.identity)as GameObject;
nTree.transform.SetParent(grassPacked.transform);
}
xGrass++;
}
xGrass = xMaxEffectiveBoard+1;
while(xGrass <= xMaxBoard){
GameObject nDGrass = Instantiate(deepGrass, Vector3.zero, Quaternion.identity) as GameObject;
nDGrass.transform.position = new Vector3(xGrass, 0,0);
nDGrass.transform.SetParent(grassPacked.transform);
GameObject nTree = Instantiate(tree[UnityEngine.Random.Range(0, tree.Length)],new Vector3(xGrass, 0,0), Quaternion.identity)as GameObject;
nTree.transform.SetParent(grassPacked.transform);
xGrass++;
}
grassPacked.tag = "Grass";
MeshCombine.CreatePrefab(grassPacked, pathFolder, "Grass", "Grass");
Destroy(grassPacked);
#endif
}
static Mesh CreateSlopeMesh(Sprite sprite, Sprite sideSprite, Sprite backSprite, float height)
{
//
Mesh main = SpriteTileGenerator.CreateMeshFromSprite(sprite);
Vector3[] verts = main.vertices;
for (int i = 0; i <= 1; i++)
{
verts[i] += Vector3.up * height;
}
main.SetVertices(verts);
main.RecalculateNormals();
main.RecalculateTangents();
if (sideSprite)
{
Mesh[] partials = new Mesh[4]; // two quads, two tris
partials[0] = main;
partials[1] = CreatePartialQuad(backSprite ?? sideSprite, height);
TransformMesh(partials[1],
Quaternion.Euler(270f, 90f, 90f),
new Vector3(0f, 0.5f, 0.5f));
partials[2] = CreatePartialTris(sideSprite, height);
TransformMesh(partials[2],
Quaternion.Euler(90f, 90f, 0f),
new Vector3(0.5f, 0.5f, 0f));
partials[3] = CreatePartialTris(sideSprite, height);
TransformMesh(partials[3],
Quaternion.Euler(90f, 90f, 0f),
new Vector3(-0.5f, 0.5f, 0f));
partials[3].triangles = new int[] { partials[3].triangles[2], partials[3].triangles[1], partials[3].triangles[0] };
return(MeshCombine.CombineMeshes(partials));
}
else
{
return(main);
}
//return CreatePartialQuad(sprite, height);
}
static Mesh CreateBlockMesh(Sprite sprite, Sprite topSprite)
{
Mesh[] partials = new Mesh[5];
for (int i = 0; i <= 3; i++)
{
partials[i] = SpriteTileGenerator.CreateMeshFromSprite(sprite);
TransformMesh(partials[i],
Quaternion.Euler(270f, 90f + 90f * i, 90f),
Vector3.up * 0.5f
+ Quaternion.Euler(0f, 90f * i, 0f).normalized *Vector3.forward * 0.5f);
}
if (topSprite)
{
partials[4] = SpriteTileGenerator.CreateMeshFromSprite(topSprite);
TransformMesh(partials[4],
Quaternion.Euler(0f, 0f, 0f),
Vector3.up * 1f);
}
return(MeshCombine.CombineMeshes(partials));
}
void CreateTrain(){
#if UNITY_EDITOR
AssetDatabase.DeleteAsset(pathFolder+"/"+"Train");
AssetDatabase.CreateFolder(pathFolder, "Train");
int longTrain = minLongTrain;
while(longTrain <= maxLongTrain){
float trainWidth;
GameObject realTrainInstance = new GameObject("TrainLong_"+longTrain.ToString());
GameObject trainDummy = Instantiate(carriage, new Vector3(-300, -300, -300), Quaternion.identity) as GameObject;
trainWidth = trainDummy.transform.GetChild(0).GetComponent<MeshRenderer>().bounds.size.x;
Destroy(trainDummy);
GameObject headTr = Instantiate(headTrain, transform.position, Quaternion.identity) as GameObject;
int i =0;
while(i < longTrain){
GameObject trainInstance = Instantiate(carriage, new Vector3(transform.position.x - (i * trainWidth), transform.position.y, transform.position.z), Quaternion.identity) as GameObject;
trainInstance.transform.SetParent(headTr.transform);
i++;
}
realTrainInstance.transform.position = transform.position;
headTr.transform.SetParent(realTrainInstance.transform);
MeshCombine.CreatePrefab(realTrainInstance, pathFolder, "Train", "Train");
// //This so heavy
// UnityEngine.Object dummyPrefab = EditorUtility.CreateEmptyPrefab("Assets/CrossyWay/Prefabs/Train/TrainComplete/RealTrain_"+longTrain.ToString()+".prefab");
// GameObject prefabTrain = PrefabUtility.ReplacePrefab(realTrainInstance, dummyPrefab, ReplacePrefabOptions.ConnectToPrefab) as GameObject;
// prefabTrain.tag = "Train";
// //Heavy part end
Destroy(realTrainInstance);
longTrain++;
}
#endif
}
public GameObject MergeMeshes(GameObject source)
{
// Get a copy of the source GameObject
GameObject sourceParent = GameObject.Instantiate(source);
// ---------------------------------------------------------------------------
// Remove GameObjects to Exclude from the Merge and move them back later
// ---------------------------------------------------------------------------
// Create GameObject that will hold all models to exclude from the Merge
GameObject excludeFromMergeParent = new GameObject("Not Merged");
// Get all child Transforms in the Source GameObject
Transform[] sourceTransforms = sourceParent.GetComponentsInChildren <Transform>();
// Loop through each child Transform in the Source GameObject
for (int i = sourceTransforms.Length - 1; i >= 0; i--)
{
// If not including this GameObject in the MeshCombine
if (!IncludeInMerge(sourceTransforms[i].gameObject))
{
sourceTransforms[i].parent = excludeFromMergeParent.transform;
}
}
// Get all MeshFilters and MeshRenderers from the source GameObject's children
MeshFilter[] sourceMeshFilters = sourceParent.GetComponentsInChildren <MeshFilter>();
MeshRenderer[] sourceMeshRenderers = sourceParent.GetComponentsInChildren <MeshRenderer>();
// ---------------------------------------------------------------------------
// Get Unique Material List
// ---------------------------------------------------------------------------
// Create a List containing all unique Materials in the GameObjects
List <Material> uniqueMats = new List <Material>();
bool foundMat;
// Loop through each MeshRenderer
for (int i = 0; i < sourceMeshRenderers.Length; i++)
{
// Loop through each MeshRenderer's SharedMaterials
for (int j = 0; j < sourceMeshRenderers[i].sharedMaterials.Length; j++)
{
// Set Found Material flag to "False"
foundMat = false;
// Loop through all Materials in the Unique Material list
for (int k = 0; k < uniqueMats.Count; k++)
{
// If Material was found, set the Found Material flag to "True"
if (sourceMeshRenderers[i].sharedMaterials[j].name == uniqueMats[k].name)
{
foundMat = true;
}
}
// If Found Material flag is "True", add the Material to the Unique Material Array
if (!foundMat)
{
uniqueMats.Add(sourceMeshRenderers[i].sharedMaterials[j]);
}
}
}
// ---------------------------------------------------------------------------
// Extract Meshes into Separate CombineInstances based on Material
// ---------------------------------------------------------------------------
// Create a MeshCombine Class Array the size of the uniqueMats List and initialize
MeshCombine[] uniqueMatMeshCombine = new MeshCombine[uniqueMats.Count];
for (int i = 0; i < uniqueMats.Count; i++)
{
uniqueMatMeshCombine[i] = new MeshCombine();
uniqueMatMeshCombine[i].combineList = new List <CombineInstance>();
}
// Prepare variables
CombineInstance combineInstance;
// Loop through each MeshRenderer in sourceMeshRenderers
for (int i = 0; i < sourceMeshRenderers.Length; i++)
{
// Loop through each Material in each MeshRenderer
for (int j = 0; j < sourceMeshRenderers[i].sharedMaterials.Length; j++)
{
// Loop through each Material in the uniqueMats List
for (int k = 0; k < uniqueMats.Count; k++)
{
// If this Material matches the Material in the uniqueMats List
if (sourceMeshRenderers[i].sharedMaterials[j] == uniqueMats[k])
{
// Initialize a Combine Instance
combineInstance = new CombineInstance();
// Copy this mesh to the Combine Instance
combineInstance.mesh = sourceMeshFilters[i].sharedMesh;
// Set it to only include the Mesh with the specified material
combineInstance.subMeshIndex = j;
// Transform to world matrix
combineInstance.transform = sourceMeshFilters[i].transform.localToWorldMatrix;
// Add this CombineInstance to the appropriate CombineInstance List (by Material)
uniqueMatMeshCombine[k].combineList.Add(combineInstance);
}
}
}
}
// ---------------------------------------------------------------------------
// Combine all Mesh Instances into a single GameObject
// ---------------------------------------------------------------------------
// Disable all Source GameObjects
for (int i = 0; i < sourceMeshFilters.Length; i++)
{
sourceMeshFilters[i].gameObject.SetActive(false);
}
// Create the final GameObject that will hold all the other GameObjects
GameObject finalGameObject = new GameObject("Merged Meshes");
// Create a new GameObject Array the size of the All Materials List
GameObject[] singleMatGameObject = new GameObject[uniqueMats.Count];
// Combine meshes for each singleMatGameObject into one mesh
CombineInstance[] finalCombineInstance = new CombineInstance[uniqueMats.Count];
// Enable all Source GameObjects
for (int i = 0; i < sourceMeshFilters.Length; i++)
{
sourceMeshFilters[i].gameObject.SetActive(true);
}
// Prepare mesh filter and mesh renderer arrays for the final combine
MeshFilter[] meshFilter = new MeshFilter[uniqueMats.Count];
MeshRenderer[] meshRenderer = new MeshRenderer[uniqueMats.Count];
// Loop through each Material in the uniqueMats List
for (int i = 0; i < uniqueMats.Count; i++)
{
// Initialize GameObject
singleMatGameObject[i] = new GameObject();
singleMatGameObject[i].name = uniqueMats[i].name;
// Add a MeshRender and set the Material
meshRenderer[i] = singleMatGameObject[i].AddComponent <MeshRenderer>();
meshRenderer[i].sharedMaterial = uniqueMats[i];
// Add a MeshFilter and add the Combined Meshes with this Material
meshFilter[i] = singleMatGameObject[i].AddComponent <MeshFilter>();
meshFilter[i].sharedMesh = new Mesh();
meshFilter[i].sharedMesh.CombineMeshes(uniqueMatMeshCombine[i].combineList.ToArray());
// Add this Mesh to the final Mesh Combine
finalCombineInstance[i].mesh = meshFilter[i].sharedMesh;
finalCombineInstance[i].transform = meshFilter[i].transform.localToWorldMatrix;
// Hide the GameObject
meshFilter[i].gameObject.SetActive(false);
GameObject.DestroyImmediate(singleMatGameObject[i]);
}
// Add MeshFilter to final GameObject and Combine all Meshes
MeshFilter finalMeshFilter = finalGameObject.AddComponent <MeshFilter>();
finalMeshFilter.sharedMesh = new Mesh();
finalMeshFilter.sharedMesh.CombineMeshes(finalCombineInstance, false, false);
// Add MeshRenderer to final GameObject Attach Materials
MeshRenderer finalMeshRenderer = finalGameObject.AddComponent <MeshRenderer>();
finalMeshRenderer.sharedMaterials = uniqueMats.ToArray();
// Name finalGameObject and make it the child of an empty parent
GameObject finalGameObjectParent = new GameObject(sourceParent.name + " Merged");
finalGameObject.transform.parent = finalGameObjectParent.transform;
// If the Unmerged GameObject holder is isn't empty, make it a child of the empty parent
if (excludeFromMergeParent.transform.childCount > 0)
{
excludeFromMergeParent.transform.parent = finalGameObjectParent.transform;
}
// If the Unmerged GameObject holder is empty, delete it
else
{
GameObject.DestroyImmediate(excludeFromMergeParent);
}
// Delete unneeded GameObjects
GameObject.DestroyImmediate(sourceParent);
// Return the complete GameObject
return(finalGameObjectParent);
}
// ---------------------------------------------------------------------------
// Merge all Meshes by Material
// ---------------------------------------------------------------------------
public GameObject MergeMeshesByMaterial(GameObject sourceParent)
{
// Recursively search through child tree and add any unique materials
// This will result in 2 lists: [Materials mats] and [string matNames]
FindUniqueMaterials(sourceParent.transform);
// Prep Mesh combine array
meshCombine = new MeshCombine[matNames.Count];
for (int i = 0; i < matNames.Count; i++)
{
meshCombine[i] = new MeshCombine();
meshCombine[i].combineList = new List <CombineInstance>();
}
// Recursively search through child tre and add each Mesh
// to the corresponding array, sorted by Material name
GroupMeshesByMaterial(sourceParent.transform);
// Create the target parent. This will add it to the Hierarchy as well
GameObject targetParent = new GameObject();
// Define variable used to create target GameObject
GameObject targetChild;
MeshFilter targetMeshFilter;
Renderer targetRenderer;
// Loop through each list of Meshes
for (int i = 0; i < matNames.Count; i++)
{
// Create child GameObject for all Meshes with this Material
targetChild = new GameObject();
targetChild.SetActive(false);
targetChild.transform.SetParent(targetParent.transform);
targetChild.name = matNames[i];
// Add MeshFilter and Meshes
targetMeshFilter = targetChild.AddComponent <MeshFilter>();
targetMeshFilter.mesh = new Mesh();
targetMeshFilter.sharedMesh.CombineMeshes(meshCombine[i].combineList.ToArray());
// Add MeshRender and Material
targetRenderer = targetChild.AddComponent <MeshRenderer>();
targetRenderer.sharedMaterial = mats[i];
// Enable child
targetChild.SetActive(true);
}
// Add copy of each excluded from merge GameObject to the parent GameObject
GameObject unmergedGameObject;
foreach (GameObject gameObject in excludeFromMerge)
{
unmergedGameObject = GameObject.Instantiate(gameObject);
unmergedGameObject.name = gameObject.name;
unmergedGameObject.transform.SetParent(targetParent.transform);
}
// Return the new target parent
return(targetParent);
}
void CreateRoadLandAsset(){
#if UNITY_EDITOR
AssetDatabase.DeleteAsset(pathFolder+"/Road");
AssetDatabase.CreateFolder(pathFolder, "Road");
GameObject solidRoadPacked = new GameObject("SolidRoadPacked");
int mX = xMinEffectiveBoard;
while(mX <= xMaxEffectiveBoard){
GameObject nRail = Instantiate(road, Vector3.zero, Quaternion.identity)as GameObject;
nRail.transform.position = new Vector3(mX, 0, 0);
nRail.transform.SetParent(solidRoadPacked.transform);
mX++;
}
mX = xMinBoard;
while(mX < xMinEffectiveBoard){
GameObject nRail = Instantiate(deepRoad, Vector3.zero, Quaternion.identity) as GameObject;
nRail.transform.position = new Vector3(mX, 0,0);
nRail.transform.SetParent(solidRoadPacked.transform);
mX++;
}
mX = xMaxEffectiveBoard+1;
while(mX <= xMaxBoard){
GameObject nRail = Instantiate(deepRoad, Vector3.zero, Quaternion.identity) as GameObject;
nRail.transform.position = new Vector3(mX, 0,0);
nRail.transform.SetParent(solidRoadPacked.transform);
mX++;
}
MeshCombine.CreatePrefab(solidRoadPacked, pathFolder, "Road", "SolidRoad");
Destroy(solidRoadPacked);
//BREAK =========================================================
GameObject roadTopLinePacked = new GameObject("roadTopLinePacked");
mX = xMinEffectiveBoard;
while(mX <= xMaxEffectiveBoard){
GameObject nRoad;
if(mX % 2 == 0){
nRoad = Instantiate(roadTopLine, Vector3.zero, Quaternion.identity)as GameObject;
}
else
nRoad = Instantiate(road, Vector3.zero, Quaternion.identity)as GameObject;
nRoad.transform.position = new Vector3(mX, 0, 0);
nRoad.transform.SetParent(roadTopLinePacked.transform);
mX++;
}
mX = xMinBoard;
while(mX < xMinEffectiveBoard){
GameObject nRail = Instantiate(deepRoad, Vector3.zero, Quaternion.identity) as GameObject;
nRail.transform.position = new Vector3(mX, 0,0);
nRail.transform.SetParent(roadTopLinePacked.transform);
mX++;
}
mX = xMaxEffectiveBoard+1;
while(mX <= xMaxBoard){
GameObject nRail = Instantiate(deepRoad, Vector3.zero, Quaternion.identity) as GameObject;
nRail.transform.position = new Vector3(mX, 0,0);
nRail.transform.SetParent(roadTopLinePacked.transform);
mX++;
}
MeshCombine.CreatePrefab(roadTopLinePacked, pathFolder, "Road", "RoadTopLine");
Destroy(roadTopLinePacked);
//BREAK =========================================================
GameObject roadBothLinePacked = new GameObject("roadBothLinePacked");
mX = xMinEffectiveBoard;
while(mX <= xMaxEffectiveBoard){
GameObject nRoad;
if(mX % 2 == 0){
nRoad = Instantiate(roadBothLine, Vector3.zero, Quaternion.identity)as GameObject;
}
else
nRoad = Instantiate(road, Vector3.zero, Quaternion.identity)as GameObject;
nRoad.transform.position = new Vector3(mX, 0, 0);
nRoad.transform.SetParent(roadBothLinePacked.transform);
mX++;
}
mX = xMinBoard;
while(mX < xMinEffectiveBoard){
GameObject nRail = Instantiate(deepRoad, Vector3.zero, Quaternion.identity) as GameObject;
nRail.transform.position = new Vector3(mX, 0,0);
nRail.transform.SetParent(roadBothLinePacked.transform);
mX++;
}
mX = xMaxEffectiveBoard+1;
while(mX <= xMaxBoard){
GameObject nRail = Instantiate(deepRoad, Vector3.zero, Quaternion.identity) as GameObject;
nRail.transform.position = new Vector3(mX, 0,0);
nRail.transform.SetParent(roadBothLinePacked.transform);
mX++;
}
MeshCombine.CreatePrefab(roadBothLinePacked, pathFolder, "Road", "RoadBothLine");
Destroy(roadBothLinePacked);
//BREAK =========================================================
GameObject roadBottomLinePacked = new GameObject("roadBottomLinePacked");
mX = xMinEffectiveBoard;
while(mX <= xMaxEffectiveBoard){
GameObject nRoad;
if(mX % 2 == 0){
nRoad = Instantiate(roadBottomLine, Vector3.zero, Quaternion.identity)as GameObject;
}
else
nRoad = Instantiate(road, Vector3.zero, Quaternion.identity)as GameObject;
nRoad.transform.position = new Vector3(mX, 0, 0);
nRoad.transform.SetParent(roadBottomLinePacked.transform);
mX++;
}
mX = xMinBoard;
while(mX < xMinEffectiveBoard){
GameObject nRail = Instantiate(deepRoad, Vector3.zero, Quaternion.identity) as GameObject;
nRail.transform.position = new Vector3(mX, 0,0);
nRail.transform.SetParent(roadBottomLinePacked.transform);
mX++;
}
mX = xMaxEffectiveBoard+1;
while(mX <= xMaxBoard){
GameObject nRail = Instantiate(deepRoad, Vector3.zero, Quaternion.identity) as GameObject;
nRail.transform.position = new Vector3(mX, 0,0);
nRail.transform.SetParent(roadBottomLinePacked.transform);
mX++;
}
MeshCombine.CreatePrefab(roadBottomLinePacked, pathFolder, "Road", "RoadBottomLine");
Destroy(roadBottomLinePacked);
#endif
}
public static GameObject CombineAllMeshesInGameObject(List <Material> matsInCombine, MeshFilter[] sourceMeshFilters, MeshRenderer[] sourceMeshRenderers)
{
// ---------------------------------------------------------------------------
// Extract Meshes into Separate CombineInstances based on Material
// ---------------------------------------------------------------------------
// Create a MeshCombine Class Array the size of the uniqueMats List and initialize
MeshCombine[] uniqueMatMeshCombine = new MeshCombine[matsInCombine.Count];
for (int i = 0; i < matsInCombine.Count; i++)
{
uniqueMatMeshCombine[i] = new MeshCombine();
uniqueMatMeshCombine[i].combineList = new List <CombineInstance>();
}
// Prepare variables
CombineInstance combineInstance;
// Loop through each MeshRenderer in sourceMeshRenderers
for (int i = 0; i < sourceMeshRenderers.Length; i++)
{
// Loop through each Material in each MeshRenderer
for (int j = 0; j < sourceMeshRenderers[i].sharedMaterials.Length; j++)
{
// Loop through each Material in the uniqueMats List
for (int k = 0; k < matsInCombine.Count; k++)
{
// If this Material matches the Material in the uniqueMats List
if (sourceMeshRenderers[i].sharedMaterials[j] == matsInCombine[k])
{
// Initialize a Combine Instance
combineInstance = new CombineInstance();
// Copy this mesh to the Combine Instance
combineInstance.mesh = sourceMeshFilters[i].sharedMesh;
// Set it to only include the Mesh with the specified material
combineInstance.subMeshIndex = j;
// Transform to world matrix
combineInstance.transform = sourceMeshFilters[i].transform.localToWorldMatrix;
// Add this CombineInstance to the appropriate CombineInstance List (by Material)
uniqueMatMeshCombine[k].combineList.Add(combineInstance);
}
}
}
}
// ---------------------------------------------------------------------------
// Combine all Mesh Instances into a single GameObject
// ---------------------------------------------------------------------------
// Disable all Source GameObjects
for (int i = 0; i < sourceMeshFilters.Length; i++)
{
sourceMeshFilters[i].gameObject.SetActive(false);
}
// Create the final GameObject that will hold all the other GameObjects
GameObject finalGameObject = new GameObject("Merged Meshes");
// Create a new GameObject Array the size of the All Materials List
GameObject[] singleMatGameObject = new GameObject[matsInCombine.Count];
// Combine meshes for each singleMatGameObject into one mesh
CombineInstance[] finalCombineInstance = new CombineInstance[matsInCombine.Count];
// Enable all Source GameObjects
for (int i = 0; i < sourceMeshFilters.Length; i++)
{
sourceMeshFilters[i].gameObject.SetActive(true);
}
// Prepare mesh filter and mesh renderer arrays for the final combine
MeshFilter[] meshFilter = new MeshFilter[matsInCombine.Count];
MeshRenderer[] meshRenderer = new MeshRenderer[matsInCombine.Count];
// Loop through each Material in the uniqueMats List
for (int i = 0; i < matsInCombine.Count; i++)
{
// Initialize GameObject
singleMatGameObject[i] = new GameObject();
singleMatGameObject[i].name = matsInCombine[i].name;
// Add a MeshRender and set the Material
meshRenderer[i] = singleMatGameObject[i].AddComponent <MeshRenderer>();
meshRenderer[i].sharedMaterial = matsInCombine[i];
// Add a MeshFilter and add the Combined Meshes with this Material
meshFilter[i] = singleMatGameObject[i].AddComponent <MeshFilter>();
meshFilter[i].sharedMesh = new Mesh();
meshFilter[i].sharedMesh.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32;
meshFilter[i].sharedMesh.CombineMeshes(uniqueMatMeshCombine[i].combineList.ToArray());
// Weld duplicate vertices
//meshFilter[i].sharedMesh = WeldVertices(meshFilter[i].sharedMesh, 0.001f);
// Add this Mesh to the final Mesh Combine
finalCombineInstance[i].mesh = meshFilter[i].sharedMesh;
finalCombineInstance[i].transform = meshFilter[i].transform.localToWorldMatrix;
// Hide the GameObject
meshFilter[i].gameObject.SetActive(false);
GameObject.DestroyImmediate(singleMatGameObject[i]);
}
// Combine the Mesh, optimize it, and recalculate the bounds
Mesh mesh = new Mesh();
mesh.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32;
mesh.CombineMeshes(finalCombineInstance, false, false);
MeshUtility.Optimize(mesh);
mesh.RecalculateBounds();
// Add MeshFilter to final GameObject and Combine all Meshes
MeshFilter finalMeshFilter = finalGameObject.AddComponent <MeshFilter>();
finalMeshFilter.sharedMesh = new Mesh();
finalMeshFilter.sharedMesh = mesh;
// Add MeshRenderer to final GameObject Attach Materials
MeshRenderer finalMeshRenderer = finalGameObject.AddComponent <MeshRenderer>();
finalMeshRenderer.sharedMaterials = matsInCombine.ToArray();
return(finalGameObject);
}
void Awake()
{
meshCombine = new MeshCombine();
meshCombine.combineMeshes(rocksParent);
}
