public static void Log(this Object obj, string msg) { Debug.Log("[MKS] [" + (new StackTrace()).GetFrame(1).GetMethod().Name + "] " + msg); }
public static List <BurstCompileTarget> FindExecuteMethods(AssembliesType assemblyTypes) { var methodsToCompile = new List <BurstCompileTarget>(); var methodsToCompileSet = new HashSet <MethodInfo>(); var valueTypes = new List <TypeToVisit>(); var interfaceToProducer = new Dictionary <Type, Type>(); var assemblyList = GetAssemblyList(assemblyTypes); //Debug.Log("Filtered Assembly List: " + string.Join(", ", assemblyList.Select(assembly => assembly.GetName().Name))); // Find all ways to execute job types (via producer attributes) var typesVisited = new HashSet <string>(); var typesToVisit = new HashSet <string>(); foreach (var assembly in assemblyList) { var types = new List <Type>(); try { types.AddRange(assembly.GetTypes()); // Collect all generic type instances (excluding indirect instances) CollectGenericTypeInstances(assembly, types); } catch (Exception ex) { Debug.LogWarning("Unexpected exception while collecting types in assembly `" + assembly.FullName + "` Exception: " + ex); } for (var i = 0; i < types.Count; i++) { var t = types[i]; if (typesToVisit.Add(t.FullName)) { // Because the list of types returned by CollectGenericTypeInstances does not detect nested generic classes that are not // used explicitly, we need to create them if a declaring type is actually used // so for example if we have: // class MyClass<T> { class MyNestedClass { } } // class MyDerived : MyClass<int> { } // The CollectGenericTypeInstances will return typically the type MyClass<int>, but will not list MyClass<int>.MyNestedClass // So the following code is correcting this in order to fully query the full graph of generic instance types, including indirect types var nestedTypes = t.GetNestedTypes(BindingFlags.Public | BindingFlags.NonPublic); foreach (var nestedType in nestedTypes) { if (t.IsGenericType && !t.IsGenericTypeDefinition) { var parentGenericTypeArguments = t.GetGenericArguments(); // Only create nested types that are closed generic types (full generic instance types) // It happens if for example the parent class is `class MClass<T> { class MyNestedGeneric<T1> {} }` // In that case, MyNestedGeneric<T1> is closed in the context of MClass<int>, so we don't process them if (nestedType.GetGenericArguments().Length == parentGenericTypeArguments.Length) { var instanceNestedType = nestedType.MakeGenericType(parentGenericTypeArguments); types.Add(instanceNestedType); } } else { types.Add(nestedType); } } } } foreach (var t in types) { // If the type has been already visited, don't try to visit it if (!typesVisited.Add(t.FullName) || (t.IsGenericTypeDefinition && !t.IsInterface)) { continue; } try { // collect methods with types having a [BurstCompile] attribute bool visitStaticMethods = HasBurstCompileAttribute(t); bool isValueType = false; if (t.IsInterface) { object[] attrs = t.GetCustomAttributes(typeof(JobProducerTypeAttribute), false); if (attrs.Length == 0) { continue; } JobProducerTypeAttribute attr = (JobProducerTypeAttribute)attrs[0]; interfaceToProducer.Add(t, attr.ProducerType); //Debug.Log($"{t} has producer {attr.ProducerType}"); } else if (t.IsValueType) { // NOTE: Make sure that we don't use a value type generic definition (e.g `class Outer<T> { struct Inner { } }`) // We are only working on plain type or generic type instance! if (!t.IsGenericTypeDefinition) { isValueType = true; } } if (isValueType || visitStaticMethods) { valueTypes.Add(new TypeToVisit(t, visitStaticMethods)); } } catch (Exception ex) { Debug.LogWarning("Unexpected exception while inspecting type `" + t + "` IsConstructedGenericType: " + t.IsConstructedGenericType + " IsGenericTypeDef: " + t.IsGenericTypeDefinition + " IsGenericParam: " + t.IsGenericParameter + " Exception: " + ex); } } } //Debug.Log($"Mapped {interfaceToProducer.Count} producers; {valueTypes.Count} value types"); // Revisit all types to find things that are compilable using the above producers. foreach (var typePair in valueTypes) { var type = typePair.Type; // collect static [BurstCompile] methods if (typePair.CollectStaticMethods) { try { var methods = type.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic); foreach (var method in methods) { if (HasBurstCompileAttribute(method)) { var target = new BurstCompileTarget(method, type, null, true); methodsToCompile.Add(target); } } } catch (Exception ex) { Debug.LogException(ex); } } // If the type is not a value type, we don't need to proceed with struct Jobs if (!type.IsValueType) { continue; } // Otherwise try to find if we have an interface producer setup on the class foreach (var interfaceType in type.GetInterfaces()) { var genericLessInterface = interfaceType; if (interfaceType.IsGenericType) { genericLessInterface = interfaceType.GetGenericTypeDefinition(); } Type foundProducer; if (interfaceToProducer.TryGetValue(genericLessInterface, out foundProducer)) { var genericParams = new List <Type> { type }; if (interfaceType.IsGenericType) { genericParams.AddRange(interfaceType.GenericTypeArguments); } try { var executeType = foundProducer.MakeGenericType(genericParams.ToArray()); var executeMethod = executeType.GetMethod("Execute"); if (executeMethod == null) { throw new InvalidOperationException($"Burst reflection error. The type `{executeType}` does not contain an `Execute` method"); } // We will not try to record more than once a method in the methods to compile // This can happen if a job interface is inheriting from another job interface which are using in the end the same // job producer type if (methodsToCompileSet.Add(executeMethod)) { var target = new BurstCompileTarget(executeMethod, type, interfaceType, false); methodsToCompile.Add(target); } } catch (Exception ex) { Debug.LogException(ex); } } } } return(methodsToCompile); }
/// <summary>Generates the URL for a YouTube video thumbnail for the given id.</summary> public static string GenerateYouTubeThumbnailURL(string youTubeId) { Debug.Assert(youTubeId != null); return(@"https://img.youtube.com/vi/" + youTubeId + @"/hqdefault.jpg"); }
protected override void OnUpdate() { k_LayoutSharedMeshData.Begin(); int vertexCount = 0; int boneInfluencesCount = 0; int blendShapeVertexCount = 0; Parent.MeshHashToSharedBuffer.Clear(); foreach (var meshData in Parent.UniqueSharedMeshData) { Parent.MeshHashToSharedBuffer.Add(meshData.RenderMeshHash, new SharedMeshBufferIndex { GeometryIndex = vertexCount, BoneInfluencesIndex = boneInfluencesCount, BlendShapeIndex = blendShapeVertexCount }); vertexCount += meshData.VertexCount; boneInfluencesCount += meshData.BoneInfluencesCount; blendShapeVertexCount += meshData.BlendShapeVertexCount; } Debug.Assert(vertexCount == Parent.m_ResizeBuffersSystem.totalSharedVertexCount, $"vertexCount: {vertexCount} is expected to be equal to totalVertexCount {Parent.m_ResizeBuffersSystem.totalSharedVertexCount}."); k_LayoutSharedMeshData.End(); k_CollectSharedMeshData.Begin(); foreach (var meshData in Parent.UniqueSharedMeshData) { if (meshData.RenderMeshHash == 0) { continue; } var renderMesh = Parent.m_MeshHashToRenderMesh[meshData.RenderMeshHash]; var bufferIndex = Parent.MeshHashToSharedBuffer[meshData.RenderMeshHash]; Parent.MeshBufferManager.FetchMeshData(renderMesh.mesh, bufferIndex.GeometryIndex); if (meshData.HasSkinning) { Parent.SkinningBufferManager.FetchMeshData(renderMesh.mesh, bufferIndex.GeometryIndex, bufferIndex.BoneInfluencesIndex); } if (meshData.HasBlendShapes) { Parent.BlendShapeBufferManager.FetchMeshData(renderMesh.mesh, bufferIndex.GeometryIndex, bufferIndex.BlendShapeIndex); } } k_CollectSharedMeshData.End(); k_UploadSharedMeshData.Begin(); Parent.MeshBufferManager.PushMeshData(); Parent.BlendShapeBufferManager.PushSharedMeshData(); Parent.SkinningBufferManager.PushSharedMeshData(); k_UploadSharedMeshData.End(); Parent.m_RebuildSharedMeshBuffers = false; }
public static FloatTensor Concatenate(FloatTensorFactory factory, FloatTensor[] tensors_inp, int axis, FloatTensor result = null) { FloatTensor first = tensors_inp[0]; FloatTensor[] tensors = new FloatTensor[tensors_inp.Length - 1]; for (int i = 0; i < tensors_inp.Length - 1; i++) { tensors[i] = tensors_inp[i + 1]; } if (first.DataOnGpu) { throw new NotImplementedException("Can't concatenate GPU tensors yet"); } int num_new_rows = 0; List <IntTensor> int_tensors_for_index_add = new List <IntTensor>(); int[] first_indices = new int[first.Shape[axis]]; for (int i = 0; i < first.Shape[axis]; i++) { first_indices[i] = i + num_new_rows; } int_tensors_for_index_add.Add( factory.ctrl.intTensorFactory.Create(_shape: new int[1] { first.Shape[axis] }, _data: first_indices)); num_new_rows += first.Shape[axis]; foreach (FloatTensor tensor in tensors) { if (tensor.Shape.Length != first.Shape.Length) { throw new InvalidOperationException("Tensors do not have the same number of dimensions."); } for (int i = 0; i < tensor.Shape.Length; i++) { if (i != axis) { if (tensor.Shape[i] != first.Shape[i]) { throw new InvalidOperationException("Tensors do not have the same shape."); } } } if (tensor.DataOnGpu != first.DataOnGpu) { throw new InvalidOperationException("All tensors must be on the same device..."); } int[] indices = new int[tensor.Shape[axis]]; for (int i = 0; i < tensor.Shape[axis]; i++) { indices[i] = i + num_new_rows; } int_tensors_for_index_add.Add( factory.ctrl.intTensorFactory.Create(_shape: new int[1] { tensor.Shape[axis] }, _data: indices)); num_new_rows += tensor.Shape[axis]; } Debug.Log("Num new Rows:" + num_new_rows); int[] concat_shape = new int[first.Shape.Length]; for (int i = 0; i < first.Shape.Length; i++) { if (i == axis) { concat_shape[i] = num_new_rows; } else { concat_shape[i] = first.Shape[i]; } } result = first.HookGraph(ref result, tensor_inputs: tensors, creation_op: "concatenate_" + axis, inline: false, resultShape: concat_shape, indices: int_tensors_for_index_add.ToArray()); if (axis != 0) { result.IndexAdd(int_tensors_for_index_add[0], axis, first, inline: true); for (int i = 0; i < tensors.Length; i++) { result.IndexAdd(int_tensors_for_index_add[i + 1], axis, tensors[i], inline: true); } } else { //Debug.Log("Result Size:" + result.Size); //Debug.Log("First Size:" + first.Size); int result_i = 0; for (int i = 0; i < first.Data.Length; i++) { result.Data[result_i] = first.Data[i]; result_i += 1; } foreach (FloatTensor tensor in tensors) { //Debug.Log("Tensor Size:" + tensor.Size); for (int i = 0; i < tensor.Data.Length; i++) { result.Data[result_i] = tensor.Data[i]; result_i += 1; } } } return(result); }
private static void Init() { var projectDirectory = Directory.GetParent(Application.dataPath).FullName; var projectName = Path.GetFileName(projectDirectory); SlnFile = Path.GetFullPath($"{projectName}.sln"); InitializeEditorInstanceJson(); ResetDefaultFileExtensions(); // process csproj files once per Unity process if (!RiderScriptableSingleton.Instance.CsprojProcessedOnce) { // Perform on next editor frame update, so we avoid this exception: // "Must set an output directory through SetCompileScriptsOutputDirectory before compiling" EditorApplication.update += SyncSolutionOnceCallBack; } var lifetimeDefinition = Lifetime.Define(Lifetime.Eternal); var lifetime = lifetimeDefinition.Lifetime; AppDomain.CurrentDomain.DomainUnload += (EventHandler)((_, __) => { ourLogger.Verbose("lifetimeDefinition.Terminate"); lifetimeDefinition.Terminate(); }); if (PluginSettings.SelectedLoggingLevel >= LoggingLevel.VERBOSE) { Debug.Log($"Rider plugin initialized. LoggingLevel: {PluginSettings.SelectedLoggingLevel}. Change it in Unity Preferences -> Rider. Logs path: {LogPath}."); } var list = new List <ProtocolInstance>(); CreateProtocolAndAdvise(lifetime, list, new DirectoryInfo(Directory.GetCurrentDirectory()).Name); // list all sln files in CurrentDirectory, except main one and create server protocol for each of them var currentDir = new DirectoryInfo(Directory.GetCurrentDirectory()); var solutionFiles = currentDir.GetFiles("*.sln", SearchOption.TopDirectoryOnly); foreach (var solutionFile in solutionFiles) { if (Path.GetFileNameWithoutExtension(solutionFile.FullName) != currentDir.Name) { CreateProtocolAndAdvise(lifetime, list, Path.GetFileNameWithoutExtension(solutionFile.FullName)); } } ourOpenAssetHandler = new OnOpenAssetHandler(ourRiderPathLocator, ourPluginSettings, SlnFile); ourLogger.Verbose("Writing Library/ProtocolInstance.json"); var protocolInstanceJsonPath = Path.GetFullPath("Library/ProtocolInstance.json"); File.WriteAllText(protocolInstanceJsonPath, ProtocolInstance.ToJson(list)); AppDomain.CurrentDomain.DomainUnload += (sender, args) => { ourLogger.Verbose("Deleting Library/ProtocolInstance.json"); File.Delete(protocolInstanceJsonPath); }; PlayModeSavedState = GetPlayModeState(); SetupAssemblyReloadEvents(); ourInitialized = true; }
private static AllowedAssembly[] GetAssembliesInBuild() { #if ACTK_DEBUG_VERBOSE sw.Stop(); Debug.Log(ACTkConstants.LogPrefix + "Trying to guess which assemblies can get into the build..."); sw.Start(); #endif var libraries = BuildPostProcessor.GetGuessedLibrariesForBuild(); #if ACTK_DEBUG_VERBOSE sw.Stop(); Debug.Log(ACTkConstants.LogPrefix + "Total libraries candidates: " + libraries.Length); sw.Start(); var invalidAssemblies = string.Empty; #endif var result = new List <AllowedAssembly>(); foreach (var libraryPath in libraries) { #if ACTK_DEBUG_PARANIOD sw.Stop(); Debug.Log(ACTkConstants.LogPrefix + "Checking library at the path: " + libraryPath); sw.Start(); #endif try { var assName = AssemblyName.GetAssemblyName(libraryPath); var name = assName.Name; var hash = InjectionRoutines.GetAssemblyHash(assName); var allowed = result.FirstOrDefault(allowedAssembly => allowedAssembly.name == name); if (allowed != null) { allowed.AddHash(hash); } else { allowed = new AllowedAssembly(name, new[] { hash }); result.Add(allowed); } } catch { // not a valid IL assembly, skipping #if ACTK_DEBUG_VERBOSE invalidAssemblies += libraryPath + "\n"; #endif } } #if ACTK_DEBUG_VERBOSE if (!string.IsNullOrEmpty(invalidAssemblies)) { sw.Stop(); Debug.Log(ACTkConstants.LogPrefix + "Not valid assemblies:\n" + invalidAssemblies); sw.Start(); } #endif #if ACTK_DEBUG sw.Stop(); var trace = ACTkConstants.LogPrefix + "Found assemblies in build (" + result.Count + ", " + sw.ElapsedMilliseconds + " ms):\n"; foreach (var allowedAssembly in result) { trace += " Name: " + allowedAssembly.name + "\n"; trace = allowedAssembly.hashes.Aggregate(trace, (current, hash) => current + (" Hash: " + hash + "\n")); } Debug.Log(trace); sw.Start(); #endif return(result.ToArray()); }
protected static HashSet <string> GetActiveScriptCompilationDefines() { if (activeScriptCompilationDefines != null) { return(activeScriptCompilationDefines); } activeScriptCompilationDefines = new HashSet <string>(UnityEditor.EditorUserBuildSettings.activeScriptCompilationDefines); string rspText = null; try { string rspFileName = null; for (var i = 0; i < rspFileNames.Length; ++i) { if (System.IO.File.Exists(rspFileNames[i])) { rspFileName = rspFileNames[i]; break; } } if (rspFileName != null) { rspText = System.IO.File.ReadAllText(rspFileName); } } catch (System.Exception e) { Debug.LogException(e); } if (rspText != null) { var options = rspText.Split(optionsSeparators, StringSplitOptions.RemoveEmptyEntries); for (var i = options.Length; i-- > 0;) { var option = options[i]; if (option.StartsWith("-define:", StringComparison.OrdinalIgnoreCase) || option.StartsWith("/define:", StringComparison.OrdinalIgnoreCase)) { option = option.Substring("-define:".Length); } else if (option.StartsWith("-d:", StringComparison.OrdinalIgnoreCase) || option.StartsWith("/d:", StringComparison.OrdinalIgnoreCase)) { option = option.Substring("-d:".Length); } else { continue; } var defineOptions = option.Split(definesSeparators, StringSplitOptions.RemoveEmptyEntries); for (var j = defineOptions.Length; j-- > 0;) { activeScriptCompilationDefines.Add(defineOptions[j]); } } } return(activeScriptCompilationDefines); }
public static void Warn(string message) { Debug.LogWarning(message); }
public static void LogException(Exception e) { Debug.LogException(e); }
static ConditionalCompilationUtility() { var buildTargetGroup = EditorUserBuildSettings.selectedBuildTargetGroup; var defines = PlayerSettings.GetScriptingDefineSymbolsForGroup(buildTargetGroup).Split(';').ToList(); if (!defines.Contains(k_EnableCCU, StringComparer.OrdinalIgnoreCase)) { defines.Add(k_EnableCCU); PlayerSettings.SetScriptingDefineSymbolsForGroup(buildTargetGroup, string.Join(";", defines.ToArray())); // This will trigger another re-compile, which needs to happen, so all the custom attributes will be visible return; } var ccuDefines = new List <string> { k_EnableCCU }; var conditionalAttributeType = typeof(ConditionalAttribute); const string kDependentClass = "dependentClass"; const string kDefine = "define"; var attributeTypes = GetAssignableTypes(typeof(Attribute), type => { var conditionals = (ConditionalAttribute[])type.GetCustomAttributes(conditionalAttributeType, true); foreach (var conditional in conditionals) { if (string.Equals(conditional.ConditionString, k_EnableCCU, StringComparison.OrdinalIgnoreCase)) { var dependentClassField = type.GetField(kDependentClass); if (dependentClassField == null) { Debug.LogErrorFormat("[CCU] Attribute type {0} missing field: {1}", type.Name, kDependentClass); return(false); } var defineField = type.GetField(kDefine); if (defineField == null) { Debug.LogErrorFormat("[CCU] Attribute type {0} missing field: {1}", type.Name, kDefine); return(false); } } return(true); } return(false); }); var dependencies = new Dictionary <string, string>(); ForEachAssembly(assembly => { var typeAttributes = assembly.GetCustomAttributes(false).Cast <Attribute>(); foreach (var typeAttribute in typeAttributes) { if (attributeTypes.Contains(typeAttribute.GetType())) { var t = typeAttribute.GetType(); // These fields were already validated in a previous step var dependentClass = t.GetField(kDependentClass).GetValue(typeAttribute) as string; var define = t.GetField(kDefine).GetValue(typeAttribute) as string; if (!string.IsNullOrEmpty(dependentClass) && !string.IsNullOrEmpty(define) && !dependencies.ContainsKey(dependentClass)) { dependencies.Add(dependentClass, define); } } } }); ForEachAssembly(assembly => { foreach (var dependency in dependencies) { var type = assembly.GetType(dependency.Key); if (type != null) { var define = dependency.Value; if (!defines.Contains(define, StringComparer.OrdinalIgnoreCase)) { defines.Add(define); } ccuDefines.Add(define); } } }); ConditionalCompilationUtility.defines = ccuDefines.ToArray(); PlayerSettings.SetScriptingDefineSymbolsForGroup(buildTargetGroup, string.Join(";", defines.ToArray())); }
public static void LogError(object obj) { Debug.LogError("[UPDATER_LOG] " + obj); }
public static void LogWaring(object obj) { Debug.LogWarning("[UPDATER_LOG] " + obj); }
/// <summary> /// Reverts all changes that were done during or after the given tick /// </summary> public void RollbackTo(int tick, int missFrameTick, bool isNeedClear = true) { var snapshotIndices = Contexts.snapshot.GetEntities(SnapshotMatcher.Tick) .Where(entity => entity.tick.value <= tick).Select(entity => entity.tick.value).ToList(); if (snapshotIndices.Count <= 0) { return; } snapshotIndices.Sort(); UnityEngine.Debug.Assert(snapshotIndices.Count > 0 && snapshotIndices[0] <= tick, $"Error! no correct history frame to revert minTick{(snapshotIndices.Count > 0 ? snapshotIndices[0] : 0)} targetTick {tick}"); int i = snapshotIndices.Count - 1; for (; i >= 0; i--) { if (snapshotIndices[i] <= tick) { break; } } var resultTick = snapshotIndices[i]; if (resultTick == Tick) { Logging.Debug.Log("SelfTick should not rollback"); return; } var snaps = ""; foreach (var idx in snapshotIndices) { snaps += idx + " "; } Debug.Log( $"Rolling back {Tick}->{tick} :final from {resultTick} to {Contexts.gameState.tick.value} " + $"missTick:{missFrameTick} total:{Tick - resultTick} "); /* * ====================== Revert actors ====================== * most importantly: the entity-count per actor gets reverted so the composite key (Id + ActorId) of GameEntities stays in sync */ var backedUpActors = Contexts.actor.GetEntities(ActorMatcher.Backup).Where(e => e.backup.tick == resultTick); foreach (var backedUpActor in backedUpActors) { var target = Contexts.actor.GetEntityWithId(backedUpActor.backup.actorId); if (target == null) { target = Contexts.actor.CreateEntity(); target.AddId(backedUpActor.backup.actorId); } //CopyTo does NOT remove additional existing components, so remove them first var additionalComponentIndices = target.GetComponentIndices().Except( backedUpActor.GetComponentIndices() .Except(new[] { ActorComponentsLookup.Backup }) .Concat(new[] { ActorComponentsLookup.Id })); foreach (var index in additionalComponentIndices) { target.RemoveComponent(index); } backedUpActor.CopyTo(target, true, backedUpActor.GetComponentIndices().Except(new[] { ActorComponentsLookup.Backup }).ToArray()); } /* * ====================== Revert game-entities ====================== */ var currentEntities = Contexts.game.GetEntities(GameMatcher.LocalId); var backupEntities = Contexts.game.GetEntities(GameMatcher.Backup).Where(e => e.backup.tick == resultTick) .ToList(); var backupEntityIds = backupEntities.Select(entity => entity.backup.localEntityId); //Entities that were created in the prediction have to be destroyed var invalidEntities = currentEntities.Where(entity => !backupEntityIds.Contains(entity.localId.value)) .ToList(); foreach (var invalidEntity in invalidEntities) { invalidEntity.isDestroyed = true; } //将太后 和太前的snapshot 删除掉 if (isNeedClear) { foreach (var invalidBackupEntity in Contexts.actor.GetEntities(ActorMatcher.Backup) .Where(e => e.backup.tick != resultTick)) { invalidBackupEntity.Destroy(); } foreach (var invalidBackupEntity in Contexts.game.GetEntities(GameMatcher.Backup) .Where(e => e.backup.tick != resultTick)) { invalidBackupEntity.Destroy(); } foreach (var snapshotEntity in Contexts.snapshot.GetEntities(SnapshotMatcher.Tick) .Where(e => e.tick.value != resultTick)) { snapshotEntity.Destroy(); } } //Copy old state to the entity foreach (var backupEntity in backupEntities) { var target = Contexts.game.GetEntityWithLocalId(backupEntity.backup.localEntityId); if (target == null) { target = Contexts.game.CreateEntity(); target.AddLocalId(backupEntity.backup.localEntityId); } //CopyTo does NOT remove additional existing components, so remove them first var additionalComponentIndices = target.GetComponentIndices().Except( backupEntity.GetComponentIndices() .Except(new[] { GameComponentsLookup.Backup }) .Concat(new[] { GameComponentsLookup.LocalId })); foreach (var index in additionalComponentIndices) { target.RemoveComponent(index); } backupEntity.CopyTo(target, true, backupEntity.GetComponentIndices().Except(new[] { GameComponentsLookup.Backup }).ToArray()); } //TODO: restore locally destroyed entities //Cleanup game-entities that are marked as destroyed _systems.Cleanup(); Contexts.gameState.ReplaceTick(resultTick); _timeMachineService.RollbackTo(resultTick); _timeMachineService.CurTick = resultTick; }
protected override void OnUpdate() { k_ChangesMarker.Begin(); bool changeDetected = false; // Detect removed SharedMeshes Entities .WithNone <RenderMesh, DeformedEntity>() .WithStructuralChanges() .ForEach((Entity e, SharedMeshData meshData) => { Parent.MeshHashToInstanceCount[meshData.RenderMeshHash]--; var count = Parent.MeshHashToInstanceCount[meshData.RenderMeshHash]; // Clean-up if this was the last instance if (count == 0) { Parent.MeshHashToInstanceCount.Remove(meshData.RenderMeshHash); m_MeshHashToSharedMeshData.Remove(meshData.RenderMeshHash); #if ENABLE_COMPUTE_DEFORMATIONS Parent.m_MeshHashToRenderMesh.Remove(meshData.RenderMeshHash); totalSharedVertexCount -= meshData.VertexCount; totalBlendshapeVertexCount -= meshData.HasBlendShapes ? meshData.BlendShapeVertexCount : 0; totalBoneWeightCount -= meshData.HasSkinning ? meshData.BoneInfluencesCount : 0; #endif } #if ENABLE_COMPUTE_DEFORMATIONS if (meshData.HasBlendShapes) { EntityManager.RemoveComponent <BlendWeightBufferIndex>(e); } #endif if (meshData.HasSkinning) { EntityManager.RemoveComponent <SkinMatrixBufferIndex>(e); } EntityManager.RemoveComponent <SharedMeshData>(e); #if ENABLE_COMPUTE_DEFORMATIONS EntityManager.RemoveComponent <DeformedMeshIndex>(e); #endif changeDetected = true; }) .Run(); // Detect new SharedMeshes Entities .WithAll <DeformedEntity>() .WithNone <SharedMeshData>() .WithStructuralChanges() .ForEach((Entity e, RenderMesh renderMesh) => { if (m_MeshHashToSharedMeshData.TryGetValue(renderMesh.GetHashCode(), out var meshData)) { #if ENABLE_COMPUTE_DEFORMATIONS EntityManager.AddComponent <DeformedMeshIndex>(e); if (meshData.HasBlendShapes) { EntityManager.AddComponent <BlendWeightBufferIndex>(e); } #endif if (meshData.HasSkinning) { EntityManager.AddComponent <SkinMatrixBufferIndex>(e); } EntityManager.AddSharedComponentData(e, meshData); Parent.MeshHashToInstanceCount[meshData.RenderMeshHash]++; } else { var mesh = renderMesh.mesh; var meshHash = renderMesh.GetHashCode(); meshData = new SharedMeshData { VertexCount = mesh.vertexCount, BlendShapeCount = mesh.blendShapeCount, #if ENABLE_COMPUTE_DEFORMATIONS BlendShapeVertexCount = mesh.blendShapeCount > 0 ? Parent.BlendShapeBufferManager.CalculateSparseBlendShapeVertexCount(mesh) : 0, #else BlendShapeVertexCount = 0, #endif BoneCount = mesh.bindposes.Length, BoneInfluencesCount = mesh.GetAllBoneWeights().Length, RenderMeshHash = meshHash, }; #if ENABLE_COMPUTE_DEFORMATIONS EntityManager.AddComponent <DeformedMeshIndex>(e); if (meshData.HasBlendShapes) { EntityManager.AddComponent <BlendWeightBufferIndex>(e); } #endif if (meshData.HasSkinning) { EntityManager.AddComponent <SkinMatrixBufferIndex>(e); } EntityManager.AddSharedComponentData(e, meshData); Parent.MeshHashToInstanceCount.Add(meshHash, 1); m_MeshHashToSharedMeshData.Add(meshHash, meshData); #if ENABLE_COMPUTE_DEFORMATIONS Parent.m_MeshHashToRenderMesh.Add(meshHash, renderMesh); totalSharedVertexCount += meshData.VertexCount; totalBlendshapeVertexCount += meshData.HasBlendShapes ? meshData.BlendShapeVertexCount : 0; totalBoneWeightCount += meshData.HasSkinning ? meshData.BoneInfluencesCount : 0; // A new shared mesh was detected. Force the buffers to be uploaded. Parent.m_RebuildSharedMeshBuffers = true; #endif } changeDetected = true; }).Run(); #if ENABLE_COMPUTE_DEFORMATIONS // Sanity check for desired SharedMesh data sizes Debug.Assert(totalSharedVertexCount >= 0); Debug.Assert(totalBlendshapeVertexCount >= 0); Debug.Assert(totalBoneWeightCount >= 0); #endif k_ChangesMarker.End(); // Early exit if no changes are detected if (!changeDetected) { return; } k_ResizeMarker.Begin(); #if ENABLE_COMPUTE_DEFORMATIONS Parent.m_RebuildSharedMeshBuffers |= Parent.MeshBufferManager.ResizeSharedMeshBuffersIfRequired(totalSharedVertexCount); Parent.m_RebuildSharedMeshBuffers |= Parent.SkinningBufferManager.ResizeSharedBufferIfRequired(totalBoneWeightCount, totalSharedVertexCount); Parent.m_RebuildSharedMeshBuffers |= Parent.BlendShapeBufferManager.ResizeSharedBufferIfRequired(totalBlendshapeVertexCount, totalSharedVertexCount); #endif k_ResizeMarker.End(); k_OutputBuffer.Begin(); k_OutputCountBuffer.Begin(); #if ENABLE_COMPUTE_DEFORMATIONS int deformedMeshVertexCount = 0; int blendShapeWeightCount = 0; #endif int skinMatrixCount = 0; m_SharedMeshQuery.CompleteDependency(); Parent.UniqueSharedMeshData.Clear(); EntityManager.GetAllUniqueSharedComponentData(Parent.UniqueSharedMeshData); foreach (var meshData in Parent.UniqueSharedMeshData) { if (meshData.RenderMeshHash == 0) { continue; } int instanceCount = Parent.MeshHashToInstanceCount[meshData.RenderMeshHash]; #if ENABLE_COMPUTE_DEFORMATIONS deformedMeshVertexCount += instanceCount * meshData.VertexCount; if (meshData.HasBlendShapes) { blendShapeWeightCount += instanceCount * meshData.BlendShapeCount; } #endif if (meshData.HasSkinning) { skinMatrixCount += instanceCount * meshData.BoneCount; } } #if ENABLE_COMPUTE_DEFORMATIONS totalDeformedVertexCount = deformedMeshVertexCount; totalBlendShapeWeightCount = blendShapeWeightCount; #endif totalSkinMatrixCount = skinMatrixCount; k_OutputCountBuffer.End(); k_OutputResizeBuffer.Begin(); Parent.SkinningBufferManager.ResizePassBufferIfRequired(totalSkinMatrixCount); #if ENABLE_COMPUTE_DEFORMATIONS Parent.BlendShapeBufferManager.ResizePassBufferIfRequired(totalBlendshapeVertexCount); Parent.MeshBufferManager.ResizeAndPushDeformMeshBuffersIfRequired(totalDeformedVertexCount); #endif k_OutputResizeBuffer.End(); // Force the DeformedMesh layout to be updated. // As either; an deformed mesh has been removed, or a new one has been added. // Both result in a shift of indices. Parent.m_RebuildDeformedMeshBuffers = true; k_OutputBuffer.End(); }
public static void Error(string message) { Debug.LogError(message); }
public string GetAbsoluteFilePath(InkFile masterInkFile) { Debug.Log(masterInkFile.absoluteFolderPath); Debug.Log(relativeFilePath); return(System.IO.Path.Combine(masterInkFile.absoluteFolderPath, relativeFilePath)); }
public static void Message(string message) { Debug.Log(message); }
private static void Log(object msg) { Debug.Log(msg); }
private static void PushSameDependABToABUnit(IAssetDataQuerier varQuerier, List <string> varRepeatAssets, Dictionary <string, List <string> > varAssetBeDep, Dictionary <string, List <string> > varABBeDep, Dictionary <string, List <string> > varABDepABs) { var tempHashSetHelper = new HashSet <string>(); for (int iR = 0; iR < varRepeatAssets.Count; ++iR) { var tempAssetPath = varRepeatAssets[iR]; var tempAssetBeDeps = varAssetBeDep[tempAssetPath]; if (tempAssetBeDeps.Count < 2) { UDebug.LogErrorFormat("Repeat analysis error.[{0}]", tempAssetPath); iR++; continue; } tempHashSetHelper.Clear(); for (int iBD = 0; iBD < tempAssetBeDeps.Count; ++iBD) { var tempABName = tempAssetBeDeps[iBD]; tempHashSetHelper.UnionWith(varABDepABs[tempABName]); tempHashSetHelper.Add(tempABName); } var tempAllABDeps = tempHashSetHelper.OrderBy(a => a).ToList(); for (int iAD = tempAllABDeps.Count - 1; iAD >= 0; --iAD) { var tempABName = tempAllABDeps[iAD]; if (!varABBeDep.TryGetValue(tempABName, out var tempBeDeps)) { continue; } if (tempAssetBeDeps.Count != tempBeDeps.Count) { continue; } bool tempSame = true; for (int iBD = 0; iBD < tempAssetBeDeps.Count; ++iBD) { if (tempAssetBeDeps[iBD] == tempBeDeps[iBD]) { continue; } tempSame = false; break; } if (!tempSame) { continue; } varQuerier.SetAssetBundleName(tempAssetPath, tempABName); varRepeatAssets.RemoveAt(iR); iR++; break; } } }
public static CompiledTemplateData LoadRuntimeTemplates(Type type, TemplateSettings templateSettings) { CompiledTemplateData compiledTemplateData = TemplateCompiler.CompileTemplates(type, templateSettings); // Stopwatch stopwatch = Stopwatch.StartNew(); Func <UIElement, TemplateScope, UIElement>[] templates = new Func <UIElement, TemplateScope, UIElement> [compiledTemplateData.compiledTemplates.size]; Action <UIElement, UIElement>[] bindings = new Action <UIElement, UIElement> [compiledTemplateData.compiledBindings.size]; Func <UIElement, UIElement, TemplateScope, UIElement>[] slots = new Func <UIElement, UIElement, TemplateScope, UIElement> [compiledTemplateData.compiledSlots.size]; TemplateMetaData[] templateMetaData = new TemplateMetaData[compiledTemplateData.compiledTemplates.size]; OrderablePartitioner <Tuple <int, int> > partition; if (templateMetaData.Length < 10) { for (int i = 0; i < templateMetaData.Length; i++) { templates[i] = (Func <UIElement, TemplateScope, UIElement>)compiledTemplateData.compiledTemplates[i].templateFn.Compile(); } } else { partition = Partitioner.Create(0, templateMetaData.Length); Parallel.ForEach(partition, (range, loopState) => { for (int i = range.Item1; i < range.Item2; i++) { templates[i] = (Func <UIElement, TemplateScope, UIElement>)compiledTemplateData.compiledTemplates[i].templateFn.Compile(); } }); } if (compiledTemplateData.compiledSlots.size < 10) { for (int i = 0; i < compiledTemplateData.compiledSlots.size; i++) { slots[i] = (Func <UIElement, UIElement, TemplateScope, UIElement>)compiledTemplateData.compiledSlots[i].templateFn.Compile(); } } else { partition = Partitioner.Create(0, compiledTemplateData.compiledSlots.size); Parallel.ForEach(partition, (range, loopState) => { for (int i = range.Item1; i < range.Item2; i++) { slots[i] = (Func <UIElement, UIElement, TemplateScope, UIElement>)compiledTemplateData.compiledSlots[i].templateFn.Compile(); } }); } if (bindings.Length < 10) { for (int i = 0; i < bindings.Length; i++) { try { bindings[i] = (Action <UIElement, UIElement>)compiledTemplateData.compiledBindings[i].bindingFn.Compile(); } catch (Exception e) { Debug.Log("binding " + compiledTemplateData.compiledBindings[i].bindingFn.ToCSharpCode()); Debug.Log(e); } } } else { partition = Partitioner.Create(0, bindings.Length); Parallel.ForEach(partition, (range, loopState) => { for (int i = range.Item1; i < range.Item2; i++) { try { bindings[i] = (Action <UIElement, UIElement>)compiledTemplateData.compiledBindings[i].bindingFn.Compile(); } catch (Exception e) { Debug.Log("binding " + compiledTemplateData.compiledBindings[i].bindingFn.ToCSharpCode()); Debug.Log(e); } } }); } LightList <UIStyleGroupContainer> styleList = new LightList <UIStyleGroupContainer>(128); StyleSheet[] sheets = compiledTemplateData.styleImporter.GetImportedStyleSheets(); for (int i = 0; i < sheets.Length; i++) { StyleSheet sheet = sheets[i]; styleList.EnsureAdditionalCapacity(sheet.styleGroupContainers.Length); for (int j = 0; j < sheet.styleGroupContainers.Length; j++) { styleList.array[styleList.size++] = sheet.styleGroupContainers[j]; } } for (int i = 0; i < templateMetaData.Length; i++) { templateMetaData[i] = compiledTemplateData.compiledTemplates[i].templateMetaData; templateMetaData[i].styleMap = styleList.array; templateMetaData[i].BuildSearchMap(); } Dictionary <int, Func <ConstructedElement> > constructorFnMap = new Dictionary <int, Func <ConstructedElement> >(37); ConstructorInfo constructedTypeCtor = typeof(ConstructedElement).GetConstructor(new Type[] { typeof(int), typeof(UIElement) }); System.Diagnostics.Debug.Assert(constructedTypeCtor != null, nameof(constructedTypeCtor) + " != null"); compiledTemplateData.bindings = bindings; compiledTemplateData.slots = slots; compiledTemplateData.templates = templates; compiledTemplateData.templateMetaData = templateMetaData; compiledTemplateData.constructorFnMap = constructorFnMap; compiledTemplateData.constructElement = (typeId) => compiledTemplateData.constructorFnMap[typeId].Invoke(); // stopwatch.Stop(); // Debug.Log("Loaded UIForia templates in " + stopwatch.Elapsed.TotalSeconds.ToString("F2") + " seconds"); return(compiledTemplateData); }
private void ApplyInterpretedValues() { this.isAuthenticationInvalid = false; this.isServerUnreachable = false; this.isRequestUnresolvable = false; this.limitedUntilTimeStamp = -1; this.displayMessage = string.Empty; if (this.webRequest == null) { return; } // Interpret code switch (this.webRequest.responseCode) { // - Generic coding errors - // Bad Request case 400: // Method Not Allowed case 405: // Not Acceptable case 406: // Unsupported Media Type case 415: { this.displayMessage = ("Error synchronizing with the mod.io servers."); this.isRequestUnresolvable = true; Debug.LogWarning("[mod.io] " + this.ToUnityDebugString()); } break; // Bad authorization case 401: { this.displayMessage = ("Your mod.io authentication details have changed." + "\nLogging out and in again should correct this issue."); this.isAuthenticationInvalid = true; this.isRequestUnresolvable = true; } break; // Forbidden case 403: { this.displayMessage = ("Your account does not have the required permissions."); this.isRequestUnresolvable = true; } break; // Not found case 404: // Gone case 410: { this.displayMessage = ("A mod.io networking error was encountered." + "\nPlease report this as [" + this.webRequest.responseCode.ToString() + "@" + this.webRequest.url + "] to [email protected]"); this.isRequestUnresolvable = true; } break; // case 405: Handled Above // case 406: Handled Above // Timeout case 408: { this.displayMessage = ("The mod.io servers cannot be reached." + "\nPlease check your internet connection."); this.isServerUnreachable = true; } break; // case 410: Handled Above // Unprocessable Entity case 422: { var displayString = new System.Text.StringBuilder(); displayString.AppendLine("The submitted data contained error(s)."); if (this.fieldValidationMessages != null && this.fieldValidationMessages.Count > 0) { foreach (var kvp in fieldValidationMessages) { displayString.AppendLine("- [" + kvp.Key + "] " + kvp.Value); } } if (displayString.Length > 0 && displayString[displayString.Length - 1] == '\n') { --displayString.Length; } this.displayMessage = displayString.ToString(); this.isRequestUnresolvable = true; } break; // Too Many Requests case 429: { string retryAfterString; int retryAfterSeconds; var responseHeaders = this.webRequest.GetResponseHeaders(); if (!(responseHeaders.TryGetValue("X-Ratelimit-RetryAfter", out retryAfterString) && int.TryParse(retryAfterString, out retryAfterSeconds))) { retryAfterSeconds = 60; Debug.LogWarning("[mod.io] Too many APIRequests have been made, however" + " no valid X-Ratelimit-RetryAfter header was detected." + "\nPlease report this to [email protected] with the following information:" + "\n[" + this.webRequest.url + ":" + this.webRequest.method + "-" + this.errorMessage + "]"); } this.displayMessage = ("Too many requests have been made to the mod.io servers." + "\nReconnecting in " + retryAfterSeconds.ToString() + " seconds."); this.limitedUntilTimeStamp = this.timeStamp + retryAfterSeconds; } break; // Internal server error case 500: { this.displayMessage = ("There was an error with the mod.io servers. Staff have been" + " notified, and will attempt to fix the issue as soon as possible."); this.isRequestUnresolvable = true; } break; // Service Unavailable case 503: { this.displayMessage = "The mod.io servers are currently offline."; this.isServerUnreachable = true; } break; default: { // Cannot connect resolve destination host, used by Unity if (this.webRequest.responseCode <= 0) { this.displayMessage = ("The mod.io servers cannot be reached." + "\nPlease check your internet connection."); this.isServerUnreachable = true; } else { this.displayMessage = ("Error synchronizing with the mod.io servers."); this.isRequestUnresolvable = true; Debug.LogWarning("[mod.io] An unhandled error was returned during a web request." + "\nPlease report this to [email protected] with the following information:\n" + this.ToUnityDebugString()); } } break; } }
static void Log(object message) => Debug.Log(message);
public static void LogAsWarning(WebRequestError error) { Debug.LogWarning(error.ToUnityDebugString()); }
public static void logError(string message, Exception ex = null) { Debug.LogException(new ReportError(message, ex)); }
public override void Execute() { Debug.Log("启动框架"); }
public static void InvalidFinalCategory(CategoryIndex _interiorCategory) { Debug.Assert(false, $"Invalid final category {_interiorCategory}"); }
public async Task <Tuple <Stack <Rotation>, int, TimeSpan> > Solve() { return(await Task.Run(() => { Debug.Log("Start"); _stopwatch.Start(); var solutionPath = new Stack <Rotation>(); //Create open and closed lists var open = new Queue <CubeState>(); var closed = new Queue <CubeState>(); //Add the initial state to the open list open.Enqueue(_givenState); //Retrieve the possible rotations var possibleRotations = CubeState.GetPossibleRotations(); //Loop as long as states remain in the open list while (open.Any() && _exploredStates < 25000) { //Retrieve the first state in the open list var currentState = open.Dequeue(); _exploredStates++; Debug.Log("Dequeueing " + _exploredStates + ". Depth is " + currentState.depth); //Generate the children of the current state if the maximum search depth has not been reached if (currentState.depth <= MAX_DEPTH) { foreach (var rotation in possibleRotations) { //Generate the child state produced by the current rotation var childState = currentState.Clone(); childState.Rotate(rotation.FaceColor, rotation.Direction); //If the generated state is the goal, return the list of rotations leading to the solution if (childState.IsSolved()) { solutionPath.Push(rotation); var previousState = currentState; while (previousState.rotation != null) { solutionPath.Push(previousState.rotation); previousState = previousState.parentState; } Debug.Log("End"); _stopwatch.Stop(); return new Tuple <Stack <Rotation>, int, TimeSpan>(solutionPath, _generatedStates, _stopwatch.Elapsed); } //Check if the state is already on the open or closed list var alreadyExists = false; foreach (var existingState in open) { if (childState.EqualsState(existingState)) { alreadyExists = true; break; } } if (!alreadyExists) { foreach (var existingState in closed) { if (childState.EqualsState(existingState)) { alreadyExists = true; break; } } } //Add the child state to the open list if it does not already exist if (!alreadyExists) { childState.parentState = currentState; childState.rotation = rotation; childState.depth = (byte)(currentState.depth + 1); open.Enqueue(childState); _generatedStates++; } } } //Put the current state on the closed list closed.Enqueue(currentState); } //If no solution was found, return the empty list _stopwatch.Stop(); return new Tuple <Stack <Rotation>, int, TimeSpan>(solutionPath, _generatedStates, _stopwatch.Elapsed); })); }