private void ProcessBatch() { foreach (var modifyModel in m_batchedModifyItems) { ModifyItemModel(modifyModel.LocalId, modifyModel.LocalModelId, false, false); } if (Physics != null) { Physics.ContactPointCallback -= Physics_ContactPointCallback; Physics.Close(); Physics = null; } BoundingBoxD aabbWorld = BoundingBoxD.CreateInvalid(); Dictionary <MyStringHash, HkShape> subtypeIdToShape = new Dictionary <MyStringHash, HkShape>(MyStringHash.Comparer); HkStaticCompoundShape sectorRootShape = new HkStaticCompoundShape(HkReferencePolicy.None); m_physicsShapeInstanceIdToLocalId.Clear(); m_localIdToPhysicsShapeInstanceId.Clear(); foreach (var item in m_itemsData) { if (!item.Value.Enabled) { continue; } int physicsShapeInstanceId; var data = item.Value; int modelId = data.ModelId; MyModel model = MyModels.GetModelOnlyData(MyModel.GetById(modelId)); var matrix = data.Transform.TransformMatrix; aabbWorld.Include(model.BoundingBox.Transform(matrix)); if (AddPhysicsShape(data.SubtypeId, model, ref matrix, sectorRootShape, subtypeIdToShape, out physicsShapeInstanceId)) { m_physicsShapeInstanceIdToLocalId[physicsShapeInstanceId] = item.Key; m_localIdToPhysicsShapeInstanceId[item.Key] = physicsShapeInstanceId; } } foreach (var item in m_batchedAddItems) { var matrix = MatrixD.CreateWorld(item.Position, Vector3D.Forward, Vector3D.Up); var definition = m_definition.GetItemDefinition(item.SubtypeId); AddItem(definition, ref matrix, ref aabbWorld, sectorRootShape, subtypeIdToShape, item.LocalModelId); } PrepareItemsPhysics(sectorRootShape, ref aabbWorld); PrepareItemsGraphics(); foreach (var pair in subtypeIdToShape) { pair.Value.RemoveReference(); } subtypeIdToShape.Clear(); }
private bool IsPlayerNearby() { BoundingBoxD playerBox = BoundingBoxD.CreateInvalid(); Sandbox.Game.Entities.MyEntities.GetInflatedPlayerBoundingBox(ref playerBox, 2000f); return(playerBox.Contains(base.ShipController.PositionComp.GetPosition()) == ContainmentType.Contains); }
protected void UpdateRenderObject() { m_actualWorldAABB = BoundingBoxD.CreateInvalid(); if (AnimationController.CharacterBones != null) { for (int i = 1; i < Model.Bones.Length; i++) { Vector3D p1 = Vector3D.Transform(AnimationController.CharacterBones[i].Parent.AbsoluteTransform.Translation, WorldMatrix); Vector3D p2 = Vector3D.Transform(AnimationController.CharacterBones[i].AbsoluteTransform.Translation, WorldMatrix); m_actualWorldAABB.Include(ref p1); m_actualWorldAABB.Include(ref p2); } } ContainmentType containmentType; m_aabb.Contains(ref m_actualWorldAABB, out containmentType); if (containmentType != ContainmentType.Contains) { m_actualWorldAABB.Inflate(0.5f); MatrixD worldMatrix = WorldMatrix; VRageRender.MyRenderProxy.UpdateRenderObject(Render.RenderObjectIDs[0], ref worldMatrix, false, m_actualWorldAABB); m_aabb = m_actualWorldAABB; } }
private static void CalculateAABB(ref BoundingBoxD bbox, out float scaleZ, out float scaleXY, Vector3D position, Vector3 direction, Vector3 up, float reflectorConeMaxAngleCos, float reflectorRange) { float cosAngle = 1 - reflectorConeMaxAngleCos; scaleZ = reflectorRange; // Calculate cone side (hypotenuse of triangle) float side = reflectorRange / cosAngle; // Calculate cone bottom scale (Pythagoras theorem) scaleXY = (float)System.Math.Sqrt(side * side - reflectorRange * reflectorRange) * 2; Vector3 coneSideDirection = Vector3.Cross(up, direction); coneSideDirection = MyUtils.Normalize(coneSideDirection); Vector3D coneCenter = position + direction * scaleZ; Vector3D pt1 = coneCenter + coneSideDirection * scaleXY / 2 + up * scaleXY / 2; Vector3D pt2 = coneCenter - coneSideDirection * scaleXY / 2 + up * scaleXY / 2; Vector3D pt3 = coneCenter + coneSideDirection * scaleXY / 2 - up * scaleXY / 2; Vector3D pt4 = coneCenter - coneSideDirection * scaleXY / 2 - up * scaleXY / 2; bbox = BoundingBoxD.CreateInvalid(); bbox = bbox.Include(ref position); //bbox = bbox.Include(ref coneCenter); bbox = bbox.Include(ref pt1); bbox = bbox.Include(ref pt2); bbox = bbox.Include(ref pt3); bbox = bbox.Include(ref pt4); }
public ConstructionCopy(ProceduralRoom room, RoomRemapper remapper = null) { Logger = room.Owner.Logger.Root().CreateProxy(GetType().Name); var i = room.Part.PrimaryGrid; var o = new MyObjectBuilder_CubeGrid { GridSizeEnum = i.GridSizeEnum, IsStatic = true, DampenersEnabled = true, Handbrake = true, DisplayName = room.Owner.Seed.Name, DestructibleBlocks = true, IsRespawnGrid = false, Editable = true, PersistentFlags = MyPersistentEntityFlags2.Enabled | MyPersistentEntityFlags2.InScene | MyPersistentEntityFlags2.CastShadows, PositionAndOrientation = new MyPositionAndOrientation(GridCreator.WorldTransformFor(room.Owner)) }; BoundingBox = BoundingBoxD.CreateInvalid(); Construction = room.Owner; PrimaryGrid = o; AuxGrids = new List <MyObjectBuilder_CubeGrid>(); m_remapper = remapper ?? new RoomRemapper(Logger.Root()); var iwatch = new Stopwatch(); m_remapper.Remap(room, this); Logger.Debug("Added room {3} of {0} blocks with {1} aux grids in {2}", room.Part.PrimaryGrid.CubeBlocks.Count, room.Part.Prefab.CubeGrids.Length - 1, iwatch.Elapsed, room.Part.Name); }
protected static void DrawRemovingCubes(Vector3I?startRemove, Vector3I?continueBuild, MySlimBlock removeBlock) { if (startRemove == null || continueBuild == null || removeBlock == null) { return; } Color white = Color.White; Vector3I stepDelta; Vector3I counter; int stepCount; ComputeSteps(startRemove.Value, continueBuild.Value, Vector3I.One, out stepDelta, out counter, out stepCount); var matrix = removeBlock.CubeGrid.WorldMatrix; BoundingBoxD aabb = BoundingBoxD.CreateInvalid(); aabb.Include((startRemove.Value * removeBlock.CubeGrid.GridSize)); aabb.Include((continueBuild.Value * removeBlock.CubeGrid.GridSize)); aabb.Min -= new Vector3(removeBlock.CubeGrid.GridSize / 2.0f + 0.02f); aabb.Max += new Vector3(removeBlock.CubeGrid.GridSize / 2.0f + 0.02f); MySimpleObjectDraw.DrawTransparentBox(ref matrix, ref aabb, ref white, MySimpleObjectRasterizer.Wireframe, counter, 0.04f, null, "GizmoDrawLineRed", true); Color faceColor = new Color(Color.Red * 0.2f, 0.3f); MySimpleObjectDraw.DrawTransparentBox(ref matrix, ref aabb, ref faceColor, MySimpleObjectRasterizer.Solid, 0, 0.04f, "Square", null, true); }
public MyRenderBatch(uint id, string debugName, MatrixD worldMatrix, RenderFlags renderFlags, List <MyRenderBatchPart> batchParts) : base(id, debugName, worldMatrix, renderFlags) { m_localAABB = BoundingBoxD.CreateInvalid(); m_batchParts.Clear(); m_batchParts.AddList(batchParts); }
private static void SendGlobalOutputMessages() { ProfilerShort.Begin("SendGlobalOutputMessages"); ProfilerShort.Begin("Root"); foreach (var groupRootComponent in MyComponentFactory <MyGroupRootComponent> .GetAll()) { if (true) { BoundingBoxD bb = BoundingBoxD.CreateInvalid(); foreach (var child in groupRootComponent.m_children) { if (child.IsVisible) { bb.Include(child.Aabb); } } if (MyRender11.Environment.ViewFrustumClippedD.Contains(bb) != VRageMath.ContainmentType.Disjoint) { MyRenderProxy.VisibleObjectsWrite.Add(groupRootComponent.Owner.ID); } } } ProfilerShort.BeginNextBlock("Clipmap"); foreach (var id in MyClipmapFactory.ClipmapByID.Keys) { MyRenderProxy.VisibleObjectsWrite.Add(id); } ProfilerShort.End(); ProfilerShort.End(); }
protected static bool TestBlockPlacementArea(MySlimBlock block, ref MyGridPlacementSettings settings, bool dynamicMode) { var localAabb = BoundingBoxD.CreateInvalid(); localAabb.Include(block.Min * block.CubeGrid.GridSize - block.CubeGrid.GridSize / 2); localAabb.Include(block.Max * block.CubeGrid.GridSize + block.CubeGrid.GridSize / 2); return(MyCubeGrid.TestBlockPlacementArea(block.BlockDefinition, block.Orientation, block.CubeGrid.WorldMatrix, ref settings, localAabb, dynamicMode, ignoredEntity: block.CubeGrid)); }
protected static bool TestVoxelPlacement(MySlimBlock block, ref MyGridPlacementSettings settings, bool dynamicMode) { var localAabb = BoundingBoxD.CreateInvalid(); localAabb.Include(block.Min * block.CubeGrid.GridSize - block.CubeGrid.GridSize / 2); localAabb.Include(block.Max * block.CubeGrid.GridSize + block.CubeGrid.GridSize / 2); return(MyCubeGrid.TestVoxelPlacement(block.BlockDefinition, settings, dynamicMode, block.CubeGrid.WorldMatrix, localAabb)); }
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); }
private static bool IntersectsVoxelSurface(OrientedBoundingBoxD box) { var data = VoxelData; using (PoolManager.Get(out List <MyEntity> entities)) { MyGamePruningStructure.GetTopmostEntitiesInBox(box.GetAABB(), entities, MyEntityQueryType.Static); foreach (var ent in entities) { if (ent is MyVoxelBase voxel && !(ent is MyVoxelPhysics)) { var invWorld = voxel.PositionComp.WorldMatrixInvScaled; var storageBounds = BoundingBoxD.CreateInvalid(); var voxelOffset = (voxel.Size >> 1) + voxel.StorageMin; var storageObb = box; storageObb.Transform(invWorld); storageObb.HalfExtent /= voxel.VoxelSize; storageObb.Center = storageObb.Center / voxel.VoxelSize + voxelOffset; storageBounds.Include(storageObb.GetAABB()); var storageMin = Vector3I.Max(Vector3I.Floor(storageBounds.Min), voxel.StorageMin); var storageMax = Vector3I.Min(Vector3I.Ceiling(storageBounds.Max), voxel.StorageMax); var localBox = new BoundingBoxI(storageMin, storageMax); localBox.Inflate(1); var floatBox = new BoundingBox(localBox); if (voxel.IntersectStorage(ref floatBox) == ContainmentType.Disjoint) { continue; } data.Resize(storageMin, storageMax); voxel.Storage.ReadRange(data, MyStorageDataTypeFlags.Content, 0, storageMin, storageMax); foreach (var pt in new BoundingBoxI(Vector3I.Zero, storageMax - storageMin).EnumeratePoints()) { var voxelBox = new BoundingBoxD(storageMin + pt, storageMin + pt + 1); var containment = storageObb.Contains(ref voxelBox); if (containment == ContainmentType.Disjoint) { continue; } var tmpPt = pt; var index = data.ComputeLinear(ref tmpPt); var content = data.Content(index); if (containment == ContainmentType.Intersects && content >= 127) { return(true); } if (containment == ContainmentType.Contains && content > 0) { return(true); } } } } } return(false); }
private void CalculateShape() { if (!Definition.RequiredSupport.HasValue) { return; } var shape = Definition.RequiredSupport.Value; var edge = _bendy.Edges.FirstOrDefault(); var curve = edge?.Curve; if (curve == null) { return; } _shapeDirty = false; _localBox = BoundingBoxD.CreateInvalid(); for (var i = 0; i < shape.Segments; i++) { Matrix matrix; { var t = (i + 0.5f) / shape.Segments; var pos = (Vector3)Vector3D.Transform(curve.Sample(t), Entity.PositionComp.WorldMatrixNormalizedInv); var up = Vector3.TransformNormal(Vector3.Lerp((Vector3)edge.From.Up, (Vector3)edge.To.Up, t), Entity.PositionComp.WorldMatrixNormalizedInv); var tan = Vector3.TransformNormal((Vector3)curve.SampleDerivative(t), Entity.PositionComp.WorldMatrixNormalizedInv); tan.Normalize(); up.Normalize(); matrix = Matrix.CreateWorld(Vector3.Zero, tan, up); } var box = BoundingBox.CreateInvalid(); var mi = Entity.PositionComp.WorldMatrixNormalizedInv * (MatrixD)Matrix.Invert(ref matrix); for (var j = 0; j <= 1; j++) { var t = (i + j) / (float)shape.Segments; var pos = curve.Sample(t); var up = Vector3.Lerp((Vector3)edge.From.Up, (Vector3)edge.To.Up, t); var tan = (Vector3)curve.SampleDerivative(t); var norm = Vector3.Cross(up, tan); norm.Normalize(); var nl = (Vector3)Vector3D.TransformNormal(norm, ref mi); var ul = (Vector3)Vector3D.TransformNormal(up, ref mi); var pl = (Vector3)Vector3D.Transform(pos, ref mi); box.Include(pl + nl * shape.HalfWidth + ul * shape.VerticalOffset); box.Include(pl - nl * shape.HalfWidth + ul * shape.VerticalOffset); } var obb = new OrientedBoundingBox(Vector3.Transform(box.Center, matrix), box.HalfExtents, Quaternion.CreateFromRotationMatrix(matrix)); _localBox = _localBox.Include(obb.GetAABB()); } }
internal static BoundingBoxD MakeAabbFromSpotlightCone(ref MySpotlightInfo spotlight, Vector3D position) { float ratio = (float)Math.Sqrt(1 - spotlight.ApertureCos * spotlight.ApertureCos) / spotlight.ApertureCos; float h = ratio * spotlight.Range; var bb = BoundingBoxD.CreateInvalid(); bb.Include(new Vector3D(-h, -h, 0)); bb.Include(new Vector3D(h, h, -spotlight.Range)); return(bb.Transform(MatrixD.CreateLookAtInverse(position, position + spotlight.Direction, spotlight.Up))); }
public override void UpdateWorldAABB() { m_aabb = BoundingBoxD.CreateInvalid(); var pointA = (Vector3D)m_pointA; var pointB = (Vector3D)m_pointB; m_aabb.Include(ref pointA); m_aabb.Include(ref pointB); m_aabb.Inflate(0.25); m_aabb.Translate(m_worldPosition); base.UpdateWorldAABB(); }
void UpdateBoundingFrustum() { // Update frustum BoundingFrustum.Matrix = ViewProjectionMatrix; // Update bounding box BoundingBox = BoundingBoxD.CreateInvalid(); BoundingBox.Include(ref BoundingFrustum); // Update bounding sphere BoundingSphere = MyUtils.GetBoundingSphereFromBoundingBox(ref BoundingBox); }
internal void UpdateBeforeDraw() { if (m_dirtyProxy) { RebuildProxies(); } foreach (var val in m_materialGroups.Values) { var index = val.m_index; val.UpdateProxyVerticesNum(ref m_proxy.Proxies[index]); } if (m_dirtyPosition) { foreach (var val in m_materialGroups.Values) { val.UpdateAll(); } m_dirtyPosition = false; } if (m_dirtyTree) { var bb = BoundingBoxD.CreateInvalid(); foreach (var child in m_children) { if (child.m_visible && child.GetRenderable() != null && !child.GetRenderable().IsRendered) { bb.Include(child.Aabb); } } m_owner.Aabb = bb; if (m_materialGroups.Count > 0) { if (m_btreeProxy == -1) { m_btreeProxy = MyScene.GroupsDBVH.AddProxy(ref m_owner.Aabb, m_proxy, 0); } else { MyScene.GroupsDBVH.MoveProxy(m_btreeProxy, ref m_owner.Aabb, Vector3.Zero); } } m_dirtyTree = false; } }
internal void Construct() { m_components.Clear(); m_visible = true; m_renderProxyDirty = true; m_ID = new MyIDTracker <MyActor>(); m_localAabb = null; m_relativeTransform = null; Aabb = BoundingBoxD.CreateInvalid(); }
internal void Construct() { m_components.Clear(); m_visible = true; MyUtils.Init(ref m_ID); m_ID.Clear(); LocalAabb = null; RelativeTransform = null; Aabb = BoundingBoxD.CreateInvalid(); }
public bool GetIslandAABBForEntity(IMyEntity entity, out BoundingBoxD aabb) { int islandIndex; aabb = BoundingBoxD.CreateInvalid(); if (m_rootEntityIslandIndex.TryGetValue(entity, out islandIndex)) { aabb = m_rootIslands[islandIndex].AABB; return(true); } return(false); }
public void Update() { m_actualWorldAABB = BoundingBoxD.CreateInvalid(); ContainmentType containmentType; m_aabb.Contains(ref m_actualWorldAABB, out containmentType); if (containmentType != ContainmentType.Contains) { SetDirty(); MyRender.UpdateRenderObject(this, false); } }
private static void VoxelReading() { var camera = MySector.MainCamera; if (camera == null) { return; } var offset = 0; // MyVoxelConstants.VOXEL_SIZE_IN_METRES_HALF; var targetPosition = camera.Position + (Vector3D)camera.ForwardVector * 4.5f - offset; MyVoxelBase targetVoxelMap = null; foreach (var voxelMap in MySession.Static.VoxelMaps.Instances) { if (voxelMap.PositionComp.WorldAABB.Contains(targetPosition) == ContainmentType.Contains) { targetVoxelMap = voxelMap; break; } } if (targetVoxelMap == null) { return; } var targetMin = targetPosition - Vector3.One * MyVoxelConstants.VOXEL_SIZE_IN_METRES; var targetMax = targetPosition + Vector3.One * MyVoxelConstants.VOXEL_SIZE_IN_METRES; Vector3I minVoxel, maxVoxel; MyVoxelCoordSystems.WorldPositionToVoxelCoord(targetVoxelMap.PositionLeftBottomCorner, ref targetMin, out minVoxel); MyVoxelCoordSystems.WorldPositionToVoxelCoord(targetVoxelMap.PositionLeftBottomCorner, ref targetMax, out maxVoxel); MyVoxelCoordSystems.VoxelCoordToWorldPosition(targetVoxelMap.PositionLeftBottomCorner, ref minVoxel, out targetMin); MyVoxelCoordSystems.VoxelCoordToWorldPosition(targetVoxelMap.PositionLeftBottomCorner, ref maxVoxel, out targetMax); { BoundingBoxD bbox = BoundingBoxD.CreateInvalid(); bbox.Include(targetMin); bbox.Include(targetMax); VRageRender.MyRenderProxy.DebugDrawAABB(bbox, Vector3.One, 1f, 1f, true); } if (MyInput.Static.IsNewLeftMousePressed()) { var cache = new MyStorageData(); cache.Resize(minVoxel, maxVoxel); targetVoxelMap.Storage.ReadRange(cache, MyStorageDataTypeFlags.Content, 0, ref minVoxel, ref maxVoxel); targetVoxelMap.Storage.WriteRange(cache, MyStorageDataTypeFlags.Content, ref minVoxel, ref maxVoxel); Debug.Assert(true); } }
internal static VRageMath.BoundingBoxD GetBoundingBox(ref Vector3D worldPointA, ref Vector3D worldPointB) { var worldPosition = (worldPointA + worldPointB) * 0.5f; var pointA = worldPointA - worldPosition; var pointB = worldPointB - worldPosition; var aabb = BoundingBoxD.CreateInvalid(); aabb.Include(ref pointA); aabb.Include(ref pointB); aabb.Inflate(0.25); //aabb.Translate(worldPosition); return(aabb); }
static void UpdateBoundingFrustum() { // Update frustum m_boundingFrustum.Matrix = ViewProjectionMatrix; // Update bounding box BoundingBox = BoundingBoxD.CreateInvalid(); //todo //BoundingBox = BoundingBoxHelper.AddFrustum(ref BoundingFrustum, ref BoundingBox); // Update bounding sphere //todo //BoundingSphere = MyUtils.GetBoundingSphereFromBoundingBox(ref BoundingBox); }
public MeshGradeShape(EdgeBlit edge, ICurve curve, TriangleUtil.Triangle[] tri) { var box = BoundingBoxD.CreateInvalid(); foreach (var k in tri) { box.Include(k.Origin); box.Include(k.Origin + k.Edge1); box.Include(k.Origin + k.Edge2); } Box = box.Inflate(0.5f); _tris = tri; _edge = edge; _curve = curve; }
public override void UpdateWorldAABB() { CulledObjects.GetAll(m_list, true); m_localAABB = BoundingBoxD.CreateInvalid(); foreach (var element in m_list) { m_localAABB = m_localAABB.Include(element.WorldAABB); } m_aabb = m_localAABB.Transform(ref m_worldMatrix); base.UpdateWorldAABB(); }
public void Init(IMyEnvironmentOwner owner, ref MyEnvironmentSectorParameters parameters) { // Copy parameters in SectorCenter = parameters.Center; Bounds = parameters.Bounds; m_dataRange = parameters.DataRange; m_environment = (MyProceduralEnvironmentDefinition)parameters.Environment; EnvironmentDefinition = parameters.Environment; m_owner = owner; m_provider = parameters.Provider; // Compute appropriate render origin. Vector3D center = parameters.Center; owner.ProjectPointToSurface(ref center); if (!Engine.Platform.Game.IsDedicated) { m_render = new MyInstancedRenderSector(string.Format("{0}:Sector({1:X})", owner, parameters.SectorId), MatrixD.CreateTranslation(center)); } SectorId = parameters.SectorId; BoundingBoxD worldBounds = BoundingBoxD.CreateInvalid(); for (int i = 0; i < 8; ++i) { worldBounds.Include(Bounds[i]); } // Entity stuff PositionComp.SetPosition(parameters.Center); PositionComp.WorldAABB = worldBounds; // Add missing stuff AddDebugRenderComponent(new MyDebugRenderComponentEnvironmentSector(this)); GameLogic = new MyNullGameLogicComponent(); Save = false; IsClosed = false; }
public void Start(MyParticleEffect effect) { System.Diagnostics.Debug.Assert(m_effect == null); System.Diagnostics.Debug.Assert(m_particles.Count == 0); System.Diagnostics.Debug.Assert(Birth == null); m_effect = effect; m_name = "ParticleGeneration"; m_emitter.Start(); m_lastEffectPosition = null; IsInherited = false; m_birthRate = 0.0f; m_particlesToCreate = 0.0f; m_AABB = BoundingBoxD.CreateInvalid(); }
private BoundingBoxD GetAggregateBBox() { if (m_grid.MarkedForClose) { return(BoundingBoxD.CreateInvalid()); } BoundingBoxD bbox = m_grid.PositionComp.WorldAABB; foreach (var grid in m_connectedGrids) { if (grid.PositionComp != null) { bbox.Include(grid.PositionComp.WorldAABB); } } return(bbox); }
private void ExecuteUpdate(long dt) { _updateScheduled = false; if (!_powerObserver.IsPowered) { return; } if (Definition.RequiredStates.Count > 0 && _state != null && !Definition.RequiredStates.Contains(_state.CurrentState)) { return; } using (PoolManager.Get(out List <OrientedBoundingBoxD> boxes)) using (PoolManager.Get(out List <MyVoxelBase> voxels)) { GatherWorldVolumes(boxes); if (boxes.Count == 0) { return; } var worldBounds = BoundingBoxD.CreateInvalid(); foreach (var box in boxes) { worldBounds.Include(box.GetAABB()); } GatherVoxels(worldBounds, voxels); if (voxels.Count == 0) { return; } var availableForDeposit = ComputeDepositAvailability(); if (availableForDeposit == 0) { return; } var used = PerformVoxelOp(voxels, boxes, Definition.PlacementDefinition.Material.Index, availableForDeposit, _miningBuffer, Definition.RemoveFarmingItems); if (used <= 0) { return; } _eventBus?.Invoke(EventDidWork, true); UseDepositMaterials(used); GiftMiningMaterials(); } }