private void TriggerToNode(IDetector detector, TriggerHandle <T> handle, int depth, float centerx, float centerz, float sizex,
float sizez)
{
if (depth == m_MaxDepth)
{
uint m = Morton2FromWorldPos(centerx, centerz);
if (m_Nodes.ContainsKey(m) && m_Nodes[m] != null)
{
m_Nodes[m].Trigger(detector, handle);
}
}
else
{
int colider = detector.GetDetectedCode(centerx, m_Bounds.center.y, centerz, true);
float sx = sizex * 0.5f, sz = sizez * 0.5f;
if ((colider & 1) != 0)
{
TriggerToNode(detector, handle, depth + 1, centerx - sx * 0.5f, centerz - sz * 0.5f, sx, sz);
}
if ((colider & 2) != 0)
{
TriggerToNode(detector, handle, depth + 1, centerx - sx * 0.5f, centerz + sz * 0.5f, sx, sz);
}
if ((colider & 4) != 0)
{
TriggerToNode(detector, handle, depth + 1, centerx + sx * 0.5f, centerz - sz * 0.5f, sx, sz);
}
if ((colider & 8) != 0)
{
TriggerToNode(detector, handle, depth + 1, centerx + sx * 0.5f, centerz + sz * 0.5f, sx, sz);
}
}
}
private void TriggerDetectorNearToFar(IDetector detector, TriggerHandle <T> handle)
{
uint row = (uint)Mathf.FloorToInt((detector.Position.x - m_Bounds.min.x) / m_DeltaWidth);
uint col = (uint)Mathf.FloorToInt((detector.Position.z - m_Bounds.min.z) / m_DeltaHeight);
uint maxcol = (uint)Mathf.Pow(2, m_MaxDepth);
float bias = Mathf.Cos(22.5f * Mathf.Deg2Rad);
int direct = 1;
if (detector.Rotation != null)
{
direct = Mathf.FloorToInt(((detector.Rotation.y + 360.0f) % 360.0f + 22.5f) / 45.0f) + 1;
}
//完整遍历的最大N
int circleN = (int)Mathf.Min(maxcol - row, maxcol - col, row, col);
TriggerOneCircleNodes(detector, (int)row, (int)col, 0, direct, (int)maxcol, handle);
/*
* if (row <= maxcol && col <= maxcol)
* {
* uint m = MortonCodeUtil.EncodeMorton2(row, col);
* if (m_Nodes.ContainsKey(m) && m_Nodes[m] != null)
* {
* m_Nodes[m].Trigger(detector, handle);
* }
* }
* for (int i = 1; i < 9; i++)
* {
* uint nrow = row + (uint)directs[i].x;
* uint ncol = col + (uint)directs[i].y;
* TriggerOneNode(detector, nrow, ncol, i, maxcol, handle);
* }*/
}
public void Trigger(IDetector detector, TriggerHandle <T> handle)
{
if (handle == null)
{
return;
}
for (int i = 0; i < m_ChildNodes.Length; i++)
{
var node = m_ChildNodes[i];
if (node != null)
{
node.Trigger(detector, handle);
}
}
if (detector.IsDetected(m_Bounds))
{
var node = m_ObjectList.First;
while (node != null)
{
if (detector.IsDetected(node.Value.Bounds))
{
handle(node.Value);
}
node = node.Next;
}
}
}
public void Trigger(IDetector detector, TriggerHandle <T> handle)
{
if (handle == null)
{
return;
}
//bool isInView = false;
if (!detector.IsDetected(m_Bounds))
{
return;
}
//触发当前节点下的所有物体
var node = m_ObjectList.First;
while (node != null)
{
//如果是最大节点， 就不检测了，直接触发
if (m_CurrentDepth == m_MaxDepth || detector.IsDetected(node.Value.Bounds))
{
handle(node.Value);
}
node = node.Next;
}
for (int i = 0; i < m_ChildNodes.Length; i++)
{
if (m_ChildNodes[i] != null)
{
m_ChildNodes[i].Trigger(detector, handle);
}
}
}
public void ResetAllData()
{
StopAllCoroutines();
if (m_QuadTree)
{
m_QuadTree.Clear();
}
m_QuadTree = null;
if (m_ProcessTaskQueue != null)
{
m_ProcessTaskQueue.Clear();
}
if (m_LoadedObjectList != null)
{
foreach (var item in m_LoadedObjectList)
{
DestroyObject(item, false);
}
m_LoadedObjectList.Clear();
}
m_ProcessTaskQueue = null;
m_LoadedObjectList = null;
m_TriggerHandle = null;
m_IsInitialized = false;
}
/// <summary>
/// create and attach instance
/// </summary>
/// <param name="target"></param>
/// <param name="time"></param>
/// <param name="timeOffset"></param>
/// <param name="GoFunction"></param>
public static void Construct(GameObject target, float time, float timeOffset, TriggerHandle GoFunction)
{
var tt = target.transform.GetOrAddComponent <TriggerTimer>();
tt._time = time;
tt._timeOffset = timeOffset;
tt.GoFunctionExecute = GoFunction;
}
public void Trigger(IDetector detector, TriggerHandle <T> handle)
{
if (handle == null)
{
return;
}
m_Root.Trigger(detector, handle);
}
private void TriggeLeafNode(IDetector detector, uint row, uint col, TriggerHandle <T> handle)
{
uint m = MortonCodeUtil.EncodeMorton2((uint)row, (uint)col);
if (m_Nodes.ContainsKey(m) && m_Nodes[m] != null)
{
m_Nodes[m].Trigger(detector, handle);
}
}
/// <summary>
/// Create and Attach Instance
/// </summary>
/// <param name="switchObject"></param>
/// <param name="GoFunction"></param>
public static void Construct(Object switchObject, TriggerHandle GoFunction)
{
var objectAsGO = switchObject as GameObject;
if (objectAsGO != null)
{
var ts = ApplyAsGameObject(objectAsGO);
ts.GoFunctionsExecute += GoFunction;
}
}
public void Trigger(IDetector detector, TriggerHandle <T> handle)
{
if (handle == null)
{
return;
}
if (detector.IsDetected(m_Root.Bounds) == false)
{
return;
}
m_Root.Trigger(detector, m_TreeType, handle);
}
public void EditorInit()
{
CreateTree(data.bounds.center, data.bounds.size, data.treeType, data.treeDepth);
m_LoadedObjectLinkedList = new LinkedList <SceneObject>();
m_PreDestroyObjectQueue = new PriorityQueue <SceneObject>(new SceneObjectWeightComparer());
m_TriggerHandle = new TriggerHandle <SceneObject>(this.TriggerHandle);
m_MaxCreateCount = Mathf.Max(0, data.maxCreateCount);
m_MinCreateCount = Mathf.Clamp(data.minCreateCount, 0, data.maxCreateCount);
m_MaxRefreshTime = data.maxRefreshTime;
m_MaxDestroyTime = data.maxDestroyTime;
m_Asyn = data.asyn;
m_RefreshTime = data.maxRefreshTime;
}
void OnDestroy()
{
if (m_QuadTree)
{
m_QuadTree.Clear();
}
m_QuadTree = null;
if (m_LoadedObjectList != null)
{
m_LoadedObjectList.Clear();
}
m_LoadedObjectList = null;
m_TriggerHandle = null;
}
public void Trigger(IDetector detector, TriggerHandle <T> handle)
{
if (handle == null)
{
return;
}
if (detector.UseCameraCulling)
{
TreeCullingCode code = new TreeCullingCode()
{
leftbottomback = detector.GetDetectedCode(m_Bounds.min.x, m_Bounds.min.y, m_Bounds.min.z, true),
leftbottomforward = detector.GetDetectedCode(m_Bounds.min.x, m_Bounds.min.y, m_Bounds.max.z, true),
lefttopback = detector.GetDetectedCode(m_Bounds.min.x, m_Bounds.max.y, m_Bounds.min.z, true),
lefttopforward = detector.GetDetectedCode(m_Bounds.min.x, m_Bounds.max.y, m_Bounds.max.z, true),
rightbottomback = detector.GetDetectedCode(m_Bounds.max.x, m_Bounds.min.y, m_Bounds.min.z, true),
rightbottomforward = detector.GetDetectedCode(m_Bounds.max.x, m_Bounds.min.y, m_Bounds.max.z, true),
righttopback = detector.GetDetectedCode(m_Bounds.max.x, m_Bounds.max.y, m_Bounds.min.z, true),
righttopforward = detector.GetDetectedCode(m_Bounds.max.x, m_Bounds.max.y, m_Bounds.max.z, true),
};
TriggerByCamera(detector, handle, code);
}
else
{
int code = detector.GetDetectedCode(m_Bounds.center.x, m_Bounds.center.y, m_Bounds.center.z, m_ChildCount == 4);
for (int i = 0; i < m_ChildNodes.Length; i++)
{
var node = m_ChildNodes[i];
if (node != null && (code & (1 << i)) != 0)
{
node.Trigger(detector, handle);
}
}
{
var node = m_ObjectList.First;
while (node != null)
{
if (detector.IsDetected(node.Value.Bounds))
{
handle(node.Value);
}
node = node.Next;
}
}
}
}
public void Trigger(IDetector detector, TriggerHandle <T> handle)
{
if (handle != null)
{
LinkedListNode <T> node = m_DataList.First;
while (node != null)
{
if (detector.IsDetected(node.Value.Bounds))
{
handle(node.Value);
}
node = node.Next;
}
}
}
/// <summary>
/// 初始化
/// </summary>
/// <param name="center">场景区域中心</param>
/// <param name="size">场景区域大小</param>
/// <param name="asyn">是否异步</param>
/// <param name="maxCreateCount">最大创建数量</param>
/// <param name="minCreateCount">最小创建数量</param>
/// <param name="maxRefreshTime">更新区域时间间隔</param>
/// <param name="maxDestroyTime">检查销毁时间间隔</param>
/// <param name="quadTreeDepth">四叉树深度</param>
public void Init(Vector3 center, Vector3 size, bool asyn, int maxCreateCount, int minCreateCount, float maxRefreshTime, float maxDestroyTime, TreeType treeType, int quadTreeDepth = 5)
{
if (m_IsInitialized)
{
return;
}
switch (treeType)
{
case TreeType.LinearOcTree:
m_Tree = new LinearSceneOcTree <SceneObject>(center, size, quadTreeDepth);
break;
case TreeType.LinearQuadTree:
m_Tree = new LinearSceneQuadTree <SceneObject>(center, size, quadTreeDepth);
break;
case TreeType.OcTree:
m_Tree = new SceneTree <SceneObject>(center, size, quadTreeDepth, true);
break;
case TreeType.QuadTree:
m_Tree = new SceneTree <SceneObject>(center, size, quadTreeDepth, false);
break;
default:
m_Tree = new LinearSceneQuadTree <SceneObject>(center, size, quadTreeDepth);
break;
}
m_LoadedObjectLinkedList = new LinkedList <SceneObject>();
m_PreDestroyObjectQueue = new PriorityQueue <SceneObject>(new SceneObjectWeightComparer());
m_TriggerHandle = new TriggerHandle <SceneObject>(this.TriggerHandle);
m_MaxCreateCount = Mathf.Max(0, maxCreateCount);
m_MinCreateCount = Mathf.Clamp(minCreateCount, 0, m_MaxCreateCount);
m_MaxRefreshTime = maxRefreshTime;
m_MaxDestroyTime = maxDestroyTime;
m_Asyn = asyn;
m_IsInitialized = true;
m_RefreshTime = maxRefreshTime;
}
public void Trigger(IDetector detector, TriggerHandle <T> handle)
{
if (handle == null)
{
return;
}
if (detector.UseCameraCulling)
{
m_Root.Trigger(detector, handle);
}
else
{
if (detector.IsDetected(Bounds) == false)
{
return;
}
m_Root.Trigger(detector, handle);
}
}
void OnDestroy()
{
if (m_Tree != null)
{
m_Tree.Clear();
}
m_Tree = null;
if (m_ProcessTaskQueue != null)
{
m_ProcessTaskQueue.Clear();
}
if (m_LoadedObjectLinkedList != null)
{
m_LoadedObjectLinkedList.Clear();
}
m_ProcessTaskQueue = null;
m_LoadedObjectLinkedList = null;
m_TriggerHandle = null;
}
public override void Trigger(IDetector detector, TriggerHandle <T> handle)
{
if (handle == null)
{
return;
}
if (detector.UseCameraCulling)
{
TreeCullingCode code = new TreeCullingCode()
{
leftbottomback = detector.GetDetectedCode(m_Bounds.min.x, m_Bounds.min.y, m_Bounds.min.z, true),
leftbottomforward = detector.GetDetectedCode(m_Bounds.min.x, m_Bounds.min.y, m_Bounds.max.z, true),
lefttopback = detector.GetDetectedCode(m_Bounds.min.x, m_Bounds.max.y, m_Bounds.min.z, true),
lefttopforward = detector.GetDetectedCode(m_Bounds.min.x, m_Bounds.max.y, m_Bounds.max.z, true),
rightbottomback = detector.GetDetectedCode(m_Bounds.max.x, m_Bounds.min.y, m_Bounds.min.z, true),
rightbottomforward = detector.GetDetectedCode(m_Bounds.max.x, m_Bounds.min.y, m_Bounds.max.z, true),
righttopback = detector.GetDetectedCode(m_Bounds.max.x, m_Bounds.max.y, m_Bounds.min.z, true),
righttopforward = detector.GetDetectedCode(m_Bounds.max.x, m_Bounds.max.y, m_Bounds.max.z, true),
};
TriggerToNodeByCamera(detector, handle, 0, code, m_Bounds.center.x, m_Bounds.center.z, m_Bounds.size.x,
m_Bounds.size.z);
}
else if (detector.IsRebuild)
{
TriggerDetectorNearToFar(detector, handle);
}
else
{
if (m_MaxDepth == 0)
{
if (m_Nodes.ContainsKey(0) && m_Nodes[0] != null)
{
m_Nodes[0].Trigger(detector, handle);
}
}
else
{
TriggerToNode(detector, handle, 0, m_Bounds.center.x, m_Bounds.center.z, m_Bounds.size.x, m_Bounds.size.z);
}
}
}
/// <summary>
/// 初始化
/// </summary>
/// <param name="center">场景区域中心</param>
/// <param name="size">场景区域大小</param>
/// <param name="asyn">是否异步</param>
/// <param name="maxCreateCount">最大创建数量</param>
/// <param name="minCreateCount">最小创建数量</param>
/// <param name="maxRefreshTime">更新区域时间间隔</param>
/// <param name="maxDestroyTime">检查销毁时间间隔</param>
/// <param name="quadTreeDepth">四叉树深度</param>
public void Init(Vector3 center, Vector3 size, bool asyn, int maxCreateCount, int minCreateCount, float maxRefreshTime, float maxDestroyTime, SceneSeparateTreeType treeType, int quadTreeDepth = 5)
{
if (m_IsInitialized)
{
return;
}
m_QuadTree = new SceneSeparateTree <SceneObject>(treeType, center, size, quadTreeDepth);
m_LoadedObjectList = new List <SceneObject>();
//m_PreDestroyObjectQueue = new Queue<SceneObject>();
m_PreDestroyObjectQueue = new PriorityQueue <SceneObject>(new SceneObjectWeightComparer());
m_TriggerHandle = new TriggerHandle <SceneObject>(this.TriggerHandle);
m_MaxCreateCount = Mathf.Max(0, maxCreateCount);
m_MinCreateCount = Mathf.Clamp(minCreateCount, 0, m_MaxCreateCount);
m_MaxRefreshTime = maxRefreshTime;
m_MaxDestroyTime = maxDestroyTime;
m_Asyn = asyn;
m_IsInitialized = true;
m_RefreshTime = maxRefreshTime;
}
public void Trigger(IDetector detector, SceneSeparateTreeType treeType, TriggerHandle <T> handle)
{
if (handle == null)
{
return;
}
int code = detector.DetectedCode(m_Bounds, treeType);
for (int i = 0; i < m_ChildNodes.Length; i++)
{
var node = m_ChildNodes[i];
if (node != null && (code & (1 << i)) != 0)
{
node.Trigger(detector, treeType, handle);
}
}
//if (detector.IsDetected(m_Bounds))
{
var node = m_ObjectList.First;
while (node != null)
{
if (detector.IsDetected(node.Value.Bounds))
{
handle(node.Value);
}
node = node.Next;
}
//for (int i = 0; i < m_ObjectList.Count; i++)
//{
// if (m_ObjectList[i] != null)
// {
// if (detector.IsDetected(m_ObjectList[i].Bounds))
// handle(m_ObjectList[i]);
// }
//}
}
}
public void EventHook(TriggerHandle chu)
{
TriggerEvent -= chu;
TriggerEvent += chu;
_subscribers++;
}
public void SetHandle(TriggerHandle handle)
{
mainTriggerHandle = handle;
}
private void MoveOneStep(IDetector detector, int row, int col, ref int stepx, ref int stepy, int maxcol, ref Vector2 speed, int direct, int depth, ref int count, TriggerHandle <T> handle)
{
if (count >= 4 * depth - 1)
{
return;
}
int a = (direct % 2) == 0 ? 2 * depth : depth;
int nextCornerX = stepx + (int)speed.x * a;
int nextCornerY = stepy + (int)speed.y * a;
bool nextCorInRegion = nextCornerX < maxcol && nextCornerY < maxcol && nextCornerX >= 0 && nextCornerY >= 0;
//移动一步
int nextx = stepx + (int)speed.x;
int nexty = stepy + (int)speed.y;
//下一个点在不在区域内
bool nextIn = (nextx < maxcol && nexty < maxcol && nextx >= 0 && nexty >= 0);
if (nextIn)
{
stepx = nextx;
stepy = nexty;
count += 1;
TriggeLeafNode(detector, (uint)stepx, (uint)stepy, handle);
}
else
{
//下一个拐点不在区域内
if (!nextCorInRegion)
{
//跳到拐点修改速度
stepx = nextCornerX;
stepy = nextCornerY;
speed.x -= (int)Mathf.Sign(nextCornerX);
speed.y -= (int)Mathf.Sign(nextCornerY);
count += 2 * depth;
}
else//求交点跳到交点
{
int stepx2 = stepx == nextCornerX ? stepx:(stepx * nextCornerX < 0?0:maxcol - 1);
int stepy2 = stepy == nextCornerY ? stepy : (stepy * nextCornerY < 0 ? 0 : maxcol - 1);
count += Mathf.Abs(stepx2 - stepx + stepy2 - stepy);
}
}
MoveOneStep(detector, row, col, ref stepx, ref stepy, maxcol, ref speed, direct, depth, ref count, handle);
/*
* //沿速度方向走一格
* stepx += (int)speed.x;
* stepy += (int)speed.y;
* //是否在范围内
* if (stepx < maxcol && stepy < maxcol && stepx >= 0 && stepy >= 0)
* {
* TriggeLeafNode(detector, (uint)stepx, (uint)stepy, handle);
* }
* //查看是否在拐点 在拐点修改速度
* int s1 = (stepx - row) / depth;
* int s2 = (stepy - col) / depth;
* if (Mathf.Abs(s1) == 1 && Mathf.Abs(s2) == 1)
* {
* speed.x -= s1;
* speed.y -= s2;
* }*/
}
//广度遍历
private void TriggerOneCircleNodes(IDetector detector, int row, int col, int n, int direct, int maxcol, TriggerHandle <T> handle)
{
if (n > maxcol)
{
return;
}
//遍历一周 距离中心距离是n 行列的周期是n 值域是 -n到n
Vector2 dir = directs[direct];
Vector2 speed1 = Vector2.zero;
Vector2 speed2 = Vector2.zero;
//计算初始速度
if (Mathf.Abs(dir.x) == 1 && Mathf.Abs(dir.y) == 1)
{
speed1.x = (int)dir.x * (-1);
speed2.y = (int)dir.y * (-1);
}
else if (dir.x == 0)
{
speed1.x = -1;
speed2.x = 1;
}
else if (dir.y == 0)
{
speed1.y = -1;
speed2.y = 1;
}
//起始点
int beginrow = row + n * (int)dir.x;
int begincol = col + n * (int)dir.y;
int endrow = row - n * (int)dir.x;
int endcol = col - n * (int)dir.y;
bool beginInRegion = beginrow < maxcol && begincol < maxcol && beginrow >= 0 && begincol >= 0;
//起始点判断
if (beginInRegion)
{
TriggeLeafNode(detector, (uint)beginrow, (uint)begincol, handle);
}
int step1x = beginrow;
int step1y = begincol;
int step2x = beginrow;
int step2y = begincol;
//顺时针和逆时针各走半个周长
//for (int i = 1; i < 4 * n - 1; i++)
{
int count1 = 0;
int count2 = 0;
MoveOneStep(detector, row, col, ref step1x, ref step1y, maxcol, ref speed1, direct, n, ref count1, handle);
MoveOneStep(detector, row, col, ref step2x, ref step2y, maxcol, ref speed2, direct, n, ref count2, handle);
}
//终点判断
if (endrow < maxcol && endcol < maxcol && endrow >= 0 && endcol >= 0)
{
TriggeLeafNode(detector, (uint)endrow, (uint)endcol, handle);
}
TriggerOneCircleNodes(detector, row, col, n + 1, direct, maxcol, handle);
}
private void TriggerToNodeByCamera(IDetector detector, TriggerHandle <T> handle, int depth, TreeCullingCode cullingCode, float centerx, float centerz, float sizex,
float sizez)
{
if (cullingCode.IsCulled())
{
return;
}
if (depth == m_MaxDepth)
{
uint m = Morton2FromWorldPos(centerx, centerz);
if (m_Nodes.ContainsKey(m) && m_Nodes[m] != null)
{
m_Nodes[m].Trigger(detector, handle);
}
}
else
{
float sx = sizex * 0.5f, sz = sizez * 0.5f;
int leftbottommiddle = detector.GetDetectedCode(centerx - sx, m_Bounds.min.y, centerz, true);
int middlebottommiddle = detector.GetDetectedCode(centerx, m_Bounds.min.y, centerz, true);
int rightbottommiddle = detector.GetDetectedCode(centerx + sx, m_Bounds.min.y, centerz, true);
int middlebottomback = detector.GetDetectedCode(centerx, m_Bounds.min.y, centerz - sz, true);
int middlebottomforward = detector.GetDetectedCode(centerx, m_Bounds.min.y, centerz + sz, true);
int lefttopmiddle = detector.GetDetectedCode(centerx - sx, m_Bounds.max.y, centerz, true);
int middletopmiddle = detector.GetDetectedCode(centerx, m_Bounds.max.y, centerz, true);
int righttopmiddle = detector.GetDetectedCode(centerx + sx, m_Bounds.max.y, centerz, true);
int middletopback = detector.GetDetectedCode(centerx, m_Bounds.max.y, centerz - sz, true);
int middletopforward = detector.GetDetectedCode(centerx, m_Bounds.max.y, centerz + sz, true);
TriggerToNodeByCamera(detector, handle, depth + 1, new TreeCullingCode()
{
leftbottomback = cullingCode.leftbottomback,
leftbottomforward = leftbottommiddle,
lefttopback = cullingCode.lefttopback,
lefttopforward = lefttopmiddle,
rightbottomback = middlebottomback,
rightbottomforward = middlebottommiddle,
righttopback = middletopback,
righttopforward = middletopmiddle,
}, centerx - sx * 0.5f, centerz - sz * 0.5f, sx, sz);
TriggerToNodeByCamera(detector, handle, depth + 1, new TreeCullingCode()
{
leftbottomback = leftbottommiddle,
leftbottomforward = cullingCode.leftbottomforward,
lefttopback = lefttopmiddle,
lefttopforward = cullingCode.lefttopforward,
rightbottomback = middlebottommiddle,
rightbottomforward = middlebottomforward,
righttopback = middletopmiddle,
righttopforward = middletopforward,
}, centerx - sx * 0.5f, centerz + sz * 0.5f, sx, sz);
TriggerToNodeByCamera(detector, handle, depth + 1, new TreeCullingCode()
{
leftbottomback = middlebottomback,
leftbottomforward = middlebottommiddle,
lefttopback = middletopback,
lefttopforward = middletopmiddle,
rightbottomback = cullingCode.rightbottomback,
rightbottomforward = rightbottommiddle,
righttopback = cullingCode.righttopback,
righttopforward = righttopmiddle,
}, centerx + sx * 0.5f, centerz - sz * 0.5f, sx, sz);
TriggerToNodeByCamera(detector, handle, depth + 1, new TreeCullingCode()
{
leftbottomback = middlebottommiddle,
leftbottomforward = middlebottomforward,
lefttopback = middletopmiddle,
lefttopforward = middletopforward,
rightbottomback = rightbottommiddle,
rightbottomforward = cullingCode.rightbottomforward,
righttopback = righttopmiddle,
righttopforward = cullingCode.righttopforward,
}, centerx + sx * 0.5f, centerz + sz * 0.5f, sx, sz);
}
}
public abstract void Trigger(IDetector detector, TriggerHandle <T> handle);
//深度遍历
private void TriggerOneNode(IDetector detector, uint row, uint col, int direct, uint maxcol, TriggerHandle <T> handle)
{
if (row < maxcol && col < maxcol)
{
TriggeLeafNode(detector, row, col, handle);
int[] nextDirs = DirectParams[direct];
for (int i = 0; i < nextDirs.Length; i++)
{
uint nrow = row + (uint)directs[nextDirs[i]].x;
uint ncol = col + (uint)directs[nextDirs[i]].y;
TriggerOneNode(detector, nrow, ncol, nextDirs[i], maxcol, handle);
}
}
}
public void Trigger(IDetector detector, TriggerHandle <T> handle)
{
m_Root.Trigger(detector, handle);
}
private void TriggerByCamera(IDetector detector, TriggerHandle <T> handle, TreeCullingCode code)
{
if (code.IsCulled())
{
return;
}
var node = m_ObjectList.First;
while (node != null)
{
if (detector.IsDetected(node.Value.Bounds))
{
handle(node.Value);
}
node = node.Next;
}
float centerx = m_Bounds.center.x, centery = m_Bounds.center.y, centerz = m_Bounds.center.z;
float sx = m_Bounds.size.x * 0.5f, sy = m_Bounds.size.y * 0.5f, sz = m_Bounds.size.z * 0.5f;
int leftbottommiddle = detector.GetDetectedCode(centerx - sx, centery - sy, centerz, true);
int middlebottommiddle = detector.GetDetectedCode(centerx, centery - sy, centerz, true);
int rightbottommiddle = detector.GetDetectedCode(centerx + sx, centery - sy, centerz, true);
int middlebottomback = detector.GetDetectedCode(centerx, centery - sy, centerz - sz, true);
int middlebottomforward = detector.GetDetectedCode(centerx, centery - sy, centerz + sz, true);
int lefttopmiddle = detector.GetDetectedCode(centerx - sx, centery + sy, centerz, true);
int middletopmiddle = detector.GetDetectedCode(centerx, centery + sy, centerz, true);
int righttopmiddle = detector.GetDetectedCode(centerx + sx, centery + sy, centerz, true);
int middletopback = detector.GetDetectedCode(centerx, centery + sy, centerz - sz, true);
int middletopforward = detector.GetDetectedCode(centerx, centery + sy, centerz + sz, true);
if (m_ChildCount == 8)
{
int leftmiddleback = detector.GetDetectedCode(centerx - sx, centery, centerz - sz, true);
int leftmiddlemiddle = detector.GetDetectedCode(centerx - sx, centery, centerz, true);
int leftmiddleforward = detector.GetDetectedCode(centerx - sx, centery, centerz + sz, true);
int middlemiddleback = detector.GetDetectedCode(centerx, centery, centerz - sz, true);
int middlemiddlemiddle = detector.GetDetectedCode(centerx, centery, centerz, true);
int middlemiddleforward = detector.GetDetectedCode(centerx, centery, centerz + sz, true);
int rightmiddleback = detector.GetDetectedCode(centerx + sx, centery, centerz - sz, true);
int rightmiddlemiddle = detector.GetDetectedCode(centerx + sx, centery, centerz, true);
int rightmiddleforward = detector.GetDetectedCode(centerx + sx, centery, centerz + sz, true);
if (m_ChildNodes.Length > 0 && m_ChildNodes[0] != null)
{
m_ChildNodes[0].TriggerByCamera(detector, handle, new TreeCullingCode()
{
leftbottomback = code.leftbottomback,
leftbottomforward = leftbottommiddle,
lefttopback = leftmiddleback,
lefttopforward = leftmiddlemiddle,
rightbottomback = middlebottomback,
rightbottomforward = middlebottommiddle,
righttopback = middlemiddleback,
righttopforward = middlemiddlemiddle,
});
}
if (m_ChildNodes.Length > 1 && m_ChildNodes[1] != null)
{
m_ChildNodes[1].TriggerByCamera(detector, handle, new TreeCullingCode()
{
leftbottomback = leftbottommiddle,
leftbottomforward = code.leftbottomforward,
lefttopback = leftmiddlemiddle,
lefttopforward = leftmiddleforward,
rightbottomback = middlebottommiddle,
rightbottomforward = middlebottomforward,
righttopback = middlemiddlemiddle,
righttopforward = middlemiddleforward,
});
}
if (m_ChildNodes.Length > 2 && m_ChildNodes[2] != null)
{
m_ChildNodes[2].TriggerByCamera(detector, handle, new TreeCullingCode()
{
leftbottomback = leftmiddleback,
leftbottomforward = leftmiddlemiddle,
lefttopback = code.lefttopback,
lefttopforward = lefttopmiddle,
rightbottomback = middlemiddleback,
rightbottomforward = middlemiddlemiddle,
righttopback = middletopback,
righttopforward = middletopmiddle,
});
}
if (m_ChildNodes.Length > 3 && m_ChildNodes[3] != null)
{
m_ChildNodes[3].TriggerByCamera(detector, handle, new TreeCullingCode()
{
leftbottomback = leftmiddlemiddle,
leftbottomforward = leftmiddleforward,
lefttopback = lefttopmiddle,
lefttopforward = code.lefttopforward,
rightbottomback = middlemiddlemiddle,
rightbottomforward = middlemiddleforward,
righttopback = middletopmiddle,
righttopforward = middletopforward,
});
}
if (m_ChildNodes.Length > 4 && m_ChildNodes[4] != null)
{
m_ChildNodes[4].TriggerByCamera(detector, handle, new TreeCullingCode()
{
leftbottomback = middlebottomback,
leftbottomforward = middlebottommiddle,
lefttopback = middlemiddleback,
lefttopforward = middlemiddlemiddle,
rightbottomback = code.rightbottomback,
rightbottomforward = rightbottommiddle,
righttopback = rightmiddleback,
righttopforward = rightmiddlemiddle,
});
}
if (m_ChildNodes.Length > 5 && m_ChildNodes[5] != null)
{
m_ChildNodes[5].TriggerByCamera(detector, handle, new TreeCullingCode()
{
leftbottomback = middlebottommiddle,
leftbottomforward = middlebottomforward,
lefttopback = middlemiddlemiddle,
lefttopforward = middlemiddleforward,
rightbottomback = rightbottommiddle,
rightbottomforward = code.rightbottomforward,
righttopback = rightmiddlemiddle,
righttopforward = rightmiddleforward,
});
}
if (m_ChildNodes.Length > 6 && m_ChildNodes[6] != null)
{
m_ChildNodes[6].TriggerByCamera(detector, handle, new TreeCullingCode()
{
leftbottomback = middlemiddleback,
leftbottomforward = middlemiddlemiddle,
lefttopback = middletopback,
lefttopforward = middletopmiddle,
rightbottomback = rightmiddleback,
rightbottomforward = rightmiddlemiddle,
righttopback = code.righttopback,
righttopforward = righttopmiddle,
});
}
if (m_ChildNodes.Length > 7 && m_ChildNodes[7] != null)
{
m_ChildNodes[7].TriggerByCamera(detector, handle, new TreeCullingCode()
{
leftbottomback = middlemiddlemiddle,
leftbottomforward = middlemiddleforward,
lefttopback = middletopmiddle,
lefttopforward = middletopforward,
rightbottomback = rightmiddlemiddle,
rightbottomforward = rightmiddleforward,
righttopback = righttopmiddle,
righttopforward = code.righttopforward,
});
}
}
else
{
if (m_ChildNodes.Length > 0 && m_ChildNodes[0] != null)
{
m_ChildNodes[0].TriggerByCamera(detector, handle, new TreeCullingCode()
{
leftbottomback = code.leftbottomback,
leftbottomforward = leftbottommiddle,
lefttopback = code.lefttopback,
lefttopforward = lefttopmiddle,
rightbottomback = middlebottomback,
rightbottomforward = middlebottommiddle,
righttopback = middletopback,
righttopforward = middletopmiddle,
});
}
if (m_ChildNodes.Length > 1 && m_ChildNodes[1] != null)
{
m_ChildNodes[1].TriggerByCamera(detector, handle, new TreeCullingCode()
{
leftbottomback = leftbottommiddle,
leftbottomforward = code.leftbottomforward,
lefttopback = lefttopmiddle,
lefttopforward = code.lefttopforward,
rightbottomback = middlebottommiddle,
rightbottomforward = middlebottomforward,
righttopback = middletopmiddle,
righttopforward = middletopforward,
});
}
if (m_ChildNodes.Length > 2 && m_ChildNodes[2] != null)
{
m_ChildNodes[2].TriggerByCamera(detector, handle, new TreeCullingCode()
{
leftbottomback = middlebottomback,
leftbottomforward = middlebottommiddle,
lefttopback = middletopback,
lefttopforward = middletopmiddle,
rightbottomback = code.rightbottomback,
rightbottomforward = rightbottommiddle,
righttopback = code.righttopback,
righttopforward = righttopmiddle,
});
}
if (m_ChildNodes.Length > 3 && m_ChildNodes[3] != null)
{
m_ChildNodes[3].TriggerByCamera(detector, handle, new TreeCullingCode()
{
leftbottomback = middlebottommiddle,
leftbottomforward = middlebottomforward,
lefttopback = middletopmiddle,
lefttopforward = middletopforward,
rightbottomback = rightbottommiddle,
rightbottomforward = code.rightbottomforward,
righttopback = righttopmiddle,
righttopforward = code.righttopforward,
});
}
}
}
