//删除操作
public void Remove(List <LinkedListNode <IShareThingHandle> > removes)
{
IShareThingHandle oldLast = Get();
foreach (LinkedListNode <IShareThingHandle> node in removes)
{
node.Value.m_shareThing = null;
m_handles.Remove(node);
}
//处理回调,一定要放在位置操作之后
IShareThingHandle last = Get();
if (oldLast != last)
{
if (last != null)
{
last.OnLast(oldLast);
}
if (oldLast.m_shareThing != null)//注意这里要判断下，有可能就是被删除的那个
{
oldLast.OnOverlay();
}
if (oldLast.m_removeIfOverlay)
{
m_handles.Remove(oldLast);
}
}
if (m_handles.Count == 0)
{
oldLast.OnEmpty();
}
}
//删除操作
public void Remove(IShareThingHandle handle)
{
IShareThingHandle oldLast = Get();
handle.m_shareThing = null;
if (!m_handles.Remove(handle))
{
Debuger.LogError("删除不了，不在管理器中");
return;
}
//处理回调,一定要放在位置操作之后
IShareThingHandle last = Get();
if (oldLast != last)
{
if (last != null)
{
last.OnLast(oldLast);
}
if (oldLast.m_shareThing != null)//注意这里要判断下，有可能就是被删除的那个
{
oldLast.OnOverlay();
}
if (oldLast.m_removeIfOverlay)
{
m_handles.Remove(oldLast);
}
}
if (m_handles.Count == 0)
{
handle.OnEmpty();
}
}
//修改操作,默认是放在同优先级后面(先出)，addAfter =false那么就放前(慢出)
public void Change(IShareThingHandle handle, int priority, bool after = true)
{
IShareThingHandle oldLast = Get();
if (!m_handles.Remove(handle))
{
Debuger.LogError("改变不了优先级，不在管理器中");
return;
}
//按照插入同优先级的最后面
handle.m_priority = priority;
LinkedListNode <IShareThingHandle> node = m_handles.Last;
if (node == null)
{
m_handles.AddLast(handle);
}
else
{
do
{
if (after == true && node.Value.m_priority <= priority)//插入到优先级后面
{
m_handles.AddAfter(node, handle);
break;
}
else if (after == false && node.Value.m_priority < priority)//插入到优先级前
{
m_handles.AddAfter(node, handle);
break;
}
else if (node.Previous == null)
{
m_handles.AddBefore(node, handle);
break;
}
node = node.Previous;
} while (true);
}
//处理回调,一定要放在位置操作之后
IShareThingHandle last = Get();
if (oldLast != last)
{
last.OnLast(oldLast);
oldLast.OnOverlay();
if (oldLast.m_removeIfOverlay)
{
m_handles.Remove(oldLast);
}
}
if (m_handles.Count == 0)
{
handle.OnEmpty();
}
}
public override void OnLast(IShareThingHandle prev)
{
if (onPush != null)
{
onPush(pushParam);
}
if (m_shareThing.m_param == null)
{
m_shareThing.m_param = onEmpty;//emptyParam是真正的共享资源的初始值
m_shareThing.m_param2 = emptyParam;
}
}
//修改操作,如果外部修改了优先级，可以用这个函数重新排列
public void Sort()
{
IShareThingHandle oldLast = Get();
m_handles.SortEx(Compare);
//处理回调,一定要放在位置操作之后
IShareThingHandle last = Get();
if (oldLast != last)
{
last.OnLast(oldLast);
oldLast.OnOverlay();
}
}
public override void OnLast(IShareThingHandle prev)
{
if (CameraMgr.instance)
{
CameraMgr.instance.m_curId = m_id;
CameraMgr.instance.m_curCameraInfo = m_info;
CameraMgr.instance.m_isDuration = true;
CameraMgr.instance.m_samlpeCounter = 0;
}
CameraHandle prevHandle = prev as CameraHandle;
//注意只有在被覆盖然后置顶的时候才需要重置相关东西和提升优先级
if (m_isFirst || m_info.durationType == CameraInfo.enDurationType.overWhenOverlay)
{
return;
}
if (m_info.durationType == CameraInfo.enDurationType.resetWhenLast)
{
if (prevHandle != null && prevHandle.m_info.useOverDuration)
{
if (prevHandle.m_info.blur != 0 && prevHandle.m_info.blurDuration != 0)//推镜过程模糊
{
CameraMgr.instance.PlayRadialBlur(prevHandle.m_info.blur, prevHandle.m_info.blurTarget, prevHandle.m_info.blurDuration, prevHandle.m_info.offset, prevHandle.m_info.blurBeginSmooth, prevHandle.m_info.blurEndSmooth);
}
Reset(prevHandle.m_info.isDurationInvalid, prevHandle.m_info.overDuationSmooth);
}
else
{
if (m_info.blur != 0 && m_info.blurDuration != 0)//推镜过程模糊
{
CameraMgr.instance.PlayRadialBlur(m_info.blur, m_info.blurTarget, m_info.blurDuration, m_info.offset, m_info.blurBeginSmooth, m_info.blurEndSmooth);
}
Reset(false);
}
}
else if (m_info.durationType == CameraInfo.enDurationType.keepOverTimeWhenLast)
{
ResetKeepOverTime();
}
//提升优先级
this.m_shareThing.Change(this, m_info.durationPriority);
}
//删除操作，onCheckRemove返回true则删除，注意onCheckRemove中不能有其他的增删改操作，这里是从前往后遍历，这样可以防止这个过程中多次OnLast
public void Remove(Func <IShareThingHandle, bool> onCheckRemove)
{
if (m_handles.Count == 0)
{
return;
}
IShareThingHandle oldLast = Get();
LinkedListNode <IShareThingHandle> node = m_handles.First;
LinkedListNode <IShareThingHandle> temp;
while (node != null)
{
temp = node.Next;
if (onCheckRemove(node.Value))
{
m_handles.Remove(node);
node.Value.m_shareThing = null;
}
node = temp;
}
//处理回调,一定要放在位置操作之后
IShareThingHandle last = Get();
if (oldLast != last)
{
if (last != null)
{
last.OnLast(oldLast);
}
if (oldLast.m_shareThing != null)//注意这里要判断下，有可能就是被删除的那个
{
oldLast.OnOverlay();
}
if (oldLast.m_removeIfOverlay)
{
m_handles.Remove(oldLast);
}
}
if (m_handles.Count == 0)
{
oldLast.OnEmpty();
}
}
//清空操作
public void Clear()
{
if (m_handles.Count == 0)
{
return;
}
IShareThingHandle last = Get();
LinkedListNode <IShareThingHandle> node = m_handles.First;
while (node != null)
{
node.Value.m_shareThing = null;
node = node.Next;
}
m_handles.Clear();
//处理回调,一定要放在位置操作之后
if (last != null)
{
last.OnEmpty();
}
}
public override void OnLast(IShareThingHandle prev)
{
Time.timeScale = scale;
}
public override void OnLast(IShareThingHandle prev)
{
}
//当自己为最后的时候 public abstract void OnLast(IShareThingHandle prev);
static public int Compare(IShareThingHandle a, IShareThingHandle b)
{
return(a.m_priority.CompareTo(b.m_priority));
}
//增加操作，如果已经在里面了，那么changeIfExist=true时Change()，否则报个错
public void Add(IShareThingHandle handle, int priority = 0, bool changeIfExist = false, bool removeIfOverlay = false)
{
//
if (handle.m_shareThing != null)
{
if (handle.m_shareThing != this)
{
Debuger.LogError("逻辑错误handle的shareThing不一样");
return;
}
if (!changeIfExist)
{
Debuger.LogError("已经在shareThing里面了");
return;
}
Change(handle, priority);
return;
}
IShareThingHandle oldLast = Get();
//这里检错下，如果太多，说明可能有忘记释放的地方
if (m_handles.Count > Check_Leak_Count)
{
Debuger.LogError("共享资源管理器中操作数太多。type=" + handle.GetType().ToString());
}
handle.m_shareThing = this;
handle.m_priority = priority;
handle.m_removeIfOverlay = removeIfOverlay;
//按照插入同优先级的最后面
LinkedListNode <IShareThingHandle> node = m_handles.Last;
if (node == null)
{
m_handles.AddLast(handle);
}
else
{
do
{
if (node.Value.m_priority <= priority)
{
m_handles.AddAfter(node, handle);
break;
}
else if (node.Previous == null)
{
m_handles.AddBefore(node, handle);
break;
}
node = node.Previous;
}while(true);
}
//处理回调,一定要放在位置操作之后
if (Get() == handle)
{
handle.OnLast(oldLast);
if (oldLast != null)
{
oldLast.OnOverlay();
if (oldLast.m_removeIfOverlay)
{
m_handles.Remove(oldLast);
}
}
if (m_handles.Count == 0)
{
handle.OnEmpty();
}
}
}
