protected override void OnUpdate() { Entity grid; using (var tmp = mGridQuery.ToEntityArray(Allocator.TempJob)) grid = tmp.Length > 0 ? tmp[0] : Entity.Null; Debug.Assert(grid != Entity.Null); var cellSize = EntityManager.GetComponentData <CGridCellSize>(grid).Value; var cellCount = EntityManager.GetComponentData <CGridCellCount>(grid).Value; var gridPos = EntityManager.GetComponentData <CGridPos>(grid).Value; var stackHeights = EntityManager.GetBuffer <BStackHeights>(grid); var floorStart = -Settings.Instance.FieldSize.y * 0.5f; var resourcesSize = Settings.Instance.ResourceSize; var ecb = mCommandBufferSystem.CreateCommandBuffer().AsParallelWriter(); Entities .WithAll <TResource>() .WithNone <CHeldBy, CStackHeight>() .ForEach((Entity e, int entityInQueryIndex, ref Translation translation, ref CVelocity velocity, in CGridIndex idx) => { var cellStackIdx = idx.Value.y * cellCount.x + idx.Value.x; var stackHeight = stackHeights[cellStackIdx].Value; var floorHeight = floorStart + (stackHeight + 0.5f) * resourcesSize; if (translation.Value.y < floorHeight) { if (floorHeight + resourcesSize < -floorStart) { translation.Value = new float3(translation.Value.xz, floorHeight).xzy; velocity.Value = float3.zero; ecb.AddComponent(entityInQueryIndex, e, new CStackHeight { Value = stackHeight++ }); stackHeights[cellStackIdx] = new BStackHeights { Value = stackHeight }; } else { ecb.DestroyEntity(entityInQueryIndex, e); } } }) .Schedule(); mCommandBufferSystem.AddJobHandleForProducer(Dependency); }
/// <summary> /// Determines if the target application is running on the target device. /// </summary> /// <param name="appInfo">Optional cached <see cref="Microsoft.MixedReality.Toolkit.WindowsDevicePortal.ApplicationInfo"/>.</param> /// <returns>True, if the application is running.</returns> public static async Task <bool> IsAppRunningAsync(string packageName, DeviceInfo targetDevice, ApplicationInfo appInfo = null) { Debug.Assert(!string.IsNullOrEmpty(packageName)); if (appInfo == null) { appInfo = await GetApplicationInfoAsync(packageName, targetDevice); } if (appInfo == null) { Debug.LogError($"{packageName} not installed."); return(false); } var response = await Rest.GetAsync(string.Format(ProcessQuery, FinalizeUrl(targetDevice.IP)), targetDevice.Authorization); if (response.Successful) { var processList = JsonUtility.FromJson <ProcessList>(response.ResponseBody); for (int i = 0; i < processList.Processes.Length; ++i) { if (processList.Processes[i].ImageName.Contains(appInfo.Name)) { return(true); } } return(false); } if (response.ResponseCode == 403 && await RefreshCsrfTokenAsync(targetDevice)) { return(await IsAppRunningAsync(packageName, targetDevice, appInfo)); } Debug.LogError($"{response.ResponseBody}"); return(false); }
/// <summary> /// Uninstalls the target application on the target device /// </summary> /// <param name="appInfo">Optional cached <see cref="Microsoft.MixedReality.Toolkit.WindowsDevicePortal.ApplicationInfo"/>.</param> /// <returns>True, if uninstall was a success.</returns> public static async Task <bool> UninstallAppAsync(string packageName, DeviceInfo targetDevice, ApplicationInfo appInfo = null) { Debug.Assert(!string.IsNullOrEmpty(packageName)); if (appInfo == null) { appInfo = await GetApplicationInfoAsync(packageName, targetDevice); } if (appInfo == null) { Debug.LogWarning($"Application '{packageName}' not found"); return(false); } Debug.Log($"Attempting to uninstall {packageName} on {targetDevice.MachineName}..."); string query = $"{string.Format(InstallQuery, FinalizeUrl(targetDevice.IP))}?package={UnityWebRequest.EscapeURL(appInfo.PackageFullName)}"; var response = await Rest.DeleteAsync(query, targetDevice.Authorization); if (response.Successful) { Debug.Log($"Successfully uninstalled {packageName} on {targetDevice.MachineName}."); } else if (!response.Successful) { if (response.ResponseCode == 403 && await RefreshCsrfTokenAsync(targetDevice)) { return(await UninstallAppAsync(packageName, targetDevice)); } Debug.LogError($"Failed to uninstall {packageName} on {targetDevice.MachineName}"); Debug.LogError(response.ResponseBody); return(false); } return(true); }
public void RegisterDeadSheep(Sheep deadSheep, Player fromPlayer) { Debug.Assert(!deadSheep.IsAlive); KilledSheep += 1; SoundPlayer.Instance.Play(Sound.SheepHit, deadSheep.AudioSource); if (Master.Instance.CurrentDifficulty == Difficulty.Easy) { WakeUpSheep(fromPlayer); } int sheepAlive = 0; foreach (Sheep sheep in _sheep) { if (sheep.IsAlive) { sheepAlive += 1; } } if (sheepAlive > 0) { Coin coin = Instantiate(_coinPrefab, deadSheep.transform.position, Quaternion.identity); Vector2 coinVec = (coin.transform.position - fromPlayer.transform.position).normalized; coin.Rigidbody.AddForce(coinVec * Random.Range(3f, 10f), ForceMode2D.Impulse); } if (sheepAlive == 0) { _levelTime.Stop(); _levelDone = true; MainWindow.Instance.RunTimelineLevelWon(); } }
protected override void Awake() { base.Awake(); _mainCamera = Camera.main; _offsetOnPullToCamera = GalaxyExplorerManager.ForcePullToCamFixedDistance; _manipulationHandler = ManipulationHandler ? ManipulationHandler : GetComponentInChildren <ManipulationHandler>(); Debug.Assert(_manipulationHandler != null, "Force Solver failed to find a manipulation handler"); _attractionCollider = AttractionCollider ? AttractionCollider : GetComponentInChildren <Collider>(); Debug.Assert(_attractionCollider != null, "Force Solver failed to find a attraction collider"); _manipulationHandler.OnManipulationEnded.AddListener(OnManipulationEnd); if (ControllerTracker == null) { Debug.LogWarning(gameObject.name + " ForceSolver no controller tracker transform supplied will instantiate locally"); var controllerTrackerObject = new GameObject(gameObject.name + " ForceSolver autogenerated controller tracker"); ControllerTracker = controllerTrackerObject.AddComponent <ControllerTransformTracker>(); } ControllerTracker.AllTrackingLost += OnControllersLost; }
/// <summary> /// Decompose the polygon into several smaller non-concave polygon. /// If the polygon is already convex, it will return the original polygon, unless it is over MaxPolygonVertices. /// </summary> public static Vector2[][] ConvexPartition(List <Vector2> vertices) { Debug.Assert(vertices.Count > 3); if (!IsCounterClockWise(vertices)) { vertices.Reverse(); } var result = TriangulatePolygon(vertices); if (result == null) { return(null); } var returnValue = new Vector2[result.Count][]; for (int i = 0; i < result.Count; i++) { returnValue[i] = result[i].ToArray(); } return(returnValue); }
/// <summary>Deletes a file.</summary> public static bool DeleteFile(string filePath) { Debug.Assert(!String.IsNullOrEmpty(filePath)); try { if (File.Exists(filePath)) { File.Delete(filePath); } return(true); } catch (Exception e) { string warningInfo = ("[mod.io] Failed to delete file." + "\nFile: " + filePath + "\n\n"); Debug.LogWarning(warningInfo + Utility.GenerateExceptionDebugString(e)); } return(false); }
internal bool AttachToParentAt(ref IDManager hierarchyIDLookup, NativeList <CompactHierarchy> hierarchies, ref IDManager nodeIDLookup, NativeList <CompactNodeID> nodes, CompactNodeID parentID, int index, CompactNodeID compactNodeID) { Debug.Assert(IsCreated); if (index < 0) { Debug.LogError("The index must be positive"); return(false); } var parentIndex = HierarchyIndexOfInternal(parentID); if (parentIndex == -1) { throw new ArgumentException(nameof(parentID), $"{nameof(parentID)} is invalid"); } if (!IsValidCompactNodeID(compactNodeID)) { return(false); } return(AttachInternal(ref hierarchyIDLookup, hierarchies, ref nodeIDLookup, nodes, parentID, parentIndex, index, compactNodeID)); }
public void RegisterDeadPlayer(Player deadPlayer) { Debug.Assert(!deadPlayer.IsAlive); SoundPlayer.Instance.Play(Sound.PlayerHit, deadPlayer.AudioSource); int playersAlive = 0; foreach (Player player in _players) { if (player.IsAlive) { playersAlive += 1; } } if (playersAlive == 0) { _levelTime.Stop(); _levelDone = true; MainWindow.Instance.RunTimelineLevelFailed(); } }
public NodeID GetNodeIDNoErrors(CompactNodeID compactNodeID) { int nodeIndex; Debug.Assert(IsCreated); if (compactNodeID == CompactNodeID.Invalid) { return(NodeID.Invalid); } nodeIndex = HierarchyIndexOfInternalNoErrors(compactNodeID); if (nodeIndex == -1) { return(NodeID.Invalid); } if (nodeIndex < 0 || nodeIndex >= compactNodes.Length) { return(NodeID.Invalid); } return(compactNodes[nodeIndex].nodeID); }
private int AddLeaf(int parent, ItemEntry item) { Debug.Assert(parent >= 0); Debug.Assert(parent % NodeSize == 0); Debug.Assert(parent < nodeCount * NodeSize); Debug.Assert(leafCount >= 0); Debug.Assert(leafCount <= leafs.Length); if (leafCount == leafs.Length) { // Grow the array to accomodate more leafs var newLeafs = new OctreeLeaf[leafs.Length * 2]; leafs.CopyTo(newLeafs, 0); leafs = newLeafs; } ItemEntry[] leafContent; var cache = ContentCache[0]; if (cache.Count > 0) { // Extract the item container from the cache leafContent = cache[cache.Count - 1]; cache.RemoveAt(cache.Count - 1); } else { // Cache is empty, create a new container leafContent = new ItemEntry[DefaultLeafCapacity]; } leafContent[0] = item; leafs[leafCount] = new OctreeLeaf(parent, leafContent, 1); leafCount++; return(-leafCount); // Leafs have negative indexing starting at -1 }
public static JSONObj Create <T>(T val) { JSONObj obj = new JSONObj(); switch (System.Type.GetTypeCode(val.GetType())) { case System.TypeCode.Byte: case System.TypeCode.SByte: case System.TypeCode.UInt16: case System.TypeCode.UInt32: case System.TypeCode.Int16: case System.TypeCode.Int32: case System.TypeCode.Int64: obj = JSONObj.Create(System.Convert.ToInt64(val)); break; case System.TypeCode.Decimal: case System.TypeCode.Double: case System.TypeCode.Single: obj = JSONObj.Create(System.Convert.ToSingle(val)); break; case System.TypeCode.Boolean: obj = JSONObj.Create(System.Convert.ToBoolean(val)); break; case System.TypeCode.UInt64: Debug.Assert(true, "UInt64 unsupported"); break; default: obj = JSONObj.CreateStringObject(val.ToString()); break; } return(obj); }
/// Upload a file to Drive. Make sure mimetype and parents are specified. public async Task UploadFileAsync(DriveData.File file, Stream dataStream, CancellationToken token, IProgress <long> progress = null) { Debug.Assert(file.Parents != null); Debug.Assert(dataStream.CanSeek); var uploader = m_DriveService.Files.Create(file, dataStream, file.MimeType); if (progress != null) { uploader.ProgressChanged += (p) => progress.Report(p.BytesSent); } long position = dataStream.Position; var result = await Retry(() => { dataStream.Seek(position, SeekOrigin.Begin); return(uploader.UploadAsync(token)); }); if (result.Status != UploadStatus.Completed && !token.IsCancellationRequested) { Debug.LogException(new DriveSync.DataTransferError("Google Drive new file upload failed.", result.Exception)); } await RefreshFreeSpaceAsync(token); }
void CompleteTrackedRequests(bool allRequests = false) { int value; foreach (var kv in _requestsInFlight) { var req = kv.Key; var age = _frameCount - kv.Value; if (allRequests || AsyncRequest.maxAsyncRequestFrameAge > 0) { if (req.started && !req.completed && age >= AsyncRequest.maxAsyncRequestFrameAge) { req.Complete(); Debug.Assert(req.completed == true); } } if (req.completed) { _requestsInFlight.TryRemove(req, out value); } } }
/// <summary>Reads an entire file and parses the JSON Object it contains.</summary> public static bool TryReadJsonObjectFile <T>(string filePath, out T jsonObject) { Debug.Assert(!String.IsNullOrEmpty(filePath)); if (File.Exists(filePath)) { try { jsonObject = JsonConvert.DeserializeObject <T>(File.ReadAllText(filePath)); return(true); } catch (Exception e) { string warningInfo = ("[mod.io] Failed to read json object from file." + "\nFile: " + filePath + "\n\n"); Debug.LogWarning(warningInfo + Utility.GenerateExceptionDebugString(e)); } } jsonObject = default(T); return(false); }
/// <summary>Deletes a directory.</summary> public static bool DeleteDirectory(string directoryPath) { Debug.Assert(!String.IsNullOrEmpty(directoryPath)); try { if (Directory.Exists(directoryPath)) { Directory.Delete(directoryPath, true); } return(true); } catch (Exception e) { string warningInfo = ("[mod.io] Failed to delete directory." + "\nDirectory: " + directoryPath + "\n\n"); Debug.LogWarning(warningInfo + Utility.GenerateExceptionDebugString(e)); } return(false); }
public VertexProgram(string varCompiledShaderPath) { UDebug.Assert(File.Exists(varCompiledShaderPath)); var tempContent = File.ReadAllLines(varCompiledShaderPath); for (int i = 0; i < tempContent.Length; ++i) { var tempInfo = tempContent[i]; if (!tempInfo.StartsWith(VertexTagStr, false, CultureInfo.InvariantCulture)) { continue; } var tempPlatform = tempInfo.Substring(VertexTagStr.Length, tempInfo.Length - VertexTagStr.Length - 1).Replace("\"", string.Empty); if (!_DisCompiledFun.TryGetValue(tempPlatform, out var tempDisFun)) { UDebug.LogWarningFormat("[VertexProgram] not support :[{0}]", tempPlatform); } i = tempDisFun(tempContent, i, out var tempCompiledPlatform, out var tempChannel); //_DisAssembly.Add(); } }
public int AllocateRange(int length) { if (length < 0) { throw new ArgumentException("Length cannot be negative"); } if (length == 0) { return(-1); } // TODO: have some way to quickly find a free section with a given size without going through ALL free sections // Since we alternate between free and allocated sections, we can quickly find all free sections by skipping the allocated sections for (int sectionIndex = firstElementFree ? 0 : 1; sectionIndex < sections.Length; sectionIndex += 2) { Debug.Assert(IsSectionFree(sectionIndex)); var section = sections[sectionIndex]; if (length > section.length) { continue; } SetRange(sectionIndex, section.start, length, false); return(section.start); } // Create a new range at the end var lastSection = (sections.Length == 0) ? new Section { } : sections[sections.Length - 1]; var offset = lastSection.start + lastSection.length; SetRange(sections.Length, offset, length, false); return(offset); }
/// <summary> /// Launches the target application on the target device. /// </summary> /// <param name="appInfo">Optional cached <see cref="Microsoft.MixedReality.Toolkit.WindowsDevicePortal.ApplicationInfo"/>.</param> /// <returns>True, if application was successfully launched and is currently running on the target device.</returns> public static async Task <bool> LaunchAppAsync(string packageName, DeviceInfo targetDevice, ApplicationInfo appInfo = null) { Debug.Assert(!string.IsNullOrEmpty(packageName)); if (appInfo == null) { appInfo = await GetApplicationInfoAsync(packageName, targetDevice); } if (appInfo == null) { Debug.LogWarning($"Application '{packageName}' not found"); return(false); } string query = $"{string.Format(AppQuery, FinalizeUrl(targetDevice.IP))}?appid={UnityWebRequest.EscapeURL(appInfo.PackageRelativeId.EncodeTo64())}&package={UnityWebRequest.EscapeURL(appInfo.PackageFullName)}"; var response = await RestHelpers.Rest.PostAsync(query, targetDevice.Authorization, readResponseData : true, certificateHandler : DevicePortalCertificateHandler, disposeCertificateHandlerOnDispose : false); if (!response.Successful) { if (response.ResponseCode == 403 && await RefreshCsrfTokenAsync(targetDevice)) { return(await LaunchAppAsync(packageName, targetDevice)); } Debug.LogError($"{response.ResponseCode}|{await response.GetResponseBody()}"); return(false); } while (!await IsAppRunningAsync(packageName, targetDevice, appInfo)) { await new WaitForSeconds(1f); } return(true); }
/// <summary> /// Stops the target application on the target device. /// </summary> /// <param name="appInfo">Optional cached <see cref="Microsoft.MixedReality.Toolkit.WindowsDevicePortal.ApplicationInfo"/>.</param> /// <returns>true, if application was successfully stopped.</returns> public static async Task <bool> StopAppAsync(string packageName, DeviceInfo targetDevice, ApplicationInfo appInfo = null) { Debug.Assert(!string.IsNullOrEmpty(packageName)); if (appInfo == null) { appInfo = await GetApplicationInfoAsync(packageName, targetDevice); } if (appInfo == null) { Debug.LogWarning($"Application '{packageName}' not found"); return(false); } string query = $"{string.Format(AppQuery, FinalizeUrl(targetDevice.IP))}?package={UnityWebRequest.EscapeURL(appInfo.PackageFullName.EncodeTo64())}"; Response response = await Rest.DeleteAsync(query, targetDevice.Authorization); if (!response.Successful) { if (response.ResponseCode == 403 && await RefreshCsrfTokenAsync(targetDevice)) { return(await StopAppAsync(packageName, targetDevice)); } Debug.LogError(response.ResponseBody); return(false); } while (!await IsAppRunningAsync(packageName, targetDevice, appInfo)) { await new WaitForSeconds(1f); } return(true); }
/// <summary>Loads an entire binary file as a byte array.</summary> public static bool TryLoadBinaryFile(string filePath, out byte[] output) { Debug.Assert(!String.IsNullOrEmpty(filePath)); if (File.Exists(filePath)) { try { output = File.ReadAllBytes(filePath); return(true); } catch (Exception e) { string warningInfo = ("[mod.io] Failed to read binary file." + "\nFile: " + filePath + "\n\n"); Debug.LogWarning(warningInfo + Utility.GenerateExceptionDebugString(e)); } } output = null; return(false); }
/// <summary> /// Adds capabilities according to the values in the buildInfo to the manifest file. /// </summary> /// <param name="buildInfo">An IBuildInfo containing a valid OutputDirectory and all capabilities</param> public static void AddCapabilities(IBuildInfo buildInfo, XElement rootElement = null) { var manifestFilePath = GetManifestFilePath(buildInfo); if (manifestFilePath == null) { throw new FileNotFoundException("Unable to find manifest file"); } rootElement = rootElement ?? XElement.Load(manifestFilePath); var uwpBuildInfo = buildInfo as UwpBuildInfo; Debug.Assert(uwpBuildInfo != null); // Here, ResearchModeCapability must come first, in order to avoid schema errors // See https://docs.microsoft.com/windows/uwp/packaging/app-capability-declarations#restricted-capabilities if (uwpBuildInfo.ResearchModeCapabilityEnabled #if !UNITY_2021_2_OR_NEWER && EditorUserBuildSettings.wsaSubtarget == WSASubtarget.HoloLens #endif // !UNITY_2021_2_OR_NEWER ) { AddResearchModeCapability(rootElement); } if (uwpBuildInfo.DeviceCapabilities != null) { AddCapabilities(rootElement, uwpBuildInfo.DeviceCapabilities); } if (uwpBuildInfo.GazeInputCapabilityEnabled) { AddGazeInputCapability(rootElement); } rootElement.Save(manifestFilePath); }
public static bool RestoreNugetPackages(string nugetPath, string storePath) { Debug.Assert(File.Exists(nugetPath)); Debug.Assert(Directory.Exists(storePath)); var nugetPInfo = new ProcessStartInfo { FileName = nugetPath, CreateNoWindow = true, UseShellExecute = false, Arguments = "restore \"" + storePath + "/project.json\"" }; using (var nugetP = new Process()) { nugetP.StartInfo = nugetPInfo; nugetP.Start(); nugetP.WaitForExit(); nugetP.Close(); nugetP.Dispose(); } return(File.Exists(storePath + "\\project.lock.json")); }
public JSONObjectEnumer(JSONObject jsonObject) { Debug.Assert(jsonObject.isContainer); //must be an array or object to itterate _jobj = jsonObject; }
private void SolveTOI(ref TimeStep step) { Island.Reset(2 * Settings.MaxTOIContacts, Settings.MaxTOIContacts, 0, ContactManager); if (_stepComplete) { for (var i = 0; i < BodyList.Count; i++) { BodyList[i]._flags &= ~BodyFlags.IslandFlag; BodyList[i]._sweep.Alpha0 = 0.0f; } for (var i = 0; i < ContactManager.ContactList.Count; i++) { var c = ContactManager.ContactList[i]; // Invalidate TOI c._flags &= ~ContactFlags.IslandFlag; c._flags &= ~ContactFlags.TOIFlag; c._toiCount = 0; c._toi = 1.0f; } } // Find TOI events and solve them. for (;;) { // Find the first TOI. Contact minContact = null; var minAlpha = 1.0f; for (var i = 0; i < ContactManager.ContactList.Count; i++) { var c = ContactManager.ContactList[i]; // Is this contact disabled? if (c.Enabled == false) { continue; } // Prevent excessive sub-stepping. if (c._toiCount > Settings.MaxSubSteps) { continue; } float alpha; if (c.TOIFlag) { // This contact has a valid cached TOI. alpha = c._toi; } else { var fA = c.FixtureA; var fB = c.FixtureB; // Is there a sensor? if (fA.IsSensor || fB.IsSensor) { continue; } var bA = fA.Body; var bB = fB.Body; var typeA = bA.BodyType; var typeB = bB.BodyType; Debug.Assert(typeA == BodyType.Dynamic || typeB == BodyType.Dynamic); var activeA = bA.Awake && typeA != BodyType.Static; var activeB = bB.Awake && typeB != BodyType.Static; // Is at least one body active (awake and dynamic or kinematic)? if (activeA == false && activeB == false) { continue; } var collideA = (bA.IsBullet || typeA != BodyType.Dynamic) && (fA.IgnoreCCDWith & fB.CollisionCategories) == 0 && !bA.IgnoreCCD; var collideB = (bB.IsBullet || typeB != BodyType.Dynamic) && (fB.IgnoreCCDWith & fA.CollisionCategories) == 0 && !bB.IgnoreCCD; // Are these two non-bullet dynamic bodies? if (collideA == false && collideB == false) { continue; } // Compute the TOI for this contact. // Put the sweeps onto the same time interval. var alpha0 = bA._sweep.Alpha0; if (bA._sweep.Alpha0 < bB._sweep.Alpha0) { alpha0 = bB._sweep.Alpha0; bA._sweep.Advance(alpha0); } else if (bB._sweep.Alpha0 < bA._sweep.Alpha0) { alpha0 = bA._sweep.Alpha0; bB._sweep.Advance(alpha0); } Debug.Assert(alpha0 < 1.0f); // Compute the time of impact in interval [0, minTOI] var input = new TOIInput(); input.ProxyA = new DistanceProxy(fA.Shape, c.ChildIndexA); input.ProxyB = new DistanceProxy(fB.Shape, c.ChildIndexB); input.SweepA = bA._sweep; input.SweepB = bB._sweep; input.TMax = 1.0f; TOIOutput output; TimeOfImpact.CalculateTimeOfImpact(ref input, out output); // Beta is the fraction of the remaining portion of the . var beta = output.T; if (output.State == TOIOutputState.Touching) { alpha = Mathf.Min(alpha0 + (1.0f - alpha0) * beta, 1.0f); } else { alpha = 1.0f; } c._toi = alpha; c._flags &= ~ContactFlags.TOIFlag; } if (alpha < minAlpha) { // This is the minimum TOI found so far. minContact = c; minAlpha = alpha; } } if (minContact == null || 1.0f - 10.0f * Settings.Epsilon < minAlpha) { // No more TOI events. Done! _stepComplete = true; break; } // Advance the bodies to the TOI. var fA1 = minContact.FixtureA; var fB1 = minContact.FixtureB; var bA0 = fA1.Body; var bB0 = fB1.Body; var backup1 = bA0._sweep; var backup2 = bB0._sweep; bA0.Advance(minAlpha); bB0.Advance(minAlpha); // The TOI contact likely has some new contact points. minContact.Update(ContactManager); minContact._flags &= ~ContactFlags.TOIFlag; ++minContact._toiCount; // Is the contact solid? if (minContact.Enabled == false || minContact.IsTouching == false) { // Restore the sweeps. minContact._flags &= ~ContactFlags.EnabledFlag; bA0._sweep = backup1; bB0._sweep = backup2; bA0.SynchronizeTransform(); bB0.SynchronizeTransform(); continue; } bA0.Awake = true; bB0.Awake = true; // Build the island Island.Clear(); Island.Add(bA0); Island.Add(bB0); Island.Add(minContact); bA0._flags |= BodyFlags.IslandFlag; bB0._flags |= BodyFlags.IslandFlag; minContact._flags &= ~ContactFlags.IslandFlag; // Get contacts on bodyA and bodyB. Body[] bodies = { bA0, bB0 }; for (var i = 0; i < 2; ++i) { var body = bodies[i]; if (body.BodyType == BodyType.Dynamic) { for (var ce = body.ContactList; ce != null; ce = ce.Next) { var contact = ce.Contact; if (Island.BodyCount == Island.BodyCapacity) { break; } if (Island.ContactCount == Island.ContactCapacity) { break; } // Has this contact already been added to the island? if (contact.IslandFlag) { continue; } // Only add static, kinematic, or bullet bodies. var other = ce.Other; if (other.BodyType == BodyType.Dynamic && body.IsBullet == false && other.IsBullet == false) { continue; } // Skip sensors. if (contact.FixtureA.IsSensor || contact.FixtureB.IsSensor) { continue; } // Tentatively advance the body to the TOI. var backup = other._sweep; if (!other.IsIsland) { other.Advance(minAlpha); } // Update the contact points contact.Update(ContactManager); // Was the contact disabled by the user? if (contact.Enabled == false) { other._sweep = backup; other.SynchronizeTransform(); continue; } // Are there contact points? if (contact.IsTouching == false) { other._sweep = backup; other.SynchronizeTransform(); continue; } // Add the contact to the island minContact._flags |= ContactFlags.IslandFlag; Island.Add(contact); // Has the other body already been added to the island? if (other.IsIsland) { continue; } // Add the other body to the island. other._flags |= BodyFlags.IslandFlag; if (other.BodyType != BodyType.Static) { other.Awake = true; } Island.Add(other); } } } TimeStep subStep; subStep.dt = (1.0f - minAlpha) * step.dt; subStep.inv_dt = 1.0f / subStep.dt; subStep.dtRatio = 1.0f; Island.SolveTOI(ref subStep, bA0.IslandIndex, bB0.IslandIndex); // Reset island flags and synchronize broad-phase proxies. for (var i = 0; i < Island.BodyCount; ++i) { var body = Island.Bodies[i]; body._flags &= ~BodyFlags.IslandFlag; if (body.BodyType != BodyType.Dynamic) { continue; } body.SynchronizeFixtures(); // Invalidate all contact TOIs on this displaced body. for (var ce = body.ContactList; ce != null; ce = ce.Next) { ce.Contact._flags &= ~ContactFlags.TOIFlag; ce.Contact._flags &= ~ContactFlags.IslandFlag; } } // Commit fixture proxy movements to the broad-phase so that new contacts are created. // Also, some contacts can be destroyed. ContactManager.FindNewContacts(); if (Settings.EnableSubStepping) { _stepComplete = false; break; } } }
private void Solve(ref TimeStep step) { // Size the island for the worst case. Island.Reset(BodyList.Count, ContactManager.ContactList.Count, JointList.Count, ContactManager); // Clear all the island flags. foreach (var b in BodyList) { b._flags &= ~BodyFlags.IslandFlag; } foreach (var c in ContactManager.ContactList) { c._flags &= ~ContactFlags.IslandFlag; } foreach (var j in JointList) { j.IslandFlag = false; } // Build and simulate all awake islands. var stackSize = BodyList.Count; if (stackSize > _stack.Length) { _stack = new Body[Mathf.Max(_stack.Length * 2, stackSize)]; } for (var index = BodyList.Count - 1; index >= 0; index--) { var seed = BodyList[index]; if ((seed._flags & BodyFlags.IslandFlag) == BodyFlags.IslandFlag) { continue; } if (seed.Awake == false || seed.Enabled == false) { continue; } // The seed can be dynamic or kinematic. if (seed.BodyType == BodyType.Static) { continue; } // Reset island and stack. Island.Clear(); var stackCount = 0; _stack[stackCount++] = seed; seed._flags |= BodyFlags.IslandFlag; // Perform a depth first search (DFS) on the constraint graph. while (stackCount > 0) { // Grab the next body off the stack and add it to the island. var b = _stack[--stackCount]; Debug.Assert(b.Enabled); Island.Add(b); // Make sure the body is awake (without resetting sleep timer). b._flags |= BodyFlags.AwakeFlag; // To keep islands as small as possible, we don't // propagate islands across static bodies. if (b.BodyType == BodyType.Static) { continue; } // Search all contacts connected to this body. for (var ce = b.ContactList; ce != null; ce = ce.Next) { var contact = ce.Contact; // Has this contact already been added to an island? if (contact.IslandFlag) { continue; } // Is this contact solid and touching? if (ce.Contact.Enabled == false || ce.Contact.IsTouching == false) { continue; } // Skip sensors. var sensorA = contact.FixtureA.IsSensor; var sensorB = contact.FixtureB.IsSensor; if (sensorA || sensorB) { continue; } Island.Add(contact); contact._flags |= ContactFlags.IslandFlag; var other = ce.Other; // Was the other body already added to this island? if (other.IsIsland) { continue; } Debug.Assert(stackCount < stackSize); _stack[stackCount++] = other; other._flags |= BodyFlags.IslandFlag; } // Search all joints connect to this body. for (var je = b.JointList; je != null; je = je.Next) { if (je.Joint.IslandFlag) { continue; } var other = je.Other; // WIP David //Enter here when it's a non-fixed joint. Non-fixed joints have a other body. if (other != null) { // Don't simulate joints connected to inactive bodies. if (other.Enabled == false) { continue; } Island.Add(je.Joint); je.Joint.IslandFlag = true; if (other.IsIsland) { continue; } Debug.Assert(stackCount < stackSize); _stack[stackCount++] = other; other._flags |= BodyFlags.IslandFlag; } else { Island.Add(je.Joint); je.Joint.IslandFlag = true; } } } Island.Solve(ref step, ref Gravity); // Post solve cleanup. for (var i = 0; i < Island.BodyCount; ++i) { // Allow static bodies to participate in other islands. var b = Island.Bodies[i]; if (b.BodyType == BodyType.Static) { b._flags &= ~BodyFlags.IslandFlag; } } } // Synchronize fixtures, check for out of range bodies. foreach (var b in BodyList) { // If a body was not in an island then it did not move. if (!b.IsIsland) { continue; } if (b.BodyType == BodyType.Static) { continue; } // Update fixtures (for broad-phase). b.SynchronizeFixtures(); } // Look for new contacts. ContactManager.FindNewContacts(); }
public void FindCompiledJSONAsset() { Debug.Assert(inkAsset != null); jsonAsset = AssetDatabase.LoadAssetAtPath <TextAsset>(jsonPath); }
public InkFile(DefaultAsset inkAsset) { Debug.Assert(inkAsset != null); this.inkAsset = inkAsset; }
public int GetMaxElements(PersistableTypeHandle typeHandle) { Debug.Assert(typeHandle.IsValid, "Expected a valid type handle"); return(_allPersistableTypeInfos[typeHandle.Handle - 1].MaxElements); }
public bool IsBufferType(PersistableTypeHandle typeHandle) { Debug.Assert(typeHandle.IsValid, "Expected a valid type handle"); return(_allPersistableTypeInfos[typeHandle.Handle - 1].IsBuffer); }