private void DoInstantiateAllUnit()
{
if (m_WaitInstantiateCount != 0)
{
return;
}
DoDestroyAllUnit();
AreaLayerInfo[] areaLayerInfos = m_AreaDetailInfo.AreaLayerInfos;
if (areaLayerInfos != null && areaLayerInfos.Length > 0)
{
for (int iLayer = 0; iLayer < areaLayerInfos.Length; iLayer++)
{
List <SceneUnitInfo> units = areaLayerInfos[iLayer].m_Units;
if (units != null && units.Count > 0)
{
m_WaitInstantiateCount += units.Count;
for (int iUnit = 0; iUnit < units.Count; iUnit++)
{
SceneUnitInfo iterUnitInfo = units[iUnit];
InstantiateUnit(iterUnitInfo, m_UnitsRoot);
}
}
}
}
}
public void FillUnitInfo(ref SceneUnitInfo unitInfo, Area area, Quaternion areaInverseRotation)
{
unitInfo.LocalPosition = area.transform.InverseTransformPoint(transform.position);
unitInfo.LocalRotation = areaInverseRotation * transform.rotation;
unitInfo.LocalScale = ObjectUtility.CalculateLossyScale(transform, area.transform);
unitInfo._AABB = m_AABB;
unitInfo._Diameter = MathUtility.CaculateLongestSide(m_AABB);
}
public void DeSerialize(BinaryReader reader)
{
m_Priority = reader.ReadInt32();
m_GridSize = reader.ReadInt32();
m_Offest = reader.ReadInt32();
int indexCount = reader.ReadInt32();
if (indexCount > 0)
{
AreaVirtualGridIndexs = new List <long>();
for (int iIndex = 0; iIndex < indexCount; iIndex++)
{
AreaVirtualGridIndexs.Add(reader.ReadInt64());
}
}
int gridCount = reader.ReadInt32();
if (gridCount > 0)
{
AreaVirtualGridInfos = new List <AreaVirtualGridInfo>();
for (int iGrid = 0; iGrid < gridCount; iGrid++)
{
AreaVirtualGridInfo gridInfo = new AreaVirtualGridInfo();
gridInfo.DeSerialize(reader);
m_MinIndexX = Mathf.Min(gridInfo.m_IndexX, m_MinIndexX);
m_MaxIndexX = Mathf.Max(gridInfo.m_IndexX, m_MaxIndexX);
m_MinIndexY = Mathf.Min(gridInfo.m_IndexY, m_MinIndexY);
m_MaxIndexY = Mathf.Max(gridInfo.m_IndexY, m_MaxIndexY);
m_MinIndexZ = Mathf.Min(gridInfo.m_IndexZ, m_MinIndexZ);
m_MaxIndexZ = Mathf.Max(gridInfo.m_IndexZ, m_MaxIndexZ);
AreaVirtualGridInfos.Add(gridInfo);
}
}
int unitCount = reader.ReadInt32();
if (unitCount > 0)
{
m_Units = new List <SceneUnitInfo>();
for (int iUnit = 0; iUnit < unitCount; iUnit++)
{
SceneUnitInfo sceneUnitInfo = new SceneUnitInfo();
sceneUnitInfo.DeSerialize(reader);
m_Units.Add(sceneUnitInfo);
}
}
}
public void Serialize(BinaryWriter writer)
{
writer.Write(m_Priority);
writer.Write(m_GridSize);
writer.Write(m_Offest);
List <long> areaVirtualGridIndexs = AreaVirtualGridIndexs;
if (areaVirtualGridIndexs == null || areaVirtualGridIndexs.Count <= 0)
{
writer.Write(0);
}
else
{
writer.Write(areaVirtualGridIndexs.Count);
for (int iIndex = 0; iIndex < areaVirtualGridIndexs.Count; iIndex++)
{
writer.Write(areaVirtualGridIndexs[iIndex]);
}
}
List <AreaVirtualGridInfo> areaVirtualGridInfos = AreaVirtualGridInfos;
if (areaVirtualGridInfos == null || areaVirtualGridInfos.Count <= 0)
{
writer.Write(0);
}
else
{
writer.Write(areaVirtualGridInfos.Count);
for (int iGrid = 0; iGrid < areaVirtualGridInfos.Count; iGrid++)
{
AreaVirtualGridInfo gridInfo = areaVirtualGridInfos[iGrid];
gridInfo.Serialize(writer);
}
}
List <SceneUnitInfo> units = m_Units;
if (units == null || units.Count <= 0)
{
writer.Write(0);
}
else
{
writer.Write(units.Count);
for (int iUnit = 0; iUnit < units.Count; iUnit++)
{
SceneUnitInfo sceneUnitInfo = units[iUnit];
sceneUnitInfo.Serialize(writer);
}
}
}
private void InstantiateUnit(SceneUnitInfo unitInfo, Transform parent)
{
if (m_Owner.UseAsset)
{
AssetUtil.InstanceAssetAsync(m_AreaDetailInfo.AssetInfos[unitInfo.AssetIndex].AddressableKey, (pathOrAddress, uObj, userData) =>
{
if (uObj != null)
{
GameObject resultObj = uObj as GameObject;
if (resultObj != null)
{
m_WaitInstantiateCount--;
Transform t = resultObj.transform;
t.SetParent(m_UnitsRoot);
t.localPosition = unitInfo.LocalPosition;
t.localRotation = unitInfo.LocalRotation;
t.localScale = unitInfo.LocalScale;
}
}
});
}
else
{
m_WaitInstantiateCount--;
string path = string.Format("{0}/{1}Map_{2}/{3}.prefab"
, MapEditorUtility.GetOrCreateMapEditorSetting().AssetExportDirectory
, Constants.UNIT_PREFAB_EXPORT_DIRECTORY
, m_Owner.MapInfo.Uid
, m_AreaDetailInfo.AssetInfos[unitInfo.AssetIndex].AddressableKey);
GameObject asset = AssetDatabase.LoadAssetAtPath <GameObject>(path);
if (asset == null)
{
string[] paths = AssetDatabase.FindAssets(m_AreaDetailInfo.AssetInfos[unitInfo.AssetIndex].AddressableKey);
if (paths != null && paths.Length > 0)
{
path = AssetDatabase.GUIDToAssetPath(paths[0]);
asset = AssetDatabase.LoadAssetAtPath <GameObject>(path);
}
}
if (asset != null)
{
Transform t = Instantiate(asset).transform;
t.SetParent(parent);
t.localPosition = unitInfo.LocalPosition;
t.localRotation = unitInfo.LocalRotation;
t.localScale = unitInfo.LocalScale;
}
}
}
private void OnDrawGizmosSelected()
{
if (m_AreaLayerInfos != null && m_AreaLayerInfos.Length > 0)
{
for (int iLayer = 0; iLayer < m_AreaLayerInfos.Length; iLayer++)
{
//if(m_ShowLayer[iLayer])
{
AreaLayerInfo layerInfo = m_AreaLayerInfos[iLayer];
if (layerInfo != null)
{
List <AreaVirtualGridInfo> areaVirtualGridInfos = layerInfo.AreaVirtualGridInfos;
if (areaVirtualGridInfos != null && areaVirtualGridInfos.Count > 0)
{
for (int iArea = 0; iArea < areaVirtualGridInfos.Count; iArea++)
{
AreaVirtualGridInfo gridInfo = areaVirtualGridInfos[iArea];
if (m_ShowLayer[iLayer])
{
Gizmos.color = m_Colors[iLayer];
Gizmos.DrawWireCube(gridInfo.m_Position, new Vector3(layerInfo.m_GridSize, layerInfo.m_GridSize, layerInfo.m_GridSize));
}
if (m_ShowUnitAB[iLayer])
{
List <int> unitIndexs = gridInfo.m_UnitIndexs;
if (unitIndexs != null && unitIndexs.Count > 0)
{
for (int iUnit = 0; iUnit < unitIndexs.Count; iUnit++)
{
SceneUnitInfo unitInfo = layerInfo.m_Units[unitIndexs[iUnit]];
Gizmos.color = new Color(1, 1, 1, 0.2f);
Gizmos.DrawWireCube(unitInfo._AABB.center, unitInfo._AABB.size);
}
}
}
}
}
}
}
}
}
}
public void ShowSceneUI()
{
return;
if (m_AreaLayerInfos != null && m_AreaLayerInfos.Length > 0)
{
for (int iLayer = 0; iLayer < m_AreaLayerInfos.Length; iLayer++)
{
if (m_ShowLayer[iLayer])
{
AreaLayerInfo layerInfo = m_AreaLayerInfos[iLayer];
if (layerInfo != null)
{
List <AreaVirtualGridInfo> areaVirtualGridInfos = layerInfo.AreaVirtualGridInfos;
if (areaVirtualGridInfos != null && areaVirtualGridInfos.Count > 0)
{
for (int iArea = 0; iArea < areaVirtualGridInfos.Count; iArea++)
{
AreaVirtualGridInfo gridInfo = areaVirtualGridInfos[iArea];
List <int> unitIndexs = gridInfo.m_UnitIndexs;
if (unitIndexs != null && unitIndexs.Count > 0)
{
for (int iUnit = 0; iUnit < unitIndexs.Count; iUnit++)
{
SceneUnitInfo unitInfo = layerInfo.m_Units[unitIndexs[iUnit]];
AssetInfo assetInfo = m_AreaDetailInfo.AssetInfos[unitInfo.AssetIndex];
Handles.Label(unitInfo.LocalPosition, assetInfo.AddressableKey);
}
}
}
}
}
}
}
}
}
private void OnInstantiateUnitCompleted(string pathOrAddress, UnityObject obj, SystemObject userData)
{
m_RuningUnitCommandCount--;
LoadUnitData loadData = userData as LoadUnitData;
int unitIndex = loadData.m_UnitIndex;
int unitCommandId = loadData.m_CommandId;
UnitData unitData = m_UnitDatas[unitIndex];
if (m_IsReleasing)
{
UnityObject.DestroyImmediate(obj);
unitData.RemoveState(UnitState.Instantiating);
unitData.AddState(UnitState.Released);
unitData.GameObject = null;
unitData.ClearRef();
}
else
{
GameObject resultGameObject = obj as GameObject;
m_InstantiatedUnitCount++;
unitData.GameObject = resultGameObject;
unitData.RemoveState(UnitState.Instantiating);
unitData.AddState(UnitState.Instantiated);
SceneUnitInfo unitInfo = m_Units[unitIndex];
Transform unitTransform = resultGameObject.transform;
unitTransform.SetParent(m_AreaController.GetRoot(), false);
unitTransform.localPosition = unitInfo.LocalPosition;
unitTransform.localRotation = unitInfo.LocalRotation;
unitTransform.localScale = unitInfo.LocalScale;
RendererInfo[] rendererInfos = unitInfo.RendererInfos;
if (rendererInfos != null && rendererInfos.Length > 0)
{
for (int iRenderer = 0; iRenderer < rendererInfos.Length; iRenderer++)
{
RendererInfo iterRendererInfo = rendererInfos[iRenderer];
Transform iterRendererTranfsorm = unitTransform;
if (iterRendererInfo.TransformIndexs != null)
{
for (int iTransformIndex = 0; iTransformIndex < iterRendererInfo.TransformIndexs.Length; iTransformIndex++)
{
iterRendererTranfsorm = iterRendererTranfsorm.GetChild(iterRendererInfo.TransformIndexs[iTransformIndex]);
}
}
Renderer iterRenderer = iterRendererTranfsorm.GetComponent <Renderer>();
if (iterRenderer && iterRendererInfo.LightmapIndex >= 0)
{
/* for (int iMaterial = 0; iMaterial < iterRenderer.materials.Length; iMaterial++)
* {
* Material iterMaterial = iterRenderer.materials[iMaterial];
* if (CRenderer.Shaders.GetInstance().TryFindShader(iterMaterial.shader.name, out Shader shader))
* {
* iterMaterial.shader = shader;
* }
* }*/
iterRenderer.lightmapIndex = iterRendererInfo.LightmapIndex;
iterRenderer.lightmapScaleOffset = iterRendererInfo.LightmapScaleOffset;
iterRenderer.realtimeLightmapIndex = iterRendererInfo.RealLightmapIndex;
iterRenderer.realtimeLightmapScaleOffset = iterRendererInfo.RealLightmapScaleOffset;
}
}
}
}
m_UnitDatas[unitIndex] = unitData;
}
/// <summary>
/// 执行删除和生成命令
/// </summary>
private void DoUpdateUnitCommand()
{
int releaseCommandCount = 0;
int enqueueCommandCount = 0;
while (m_RuningUnitCommandCount + releaseCommandCount
< Constants.MAX_RUNING_UNITCOMMAND_COUNT &&
m_UnitCommands.Count > enqueueCommandCount)
{
UnitCommand iterUnitCommand = m_UnitCommands.Dequeue();
UnitData iterUnitData = m_UnitDatas[iterUnitCommand.UnitIndex];
switch (iterUnitCommand.Command)
{
case CommandType.Instantiate:
if (iterUnitData.HasState(UnitState.WaitRelease))
{
continue;
}
// 防止重复实例化
else if (!iterUnitData.HasState(UnitState.Instantiated) &&
!iterUnitData.HasState(UnitState.Instantiating) &&
iterUnitData.HasState(UnitState.WaitInstantiate))
{
m_RuningUnitCommandCount++;
SceneUnitInfo unitInfo = m_Units[iterUnitCommand.UnitIndex];
AssetUtil.InstanceAssetAsync(m_AssetInfos[unitInfo.AssetIndex].AddressableKey
, OnInstantiateUnitCompleted, AssetLoaderPriority.Default, null
, new LoadUnitData(iterUnitCommand.UnitIndex, iterUnitCommand.CommandId));
iterUnitData.RemoveState(UnitState.WaitInstantiate);
iterUnitData.AddState(UnitState.Instantiating);
}
break;
case CommandType.Release:
if (iterUnitData.HasState(UnitState.WaitRelease))
{
if (iterUnitData.HasState(UnitState.Instantiated))
{
//Debug.LogError("release:" + iterUnitData.GameObject.name);
UnityObject.DestroyImmediate(iterUnitData.GameObject);
iterUnitData.GameObject = null;
iterUnitData.SetState(UnitState.Released);
iterUnitData.ClearRef();
m_InstantiatedUnitCount--;
releaseCommandCount++;
}
else
{
//Debug.LogError("未释放waitRelease:" + iterUnitData.GameObject.name);
m_UnitCommands.Enqueue(iterUnitCommand);
enqueueCommandCount++;
}
}
break;
default:
break;
}
m_UnitDatas[iterUnitCommand.UnitIndex] = iterUnitData;
}
}
