public List <MiningMaterial> MiningMaterials() { List <MiningMaterial> materials = new List <MiningMaterial>(); using (m_lock.AcquireSharedUsing()) { for (int i = 0; i < 256; i++) { if (m_materials[i].Count == 0) { continue; } var voxelDefinition = MyDefinitionManager.Static.GetVoxelMaterialDefinition((byte)i); if (voxelDefinition == null) { continue; } materials.Add(new MiningMaterial() { EntityId = m_voxelMap.EntityId, VoxelPosition = m_materials[i].VoxelPosition, WorldPosition = m_materials[i].WorldPosition, Count = m_materials[i].Count, Material = (byte)i, Definition = voxelDefinition, }); } } return(materials); }
public static MyStringHash Get(string str) { using (m_lock.AcquireSharedUsing()) { return(m_stringToHash[str]); } }
private static void GetDetectedObjects() { using (MyEntities.EntityCloseLock.AcquireSharedUsing()) { using (m_detectedObjectsLock.AcquireSharedUsing()) { Debug.Assert(m_detectedObjectsHelperCollection.Count == 0); foreach (IMyObjectToDetect obj in m_objectsToDetect) { // if we are in radar jammer's range or in sun wind jam range, then we detect only friends if (IsNearRadarJammerOrSunWind() && obj is MyEntity && (MyFactions.GetFactionsRelation(GetOwner().Faction, ((MyEntity)obj).Faction) == MyFactionRelationEnum.Enemy)) { continue; } //activeDetector.IsDetected(GetRadarPosition(), objectToDetect) if (!CanBeDetected(obj)) { continue; } BoundingSphere detectingSphere = new BoundingSphere(GetOwner().GetPosition(), DefaultRadarRange); if (!detectingSphere.Intersects(obj.WorldAABB)) { continue; } m_detectedObjectsHelperCollection.Add(obj); } m_objectsToDetect.Clear(); } } }
/// <summary> /// Perform an action on each LastSeen. Invalid LastSeen are removed by this method. /// </summary> /// <param name="method">Action invoked on each LastSeen.</param> public void ForEachLastSeen(Action <LastSeen> method) { List <LastSeen> invalid = null; using (lock_lastSeen.AcquireSharedUsing()) foreach (LastSeen seen in m_lastSeen.Values) { if (seen.IsValid) { method(seen); } else { if (invalid == null) { invalid = new List <LastSeen>(); } invalid.Add(seen); } } if (invalid != null) { Log.DebugLog("Removing " + invalid.Count + " invalid LastSeen", Logger.severity.DEBUG); using (lock_lastSeen.AcquireExclusiveUsing()) foreach (LastSeen seen in invalid) { m_lastSeen.Remove(seen.Entity.EntityId); } } m_nextClean_lastSeen = Globals.UpdateCount + s_cleanInterval; }
private MyStat GetStat(string name) { MyStat result; using (m_lock.AcquireSharedUsing()) { if (m_stats.TryGetValue(name, out result)) { return(result); } } using (m_lock.AcquireExclusiveUsing()) { // Racing condition, someone can faster insert this value if (m_stats.TryGetValue(name, out result)) { return(result); } else { result = new MyStat(); m_stats[name] = result; return(result); } } }
public static void GetBlocks(HashSet <MySlimBlock> entities) { using (_blockLock.AcquireSharedUsing()) { entities.UnionWith(_blockCache); } }
// ------------------------------------------------------------------------ // Update animation state (position and orientation of bones). // Called from MySessionComponentAnimationSystem. public void Update() { using (m_componentValidLock.AcquireSharedUsing()) { if (!m_componentValid) { return; } VRage.Animations.MyAnimationUpdateData updateData = new Animations.MyAnimationUpdateData(); updateData.DeltaTimeInSeconds = VRage.Game.MyEngineConstants.UPDATE_STEP_SIZE_IN_SECONDS; updateData.CharacterBones = m_characterBones; updateData.Controller = null; // will be set inside m_controller.Update automatically if null updateData.BonesResult = null; // will be set inside m_controller.Update (result!) m_controller.Update(ref updateData); if (updateData.BonesResult != null) { for (int i = 0; i < updateData.BonesResult.Count; i++) { CharacterBones[i].SetCompleteTransform(ref updateData.BonesResult[i].Translation, ref updateData.BonesResult[i].Rotation); } } m_lastBoneResult = updateData.BonesResult; } }
public static bool TryGetEntityById(long entityId, out MyEntity entity) { using (_entityLock.AcquireSharedUsing()) { entity = _entityCache.FirstOrDefault(e => e.EntityId == entityId); return(entity != null); } }
public static bool TryGetGridById(long entityId, out MyCubeGrid entity) { using (_gridLock.AcquireSharedUsing()) { entity = _gridCache.FirstOrDefault(e => e.EntityId == entityId); return(entity != null); } }
public static SyncByReference CreateSyncByReference(ulong typeID, SyncComponent component, SyncDirection direction, ulong id) { using (Lock.AcquireSharedUsing()) { var info = ActivatorsByID[typeID]; return(info.Activator.Invoke(info, component, direction, id)); } }
public void ReadRange(MyStorageData target, MyStorageDataTypeFlags dataToRead, int lodIndex, ref Vector3I lodVoxelRangeMin, ref Vector3I lodVoxelRangeMax, ref MyVoxelRequestFlags requestFlags) { ProfilerShort.Begin(GetType().Name + ".ReadRange"); try { const int SUBRANGE_SIZE_SHIFT = 3; const int SUBRANGE_SIZE = 1 << SUBRANGE_SIZE_SHIFT; var threshold = new Vector3I(SUBRANGE_SIZE); var rangeSize = lodVoxelRangeMax - lodVoxelRangeMin + 1; if ((dataToRead & MyStorageDataTypeFlags.Content) != 0) { target.ClearContent(0); } if ((rangeSize.X <= threshold.X && rangeSize.Y <= threshold.Y && rangeSize.Z <= threshold.Z) || !MyFakes.ENABLE_SPLIT_VOXEL_READ_QUERIES) { using (m_lock.AcquireSharedUsing()) { ReadRangeInternal(target, ref Vector3I.Zero, dataToRead, lodIndex, ref lodVoxelRangeMin, ref lodVoxelRangeMax, ref requestFlags); } } else { // These optimizations don't work when splitting the range. requestFlags &= ~(MyVoxelRequestFlags.OneMaterial | MyVoxelRequestFlags.ContentChecked); MyVoxelRequestFlags flags = requestFlags; // splitting to smaller ranges to make sure the lock is not held for too long, preventing write on update thread // subranges could be aligned to multiple of their size for possibly better performance var steps = (rangeSize - 1) >> SUBRANGE_SIZE_SHIFT; for (var it = new Vector3I.RangeIterator(ref Vector3I.Zero, ref steps); it.IsValid(); it.MoveNext()) { flags = requestFlags; var offset = it.Current << SUBRANGE_SIZE_SHIFT; var min = lodVoxelRangeMin + offset; var max = min + SUBRANGE_SIZE - 1; Vector3I.Min(ref max, ref lodVoxelRangeMax, out max); Debug.Assert(min.IsInsideInclusive(ref lodVoxelRangeMin, ref lodVoxelRangeMax)); Debug.Assert(max.IsInsideInclusive(ref lodVoxelRangeMin, ref lodVoxelRangeMax)); using (m_lock.AcquireSharedUsing()) { ReadRangeInternal(target, ref offset, dataToRead, lodIndex, ref min, ref max, ref flags); } } // If the storage is consistent this should be fine. requestFlags = flags; } } finally { ProfilerShort.End(); } }
/// <summary> /// Get the fat BoundingBox for a proxy. /// </summary> /// <param name="proxyId">The proxy id.</param> /// <param name="fatAABB">The fat BoundingBox.</param> public void GetFatAABB(int proxyId, out BoundingBox fatAABB) { MyPerformanceCounter.PerCameraDraw.StartTimer("DAABB"); using (m_rwLock.AcquireSharedUsing()) { MyCommonDebugUtils.AssertDebug(0 <= proxyId && proxyId < _nodeCapacity); fatAABB = _nodes[proxyId].Aabb; } MyPerformanceCounter.PerCameraDraw.StopTimer("DAABB"); }
public void UpdateRenderInstanceData() { using (m_instancePartsLock.AcquireSharedUsing()) { foreach (var part in m_instanceParts) { part.Value.UpdateRenderInstanceData(); } } }
public T this[int index] { get { using (lock_Queue.AcquireSharedUsing()) return(Queue[index]); } set { using (lock_Queue.AcquireExclusiveUsing()) Queue[index] = value; } }
public void EnsureGenerationStarted() { TimeRemoved = null; using (m_creationQueueSemaphore.AcquireSharedUsing()) if (m_creationQueued) { return; } using (m_creationQueueSemaphore.AcquireExclusiveUsing()) { if (m_creationQueued) { return; } m_creationQueued = true; } if (IsMarkedForRemoval) { return; } if (m_construction == null) { MyAPIGateway.Parallel.StartBackground(ParallelUtilities.WrapAction(() => { if (!Stage_Generate()) { return; } if (!Stage_Build()) { return; } MyAPIGateway.Utilities.InvokeOnGameThread(ParallelUtilities.WrapAction(Stage_SpawnGrid, Module)); }, Module)); } else if (m_grids == null) { MyAPIGateway.Parallel.StartBackground(ParallelUtilities.WrapAction(() => { if (!Stage_Build()) { return; } MyAPIGateway.Utilities.InvokeOnGameThread(ParallelUtilities.WrapAction(Stage_SpawnGrid, Module)); }, Module)); } else if (m_component == null) { MyAPIGateway.Utilities.InvokeOnGameThread(ParallelUtilities.WrapAction(Stage_SpawnGrid, Module)); } else { m_creationQueued = false; } }
/// <summary> /// Registers the arbitrary handler with SE for all domains that were /// registered with MessageManager before we init'd. /// See the note in AddHandler. /// </summary> private void RegisterForDelayedDomains() { using (Lock.AcquireSharedUsing()) { foreach (var domainId in Handlers.Keys) { MyAPIGateway.Multiplayer.RegisterMessageHandler( domainId, TryHandleMessage ); } } }
public static int GetWeaponsTargeting(IMyEntity entity) { WeaponCounts result; using (lock_WeaponsTargeting.AcquireSharedUsing()) if (!WeaponsTargeting.TryGetValue(entity.EntityId, out result)) { return(0); } return(result.Value); }
public void ReadRange(MyStorageDataCache target, MyStorageDataTypeFlags dataToRead, int lodIndex, ref Vector3I lodVoxelRangeMin, ref Vector3I lodVoxelRangeMax) { ProfilerShort.Begin(GetType().Name + ".ReadRange"); try { const int SUBRANGE_SIZE_SHIFT = 3; const int SUBRANGE_SIZE = 1 << SUBRANGE_SIZE_SHIFT; var threshold = new Vector3I(SUBRANGE_SIZE); var rangeSize = lodVoxelRangeMax - lodVoxelRangeMin + 1; if ((dataToRead & MyStorageDataTypeFlags.Content) != 0) { target.ClearContent(0); } if ((dataToRead & MyStorageDataTypeFlags.Material) != 0) { target.ClearMaterials(m_defaultMaterial); } if (rangeSize.X <= threshold.X && rangeSize.Y <= threshold.Y && rangeSize.Z <= threshold.Z) { using (m_lock.AcquireSharedUsing()) { ReadRangeInternal(target, ref Vector3I.Zero, dataToRead, lodIndex, ref lodVoxelRangeMin, ref lodVoxelRangeMax); } } else { // splitting to smaller ranges to make sure the lock is not held for too long, preventing write on update thread // subranges could be aligned to multiple of their size for possibly better performance var steps = (rangeSize - 1) >> SUBRANGE_SIZE_SHIFT; for (var it = new Vector3I.RangeIterator(ref Vector3I.Zero, ref steps); it.IsValid(); it.MoveNext()) { var offset = it.Current << SUBRANGE_SIZE_SHIFT; var min = lodVoxelRangeMin + offset; var max = min + SUBRANGE_SIZE - 1; Vector3I.Min(ref max, ref lodVoxelRangeMax, out max); Debug.Assert(min.IsInsideInclusive(ref lodVoxelRangeMin, ref lodVoxelRangeMax)); Debug.Assert(max.IsInsideInclusive(ref lodVoxelRangeMin, ref lodVoxelRangeMax)); using (m_lock.AcquireSharedUsing()) { ReadRangeInternal(target, ref offset, dataToRead, lodIndex, ref min, ref max); } } } } finally { ProfilerShort.End(); } }
public override void OnAddedToScene() { base.OnAddedToScene(); using (Lock.AcquireSharedUsing()) using (PoolManager.Get(out List <TRtKey> children)) using (PoolManager.Get(out HashSet <TRtKey> explored)) { foreach (var id in Modifiers.Keys) { children.Add(id); } while (children.Count > 0) { var id = children[children.Count - 1]; children.RemoveAt(children.Count - 1); if (!explored.Add(id)) { continue; } GetChildren(id, children); ApplyModifiers(id); } } }
public override void UpdateAfterSimulation() { base.UpdateAfterSimulation(); using (m_dictionaryLock.AcquireSharedUsing()) { foreach (var triggerSet in m_triggers.Values) { triggerSet.ApplyChanges(); foreach (var trigger in triggerSet) { trigger.Update(); } } } }
/// <summary> /// <para>Internal receive method. Adds the Message to this storage.</para> /// <para>lock_m_messages should be exclusively locked before invoking this method.</para> /// </summary> private void in_Receive(Message msg) { Action <Message> handler; bool gotHandler; Log.DebugLog("looking for a handler for " + msg.DestCubeBlock.EntityId); using (lock_messageHandlers.AcquireSharedUsing()) gotHandler = m_messageHandlers.TryGetValue(msg.DestCubeBlock.EntityId, out handler); if (gotHandler) { Log.DebugLog("have a handler for msg"); msg.IsValid = false; handler(msg); return; } if (m_messages.Count >= 100) { Log.AlwaysLog("Cannot receive more messages, at limit: " + m_messages.Count, Logger.severity.INFO); return; } if (m_messages.Add(msg)) { Log.DebugLog("got a new message: " + msg.Content + ", count is now " + m_messages.Count, Logger.severity.DEBUG); } else { Log.DebugLog("already have message: " + msg.Content + ", count is now " + m_messages.Count, Logger.severity.DEBUG); } }
/// <summary> /// Perform an action on each Message. Invalid Message are removed by this method. /// </summary> /// <param name="method">Action to invoke on each message.</param> private void ForEachMessage(Action <Message> method) { List <Message> invalid = null; using (lock_messages.AcquireSharedUsing()) foreach (Message msg in m_messages) { if (msg.IsValid) { method(msg); } else { if (invalid == null) { invalid = new List <Message>(); } invalid.Add(msg); } } if (invalid != null) { Log.DebugLog("Removing " + invalid.Count + " invalid Message", Logger.severity.DEBUG); using (lock_messages.AcquireExclusiveUsing()) foreach (Message msg in invalid) { m_messages.Remove(msg); } } m_nextClean_message = Globals.UpdateCount + s_cleanInterval; }
public void RefillPools() { if (m_missing == 0) { return; } if (m_dequeuedThisFrame && !MyFakes.CLONE_SHAPES_ON_WORKER) { m_dequeuedThisFrame = false; return; } ProfilerShort.Begin("Clone"); int clonedThisFrame = 0; if (MyFakes.CLONE_SHAPES_ON_WORKER) { StartJobs(); } else { using (m_poolLock.AcquireSharedUsing()) { foreach (var pool in m_pools) { foreach (var model in pool.Value) { if (pool.Value.Count < PREALLOCATE_COUNT) { MyCubeBlockDefinition def; MyDefinitionManager.Static.TryGetDefinition <MyCubeBlockDefinition>(pool.Key, out def); int cloneCount = Math.Min(PREALLOCATE_COUNT - pool.Value.Count, MAX_CLONE_PER_FRAME - clonedThisFrame); AllocateForDefinition(model.Key, def, cloneCount); clonedThisFrame += cloneCount; } if (clonedThisFrame >= MAX_CLONE_PER_FRAME) { break; } } } } } m_missing -= clonedThisFrame; ProfilerShort.End(clonedThisFrame); clonedThisFrame = 0; }
public IMyVoxelBase GetVoxelContainingPoint(Vector3D world, float radius = 0.866f) { var sphere = new BoundingSphereD(world, radius); using (m_voxelCacheStaticLock.AcquireSharedUsing()) { foreach (var voxelmap in m_voxelCacheStatic) { //Logger.Instance.LogMessage(string.Format("Scanning voxel {0} for point: {1}", voxelmap.GetType(), world)); if (IsInsideVoxel(voxelmap, world, radius)) { return(voxelmap); } } } return(null); }
private float CalcForceInDirection(Base6Directions.Direction direction) { float force = 0; using (lock_thrustersInDirection.AcquireSharedUsing()) foreach (MyThrust thruster in m_thrustersInDirection[(int)direction]) { if (!thruster.Closed && thruster.IsWorking) { force += GetThrusterMaxForce(thruster); } } m_totalThrustForce[(int)direction] = force; if (direction == m_primaryForce.Direction) { //Log.DebugLog("updating primary force, direction: " + direction + ", force: " + force, "CalcForceInDirection()"); m_primaryForce.Force = force; } else if (force > m_primaryForce.Force * 1.1f) { Log.DebugLog("stronger than primary force, direction: " + direction + ", force: " + force + ", acceleration: " + force / myGrid.Physics.Mass + ", primary: " + m_primaryForce, Logger.severity.DEBUG); m_secondaryForce = m_primaryForce; m_primaryForce.Direction = direction; m_primaryForce.Force = force; if (m_secondaryForce.Direction == Base6Directions.GetFlippedDirection(m_primaryForce.Direction)) { m_secondaryForce = new ForceInDirection() { Direction = Base6Directions.GetPerpendicular(m_primaryForce.Direction) } } ; Log.DebugLog("secondary: " + m_secondaryForce); Standard.SetMatrixOrientation(m_primaryForce.Direction, m_secondaryForce.Direction); Gravity.SetMatrixOrientation(m_secondaryForce.Direction, m_primaryForce.Direction); } else if (direction == m_secondaryForce.Direction) { //Log.DebugLog("updating secondary force, direction: " + direction + ", force: " + force, "CalcForceInDirection()"); m_secondaryForce.Force = force; } else if (force > m_secondaryForce.Force * 1.1f && direction != Base6Directions.GetFlippedDirection(m_primaryForce.Direction)) { Log.DebugLog("stronger than secondary force, direction: " + direction + ", force: " + force + ", acceleration: " + force / myGrid.Physics.Mass + ", secondary: " + m_secondaryForce, Logger.severity.DEBUG); m_secondaryForce.Direction = direction; m_secondaryForce.Force = force; Standard.SetMatrixOrientation(m_primaryForce.Direction, m_secondaryForce.Direction); Gravity.SetMatrixOrientation(m_secondaryForce.Direction, m_primaryForce.Direction); } //Log.DebugLog("direction: " + direction + "(" + (int)direction + ")" + ", force: " + force); return(force); }
internal void InvalidateRange(Vector3I lodMin, Vector3I lodMax) { var cell = new MyCellCoord(m_lodIndex, lodMin); for (var it = new Vector3I.RangeIterator(ref lodMin, ref lodMax); it.IsValid(); it.GetNext(out cell.CoordInLod)) { CellData data; var id = cell.PackId64(); using (m_storedCellDataLock.AcquireSharedUsing()) { if (m_storedCellData.TryGetValue(id, out data)) { data.State = CellState.Invalid; } } } }
private static void UpdateBuilders() { Parallel.ForEach(_dirtyEntities, g => UpdateGridBuilders(g)); _dirtyEntities.Clear(); var rem = new HashSet <long>(); using (_entityLock.AcquireSharedUsing()) using (_builderLock.AcquireSharedUsing()) { rem.UnionWith(from e in _bigBuilders where _gridCache.All(en => en.EntityId != e.Key) select e.Key); } using (_builderLock.AcquireExclusiveUsing()) { foreach (var r in rem) { _bigBuilders.Remove(r); } } }
private byte[] SerializePacket(Packet packet) { PacketInfo info; using (m_packetDbLock.AcquireSharedUsing()) if (!m_registeredPacketsByType.TryGetValue(packet.GetType(), out info)) { throw new ArgumentException($"Packet type {packet.GetType()} wasn't registered"); } byte[] serialized; using (var stream = MemoryStream.CreateEmptyStream(8192)) { stream.Write(info.PacketID); packet.WriteTo(stream); serialized = m_bufferPool.GetOrCreate(stream.WriteHead); Array.Copy(stream.Backing, 0, serialized, 0, stream.WriteHead); } return(serialized); }
private static void Run() { while (true) { using (lock_TurretActions.AcquireSharedUsing()) if (TurretActions.Count == 0) { break; } Action currentItem; using (lock_TurretActions.AcquireExclusiveUsing()) currentItem = TurretActions.Pop(); currentItem(); //logFinished(); } isRunning = false; }
public void ApplyActionOnAllActives(Action <T> action) { using (m_lock.AcquireSharedUsing()) { foreach (var active in m_active) { action.Invoke(active); } } }