Stack <CombineInfo> GetCombineTree(NumberedHexaTile seed, NumberedHexaTile[] ignoreTiles)
{
Stack <CombineInfo> linkedTiles = new Stack <CombineInfo>();
if (seed != null && seed.hasCell)
{
CombineInfo seedInfo = new CombineInfo(seed, 0);
linkedTiles.Push(seedInfo);
BuildCombineTree(seedInfo, ignoreTiles, ref linkedTiles);
}
return(linkedTiles);
}
void BuildCombineTree(CombineInfo seedInfo, NumberedHexaTile[] ignoreTiles, ref Stack <CombineInfo> stack)
{
HexaTile[] neighbors = seedInfo.tile.neighbors;
for (int i = 0, max = neighbors.Length; i < max; ++i)
{
NumberedHexaTile neighbor = neighbors[i] as NumberedHexaTile;
if (neighbor != null &&
neighbor.hasCell &&
neighbor.number == seedInfo.tile.number &&
Array.TrueForAll(stack.ToArray(), st => st.tile != neighbor) &&
Array.TrueForAll(ignoreTiles, it => it.number != neighbor.number))
{
CombineInfo neighborInfo = new CombineInfo(neighbor, seedInfo.depth + 1);
stack.Push(neighborInfo);
BuildCombineTree(neighborInfo, ignoreTiles, ref stack);
}
}
}
IEnumerator CombineTypeC(Stack <CombineInfo> linkedTileInfos)
{
int maxDepth = 0;
CombineInfo[] listInfos = linkedTileInfos.ToArray();
for (int i = 0, max = listInfos.Length; i < max; ++i)
{
if (listInfos[i].depth > maxDepth)
{
maxDepth = listInfos[i].depth;
}
}
float durationPerDepth = _cellCombineDuration / maxDepth;
while (linkedTileInfos.Count > 1)
{
CombineInfo info = linkedTileInfos.Pop();
NumberedHexaTile linkedTile = info.tile;
NumberedHexaTile targetTile = Array.Find(
linkedTileInfos.ToArray(),
ci => ci.tile.IsNeighbor(linkedTile)).tile;
HexaCell cell = linkedTile.cell;
Vector3 from = cell.transform.position + CELL_MOVE_OFFSET;
Vector3 to = targetTile.transform.position + CELL_MOVE_OFFSET;
cell.LeanMove(from, to, durationPerDepth).
setEaseInBack().
setDelay((maxDepth - info.depth) * durationPerDepth).
setOnComplete(() => linkedTile.Reset());
}
for (int i = 0; i < maxDepth; ++i)
{
yield return(new WaitForSeconds(durationPerDepth));
SoundManager.Instance.PlayUISoundInstance(GameConstants.FX_CELL_COMBINING);
}
}
private static void OnUpdate(System.Object obj)
{
if (combineQueue.Count > 0)
{
CombineInfo ci = combineQueue.Peek();
bool doo = true;
CharacterAsset ca;
for (int i = 0, count = ci.items.Count; i < count; i++)
{
ca = ci.items[i];
if (!ca.Check())
{
doo = false;
}
}
if (doo)
{
combineQueue.Dequeue();
if (ci.packTex)
{
_Combine(ci);
}
else
{
_Combine_NPT(ci);
}
}
}
if (curpi != null)
{
try
{
if (curpi.texil.Count > 0)
{
if (Time.realtimeSinceStartup - prevSetPixelTime > 1f)
{
byte index = curpi.texil[0];
Texture2D tex = curpi.tl.texInfo[index].tex;
Rect rect = curpi.rects[index];
Color[] colors = tex.GetPixels(0, 0, (int)rect.width, (int)rect.height);
curTex.SetPixels((int)rect.xMin, (int)rect.yMin, (int)rect.width, (int)rect.height, colors);
curpi.texil.RemoveAt(0);
prevSetPixelTime = Time.realtimeSinceStartup;
}
}
else
{
//do
if (curTex == null)
{
return;
}
Rect rect;
for (short i = 0, count = (short)curpi.tl.texInfo.Length; i < count; i++)
{
rect = curpi.rects[i];
rect.xMin = rect.xMin / TEX_W;
rect.yMin = rect.yMin / TEX_H;
curpi.rects[i] = rect;
}
curTex.Apply();
ProcessCombine(curpi.tl, curTex, curpi.rects);
if (piQueue.Count > 0)
{
curpi = piQueue.Dequeue();
CreateTexture2D();
}
else
{
curpi = null;
curTex = null;
}
}
}
catch (System.Exception e)
{
if (curpi != null)
{
if (curpi.tl != null && curpi.tl.endCombine != null)
{
curpi.tl.endCombine(null, -1, -1, curpi.tl.endParam);
}
}
if (piQueue.Count > 0)
{
curpi = piQueue.Dequeue();
}
else
{
curpi = null;
}
Debug.LogError("create texture error->" + e.ToString());
}
}
}
private static void _Combine(CombineInfo combineInfo)
{
List <Mesh> meshList = new List <Mesh>();
try
{
CharacterAsset item = null;
int i, j, k, count, count1, count2;
List <CombineInstance> combineInstances = new List <CombineInstance>();
List <Transform> bones = new List <Transform>();
Transform[] transforms = combineInfo.root.GetComponentsInChildren <Transform>();
TexInfo[] texInfo = new TexInfo[combineInfo.items.Count];
SkinnedMeshRenderer smr = null;
CombineInstance ci;
string[] strs = null;
string str = null;
Transform transform;
count2 = transforms.Length;
count = (short)combineInfo.items.Count;
for (i = 0; i < count; i++)
{
item = combineInfo.items[i];
smr = item.GetSkinnedMeshRenderer();
if (smr == null)
{
return;
}
Mesh mesh = Mesh.Instantiate(smr.sharedMesh) as Mesh;
for (j = 0, count1 = smr.sharedMesh.subMeshCount; j < count1; j++)
{
ci = new CombineInstance();
ci.mesh = mesh;
ci.subMeshIndex = j;
combineInstances.Add(ci);
}
strs = item.GetBoneNames();
for (j = 0, count1 = strs.Length; j < count1; j++)
{
str = strs[j];
for (k = 0; k < count2; k++)
{
transform = transforms[k];
if (transform.name != str)
{
continue;
}
bones.Add(transform);
break;
}
}
meshList.Add(mesh);
Object.Destroy(smr.gameObject);
}
TempLoad tl = null;
string[] strArr = new string[count];
string destName;
string path;
int size;
bool encrypt;
Example.VersionFile.Type fileType;
for (i = 0; i < count; i++)
{
item = combineInfo.items[i];
strs = item.GetTexNames();
tl = new TempLoad();
tl.texInfo = texInfo;
tl.index = (short)i;
tl.combineInstances = combineInstances;
tl.bones = bones;
tl.meshList = meshList;
tl.endCombine = combineInfo.endCombine;
tl.endParam = combineInfo.endParam;
tl.root = combineInfo.root;
tl.over = false;
tl.plus = combineInfo.plus;
tl.sub = combineInfo.sub;
tl.autoTemp = combineInfo.autoTemp;
tl.texName = strArr;
tl.light = combineInfo.light;
GameUtils.stringBuilder.Remove(0, GameUtils.stringBuilder.Length);
GameUtils.stringBuilder.Append(strs[0]);
ResUpdate.GetLoadDetails(GameUtils.stringBuilder.ToString(), out destName, out path, out size, out encrypt, out fileType);
strArr[i] = GameUtils.stringBuilder.ToString();
ResLoader.LoadByPath(strArr[i], destName, path, fileType, size, OnLoad, tl, combineInfo.autoTemp);
}
}
catch (System.Exception e)
{
for (int i = 0; i < meshList.Count; i++)
{
Object.Destroy(meshList[i]);
}
if (combineInfo != null && combineInfo.endCombine != null)
{
combineInfo.endCombine(null, -1, -1, combineInfo.endParam);
}
Debug.LogError("combine error->" + e.ToString());
}
}
public static void Combine(List <CharacterAsset> items, GameObject root, EndCombine endCombine, System.Object endParam, bool autoTemp, bool light, bool packTex)
{
lock (lockClone)
{
try
{
int plus = 0;
int sub = 0;
int i, iid;
CharacterAsset item = null;
int count = (short)items.Count;
for (i = 0; i < count; i++)
{
item = items[i];
iid = item.id;
plus += iid;
if (sub == 0)
{
sub = iid;
}
else
{
sub -= iid;
}
}
if (combinedDic2.ContainsKey(plus))
{
Dictionary <int, List <CombineObj> > dic = combinedDic2[plus];
if (dic.ContainsKey(sub))
{
List <CombineObj> list = dic[sub];
if (list.Count > 0)
{
try
{
if (!list[0].obj)
{
for (int m = 1; m < list.Count; m++)
{
if (list[m] == null || !list[m].obj)
{
list.RemoveAt(m);
m--;
}
}
}
else
{
GameObject go = (GameObject)Object.Instantiate(list[0].obj);
if (!go.activeSelf)
{
go.SetActive(true);
}
CombineObj co = new CombineObj();
co.obj = go;
co.combine = false;
list.Add(co);
//add first, then avoid to del in callback
if (endCombine != null)
{
endCombine(go, plus, sub, endParam);
}
Object.Destroy(root);
items.Clear();
return;
}
}
catch (System.Exception e)
{
Debug.LogError("combine body failed 3->" + e.ToString() + "^" + list.Count);
}
}
}
}
CombineInfo ci = new CombineInfo();
ci.items = items;
ci.root = root;
ci.endCombine = endCombine;
ci.endParam = endParam;
ci.plus = plus;
ci.sub = sub;
ci.autoTemp = autoTemp;
ci.light = light;
ci.packTex = packTex;
combineQueue.Enqueue(ci);
}
catch (System.Exception e)
{
Debug.LogError("combine error->" + e.ToString());
}
}
}
static void CombineGrassMeshes(GameObject root)
{
/*
* if (LightmapSettings.lightmaps.Length == 0) {
* Debug.LogWarning("Grass Combing need the baked lightmaps!");
* return;
* }
*/
Dictionary <Material, Dictionary <int, List <MeshFilter> > > combinedMesheDatas = new Dictionary <Material, Dictionary <int, List <MeshFilter> > >();
{
GrassObject[] details = root.GetComponentsInChildren <GrassObject>();
for (int i = 0; i < details.Length; i++)
{
MeshFilter meshFilter = details[i].GetComponent <MeshFilter>();
Renderer renderer = details[i].GetComponent <MeshRenderer>();
Material material = renderer.sharedMaterial;
int lightmapIndex = renderer.lightmapIndex;
if (material == null)
{
continue;
}
/*
* if (lightmapIndex < 0) {
* Debug.LogError("Invalid lightmap index: " + meshFilter.name);
* return;
* }
*/
if (meshFilter.sharedMesh.vertexCount != 4 && meshFilter.sharedMesh.vertexCount != 8)
{
Debug.LogError("Invalid grass mesh: " + meshFilter.name);
continue;
}
Dictionary <int, List <MeshFilter> > lightmap2MeshFilters;
if (!combinedMesheDatas.TryGetValue(material, out lightmap2MeshFilters))
{
List <MeshFilter> filters = new List <MeshFilter>();
filters.Add(meshFilter);
lightmap2MeshFilters = new Dictionary <int, List <MeshFilter> >();
lightmap2MeshFilters.Add(lightmapIndex, filters);
combinedMesheDatas.Add(material, lightmap2MeshFilters);
}
else
{
List <MeshFilter> filters;
if (!lightmap2MeshFilters.TryGetValue(lightmapIndex, out filters))
{
filters = new List <MeshFilter>();
filters.Add(meshFilter);
lightmap2MeshFilters.Add(lightmapIndex, filters);
}
else
{
filters.Add(meshFilter);
}
}
}
}
foreach (KeyValuePair <Material, Dictionary <int, List <MeshFilter> > > combinedInfo in combinedMesheDatas)
{
Material materal = combinedInfo.Key;
foreach (KeyValuePair <int, List <MeshFilter> > kvp in combinedInfo.Value)
{
int lightmapIndex = kvp.Key;
List <MeshFilter> meshFilters = kvp.Value;
CombineInfo[] combine = new CombineInfo[meshFilters.Count];
List <CombinePart> combineParts = new List <CombinePart>();
int maxVertices = 0;
int startIndex = 0;
for (int i = 0; i < meshFilters.Count; i++)
{
combine[i] = new CombineInfo();
Mesh mesh = meshFilters[i].sharedMesh;
combine[i]._mesh = mesh;
combine[i]._matrix = meshFilters[i].transform.localToWorldMatrix;
combine[i]._lightmapTilingOffset = meshFilters[i].GetComponent <Renderer>().lightmapScaleOffset;
maxVertices += mesh.vertexCount;
if (maxVertices > 20000) // 21.9k vertices limit
//Debug.Log(maxVertices);
{
CombinePart part = new CombinePart();
part._startIndex = startIndex;
part._length = i - startIndex;
part._maxVertices = maxVertices - mesh.vertexCount;
combineParts.Add(part);
startIndex = i;
maxVertices = mesh.vertexCount;
}
}
CombinePart lastPart = new CombinePart();
lastPart._startIndex = startIndex;
lastPart._length = meshFilters.Count - startIndex;
lastPart._maxVertices = maxVertices;
combineParts.Add(lastPart);
for (int i = 0; i < combineParts.Count; i++)
{
CombinePart combinePart = combineParts[i];
GameObject go = new GameObject("__CombinedMeshes__");
go.hideFlags = HideFlags.NotEditable;
go.AddComponent <CombinedGrassMesh>();
// go.layer = LayerMask.NameToLayer("Vegetation");
go.transform.SetParent(root.transform);
MeshFilter meshfilter = go.AddComponent <MeshFilter>();
Mesh newMesh = GetCombinedMeshes(combine, combinePart._startIndex, combinePart._length, combinePart._maxVertices);
newMesh.name = "CombinedMesh";
meshfilter.mesh = newMesh;
MeshRenderer meshRenderer = go.AddComponent <MeshRenderer>();
meshRenderer.lightmapIndex = lightmapIndex;
/*
* Shader replacementShader = GetReplacementShader(materal.shader.name);
* Material newMaterial = new Material(replacementShader);
* newMaterial.name = materal.name;
* newMaterial.mainTexture = materal.mainTexture;
* newMaterial.SetTexture("_LightMap", LightmapSettings.lightmaps[lightmapIndex].lightmapFar);
* newMaterial.SetFloat("_Cutoff", materal.GetFloat("_Cutoff"));
* if (materal.shader.name.Contains("Self-Illumin")) {
* newMaterial.SetFloat("_IllumStrength", materal.GetFloat("_IllumStrength"));
* newMaterial.SetTexture("_SpecIllumReflTex", materal.GetTexture("_SpecIllumReflTex"));
* }
* meshRenderer.material = newMaterial;
*/
meshRenderer.sharedMaterial = materal;
go.SetActive(false);
}
}
}
}
private static void _Combine_NPT(CombineInfo combineInfo)
{
List <Mesh> meshList = new List <Mesh>();
try
{
CharacterAsset item = null;
int i, j, k, count, count1, count2;
List <CombineInstance> combineInstances = new List <CombineInstance>();
List <Transform> bones = new List <Transform>();
List <Material> materials = new List <Material>();
Transform[] transforms = combineInfo.root.GetComponentsInChildren <Transform>();
SkinnedMeshRenderer smr = null;
CombineInstance ci;
string[] strs = null;
string str = null;
Transform transform;
count2 = transforms.Length;
count = combineInfo.items.Count;
for (i = 0; i < count; i++)
{
item = combineInfo.items[i];
smr = item.GetSkinnedMeshRenderer();
if (smr == null)
{
return;
}
materials.AddRange(smr.materials);
Mesh mesh = Mesh.Instantiate(smr.sharedMesh) as Mesh;
for (j = 0, count1 = smr.sharedMesh.subMeshCount; j < count1; j++)
{
ci = new CombineInstance();
ci.mesh = mesh;
ci.subMeshIndex = j;
combineInstances.Add(ci);
}
strs = item.GetBoneNames();
for (j = 0, count1 = strs.Length; j < count1; j++)
{
str = strs[j];
for (k = 0; k < count2; k++)
{
transform = transforms[k];
if (transform.name != str)
{
continue;
}
bones.Add(transform);
break;
}
}
meshList.Add(mesh);
Object.Destroy(smr.gameObject);
}
TempLoad_NPT tl = new TempLoad_NPT();
tl.combineInstances = combineInstances;
tl.bones = bones;
tl.meshList = meshList;
tl.materials = materials;
tl.endCombine = combineInfo.endCombine;
tl.endParam = combineInfo.endParam;
tl.root = combineInfo.root;
tl.plus = combineInfo.plus;
tl.sub = combineInfo.sub;
tl.light = combineInfo.light;
ProcessCombine(tl);
}
catch (System.Exception e)
{
if (combineInfo != null && combineInfo.endCombine != null)
{
combineInfo.endCombine(null, -1, -1, combineInfo.endParam);
}
Debug.LogError("combine error->" + e.ToString() + "\r\n" + e.StackTrace);
}
}
