public static void Add(MyEntity entity) { Debug.Assert(entity.Parent == null, "Only topmost entities"); if (entity.TopMostPruningProxyId != MyVRageConstants.PRUNING_PROXY_ID_UNITIALIZED) { return; // already inserted } BoundingBoxD bbox = GetEntityAABB(entity); if (bbox.Size == Vector3D.Zero) { return; // don't add entities with zero bounding boxes } if (IsEntityStatic(entity)) { entity.TopMostPruningProxyId = m_staticObjectsTree.AddProxy(ref bbox, entity, 0); entity.StaticForPruningStructure = true; } else { entity.TopMostPruningProxyId = m_dynamicObjectsTree.AddProxy(ref bbox, entity, 0); entity.StaticForPruningStructure = false; } var voxelMap = entity as MyVoxelBase; if (voxelMap != null) { voxelMap.VoxelMapPruningProxyId = m_voxelMapsTree.AddProxy(ref bbox, entity, 0); } }
protected void GenerateObjectSeeds(ref BoundingSphereD sphere) { ProfilerShort.Begin("GenerateObjectSeedsInBox"); BoundingBoxD box = BoundingBoxD.CreateFromSphere(sphere); Vector3I cellId = Vector3I.Floor(box.Min / CELL_SIZE); for (var iter = GetCellsIterator(sphere); iter.IsValid(); iter.GetNext(out cellId)) { if (m_cells.ContainsKey(cellId)) { continue; } var cellBox = new BoundingBoxD(cellId * CELL_SIZE, (cellId + 1) * CELL_SIZE); if (sphere.Contains(cellBox) == ContainmentType.Disjoint) { continue; } var cell = GenerateProceduralCell(ref cellId); if (cell != null) { m_cells.Add(cellId, cell); var cellBBox = cell.BoundingVolume; cell.proxyId = m_cellsTree.AddProxy(ref cellBBox, cell, 0); } } ProfilerShort.End(); }
private int ConcealGroup(ConcealGroup group) { if (ConcealedGroups.Any(g => g.Id == group.Id)) { return(0); } Log.Debug($"Concealing grids: {group.GridNames}"); group.Conceal(); foreach (var entity in group.Grids) { entity.GetStorage().SetValue(Id, "True"); } group.UpdateAABB(); var aabb = group.WorldAABB; group.ProxyId = _concealedAabbTree.AddProxy(ref aabb, group, 0); group.Closing += Group_Closing; Task.Run(() => { group.UpdatePostConceal(); Log.Debug($"Group {group.Id} cached"); group.IsConcealed = true; Torch.Invoke(() => ConcealedGroups.Add(group)); }); return(group.Grids.Count); }
public void Add(ref BoundingBoxD box, T obj, uint flags = 0) { boxes[indexes[obj] = tree.AddProxy(ref box, obj, flags)] = new AABBKeeper() { Box = box }; }
/// <summary> /// Generates all Cells data that are within sphere, if they have not been generated. /// </summary> /// <param name="sphere">Bounding Sphere of the cells to generate</param> protected void GenerateObjectsData(ref BoundingSphereD sphere) { BoundingBoxD box = BoundingBoxD.CreateFromSphere(sphere); Vector3I cellId = Vector3I.Floor(box.Min / CELL_SIZE); for (var it = GetCellsIterator(sphere); it.IsValid(); it.GetNext(out cellId)) { if (m_cells.ContainsKey(cellId)) { continue; } BoundingBoxD cellBounds = new BoundingBoxD(cellId * CELL_SIZE, (cellId + 1) * CELL_SIZE); if (!(sphere.Contains(cellBounds) != ContainmentType.Disjoint)) { continue; } MyProceduralCell cell = GenerateCell(ref cellId); if (cell != null) { m_cells.Add(cellId, cell); BoundingBoxD aabb = cell.BoundingVolume; cell.proxyId = m_cellsTree.AddProxy(ref aabb, cell, 0u); } } }
public static void AddPlaceArea(MyPlaceArea area) { if (area.PlaceAreaProxyId == MyConstants.PRUNING_PROXY_ID_UNITIALIZED) { BoundingBoxD box = area.PositionComp.WorldAABB; area.PlaceAreaProxyId = m_aabbTree.AddProxy(ref box, area, 0); } }
public static void AddBroadcaster(MyRadioBroadcaster broadcaster) { if (broadcaster.RadioProxyID == MyConstants.PRUNING_PROXY_ID_UNITIALIZED) { BoundingBoxD box = BoundingBoxD.CreateFromSphere(new BoundingSphereD(broadcaster.BroadcastPosition, broadcaster.BroadcastRadius)); broadcaster.RadioProxyID = m_aabbTree.AddProxy(ref box, broadcaster, 0); } }
internal bool OnAddedToScene(MyClipmapCellProxy cellProxy) { if (!IsUsed()) { return(false); } bool lodAabbChanged = false; int rootProxy = m_boundingBoxes.GetRoot(); BoundingBoxD lodAabbBefore = BoundingBoxD.CreateInvalid(); if (rootProxy != -1) { lodAabbBefore = m_boundingBoxes.GetAabb(rootProxy); } BoundingBoxD cellAabb = (BoundingBoxD)cellProxy.LocalAabb; m_cellProxyToAabbProxy.Add(cellProxy, m_boundingBoxes.AddProxy(ref cellAabb, null, 0)); if (rootProxy != -1) { BoundingBoxD lodAabbAfter = m_boundingBoxes.GetAabb(rootProxy); lodAabbChanged = lodAabbBefore.Equals(lodAabbAfter); } if (lodAabbChanged) { InvalidateAllMergedMeshesInLod(); } Vector3D translation = cellProxy.Translation; int divideIndex = GetDivideIndex(ref translation); m_trackedActors[divideIndex].Add(cellProxy.Actor); MyMergedLodMeshId mergedLodMeshId = MyMeshes.GetMergedLodMesh(m_mergedLodMeshProxies[divideIndex].MeshId, 0); LodMeshId lodMeshToMerge = MyMeshes.GetLodMesh(cellProxy.MeshId, 0); bool mergedMesh = mergedLodMeshId.MergeLodMesh(lodMeshToMerge); if (mergedMesh) { InvalidateAllMergedMeshesInLod(); } TryCancelMergeJob(divideIndex, MeshId.NULL); bool startedMerge = TryStartMergeJob(divideIndex, 1000); bool shouldMarkDirty = !mergedMesh && !startedMerge; if (shouldMarkDirty) { m_dirtyProxyIndices.Add(divideIndex); } return(shouldMarkDirty); }
public void AddShield(DefenseShields shield) { if (shield.DtreeProxyId != -1) { return; } BoundingBoxD worldAabb = shield.WebBox; shield.DtreeProxyId = _aabbTree.AddProxy(ref worldAabb, shield, 0U, true); }
private bool AddToTree(ProceduralObject t) { if (t.m_proxyID != -1) { return(false); } t.m_proxyID = m_tree.AddProxy(ref t.m_boundingBox, t, 0); t.OnMoved += ObjectMoved; t.OnRemoved += RemoveFromTree; return(true); }
override protected void AddRoot(IMyReplicable replicable) { System.Diagnostics.Debug.Assert(!replicable.HasToBeChild, "Cannot add children replicables to root!"); m_roots.Add(replicable); BoundingBoxD aabb = replicable.GetAABB(); m_proxies.Add(replicable, m_rootsAABB.AddProxy(ref aabb, replicable, 0)); replicable.OnAABBChanged += OnRootMoved; }
public static void AddBroadcaster(MyRadioBroadcaster broadcaster) { if (broadcaster.Parent is MyCubeBlock) { MyCubeGrid grid = (broadcaster.Parent as MyCubeBlock).CubeGrid; Debug.Assert(grid.InScene, "adding broadcaster when grid is not in scene"); } if (broadcaster.RadioProxyID == MyConstants.PRUNING_PROXY_ID_UNITIALIZED) { BoundingBoxD box = BoundingBoxD.CreateFromSphere(new BoundingSphereD(broadcaster.BroadcastPosition, broadcaster.BroadcastRadius)); broadcaster.RadioProxyID = m_aabbTree.AddProxy(ref box, broadcaster, 0); } }
public static void Add(MyEntity entity) { if (entity.GamePruningProxyId != MyConstants.PRUNING_PROXY_ID_UNITIALIZED) { return; // already inserted } BoundingBoxD bbox = GetEntityAABB(entity); if (bbox.Size == Vector3D.Zero) { return; // don't add entities with zero bounding boxes } entity.GamePruningProxyId = m_aabbTree.AddProxy(ref bbox, entity, 0); bool isTarget = false; if (MyFakes.SHOW_FACTIONS_GUI) { var moduleOwner = entity as IMyComponentOwner <MyIDModule>; MyIDModule module; if (moduleOwner != null && moduleOwner.GetComponent(out module)) { isTarget = true; } } foreach (var targetType in TargetTypes) { if (targetType == entity.GetType()) { isTarget = true; break; } } if (isTarget) { entity.TargetPruningProxyId = m_targetsTree.AddProxy(ref bbox, entity, 0); } if (SensableTypes.Contains(entity.GetType())) { entity.SensablePruningProxyId = m_sensableTree.AddProxy(ref bbox, entity, 0); } var voxelMap = entity as MyVoxelMap; if (voxelMap != null) { voxelMap.VoxelMapPruningProxyId = m_voxelMapsTree.AddProxy(ref bbox, entity, 0); } }
private void EnsureDetector(string researchKey, Ob_Trigger_Location trigger) { var key = new ResearchStatefulKey(researchKey, trigger.StateStorageKey); if (_detectors.ContainsKey(key)) { return; } var data = new DetectorData(key, trigger); _detectors.Add(key, data); var aabb = BoundingBoxD.CreateFromSphere(data.Detector); data.Handle = _detectorTree.AddProxy(ref aabb, data, 0); }
internal static int UpdateBvh(MyDynamicAABBTreeD bvh, LightId lid, bool enabled, int proxy, ref BoundingBoxD aabb) { if (enabled && proxy == -1) { return(bvh.AddProxy(ref aabb, lid, 0)); } else if (enabled && proxy != -1) { bvh.MoveProxy(proxy, ref aabb, Vector3.Zero); return(proxy); } else { bvh.RemoveProxy(proxy); } return(-1); }
public void Add(AABBEntity entity) { int proxyId = GetProxyIdForEntity(entity); Log.Trace("Add entity " + proxyId, "Add"); BoundingBoxD bbox = GetEntityAABB(entity); if (bbox.Size == Vector3D.Zero) { return; // don't add entities with zero bounding boxes } int newProxyId = MathTree.AddProxy(ref bbox, entity, 0); SetProxyIdForEntity(entity, newProxyId); Log.Trace("Finished Add entity " + newProxyId, "Add"); }
private MyCluster CreateCluster(ref BoundingBoxD clusterBB) { MyCluster cluster = new MyCluster() { AABB = clusterBB, Objects = new HashSet <ulong>() }; cluster.ClusterId = m_clusterTree.AddProxy(ref cluster.AABB, cluster, 0); if (OnClusterCreated != null) { cluster.UserData = OnClusterCreated(cluster.ClusterId, cluster.AABB); } m_clusters.Add(cluster); m_userObjects.Add(cluster.UserData); return(cluster); }
private MyCluster CreateCluster(ref BoundingBoxD clusterBB) { MyCluster cluster = new MyCluster() //Center = {X:-10968.2552425968 Y:-3958.99401506744 Z:-188.682065703847} Max = {X:11118.0759795131 Y:11202.10024965 Z:11287.440539642}Min = {X:-33054.5864647067 Y:-19120.0882797849 Z:-11664.8046710497} { AABB = clusterBB, Objects = new HashSet <ulong>() }; cluster.ClusterId = m_clusterTree.AddProxy(ref cluster.AABB, cluster, 0); if (OnClusterCreated != null) { cluster.UserData = OnClusterCreated(cluster.ClusterId, cluster.AABB); } m_clusters.Add(cluster); m_userObjects.Add(cluster.UserData); return(cluster); }
public void AddChildEntity(MyEntity child) { if (MyFakes.ENABLE_PLANET_HIERARCHY) { var bbox = child.PositionComp.WorldAABB; ProfilerShort.Begin("Add sector to tree."); int proxyId = m_sectors.AddProxy(ref bbox, child, 0); ProfilerShort.BeginNextBlock("Add to child hierarchy."); Hierarchy.AddChild(child, true); ProfilerShort.End(); MyHierarchyComponentBase childHierarchy = child.Components.Get <MyHierarchyComponentBase>(); childHierarchy.ChildId = proxyId; } else { MyEntities.Add(child); } }
/// <summary> /// Generates all marked to be loaded cells seeds /// </summary> public void LoadCells() { m_toLoadCells.ApplyAdditions(); foreach (var cellId in m_toLoadCells) { if (m_loadedCells.ContainsKey(cellId)) { continue; } MyProceduralCell cell = GenerateCellSeeds(cellId); if (cell != null) { m_loadedCells.Add(cellId, cell); BoundingBoxD aabb = cell.BoundingVolume; cell.proxyId = m_cellsTree.AddProxy(ref aabb, cell, 0u); } } m_toLoadCells.Clear(); }
public static void Add(MyEntity entity) { Debug.Assert(entity.Parent == null, "Only topmost entities"); if (entity.TopMostPruningProxyId != MyConstants.PRUNING_PROXY_ID_UNITIALIZED) { return; // already inserted } BoundingBoxD bbox = GetEntityAABB(entity); if (bbox.Size == Vector3D.Zero) { return; // don't add entities with zero bounding boxes } entity.TopMostPruningProxyId = m_topMostEntitiesTree.AddProxy(ref bbox, entity, 0); var voxelMap = entity as MyVoxelBase; if (voxelMap != null) { voxelMap.VoxelMapPruningProxyId = m_voxelMapsTree.AddProxy(ref bbox, entity, 0); } }
internal static int UpdateBvh(MyDynamicAABBTreeD bvh, LightId lid, bool enabled, int proxy, ref BoundingBoxD aabb) { if(enabled && proxy == -1) { return bvh.AddProxy(ref aabb, lid, 0); } else if(enabled && proxy != -1) { bvh.MoveProxy(proxy, ref aabb, Vector3.Zero); return proxy; } else { bvh.RemoveProxy(proxy); } return -1; }
public ulong AddObject(BoundingBoxD bbox, Vector3 velocity, IMyActivationHandler activationHandler, ulong?customId) { if (SingleCluster.HasValue && m_clusters.Count == 0) { BoundingBoxD bb = SingleCluster.Value; bb.Inflate(200); //inflate 200m so objects near world border have AABB inside => physics created CreateCluster(ref bb); } BoundingBoxD inflatedBBox; if (SingleCluster.HasValue) { inflatedBBox = bbox; } else { inflatedBBox = bbox.GetInflated(MinimumDistanceFromBorder); } m_clusterTree.OverlapAllBoundingBox(ref inflatedBBox, m_returnedClusters); MyCluster cluster = null; bool needReorder = false; if (m_returnedClusters.Count == 1) { if (m_returnedClusters[0].AABB.Contains(inflatedBBox) == ContainmentType.Contains) { cluster = m_returnedClusters[0]; } else if (m_returnedClusters[0].AABB.Contains(inflatedBBox) == ContainmentType.Intersects && activationHandler.IsStaticForCluster) { if (m_returnedClusters[0].AABB.Contains(bbox) == ContainmentType.Disjoint) { //completely out } else { cluster = m_returnedClusters[0]; } } else { needReorder = true; } } else if (m_returnedClusters.Count > 1) { needReorder = true; } else if (m_returnedClusters.Count == 0) { if (!activationHandler.IsStaticForCluster) { var clusterBB = new BoundingBoxD(bbox.Center - IdealClusterSize / 2, bbox.Center + IdealClusterSize / 2); m_clusterTree.OverlapAllBoundingBox(ref clusterBB, m_returnedClusters); if (m_returnedClusters.Count == 0) { //Space is empty, create new cluster m_staticTree.OverlapAllBoundingBox(ref clusterBB, m_objectDataResultList); cluster = CreateCluster(ref clusterBB); foreach (var ob in m_objectDataResultList) { System.Diagnostics.Debug.Assert(m_objectsData[ob].Cluster == null, "Found object must not be in cluster!"); AddObjectToCluster(cluster, ob, false); } } else //There is still some blocking cluster { needReorder = true; } } } ulong objectId = customId.HasValue ? customId.Value : m_clusterObjectCounter++; int staticObjectId = MyDynamicAABBTreeD.NullNode; m_objectsData[objectId] = new MyObjectData() { Id = objectId, Cluster = cluster, ActivationHandler = activationHandler, AABB = bbox, StaticId = staticObjectId }; System.Diagnostics.Debug.Assert(!needReorder || (!SingleCluster.HasValue && needReorder), "Object cannot be added outside borders of a single cluster"); if (needReorder && !SingleCluster.HasValue) { System.Diagnostics.Debug.Assert(cluster == null, "Error in cluster logic"); ReorderClusters(bbox, objectId); if (!m_objectsData[objectId].ActivationHandler.IsStaticForCluster) { System.Diagnostics.Debug.Assert(m_objectsData[objectId].Cluster != null, "Object not added"); } #if DEBUG m_clusterTree.OverlapAllBoundingBox(ref bbox, m_returnedClusters); System.Diagnostics.Debug.Assert(m_returnedClusters.Count <= 1, "Clusters overlap!"); if (m_returnedClusters.Count != 0) { System.Diagnostics.Debug.Assert(activationHandler.IsStaticForCluster ? m_returnedClusters[0].AABB.Contains(inflatedBBox) != ContainmentType.Disjoint : m_returnedClusters[0].AABB.Contains(inflatedBBox) == ContainmentType.Contains, "Clusters reorder failure!"); } #endif } if (activationHandler.IsStaticForCluster) { staticObjectId = m_staticTree.AddProxy(ref bbox, objectId, 0); m_objectsData[objectId].StaticId = staticObjectId; } if (cluster != null) { return(AddObjectToCluster(cluster, objectId, false)); } else { return(objectId); } }
public void AddObject(MyObjectSeed objectSeed) { var bbox = objectSeed.BoundingVolume; objectSeed.m_proxyId = m_tree.AddProxy(ref bbox, objectSeed, 0); }