public VlmBakeData()
{
Light[] allLights = Object.FindObjectsOfType <Light>();
DirectionalLights = allLights.Where(l => l.type == LightType.Directional).ToList();
Lights = allLights.Where(l => l.type != LightType.Directional).ToList();
LightSponges = Object.FindObjectsOfType <LightSponge>().ToList();
Meshes = new List <VlmMeshObject>();
MeshFilter[] meshes = Object.FindObjectsOfType <MeshFilter>();
foreach (MeshFilter mesh in meshes)
{
if (!GameObjectUtility.AreStaticEditorFlagsSet(mesh.gameObject, StaticEditorFlags.LightmapStatic))
{
continue;
}
VlmBakeOptionsComponent bakeOptions = mesh.GetComponent <VlmBakeOptionsComponent>();
if (!bakeOptions || !bakeOptions.IgnoreLightmapper)
{
Meshes.Add(new VlmMeshObject(mesh.gameObject, bakeOptions));
}
}
}
private void CheckForColliders(NavGrid parent)
{
Vector3 transformedCenter = parent.transform.TransformPoint(_relativeBounds.center);
Vector3 transformedExtents = parent.transform.TransformVector(_relativeBounds.extents);
Collider[] hitColliders = Physics.OverlapBox(transformedCenter,
transformedExtents, parent.transform.rotation);
_navigable = true;
foreach (Collider col in hitColliders)
{
if (col.gameObject.GetComponent <NavGridObstacle>() != null)
{
_navigable = false;
break;
}
#if UNITY_EDITOR
if (GameObjectUtility.AreStaticEditorFlagsSet(col.gameObject, StaticEditorFlags.NavigationStatic))
{
_navigable = false;
break;
}
#endif
}
}
/// <summary>
/// Bakes the Unity NavMesh on created NavMeshObjects.
/// </summary>
public void BakeNavMesh()
{
//loop over renderers and enable them for the baking process,
//as otherwise the NavMeshBuilder will ignore them
List <Renderer> disabledObjects = new List <Renderer>();
{
var __array1 = Object.FindObjectsOfType(typeof(Renderer));
var __arrayLength1 = __array1.Length;
for (int __i1 = 0; __i1 < __arrayLength1; ++__i1)
{
var item = (Renderer)__array1[__i1];
{
if (GameObjectUtility.AreStaticEditorFlagsSet(item.gameObject, StaticEditorFlags.NavigationStatic) &&
!item.enabled)
{
disabledObjects.Add(item);
item.renderer.enabled = true;
}
}
}
}
//trigger navmesh builder
NavMeshBuilder.BuildNavMesh();
//re-enable disabled renderers
disabledObjects.ForEach(obj => obj.enabled = false);
ShowNotification("NavMesh successfully built.");
}
static int drawMode = 0; // 0 = wireframe, 1 = full
bool IsValidCollider(Collider2D co)
{
// usable for navmesh generation if not trigger and if navigation static
bool navstatic = GameObjectUtility.AreStaticEditorFlagsSet(co.gameObject, StaticEditorFlags.NavigationStatic);
return(navstatic && co.enabled && !co.isTrigger);
}
public override bool DoCheckHierarchy(string asset, params GameObject[] rootObjs)
{
bool result = true;
List <string> list;
if (this.resultInfo.ContainsKey(asset))
{
list = this.resultInfo[asset];
}
else
{
list = new List <string>();
}
int num = 2500;
try
{
for (int i = 0; i < rootObjs.Length; i++)
{
foreach (Renderer renderer in rootObjs[i].GetComponentsInChildren <Renderer>(true))
{
int num2 = renderer.sharedMaterials.Length;
MeshFilter component = renderer.GetComponent <MeshFilter>();
if (component && component.sharedMesh)
{
string text = "";
if (component.sharedMesh.vertexCount > 220)
{
text = text + "顶点数超标:" + component.sharedMesh.vertexCount;
}
if (GameObjectUtility.AreStaticEditorFlagsSet(renderer.gameObject.gameObject, StaticEditorFlags.LightmapStatic))
{
text += "开了LightMap静态合批";
}
if (!string.IsNullOrEmpty(text))
{
for (int k = 0; k < num2; k++)
{
Material material = renderer.sharedMaterials[k];
if (material && material.renderQueue > num)
{
list.Add(CheckBase <KeyValuePair <string, List <string> >, Dictionary <string, List <string> > > .GetTransformPath(renderer.transform) + "--" + text);
result = false;
break;
}
}
}
}
}
}
if (list.Count > 0)
{
this.resultInfo[asset] = list;
}
}
catch
{
}
return(result);
}
// 获取场景中的所有游戏对象, 选出所有NavigationStatic对象.
// 静态光源等无MeshFilter的将被忽略.
private static GameObject[] GetNavStaticObjects()
{
sbLog.Append("Get navigation static objects:\n");
ArrayList navStaticObjList = new ArrayList();
GameObject[] gos = (GameObject[])FindObjectsOfType(typeof(GameObject));
foreach (GameObject go in gos)
{
// 暂无OffMeshLinkGeneration
if (!GameObjectUtility.AreStaticEditorFlagsSet(go, StaticEditorFlags.NavigationStatic))
{
continue;
}
Component[] meshfilter = go.transform.GetComponents(typeof(MeshFilter));
if (0 == meshfilter.Length)
{
continue;
}
navStaticObjList.Add(go);
sbLog.AppendFormat("Name: {0}, MeshFilters: {1}\n", go.name, meshfilter.Length);
}
return((GameObject[])navStaticObjList.ToArray(typeof(GameObject)));
}
ICollection <MeshRenderer> GetMeshRenderers(bool isLightmapStatic = false)
{
var meshRenderers = new HashSet <MeshRenderer>();
var prefabStage = PrefabStageUtility.GetCurrentPrefabStage();
var rootObjs = new GameObject[] { prefabStage?.prefabContentsRoot ?? m_RootGameObject };
if (rootObjs[0] == null)
{
rootObjs = SceneManager.GetActiveScene().GetRootGameObjects();
}
foreach (var o in rootObjs)
{
if (m_IncludeInactive || o.activeInHierarchy)
{
meshRenderers.UnionWith(o.GetComponentsInChildren <MeshRenderer>());
}
}
if (!m_IncludeInactive)
{
meshRenderers.RemoveWhere(mr => !mr.enabled);
}
if (isLightmapStatic)
{
meshRenderers.RemoveWhere(mr => !GameObjectUtility.AreStaticEditorFlagsSet(mr.gameObject, StaticEditorFlags.LightmapStatic));
}
return(meshRenderers);
}
/// <summary>
/// Make sure the <see cref="GameObject"/> of renderer is lightmap static.
/// </summary>
/// <param name="prefabs">The <see cref="System.Array"/> of <see cref="PrefabLightmapData"/>.</param>
private static void MakeSureRendererGameObjectIsLightmapStatic(PrefabLightmapData[] prefabs)
{
if (prefabs == null || prefabs.Length == 0)
{
return;
}
foreach (var lightmap in prefabs)
{
var renderers = lightmap.gameObject.GetComponentsInChildren <MeshRenderer>();
foreach (var renderer in renderers)
{
var gameObject = renderer.gameObject;
var excludedRenderer = gameObject.GetComponent <PrefabLightmapExcludedRenderer>();
if (excludedRenderer != null)
{
continue;
}
if (!GameObjectUtility.AreStaticEditorFlagsSet(gameObject, StaticEditorFlags.ContributeGI))
{
GameObjectUtility.SetStaticEditorFlags(gameObject, StaticEditorFlags.ContributeGI);
}
}
}
}
private static void OnGUISub_BatchingStaticHelpBox(MaterialEditor materialEditor)
{
// 現在のシェーダが DisableBatching == False のとき以外は何もしない (Batching されないので)
var target = materialEditor.target as Material;
if (target == null || !target.GetTag("DisableBatching", false, "False").Equals("False", StringComparison.OrdinalIgnoreCase))
{
return;
}
// ターゲットが設定用プロパティをどちらも持っていないならば何もしない
if (!target.HasProperty("_GL_DisableBackLit") && !target.HasProperty("_GL_DisableBasePos"))
{
return;
}
// 現在のシェーダ
var shader = target.shader;
// 現在編集中のマテリアルの配列
var targets = WFCommonUtility.AsMaterials(materialEditor.targets);
// 現在編集中のマテリアルのうち、Batching Static のときにオンにしたほうがいい設定がオフになっているマテリアル
var allNonStaticMaterials = targets.Where(mat => mat.GetInt("_GL_DisableBackLit") == 0 || mat.GetInt("_GL_DisableBasePos") == 0).ToArray();
if (allNonStaticMaterials.Length == 0)
{
return;
}
var scene = UnityEditor.SceneManagement.EditorSceneManager.GetActiveScene();
// 現在のシーンにある BatchingStatic の付いた MeshRenderer が使っているマテリアルのうち、このShaderGUIが扱うマテリアルの配列
var allStaticMaterialsInScene = scene.GetRootGameObjects()
.SelectMany(go => go.GetComponentsInChildren <MeshRenderer>(true))
.Where(mf => GameObjectUtility.AreStaticEditorFlagsSet(mf.gameObject, StaticEditorFlags.BatchingStatic))
.SelectMany(mf => mf.sharedMaterials)
.Where(mat => mat != null && mat.shader == shader)
.ToArray();
// Batching Static の付いているマテリアルが targets 内にあるならば警告
if (allNonStaticMaterials.Any(mat => allStaticMaterialsInScene.Contains(mat)))
{
var message = WFI18N.LangMode == EditorLanguage.日本語 ?
"このマテリアルは Batching Static な MeshRenderer から使われているようです。Batching Static 用の設定へ変更しますか？" :
"This material seems to be used by the Batching Static MeshRenderer. Do you want to change the settings for Batching Static?";
if (materialEditor.HelpBoxWithButton(new GUIContent(message, Styles.infoIcon), new GUIContent("Fix Now")))
{
// _GL_DisableBackLit と _GL_DisableBasePos をオンにする
foreach (var mat in allNonStaticMaterials)
{
mat.SetInt("_GL_DisableBackLit", 1);
mat.SetInt("_GL_DisableBasePos", 1);
}
}
}
}
public void UpdateStaticState()
{
#if UNITY_EDITOR
if (!Application.isPlaying)
{
bool _static = GameObjectUtility.AreStaticEditorFlagsSet(gameObject, StaticEditorFlags.LightmapStatic);
if (m_static != _static)
{
m_static = _static;
}
}
#endif
}
private void DoMeshesStat()
{
foreach (Transform tr in _allChildrenTransfroms)
{
if (GameObjectUtility.AreStaticEditorFlagsSet(tr.gameObject, StaticEditorFlags.BatchingStatic))
{
if (tr.gameObject.activeSelf)
{
//if (tr.GetComponent<YangStudio.DetailInfo>()) {
//AddMeshCombined(_grassVirtualMesh);
//} else {
MeshFilter meshFilter = tr.GetComponent <MeshFilter>();
if (meshFilter)
{
AddMeshCombined(meshFilter.sharedMesh);
}
else
{
SkinnedMeshRenderer renderer = tr.GetComponent <SkinnedMeshRenderer>();
if (renderer)
{
AddMeshUncombined(renderer.sharedMesh);
}
}
//}
}
}
else //不合并的mesh，无论是否激活都会占用内存
{
MeshFilter meshFilter = tr.GetComponent <MeshFilter>();
if (meshFilter)
{
AddMeshUncombined(meshFilter.sharedMesh);
}
else
{
SkinnedMeshRenderer renderer = tr.GetComponent <SkinnedMeshRenderer>();
if (renderer)
{
AddMeshUncombined(renderer.sharedMesh);
}
}
}
}
}
void ConsumeGameObjectTriangles(GameObject gameObject)
{
int layer = gameObject.layer;
//GwNavMeshSeedPoint seedPoint = gameObject.GetComponent<GwNavMeshSeedPoint>();
// if (seedPoint != null)
// RecastNavigationDllImports.PushSeedPoint(seedPoint.transform.position);
if (gameObject.isStatic == false)
{
return;
}
if (GameObjectUtility.AreStaticEditorFlagsSet(gameObject, StaticEditorFlags.NavigationStatic))
{
ConsumeComponentTriangles(gameObject, layer);
}
}
public static void SetLightProbeGroupToAllDynamicGameObjects()
{
var scene = SceneManager.GetActiveScene();
GameObject[] gameObjects = scene.GetRootGameObjects();
foreach (GameObject gameObject in gameObjects)
{
MeshRenderer[] meshRenderers = gameObject.GetComponentsInChildren<MeshRenderer>();
foreach (MeshRenderer meshRenderer in meshRenderers)
{
if (GameObjectUtility.AreStaticEditorFlagsSet(meshRenderer.gameObject, StaticEditorFlags.ContributeGI) == false)
{
GameObject lightProbeGroupGO = new GameObject("Light Probe Group GO", typeof(LightProbeGroup));
lightProbeGroupGO.transform.position = meshRenderer.gameObject.transform.position;
}
}
}
}
void OptimizeLevelGeometry(GameObject go)
{
var mfsFound = new List <MeshFilter>();
go.GetComponentsInChildren <MeshFilter>(mfsFound);
foreach (var mf in mfsFound)
{
// Only combine statically batched geometry.
bool isStaticBatch = GameObjectUtility.AreStaticEditorFlagsSet(mf.gameObject, StaticEditorFlags.BatchingStatic);
if (isStaticBatch == false)
{
continue;
}
if (mf.gameObject.activeInHierarchy == false || mf.gameObject.GetComponent <IgnoreObject>() != null)
{
continue;
}
ProxyMeshInfo.MeshTypes type = 0;
var collider = mf.GetComponent <Collider>();
if (collider != null && collider.enabled)
{
type |= ProxyMeshInfo.MeshTypes.IsCollider;
}
var renderer = mf.GetComponent <Renderer>();
if (renderer != null && renderer.enabled)
{
type |= ProxyMeshInfo.MeshTypes.IsVisual;
}
if (type == 0)
{
continue;
}
meshManager.AddMeshToProxy(mf, type);
}
}
static void CountStatics()
{
Renderer[] renderers = SceneView.FindObjectsOfType <Renderer> ();
int staticCount = 0;
int nonStaticCount = 0;
foreach (Renderer r in renderers)
{
if (GameObjectUtility.AreStaticEditorFlagsSet(r.gameObject, StaticEditorFlags.LightmapStatic))
{
staticCount++;
}
else
{
nonStaticCount++;
}
}
Debug.Log("There are " + staticCount + " static renderers and " + nonStaticCount + " non static ones.");
}
static void DisableLightProbes()
{
Renderer[] renderers = SceneView.FindObjectsOfType <MeshRenderer> ();
foreach (Renderer r in renderers)
{
if (r.name.ToLower().Contains("reference"))
{
continue;
}
if (GameObjectUtility.AreStaticEditorFlagsSet(r.gameObject, StaticEditorFlags.LightmapStatic))
{
r.lightProbeUsage = UnityEngine.Rendering.LightProbeUsage.Off;
}
else
{
r.lightProbeUsage = UnityEngine.Rendering.LightProbeUsage.BlendProbes;
}
}
}
/// <summary>
/// Bakes the Unity NavMesh on created NavMeshObjects.
/// </summary>
public void BakeNavMesh()
{
//loop over renderers and enable them for the baking process,
//as otherwise the NavMeshBuilder will ignore them
List <Renderer> disabledObjects = new List <Renderer>();
foreach (Renderer item in Object.FindObjectsOfType(typeof(Renderer)))
{
if (GameObjectUtility.AreStaticEditorFlagsSet(item.gameObject, StaticEditorFlags.NavigationStatic) && !item.enabled)
{
disabledObjects.Add(item);
item.GetComponent <Renderer>().enabled = true;
}
}
//trigger navmesh builder
NavMeshBuilder.BuildNavMesh();
//re-enable disabled renderers
disabledObjects.ForEach(obj => obj.enabled = false);
ShowNotification("NavMesh successfully built.");
}
public static void FixNavMesh()
{
Undo.RegisterSceneUndo("BakeNavMesh");
List <Renderer> disabledObjects = new List <Renderer>();
foreach (Renderer item in Object.FindObjectsOfType <Renderer>())
{
//Check if its marked as NavigationStatic, and it has a disabled renderer
if (GameObjectUtility.AreStaticEditorFlagsSet(item.gameObject, StaticEditorFlags.NavigationStatic) && !item.enabled)
{
disabledObjects.Add(item);
item.enabled = true;
}
}
UnityEditor.AI.NavMeshBuilder.BuildNavMesh();
disabledObjects.ForEach(obj => obj.enabled = false); //Disable the objects again.
Debug.Log("Done building navmesh, " + disabledObjects.Count + " objects affected.");
}
static void DoStaticBatching()
{
Dictionary <string, BatchData> CombineMap = new Dictionary <string, BatchData>();
Renderer[] renderers = GameObject.FindObjectsOfType <Renderer>();
for (int i = 0; i < renderers.Length; i++)
{
Renderer renderer = renderers[i];
if (GameObjectUtility.AreStaticEditorFlagsSet(renderer.gameObject, StaticEditorFlags.BatchingStatic))
{
MeshFilter meshFilter = renderer.GetComponent <MeshFilter>();
if (meshFilter != null)
{
Material[] materials = renderer.sharedMaterials;
Mesh mesh = meshFilter.sharedMesh;
for (int j = 0; j < materials.Length; j++)
{
var key = BatchData.GetKey(materials[j], renderer.lightmapIndex);
BatchData batchData;
if (!CombineMap.TryGetValue(key, out batchData))
{
batchData = new BatchData(materials[j], renderer.lightmapIndex);
CombineMap.Add(key, batchData);
}
batchData.AddMesh(meshFilter, j);
}
}
}
}
var itor = CombineMap.GetEnumerator();
while (itor.MoveNext())
{
var batchData = itor.Current.Value;
batchData.Batching();
}
}
/// <summary>
/// Make sure the <see cref="GameObject"/> of renderer is lightmap static.
/// </summary>
/// <param name="prefabs">The <see cref="Array"/> of <see cref="PrefabLightmapData"/>.</param>
private static void MakeSureRendererGameObjectIsLightmapStatic(PrefabLightmapData[] prefabs)
{
if (prefabs.Length > 0)
{
foreach (PrefabLightmapData lightmap in prefabs)
{
MeshRenderer[] renderers = lightmap.gameObject.GetComponentsInChildren <MeshRenderer>();
foreach (MeshRenderer renderer in renderers)
{
GameObject gameObject = renderer.gameObject;
PrefabLightmapExcludedRenderer excludedRenderer = gameObject.GetComponent <PrefabLightmapExcludedRenderer>();
if (excludedRenderer == null)
{
if (!GameObjectUtility.AreStaticEditorFlagsSet(gameObject, StaticEditorFlags.LightmapStatic))
{
GameObjectUtility.SetStaticEditorFlags(gameObject, StaticEditorFlags.LightmapStatic);
}
}
}
}
}
}
public override bool IsValid(VPaintObject vc)
{
return(GameObjectUtility.AreStaticEditorFlagsSet(vc.gameObject, StaticEditorFlags.LightmapStatic));
}
static void GetSceneMeshes(List <ExtMesh> meshes)
{
var filters = GameObject.FindObjectsOfType(typeof(MeshFilter)) as MeshFilter[];
var filteredFilters = new List <MeshFilter>(filters.Length / 3);
var mask = StaticEditorFlags.NavigationStatic | StaticEditorFlags.LightmapStatic;
var scene = EditorSceneManager.GetActiveScene();
for (int i = 0; i < filters.Length; i++)
{
MeshFilter filter = filters[i];
Renderer render = filter.GetComponent <Renderer>();
if (render == null)
{
continue;
}
if (filter.sharedMesh == null)
{
continue;
}
var flags = GameObjectUtility.GetStaticEditorFlags(filter.gameObject);
if ((flags & ~mask) != 0)
{
GameObjectUtility.SetStaticEditorFlags(filter.gameObject, flags & mask);
EditorUtility.SetDirty(filter.gameObject);
EditorSceneManager.MarkSceneDirty(scene);
}
if (!GameObjectUtility.AreStaticEditorFlagsSet(filter.gameObject, StaticEditorFlags.NavigationStatic))
{
continue;
}
if (GameObjectUtility.GetNavMeshArea(filter.gameObject) == 0)
{
if (filter.gameObject.GetComponent <MeshCollider>() == null)
{
var c = filter.gameObject.AddComponent <MeshCollider>();
c.sharedMesh = filter.sharedMesh;
EditorUtility.SetDirty(filter.gameObject);
EditorSceneManager.MarkSceneDirty(scene);
}
}
filteredFilters.Add(filter);
}
var cachedVertices = new Dictionary <Mesh, Vector3[]>();
var cachedTris = new Dictionary <Mesh, int[]>();
for (int i = 0; i < filteredFilters.Count; i++)
{
MeshFilter filter = filteredFilters[i];
Renderer render = filter.GetComponent <Renderer>();
Mesh mesh = filter.sharedMesh;
var smesh = new ExtMesh();
smesh.Matrix = render.localToWorldMatrix;
smesh.Original = filter;
smesh.Scale = filter.gameObject.transform.localScale;
if (cachedVertices.ContainsKey(mesh))
{
smesh.Vertices = cachedVertices[mesh];
smesh.Triangles = cachedTris[mesh];
}
else
{
smesh.Vertices = mesh.vertices;
smesh.Triangles = mesh.triangles;
var normal = mesh.normals;
var uv = mesh.uv;
cachedVertices[mesh] = smesh.Vertices;
cachedTris[mesh] = smesh.Triangles;
}
smesh.Bounds = render.bounds;
smesh.Area = GameObjectUtility.GetNavMeshArea(filter.gameObject);
meshes.Add(smesh);
}
}
void CheckResources()
{
ActiveTextures.Clear();
ActiveMaterials.Clear();
ActiveMeshDetails.Clear();
MissingObjects.Clear();
thingsMissing = false;
Renderer[] renderers = FindObjects <Renderer>();
MaterialDetails skyMat = new MaterialDetails();
skyMat.material = RenderSettings.skybox;
skyMat.isSky = true;
ActiveMaterials.Add(skyMat);
//Debug.Log("Total renderers "+renderers.Length);
foreach (Renderer renderer in renderers)
{
//Debug.Log("Renderer is "+renderer.name);
foreach (Material material in renderer.sharedMaterials)
{
MaterialDetails tMaterialDetails = FindMaterialDetails(material);
if (tMaterialDetails == null)
{
tMaterialDetails = new MaterialDetails();
tMaterialDetails.material = material;
ActiveMaterials.Add(tMaterialDetails);
}
tMaterialDetails.FoundInRenderers.Add(renderer);
}
if (renderer is SpriteRenderer)
{
SpriteRenderer tSpriteRenderer = (SpriteRenderer)renderer;
if (tSpriteRenderer.sprite != null)
{
var tSpriteTextureDetail = GetTextureDetail(tSpriteRenderer.sprite.texture, renderer);
if (!ActiveTextures.Contains(tSpriteTextureDetail))
{
ActiveTextures.Add(tSpriteTextureDetail);
}
}
else if (tSpriteRenderer.sprite == null)
{
MissingGraphic tMissing = new MissingGraphic();
tMissing.Object = tSpriteRenderer.transform;
tMissing.type = "sprite";
tMissing.name = tSpriteRenderer.transform.name;
MissingObjects.Add(tMissing);
thingsMissing = true;
}
}
}
if (IncludeLightmapTextures)
{
LightmapData[] lightmapTextures = LightmapSettings.lightmaps;
// Unity lightmaps
foreach (LightmapData lightmapData in lightmapTextures)
{
if (lightmapData.lightmapColor != null)
{
var textureDetail = GetTextureDetail(lightmapData.lightmapColor);
if (!ActiveTextures.Contains(textureDetail))
{
ActiveTextures.Add(textureDetail);
}
}
if (lightmapData.lightmapDir != null)
{
var textureDetail = GetTextureDetail(lightmapData.lightmapColor);
if (!ActiveTextures.Contains(textureDetail))
{
ActiveTextures.Add(textureDetail);
}
}
if (lightmapData.shadowMask != null)
{
var textureDetail = GetTextureDetail(lightmapData.shadowMask);
if (!ActiveTextures.Contains(textureDetail))
{
ActiveTextures.Add(textureDetail);
}
}
}
}
if (IncludeGuiElements)
{
Graphic[] graphics = FindObjects <Graphic>();
foreach (Graphic graphic in graphics)
{
if (graphic.mainTexture)
{
var tSpriteTextureDetail = GetTextureDetail(graphic.mainTexture, graphic);
if (!ActiveTextures.Contains(tSpriteTextureDetail))
{
ActiveTextures.Add(tSpriteTextureDetail);
}
}
if (graphic.materialForRendering)
{
MaterialDetails tMaterialDetails = FindMaterialDetails(graphic.materialForRendering);
if (tMaterialDetails == null)
{
tMaterialDetails = new MaterialDetails();
tMaterialDetails.material = graphic.materialForRendering;
tMaterialDetails.isgui = true;
ActiveMaterials.Add(tMaterialDetails);
}
tMaterialDetails.FoundInGraphics.Add(graphic);
}
}
Button[] buttons = FindObjects <Button>();
foreach (Button button in buttons)
{
CheckButtonSpriteState(button, button.spriteState.disabledSprite);
CheckButtonSpriteState(button, button.spriteState.highlightedSprite);
CheckButtonSpriteState(button, button.spriteState.pressedSprite);
}
}
foreach (MaterialDetails tMaterialDetails in ActiveMaterials)
{
Material tMaterial = tMaterialDetails.material;
if (tMaterial != null)
{
var dependencies = EditorUtility.CollectDependencies(new UnityEngine.Object[] { tMaterial });
foreach (Object obj in dependencies)
{
if (obj is Texture)
{
Texture tTexture = obj as Texture;
var tTextureDetail = GetTextureDetail(tTexture, tMaterial, tMaterialDetails);
tTextureDetail.isSky = tMaterialDetails.isSky;
tTextureDetail.instance = tMaterialDetails.instance;
tTextureDetail.isgui = tMaterialDetails.isgui;
ActiveTextures.Add(tTextureDetail);
}
}
//if the texture was downloaded, it won't be included in the editor dependencies
if (tMaterial.HasProperty("_MainTex"))
{
if (tMaterial.mainTexture != null && !dependencies.Contains(tMaterial.mainTexture))
{
var tTextureDetail = GetTextureDetail(tMaterial.mainTexture, tMaterial, tMaterialDetails);
ActiveTextures.Add(tTextureDetail);
}
}
}
}
MeshFilter[] meshFilters = FindObjects <MeshFilter>();
foreach (MeshFilter tMeshFilter in meshFilters)
{
Mesh tMesh = tMeshFilter.sharedMesh;
if (tMesh != null)
{
MeshDetails tMeshDetails = FindMeshDetails(tMesh);
if (tMeshDetails == null)
{
tMeshDetails = new MeshDetails();
tMeshDetails.mesh = tMesh;
ActiveMeshDetails.Add(tMeshDetails);
}
tMeshDetails.FoundInMeshFilters.Add(tMeshFilter);
if (GameObjectUtility.AreStaticEditorFlagsSet(tMeshFilter.gameObject, StaticEditorFlags.BatchingStatic))
{
tMeshDetails.StaticBatchingEnabled.Add(tMeshFilter.gameObject);
}
}
else if (tMesh == null && tMeshFilter.transform.GetComponent("TextContainer") == null)
{
MissingGraphic tMissing = new MissingGraphic();
tMissing.Object = tMeshFilter.transform;
tMissing.type = "mesh";
tMissing.name = tMeshFilter.transform.name;
MissingObjects.Add(tMissing);
thingsMissing = true;
}
var meshRenderrer = tMeshFilter.transform.GetComponent <MeshRenderer>();
if (meshRenderrer == null || meshRenderrer.sharedMaterial == null)
{
MissingGraphic tMissing = new MissingGraphic();
tMissing.Object = tMeshFilter.transform;
tMissing.type = "material";
tMissing.name = tMeshFilter.transform.name;
MissingObjects.Add(tMissing);
thingsMissing = true;
}
}
SkinnedMeshRenderer[] skinnedMeshRenderers = FindObjects <SkinnedMeshRenderer>();
foreach (SkinnedMeshRenderer tSkinnedMeshRenderer in skinnedMeshRenderers)
{
Mesh tMesh = tSkinnedMeshRenderer.sharedMesh;
if (tMesh != null)
{
MeshDetails tMeshDetails = FindMeshDetails(tMesh);
if (tMeshDetails == null)
{
tMeshDetails = new MeshDetails();
tMeshDetails.mesh = tMesh;
ActiveMeshDetails.Add(tMeshDetails);
}
tMeshDetails.FoundInSkinnedMeshRenderer.Add(tSkinnedMeshRenderer);
}
else if (tMesh == null)
{
MissingGraphic tMissing = new MissingGraphic();
tMissing.Object = tSkinnedMeshRenderer.transform;
tMissing.type = "mesh";
tMissing.name = tSkinnedMeshRenderer.transform.name;
MissingObjects.Add(tMissing);
thingsMissing = true;
}
if (tSkinnedMeshRenderer.sharedMaterial == null)
{
MissingGraphic tMissing = new MissingGraphic();
tMissing.Object = tSkinnedMeshRenderer.transform;
tMissing.type = "material";
tMissing.name = tSkinnedMeshRenderer.transform.name;
MissingObjects.Add(tMissing);
thingsMissing = true;
}
}
if (IncludeSpriteAnimations)
{
Animator[] animators = FindObjects <Animator>();
foreach (Animator anim in animators)
{
#if UNITY_4_6 || UNITY_4_5 || UNITY_4_4 || UNITY_4_3
UnityEditorInternal.AnimatorController ac = anim.runtimeAnimatorController as UnityEditorInternal.AnimatorController;
#elif UNITY_5 || UNITY_5_3_OR_NEWER
UnityEditor.Animations.AnimatorController ac = anim.runtimeAnimatorController as UnityEditor.Animations.AnimatorController;
#endif
//Skip animators without layers, this can happen if they don't have an animator controller.
if (!ac || ac.layers == null || ac.layers.Length == 0)
{
continue;
}
for (int x = 0; x < anim.layerCount; x++)
{
UnityEditor.Animations.AnimatorStateMachine sm = ac.layers[x].stateMachine;
int cnt = sm.states.Length;
for (int i = 0; i < cnt; i++)
{
UnityEditor.Animations.AnimatorState state = sm.states[i].state;
Motion m = state.motion;
if (m != null)
{
AnimationClip clip = m as AnimationClip;
if (clip != null)
{
EditorCurveBinding[] ecbs = AnimationUtility.GetObjectReferenceCurveBindings(clip);
foreach (EditorCurveBinding ecb in ecbs)
{
if (ecb.propertyName == "m_Sprite")
{
foreach (ObjectReferenceKeyframe keyframe in AnimationUtility.GetObjectReferenceCurve(clip, ecb))
{
Sprite tSprite = keyframe.value as Sprite;
if (tSprite != null)
{
var tTextureDetail = GetTextureDetail(tSprite.texture, anim);
if (!ActiveTextures.Contains(tTextureDetail))
{
ActiveTextures.Add(tTextureDetail);
}
}
}
}
}
}
}
}
}
}
}
if (IncludeScriptReferences)
{
MonoBehaviour[] scripts = FindObjects <MonoBehaviour>();
foreach (MonoBehaviour script in scripts)
{
BindingFlags flags = BindingFlags.Public | BindingFlags.Instance; // only public non-static fields are bound to by Unity.
FieldInfo[] fields = script.GetType().GetFields(flags);
foreach (FieldInfo field in fields)
{
System.Type fieldType = field.FieldType;
if (fieldType == typeof(Sprite))
{
Sprite tSprite = field.GetValue(script) as Sprite;
if (tSprite != null)
{
var tSpriteTextureDetail = GetTextureDetail(tSprite.texture, script);
if (!ActiveTextures.Contains(tSpriteTextureDetail))
{
ActiveTextures.Add(tSpriteTextureDetail);
}
}
}
if (fieldType == typeof(Mesh))
{
Mesh tMesh = field.GetValue(script) as Mesh;
if (tMesh != null)
{
MeshDetails tMeshDetails = FindMeshDetails(tMesh);
if (tMeshDetails == null)
{
tMeshDetails = new MeshDetails();
tMeshDetails.mesh = tMesh;
tMeshDetails.instance = true;
ActiveMeshDetails.Add(tMeshDetails);
}
}
}
if (fieldType == typeof(Material))
{
Material tMaterial = field.GetValue(script) as Material;
if (tMaterial != null)
{
MaterialDetails tMatDetails = FindMaterialDetails(tMaterial);
if (tMatDetails == null)
{
tMatDetails = new MaterialDetails();
tMatDetails.instance = true;
tMatDetails.material = tMaterial;
if (!ActiveMaterials.Contains(tMatDetails))
{
ActiveMaterials.Add(tMatDetails);
}
}
if (tMaterial.mainTexture)
{
var tSpriteTextureDetail = GetTextureDetail(tMaterial.mainTexture);
if (!ActiveTextures.Contains(tSpriteTextureDetail))
{
ActiveTextures.Add(tSpriteTextureDetail);
}
}
var dependencies = EditorUtility.CollectDependencies(new UnityEngine.Object[] { tMaterial });
foreach (Object obj in dependencies)
{
if (obj is Texture)
{
Texture tTexture = obj as Texture;
var tTextureDetail = GetTextureDetail(tTexture, tMaterial, tMatDetails);
if (!ActiveTextures.Contains(tTextureDetail))
{
ActiveTextures.Add(tTextureDetail);
}
}
}
}
}
}
}
}
TotalTextureMemory = 0;
foreach (TextureDetails tTextureDetails in ActiveTextures)
{
TotalTextureMemory += tTextureDetails.memSizeKB;
}
TotalMeshVertices = 0;
foreach (MeshDetails tMeshDetails in ActiveMeshDetails)
{
TotalMeshVertices += tMeshDetails.mesh.vertexCount;
}
// Sort by size, descending
ActiveTextures.Sort(delegate(TextureDetails details1, TextureDetails details2) { return(details2.memSizeKB - details1.memSizeKB); });
ActiveTextures = ActiveTextures.Distinct().ToList();
ActiveMeshDetails.Sort(delegate(MeshDetails details1, MeshDetails details2) { return(details2.mesh.vertexCount - details1.mesh.vertexCount); });
collectedInPlayingMode = Application.isPlaying;
// Sort by render queue
ActiveMaterials.Sort(MaterialSorter);
}
void SerializeMesh(GameObject go, LevelObject lo, bool rejectStatic = true)
{
MeshFilter mf = go.GetComponent <MeshFilter>();
MeshRenderer mr = go.GetComponent <MeshRenderer>();
bool isBatchStatic = GameObjectUtility.AreStaticEditorFlagsSet(go, StaticEditorFlags.BatchingStatic);
bool isLightmapStatic = GameObjectUtility.AreStaticEditorFlagsSet(go, StaticEditorFlags.LightmapStatic);
bool shouldBailDueToRejectingStatics = rejectStatic && isBatchStatic;
if (mf == null || mf.sharedMesh == null || shouldBailDueToRejectingStatics)
{
lo.mesh = new LevelMesh();
return;
}
var m = mf.sharedMesh;
var lm = new LevelMesh();
var mNormals = m.normals;
var mUV1 = m.uv;
var mUV2 = m.uv2;
var mTangent = m.tangents;
bool hasNormal = mNormals != null && mNormals.Length > 0;
bool hasUV1 = mUV1 != null && mUV1.Length > 0;
bool hasUV2 = mUV2 != null && mUV2.Length > 0;
bool hasTangent = mTangent != null && mTangent.Length > 0;
if (hasNormal)
{
lm.Flags |= LevelMesh.MeshFlags.Normal;
}
if (hasUV1)
{
lm.Flags |= LevelMesh.MeshFlags.UV1;
}
if (hasUV2)
{
lm.Flags |= LevelMesh.MeshFlags.UV2;
}
if (hasTangent)
{
lm.Flags |= LevelMesh.MeshFlags.Tangent;
}
Profiler.BeginSample("Write Verts");
// TODO: We should reuse the stuff above.
// Vertex order is: pos, norm, uv0, [uv1]
var uv1 = new List <Vector2>();
var uv2 = new List <Vector2>();
var tangent = new List <Vector4>();
if (hasUV1)
{
m.GetUVs(0, uv1);
}
if (hasUV2)
{
m.GetUVs(1, uv2);
}
if (hasTangent)
{
m.GetTangents(tangent);
}
Profiler.BeginSample("Copy Verts");
var vertByteSize =
3 * 4 + // Position
(hasNormal ? 3 * 4 : 0) + // Normal
(hasUV1 ? 2 * 4 : 0) + // UV1
(hasUV2 ? 2 * 4 : 0) + // UV2
(hasTangent ? 4 * 4 : 0) // Tangent
;
var bytes = new byte[vertByteSize * m.vertexCount];
var stagingFloats = new float[m.vertexCount * 4];
Debug.Assert(m.vertexCount == m.vertices.Length);
// Copy vertex data as contiguous runs by field.
var offset = 0;
offset = MemoryMapUtility.MapVector3ToBytes(m.vertexCount, bytes, 0, stagingFloats, m.vertices);
if (hasNormal)
{
Debug.AssertFormat(m.vertices.Length == m.normals.Length, "vertices[{0}] != normals[{1}]", m.vertices.Length, m.normals.Length);
offset += MemoryMapUtility.MapVector3ToBytes(m.vertexCount, bytes, offset, stagingFloats, m.normals);
}
if (hasUV1)
{
offset += MemoryMapUtility.MapVector2ToBytes(m.vertexCount, bytes, offset, stagingFloats, m.uv);
}
if (hasUV2)
{
offset += MemoryMapUtility.MapVector2ToBytes(m.vertexCount, bytes, offset, stagingFloats, m.uv2);
}
if (hasTangent)
{
offset += MemoryMapUtility.MapVector4ToBytes(m.vertexCount, bytes, offset, stagingFloats, m.tangents);
}
lm.verts.Stream = new MemoryStream(bytes, 0, offset, false, true);
lm.vertexCount = m.vertexCount;
lm.bounds = m.bounds;
Profiler.EndSample();
Profiler.EndSample();
Profiler.BeginSample("Write Indices");
var indices = m.triangles;
lm.indexCount = indices.Length;
var indexSizeInBytes = indices.Length * 2;
bytes = new byte[indexSizeInBytes];
var shortIdx = new ushort[indices.Length];
for (var i = 0; i < indices.Length; i++)
{
shortIdx[i] = (ushort)indices[i];
}
Buffer.BlockCopy(shortIdx, 0, bytes, 0, indexSizeInBytes);
lm.indices.Stream = new MemoryStream(bytes, 0, indexSizeInBytes, false, true);
Profiler.EndSample();
for (var i = 0; i < m.subMeshCount; i++)
{
var lsm = new LevelSubMesh();
lsm.start = (int)m.GetIndexStart(i);
lsm.count = (int)m.GetIndexCount(i);
lm.subMeshes.Add(lsm);
}
if (go.GetComponent <MeshCollider>() && go.GetComponent <MeshCollider>().enabled)
{
lo.SetMeshCollider();
}
if (mr && mr.enabled)
{
lo.SetMeshRenderer();
// Lightmap settings.
lm.lightmapIndex = mr.lightmapIndex;
lm.lightmapScaleOffset = mr.lightmapScaleOffset;
// Encode materials.
foreach (var mrM in mr.sharedMaterials)
{
lm.materials.Add(mapComp.ResolveMaterialName(mrM.name));
}
}
lo.mesh = lm;
}
private List <GameObjectListing> Filter(GameObjectListing[] gameObjectListings)
{
string filterString = _caseSensitive ? _filterString : _filterString.ToLower();
string[] filterSubstrings = filterString.Split(new char[] { ' ' }, System.StringSplitOptions.RemoveEmptyEntries);
var filtered = new List <GameObjectListing>();
if (gameObjectListings == null)
{
return(filtered);
}
foreach (var listing in gameObjectListings)
{
GameObject go = listing.GameObject;
// check substrings
bool passSubstringFilter = true;
foreach (var substring in filterSubstrings)
{
if (_caseSensitive ? !go.name.Contains(substring) : !go.name.ToLower().Contains(substring))
{
passSubstringFilter = false;
break;
}
}
if (!passSubstringFilter)
{
continue;
}
// check missing script
if (_filterUnassignedScript)
{
bool passMissingScriptFilter = false;
var components = go.GetComponents <Component>();
foreach (var component in components)
{
if (component == null)
{
passMissingScriptFilter = true;
break;
}
}
if (!passMissingScriptFilter)
{
continue;
}
}
// check layer
if (_filterLayer && _invertLayerFilter != (_filteredLayer != go.layer))
{
continue;
}
// check tag
if (_filterTag && _invertTagFilter != (!go.CompareTag(_filteredTag)))
{
continue;
}
// check component
if (_filterComponent)
{
System.Type componentType = _componentTypes[_filteredComponentIndex];
if (componentType != null)
{
var component = go.GetComponent(componentType);
if (_invertComponentFilter && component != null || !_invertComponentFilter && component == null)
{
continue;
}
if (!_invertComponentFilter && _filterComponentIsCollider && FilterColliderComponent(component))
{
continue;
}
}
}
// check script
if (_filterScript && _filteredScript != null && _invertScriptFilter != (go.GetComponent(_filteredScript.GetClass()) == null))
{
continue;
}
// check static
if (_filterStatic && _invertStaticFilter != !GameObjectUtility.AreStaticEditorFlagsSet(go, _filteredStaticFlag))
{
continue;
}
// add gameobject to filtered set
filtered.Add(listing);
}
return(filtered);
}
