diff --git a/Assets/AssetDependencyGraph.meta b/Assets/AssetDependencyGraph.meta new file mode 100644 index 0000000..d1dd24e --- /dev/null +++ b/Assets/AssetDependencyGraph.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: a359b65f33dc9df43950bf68bd99b6ee +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/AssetDependencyGraph/AssetDependencyGraph-Editor.asmdef b/Assets/AssetDependencyGraph/AssetDependencyGraph-Editor.asmdef new file mode 100644 index 0000000..69a8ee7 --- /dev/null +++ b/Assets/AssetDependencyGraph/AssetDependencyGraph-Editor.asmdef @@ -0,0 +1,14 @@ +{ + "name": "AssetDependencyGraph-Editor", + "references": [], + "optionalUnityReferences": [], + "includePlatforms": [ + "Editor" + ], + "excludePlatforms": [], + "allowUnsafeCode": false, + "overrideReferences": false, + "precompiledReferences": [], + "autoReferenced": true, + "defineConstraints": [] +} \ No newline at end of file diff --git a/Assets/AssetDependencyGraph/AssetDependencyGraph-Editor.asmdef.meta b/Assets/AssetDependencyGraph/AssetDependencyGraph-Editor.asmdef.meta new file mode 100644 index 0000000..ce2967d --- /dev/null +++ b/Assets/AssetDependencyGraph/AssetDependencyGraph-Editor.asmdef.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: 0f6edbbfd6f04b1479b191b629a0421f +AssemblyDefinitionImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/AssetDependencyGraph/Editor.meta b/Assets/AssetDependencyGraph/Editor.meta new file mode 100644 index 0000000..f500c85 --- /dev/null +++ b/Assets/AssetDependencyGraph/Editor.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 9303f9c952516f34cbc668b8d9217ee7 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/AssetDependencyGraph/Editor/AssetDefine.cs b/Assets/AssetDependencyGraph/Editor/AssetDefine.cs new file mode 100644 index 0000000..69d9342 --- /dev/null +++ b/Assets/AssetDependencyGraph/Editor/AssetDefine.cs @@ -0,0 +1,233 @@ +using MongoDB.Bson.Serialization.Attributes; +using MongoDB.Driver; +using System; +using System.Collections.Generic; +using System.Diagnostics.CodeAnalysis; + +namespace AssetDependencyGraph +{ + [BsonIgnoreExtraElements] + public class AssetIdentify + { + public string Path; + public string AssetType; + [AllowNull] + public string Guid; + [AllowNull] + public string Md5; + } + + [BsonIgnoreExtraElements] + public class AssetNode + { + public AssetIdentify Self; + public string AssetType; + public HashSet Dependencies = new(); + public HashSet Dependent = new(); + } + + [BsonIgnoreExtraElements] + public sealed class FolderNode : AssetNode + { + } + + [BsonIgnoreExtraElements] + public sealed class PackageNode : AssetNode + { + } + + public class AssetDependencyGraphDB + { + MongoClient client; + IMongoCollection FolderNodes; + IMongoCollection PackageNodes; + IMongoCollection AssetNodes; + Dictionary findCacheDic = new(); + + public AssetDependencyGraphDB(string user, string passwd, string ip) + { + MongoClientSettings settings = MongoClientSettings.FromUrl(new MongoUrl($"mongodb://{user}:{passwd}@{ip}:27017/")); + settings.ConnectTimeout = TimeSpan.FromSeconds(5); + settings.MinConnectionPoolSize = 1; + settings.MaxConnectionPoolSize = 25; + client = new MongoClient(settings); + var db = client.GetDatabase("assetgraph"); + FolderNodes = db.GetCollection("folder_nodes"); + PackageNodes = db.GetCollection("package_nodes"); + AssetNodes = db.GetCollection("asset_nodes"); + } + + public void Clean() + { + client.DropDatabase("assetgraph"); + var db = client.GetDatabase("assetgraph"); + FolderNodes = db.GetCollection("folder_nodes"); + PackageNodes = db.GetCollection("package_nodes"); + AssetNodes = db.GetCollection("asset_nodes"); + } + + public void UpdateOrInsert(T node) where T : AssetNode + { + switch (node) + { + case FolderNode folderNode: + { + var filter = Builders.Filter.And( + Builders.Filter.Eq(fn=>fn.Self.Path,node.Self.Path) + ); + var found = FolderNodes.Find(filter); + if (found == null || found.CountDocuments() == 0) + { + FolderNodes.InsertOne(folderNode); + } + else + { + var result = FolderNodes.UpdateOne(filter, Builders.Update.Combine( + Builders.Update.Set(fn => fn.Self, folderNode.Self), + Builders.Update.Set(fn => fn.AssetType, folderNode.AssetType), + Builders.Update.Set(fn => fn.Dependencies, folderNode.Dependencies), + Builders.Update.Set(fn => fn.Dependent, folderNode.Dependent) + )); + } + + break; + } + case PackageNode packageNode: + { + var filter = Builders.Filter.And( + Builders.Filter.Eq(fn => fn.Self.Path, node.Self.Path) + ); + var found = PackageNodes.Find(filter); + if (found == null || found.CountDocuments() == 0) + { + PackageNodes.InsertOne(packageNode); + } + else + { + var result = PackageNodes.UpdateOne(filter, Builders.Update.Combine( + Builders.Update.Set(fn => fn.Self, packageNode.Self), + Builders.Update.Set(fn => fn.AssetType, packageNode.AssetType), + Builders.Update.Set(fn => fn.Dependencies, packageNode.Dependencies), + Builders.Update.Set(fn => fn.Dependent, packageNode.Dependent) + )); + } + break; + } + case AssetNode assetNode: + { + var filter = Builders.Filter.And( + Builders.Filter.Eq(fn => fn.Self.Path, node.Self.Path) + ); + var found = AssetNodes.Find(filter); + if (found == null || found.CountDocuments() == 0) + { + AssetNodes.InsertOne(assetNode); + } + else + { + var result = AssetNodes.UpdateOne(filter, Builders.Update.Combine( + Builders.Update.Set(fn => fn.Self, assetNode.Self), + Builders.Update.Set(fn => fn.AssetType, assetNode.AssetType), + Builders.Update.Set(fn => fn.Dependencies, assetNode.Dependencies), + Builders.Update.Set(fn => fn.Dependent, assetNode.Dependent) + )); + } + break; + } + default: + break; + } + } + + public void Delete(T node) where T : AssetNode + { + switch (node) + { + case FolderNode folderNode: + { + var filter = Builders.Filter.And( + Builders.Filter.Eq(fn => fn.Self.Path, node.Self.Path) + ); + var found = FolderNodes.Find(filter); + if (found != null && found.CountDocuments() == 0) + { + // TODO: del ref dep + FolderNodes.DeleteOne(filter); + } + break; + } + case PackageNode packageNode: + { + var filter = Builders.Filter.And( + Builders.Filter.Eq(fn => fn.Self.Path, node.Self.Path) + ); + var found = PackageNodes.Find(filter); + if (found != null && found.CountDocuments() == 0) + { + // TODO: del ref dep + PackageNodes.DeleteOne(filter); + } + break; + } + case AssetNode assetNode: + { + var filter = Builders.Filter.And( + Builders.Filter.Eq(fn => fn.Self.Path, node.Self.Path) + ); + var found = AssetNodes.Find(filter); + if (found != null && found.CountDocuments() == 0) + { + // TODO: del ref dep + AssetNodes.DeleteOne(filter); + } + break; + } + default: + break; + } + } + + public AssetNode Find(string path) + { + if(findCacheDic.TryGetValue(path, out var assetNode)) + { + return assetNode; + } + + var filter = Builders.Filter.And( + Builders.Filter.Eq(fn => fn.Self.Path, path) + ); + var found = AssetNodes.Find(filter); + if (found != null && found.CountDocuments() != 0) + { + assetNode = found.First(); + findCacheDic[path] = assetNode; + return assetNode; + } + + var filter1 = Builders.Filter.And( + Builders.Filter.Eq(fn => fn.Self.Path, path) + ); + var found1 = PackageNodes.Find(filter1); + if (found1 != null && found1.CountDocuments() != 0) + { + assetNode = found1.First(); + findCacheDic[path] = assetNode; + return assetNode; + } + + var filter2 = Builders.Filter.And( + Builders.Filter.Eq(fn => fn.Self.Path, path) + ); + var found2 = FolderNodes.Find(filter2); + if (found2 != null && found2.CountDocuments() != 0) + { + assetNode = found2.First(); + findCacheDic[path] = assetNode; + return assetNode; + } + + return null; + } + } +} diff --git a/Assets/AssetDependencyGraph/Editor/AssetDefine.cs.meta b/Assets/AssetDependencyGraph/Editor/AssetDefine.cs.meta new file mode 100644 index 0000000..184b12b --- /dev/null +++ b/Assets/AssetDependencyGraph/Editor/AssetDefine.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 3b678f0fc58371c4cb7735b9906443fd +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/AssetDependencyGraph/Editor/AssetDependencyGraph.cs b/Assets/AssetDependencyGraph/Editor/AssetDependencyGraph.cs new file mode 100644 index 0000000..2fa697a --- /dev/null +++ b/Assets/AssetDependencyGraph/Editor/AssetDependencyGraph.cs @@ -0,0 +1,911 @@ +using System.Collections.Generic; +using UnityEditor; +using UnityEditor.Experimental.GraphView; +using UnityEditor.UIElements; +using UnityEngine; +using UnityEngine.UIElements; +using Object = UnityEngine.Object; + +namespace AssetDependencyGraph +{ + public class AssetGraphView : GraphView + { + public AssetGraphView() + { + SetupZoom(ContentZoomer.DefaultMinScale, ContentZoomer.DefaultMaxScale); + + this.AddManipulator(new ContentDragger()); + this.AddManipulator(new SelectionDragger()); + this.AddManipulator(new RectangleSelector()); + this.AddManipulator(new FreehandSelector()); + + VisualElement background = new VisualElement + { + style = + { + backgroundColor = new Color(0.17f, 0.17f, 0.17f, 1f) + } + }; + Insert(0, background); + + background.StretchToParentSize(); + } + } + + public class AssetGroup + { + public AssetNode AssetNode; + public Group GroupNode = new Group(); + public Node MainGraphNode = new Node(); + public Rect MainGraphNodeLastPosition = new Rect(); + public List AssetGraphNodes = new List(); + public List AssetGraphConnections = new List(); + public List DependenciesForPlacement = new List(); + } + + + public class AssetDependencyGraph : EditorWindow + { + private const float NodeWidth = 300.0f; + DependencyAnalyzer da = new DependencyAnalyzer(); + AssetDependencyGraphDB db = new AssetDependencyGraphDB("admin", "CCS20190109", "10.225.0.170"); + + Dictionary type2Toogle = new(); + (string assetType, bool show)[] assetTypeHidenTogleItems = new[] { + ("MonoScript", true), ("Material", false), ("Shader", true), + ("ComputeShader" ,true), ("AudioClip", false), ("VideoClip", false), + ("AnimationClip", false), ("Executable" , true), ("UnityAssembly", true), + ("SourceFile", true), ("VolumeProfile", true), + }; + + Toggle AlignmentToggle; + + private GraphView graphView; + + private readonly List selectedObjects = new List(); + private readonly List assetGroups = new List(); + + private readonly Dictionary fullPathNodeLookup = new Dictionary(); + + [MenuItem("Window/Asset Dependency Graph")] + public static void CreateTestGraphViewWindow() + { + var window = GetWindow(true); + window.titleContent = new GUIContent("Asset Dependency Graph"); + } + + public void OnEnable() + { + CreateGraph(); + } + + public void OnDisable() + { + rootVisualElement.Remove(graphView); + } + + void CreateGraph() + { + graphView = new AssetGraphView + { + name = "Asset Dependency Graph", + }; + + VisualElement toolbar = CreateToolbar(); + VisualElement toolbar2 = CreateFilterbar(); + + rootVisualElement.Add(toolbar); + rootVisualElement.Add(toolbar2); + rootVisualElement.Add(graphView); + graphView.StretchToParentSize(); + toolbar.BringToFront(); + toolbar2.BringToFront(); + } + + VisualElement CreateToolbar() + { + var toolbar = new VisualElement + { + style = + { + flexDirection = FlexDirection.Row, + flexGrow = 0, + backgroundColor = new Color(0.25f, 0.25f, 0.25f, 0.75f) + } + }; + + var options = new VisualElement + { + style = { alignContent = Align.Center } + }; + + toolbar.Add(options); + toolbar.Add(new Button(ExploreAsset) + { + text = "Explore Asset", + }); + toolbar.Add(new Button(ClearGraph) + { + text = "Clear" + }); + toolbar.Add(new Button(ResetGroups) + { + text = "Reset Groups" + }); + toolbar.Add(new Button(ResetAllNodes) + { + text = "Reset Nodes" + }); + toolbar.Add(new Button(() => + { + da.Analyze(Application.dataPath); + }) + { + text = "Analyze Asset" + }); + + var ts = new ToolbarSearchField(); + ts.RegisterValueChangedCallback(x => + { + if (string.IsNullOrEmpty(x.newValue)) + { + graphView.FrameAll(); + return; + } + + graphView.ClearSelection(); + graphView.graphElements.ToList().ForEach(y => + { + if (y is Node node && y.title.IndexOf(x.newValue, System.StringComparison.OrdinalIgnoreCase) >= 0) + { + graphView.AddToSelection(node); + } + }); + + graphView.FrameSelection(); + }); + toolbar.Add(ts); + + AlignmentToggle = new Toggle(); + AlignmentToggle.text = "Horizontal Layout"; + AlignmentToggle.value = true; + AlignmentToggle.RegisterValueChangedCallback(x => + { + ResetAllNodes(); + }); + toolbar.Add(AlignmentToggle); + + return toolbar; + } + + VisualElement CreateFilterbar() + { + var toolbar = new VisualElement + { + style = + { + flexDirection = FlexDirection.Row, + flexGrow = 0, + backgroundColor = new Color(0.25f, 0.25f, 0.25f, 0.75f) + } + }; + + var options = new VisualElement + { + style = { alignContent = Align.Center } + }; + + toolbar.Add(options); + + toolbar.Add(new Label("Filters: ")); + foreach (var pair in assetTypeHidenTogleItems) + { + var assetTypeTogle = new Toggle(); + assetTypeTogle.text = "Hide " + pair.assetType; + assetTypeTogle.value = pair.show; + assetTypeTogle.RegisterValueChangedCallback(x => + { + FilterAssetGroups(); + }); + toolbar.Add(assetTypeTogle); + type2Toogle[pair.assetType] = assetTypeTogle; + } + + return toolbar; + } + + private void ExploreAsset() + { + Object[] objs = Selection.objects; + + foreach (var obj in objs) + { + //Prevent readding same object + if (selectedObjects.Contains(obj)) + { + Debug.Log("Object already loaded"); + return; + } + selectedObjects.Add(obj); + + AssetGroup AssetGroup = new AssetGroup(); + AssetGroup.AssetNode = db.Find(AssetDatabase.GetAssetPath(obj).ToUnityFullPath()); + assetGroups.Add(AssetGroup); + + // assetPath will be empty if obj is null or isn't an asset (a scene object) + if (obj == null) + return; + + AssetGroup.GroupNode = new Group { title = obj.name }; + + PopulateGroup(AssetGroup, obj, new Rect(10, graphView.contentRect.height / 2, 0, 0)); + } + + } + + void PopulateGroup(AssetGroup AssetGroup, Object obj, Rect position) + { + if (obj == null) + { + obj = AssetDatabase.LoadMainAssetAtPath(AssetGroup.AssetNode.Self.Path.ToUnityRelatePath()); + + if (obj == null) + { + Debug.Log("Object doesn't exist anymore"); + return; + } + } + + AssetGroup.MainGraphNode = CreateNode(AssetGroup, AssetGroup.AssetNode, obj, true); + AssetGroup.MainGraphNode.userData = 0; + AssetGroup.MainGraphNode.SetPosition(position); + + if (!graphView.Contains(AssetGroup.GroupNode)) + { + graphView.AddElement(AssetGroup.GroupNode); + } + + graphView.AddElement(AssetGroup.MainGraphNode); + + AssetGroup.GroupNode.AddElement(AssetGroup.MainGraphNode); + + CreateDependencyNodes(AssetGroup, AssetGroup.AssetNode, AssetGroup.MainGraphNode, AssetGroup.GroupNode, 1); + CreateDependentNodes(AssetGroup, AssetGroup.AssetNode, AssetGroup.MainGraphNode, AssetGroup.GroupNode, -1); + + AssetGroup.AssetGraphNodes.Add(AssetGroup.MainGraphNode); + AssetGroup.GroupNode.capabilities &= ~Capabilities.Deletable; + + AssetGroup.GroupNode.Focus(); + + AssetGroup.MainGraphNode.RegisterCallback( + UpdateGroupDependencyNodePlacement, AssetGroup + ); + } + + //Recreate the groups but use the already created groups instead of new ones + void FilterAssetGroups() + { + + //first collect the main node's position and then clear the graph + foreach (var AssetGroup in assetGroups) + { + AssetGroup.MainGraphNodeLastPosition = AssetGroup.MainGraphNode.GetPosition(); + } + + fullPathNodeLookup.Clear(); + + foreach (var AssetGroup in assetGroups) + { + //clear the nodes and dependencies after getting the position of the main node + CleanGroup(AssetGroup); + + PopulateGroup(AssetGroup, null, AssetGroup.MainGraphNodeLastPosition); + } + } + + void CleanGroup(AssetGroup assetGroup) + { + if (assetGroup.AssetGraphConnections.Count > 0) + { + foreach (var edge in assetGroup.AssetGraphConnections) + { + graphView.RemoveElement(edge); + } + } + assetGroup.AssetGraphConnections.Clear(); + + foreach (var node in assetGroup.AssetGraphNodes) + { + graphView.RemoveElement(node); + } + assetGroup.AssetGraphNodes.Clear(); + + assetGroup.DependenciesForPlacement.Clear(); + } + + private void CreateDependencyNodes(AssetGroup assetGroup, AssetNode asssetNode, Node selfGraphNode, Group groupGraphNode, int depth) + { + foreach (var dependAssetId in asssetNode.Dependencies) + { + AssetNode dependAssetNode = db.Find(dependAssetId.Path); + var typeName = dependAssetNode.AssetType; + //filter out selected asset types + if (FilterType(typeName)) + { + continue; + } + + Node dependGraphNode = CreateNode(assetGroup, dependAssetNode, AssetDatabase.LoadMainAssetAtPath(dependAssetId.Path.ToUnityRelatePath()), false); + + if (!assetGroup.AssetGraphNodes.Contains(dependGraphNode)) + { + dependGraphNode.userData = depth; + } + + //CreateDependencyNodes(assetGroup, dependAssetNode, dependGraphNode, groupGraphNode, depth + 1); + + //if the node doesnt exists yet, put it in the group + if (!graphView.Contains(dependGraphNode)) + { + graphView.AddElement(dependGraphNode); + + assetGroup.DependenciesForPlacement.Add(dependGraphNode); + groupGraphNode.AddElement(dependGraphNode); + } + else + { + //TODO: if it already exists, put it in a separate group for shared assets + //Check if the dependencyNode is in the same group or not + //if it's a different group move it to a new shared group + /* + if (SharedToggle.value) { + if (!assetGroup.m_AssetNodes.Contains(dependencyNode)) { + if (assetGroup.SharedGroup == null) { + assetGroup.SharedGroup = new AssetGroup(); + + AssetGroups.Add(assetGroup.SharedGroup); + assetGroup.SharedGroup.assetPath = assetGroup.assetPath; + + assetGroup.SharedGroup.groupNode = new Group { title = "Shared Group" }; + + assetGroup.SharedGroup.mainNode = dependencyNode; + assetGroup.SharedGroup.mainNode.userData = 0; + } + + if (!m_GraphView.Contains(assetGroup.SharedGroup.groupNode)) { + m_GraphView.AddElement(assetGroup.SharedGroup.groupNode); + } + + //add the node to the group and remove it from the previous group + assetGroup.m_AssetNodes.Remove(dependencyNode); + //assetGroup.groupNode.RemoveElement(dependencyNode); + assetGroup.m_DependenciesForPlacement.Remove(dependencyNode); + + assetGroup.SharedGroup.m_DependenciesForPlacement.Add(dependencyNode); + + if (!assetGroup.SharedGroup.groupNode.ContainsElement(dependencyNode)) { + assetGroup.SharedGroup.groupNode.AddElement(dependencyNode); + } + + assetGroup.SharedGroup.m_AssetNodes.Add(dependencyNode); + } + }*/ + } + + Edge edge = CreateEdge(dependGraphNode, selfGraphNode); + + assetGroup.AssetGraphConnections.Add(edge); + assetGroup.AssetGraphNodes.Add(dependGraphNode); + } + + } + + private void CreateDependentNodes(AssetGroup assetGroup, AssetNode asssetNode, Node selfGraphNode, Group groupGraphNode, int depth) + { + foreach (var dependAssetId in asssetNode.Dependent) + { + AssetNode dependAssetNode = db.Find(dependAssetId.Path); + var typeName = dependAssetNode.AssetType; + //filter out selected asset types + if (FilterType(typeName)) + { + continue; + } + + Node dependentGraphNode = CreateNode(assetGroup, dependAssetNode, AssetDatabase.LoadMainAssetAtPath(dependAssetId.Path.ToUnityRelatePath()), false); + + if (!assetGroup.AssetGraphNodes.Contains(dependentGraphNode)) + { + dependentGraphNode.userData = depth; + } + + //CreateDependencyNodes(assetGroup, dependAssetNode, dependGraphNode, groupGraphNode, depth - 1); + + //if the node doesnt exists yet, put it in the group + if (!graphView.Contains(dependentGraphNode)) + { + graphView.AddElement(dependentGraphNode); + + assetGroup.DependenciesForPlacement.Add(dependentGraphNode); + groupGraphNode.AddElement(dependentGraphNode); + } + else + { + //TODO: if it already exists, put it in a separate group for shared assets + //Check if the dependencyNode is in the same group or not + //if it's a different group move it to a new shared group + /* + if (SharedToggle.value) { + if (!assetGroup.m_AssetNodes.Contains(dependencyNode)) { + if (assetGroup.SharedGroup == null) { + assetGroup.SharedGroup = new AssetGroup(); + + AssetGroups.Add(assetGroup.SharedGroup); + assetGroup.SharedGroup.assetPath = assetGroup.assetPath; + + assetGroup.SharedGroup.groupNode = new Group { title = "Shared Group" }; + + assetGroup.SharedGroup.mainNode = dependencyNode; + assetGroup.SharedGroup.mainNode.userData = 0; + } + + if (!m_GraphView.Contains(assetGroup.SharedGroup.groupNode)) { + m_GraphView.AddElement(assetGroup.SharedGroup.groupNode); + } + + //add the node to the group and remove it from the previous group + assetGroup.m_AssetNodes.Remove(dependencyNode); + //assetGroup.groupNode.RemoveElement(dependencyNode); + assetGroup.m_DependenciesForPlacement.Remove(dependencyNode); + + assetGroup.SharedGroup.m_DependenciesForPlacement.Add(dependencyNode); + + if (!assetGroup.SharedGroup.groupNode.ContainsElement(dependencyNode)) { + assetGroup.SharedGroup.groupNode.AddElement(dependencyNode); + } + + assetGroup.SharedGroup.m_AssetNodes.Add(dependencyNode); + } + }*/ + } + + Edge edge = CreateEdge(selfGraphNode, dependentGraphNode); + + assetGroup.AssetGraphConnections.Add(edge); + assetGroup.AssetGraphNodes.Add(dependentGraphNode); + } + } + + Edge CreateEdge(Node dependencyNode, Node parentNode) + { + Edge edge = new Edge + { + input = dependencyNode.inputContainer[0] as Port, + output = parentNode.outputContainer[0] as Port, + }; + edge.input?.Connect(edge); + edge.output?.Connect(edge); + + dependencyNode.RefreshPorts(); + + graphView.AddElement(edge); + + edge.capabilities &= ~Capabilities.Deletable; + + return edge; + } + + private Node CreateNode(AssetGroup assetGroup, AssetNode assetNode, Object obj, bool isMainNode) + { + Node resultNode; + string fullPath = assetNode.Self.Path; + if (fullPathNodeLookup.TryGetValue(fullPath, out resultNode)) + { + //----not sure what this is, the more dependencies the further removed on the chart? + //int currentDepth = (int)resultNode.userData; + //resultNode.userData = currentDepth + 1; + return resultNode; + } + + if (AssetDatabase.TryGetGUIDAndLocalFileIdentifier(obj, out var assetGuid, out long _)) + { + var objNode = new Node + { + title = obj.name, + style = + { + width = NodeWidth + } + }; + + objNode.extensionContainer.style.backgroundColor = new Color(0.24f, 0.24f, 0.24f, 0.8f); + + #region Select button + objNode.titleContainer.Add(new Button(() => + { + Selection.activeObject = obj; + EditorGUIUtility.PingObject(obj); + }) + { + style = + { + height = 16.0f, + alignSelf = Align.Center, + alignItems = Align.Center + }, + text = "Select" + }); + objNode.titleContainer.Add(new Button(() => + { + // assetNode + }) + { + style = + { + height = 16.0f, + alignSelf = Align.Center, + alignItems = Align.Center + }, + text = "Delete" + }); + #endregion + + #region Padding + var infoContainer = new VisualElement + { + style = + { + paddingBottom = 4.0f, + paddingTop = 4.0f, + paddingLeft = 4.0f, + paddingRight = 4.0f + } + }; + #endregion + + #region Asset Path, removed to improve visibility with large amount of assets + // infoContainer.Add(new Label { + // text = assetPath, + //#if UNITY_2019_1_OR_NEWER + // style = { whiteSpace = WhiteSpace.Normal } + //#else + // style = { wordWrap = true } + //#endif + // }); + #endregion + + #region Asset type + var typeName = assetNode.AssetType; + + var typeLabel = new Label + { + text = $"Type: {typeName}", + }; + infoContainer.Add(typeLabel); + + objNode.extensionContainer.Add(infoContainer); + #endregion + + var typeContainer = new VisualElement + { + style = + { + paddingBottom = 4.0f, + paddingTop = 4.0f, + paddingLeft = 4.0f, + paddingRight = 4.0f, + backgroundColor = GetColorByAssetType(typeName) + } + }; + + objNode.extensionContainer.Add(typeContainer); + + #region Node Icon, replaced with color + //Texture assetTexture = AssetPreview.GetAssetPreview(obj); + //if (!assetTexture) + // assetTexture = AssetPreview.GetMiniThumbnail(obj); + + //if (assetTexture) + //{ + // AddDivider(objNode); + + // objNode.extensionContainer.Add(new Image + // { + // image = assetTexture, + // scaleMode = ScaleMode.ScaleToFit, + // style = + // { + // paddingBottom = 4.0f, + // paddingTop = 4.0f, + // paddingLeft = 4.0f, + // paddingRight = 4.0f + // } + // }); + //} + #endregion + + // Ports + var dependentAmount = 0; + foreach (var item in assetNode.Dependent) + { + if (item.AssetType != "Folder") + { + ++dependentAmount; + } + } + if (assetNode.Dependent.Count > 0) + { + Port port = objNode.InstantiatePort(Orientation.Horizontal, Direction.Input, Port.Capacity.Single, typeof(Object)); + port.Add(new Button(() => + { + CreateDependentNodes(assetGroup, assetNode, fullPathNodeLookup[fullPath], assetGroup.GroupNode, (int)fullPathNodeLookup[fullPath].userData - 1); + EditorApplication.delayCall += () => ResetAllNodes(); + }) + { + style = + { + height = 16.0f, + alignSelf = Align.Center, + alignItems = Align.Center + }, + text = "展开" + }); + port.portName = dependentAmount + "个引用"; + objNode.inputContainer.Add(port); + } + + var dependencyAmount = assetNode.Dependencies.Count; + if (dependencyAmount > 0) + { + Port port = objNode.InstantiatePort(Orientation.Horizontal, Direction.Output, Port.Capacity.Single, typeof(Object)); + port.Add(new Button(() => + { + CreateDependencyNodes(assetGroup, assetNode, fullPathNodeLookup[fullPath], assetGroup.GroupNode, (int)fullPathNodeLookup[fullPath].userData + 1); + EditorApplication.delayCall += () => ResetAllNodes(); + + }) + { + style = + { + height = 16.0f, + alignSelf = Align.Center, + alignItems = Align.FlexEnd + }, + text = "展开" + }); + port.portName = dependencyAmount + "个依赖"; + objNode.outputContainer.Add(port); + objNode.RefreshPorts(); + } + + resultNode = objNode; + + resultNode.RefreshExpandedState(); + resultNode.RefreshPorts(); + resultNode.capabilities &= ~Capabilities.Deletable; + resultNode.capabilities |= Capabilities.Collapsible; + } + fullPathNodeLookup[fullPath] = resultNode; + return resultNode; + } + + bool FilterType(string type) + { + if (type2Toogle.TryGetValue(type, out var result)) + { + return result.value; + } + + return false; + } + + + StyleColor GetColorByAssetType(string typeName) + { + switch (typeName) + { + case "MonoScript": + return Color.black; + case "Material": + return new Color(0.1f, 0.5f, 0.1f); //green + case "Texture2D": + return new Color(0.5f, 0.1f, 0.1f); //red + case "RenderTexture": + return new Color(0.8f, 0.1f, 0.1f); //red + case "Shader": + return new Color(0.1f, 0.1f, 0.5f); //dark blue + case "ComputeShader": + return new Color(0.1f, 0.1f, 0.5f); //dark blue + case "GameObject": + return new Color(0f, 0.8f, 0.7f); //light blue + case "AnimationClip": + return new Color(1, 0.7f, 1); //pink + case "AnimatorController": + return new Color(1, 0.7f, 0.8f); //pink + case "AudioClip": + return new Color(1, 0.8f, 0); //orange + case "AudioMixerController": + return new Color(1, 0.8f, 0); //orange + case "Font": + return new Color(0.9f, 1, 0.9f); //light green + case "TMP_FontAsset": + return new Color(0.9f, 1, 0.9f); //light green + case "Mesh": + return new Color(0.5f, 0, 0.5f); //purple + case "TerrainLayer": + return new Color(0.5f, 0.8f, 0f); //green + default: + break; + } + + return CustomColor(typeName); + } + + //Add custom assets here + StyleColor CustomColor(string assetType) + { + switch (assetType) + { + case "GearObject": + return new Color(0.9f, 0, 0.9f); //pink + case "TalentObject": + return new Color(0.9f, 0, 0.9f); // + case "AbilityInfo": + return new Color(0.9f, 0, 0.9f); // + case "HealthSO": + return new Color(0.9f, 0, 0.9f); // + default: + break; + } + + //standard color + return new Color(0.24f, 0.24f, 0.24f, 0.8f); + } + + private static void AddDivider(Node objNode) + { + var divider = new VisualElement { name = "divider" }; + divider.AddToClassList("horizontal"); + objNode.extensionContainer.Add(divider); + } + + private void ClearGraph() + { + selectedObjects.Clear(); + + foreach (var assetGroup in assetGroups) + { + EmptyGroup(assetGroup); + } + + fullPathNodeLookup.Clear(); + + assetGroups.Clear(); + } + + void EmptyGroup(AssetGroup assetGroup) + { + if (assetGroup.AssetGraphConnections.Count > 0) + { + foreach (var edge in assetGroup.AssetGraphConnections) + { + graphView.RemoveElement(edge); + } + } + assetGroup.AssetGraphConnections.Clear(); + + foreach (var node in assetGroup.AssetGraphNodes) + { + graphView.RemoveElement(node); + } + assetGroup.AssetGraphNodes.Clear(); + + assetGroup.DependenciesForPlacement.Clear(); + + graphView.RemoveElement(assetGroup.GroupNode); + + assetGroup.GroupNode = null; + } + + private void UpdateGroupDependencyNodePlacement(GeometryChangedEvent e, AssetGroup assetGroup) + { + assetGroup.MainGraphNode.UnregisterCallback( + UpdateGroupDependencyNodePlacement + ); + + ResetNodes(assetGroup); + } + + void ResetAllNodes() + { + foreach (var assetGroup in assetGroups) + { + ResetNodes(assetGroup); + } + } + + //Reset the node positions of the given group + void ResetNodes(AssetGroup assetGroup) + { + // The current y offset in per depth + var depthOffset = new Dictionary(); + + foreach (var node in assetGroup.DependenciesForPlacement) + { + int depth = (int)node.userData; + + if (!depthOffset.ContainsKey(depth)) + depthOffset.Add(depth, 0.0f); + + if (AlignmentToggle.value) + { + depthOffset[depth] += node.layout.height; + } + else + { + depthOffset[depth] += node.layout.width; + } + } + + // Move half of the node into negative y space so they're on either size of the main node in y axis + var depths = new List(depthOffset.Keys); + foreach (int depth in depths) + { + if (depth == 0) + continue; + + float offset = depthOffset[depth]; + depthOffset[depth] = (0f - offset / 2.0f); + } + + Rect mainNodeRect = assetGroup.MainGraphNode.GetPosition(); + + foreach (var node in assetGroup.DependenciesForPlacement) + { + int depth = (int)node.userData; + if (AlignmentToggle.value) + { + node.SetPosition(new Rect(mainNodeRect.x + node.layout.width * 1.5f * depth, mainNodeRect.y + depthOffset[depth], 0, 0)); + } + else + { + node.SetPosition(new Rect(mainNodeRect.x + depthOffset[depth], mainNodeRect.y + node.layout.height * 1.5f * depth, 0, 0)); + } + + if (AlignmentToggle.value) + { + depthOffset[depth] += node.layout.height; + } + else + { + depthOffset[depth] += node.layout.width; + } + } + } + + //fix the position of the groups so they dont overlap + void ResetGroups() + { + float y = 0; + float x = 0; + + foreach (var assetGroup in assetGroups) + { + if (AlignmentToggle.value) + { + Rect pos = assetGroup.GroupNode.GetPosition(); + pos.x = x; + assetGroup.GroupNode.SetPosition(pos); + x += assetGroup.GroupNode.GetPosition().width; + } + else + { + Rect pos = assetGroup.GroupNode.GetPosition(); + pos.y = y; + assetGroup.GroupNode.SetPosition(pos); + y += assetGroup.GroupNode.GetPosition().height; + } + } + } + } +} diff --git a/Assets/AssetDependencyGraph/Editor/AssetDependencyGraph.cs.meta b/Assets/AssetDependencyGraph/Editor/AssetDependencyGraph.cs.meta new file mode 100644 index 0000000..d9fbff0 --- /dev/null +++ b/Assets/AssetDependencyGraph/Editor/AssetDependencyGraph.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 43eecbcf2afaca84aa2af29388e193de +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/AssetDependencyGraph/Editor/DependencyAnalysis.cs b/Assets/AssetDependencyGraph/Editor/DependencyAnalysis.cs new file mode 100644 index 0000000..7a27954 --- /dev/null +++ b/Assets/AssetDependencyGraph/Editor/DependencyAnalysis.cs @@ -0,0 +1,264 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.IO; +using System.Threading.Tasks; +using UnityEditor; +using Object = UnityEngine.Object; + +namespace AssetDependencyGraph +{ + public interface IDependencyAnalysis + { + void Analyze(string path, Dictionary result); + + public (AssetIdentify id, AssetNode node) GetOrCreateFolderNode(string path, Dictionary result) + { + AssetIdentify k = null; + + foreach (var item in result.Keys) + { + if (item.Path == path) + { + k = item; + } + } + + if (k == null) + { + k = new AssetIdentify() + { + Path = path, + AssetType = "Folder", + Guid = null, + Md5 = null + }; + result[k] = new FolderNode() + { + Self = k, + AssetType = "Folder", + }; + } + + return (k, result[k]); + } + + public (AssetIdentify id, AssetNode node) GetOrCreateAssetNode(string path, Dictionary result) + { + AssetIdentify k = null; + + foreach (var item in result.Keys) + { + if (item.Path == path) + { + k = item; + } + } + + if (k == null) + { + k = new AssetIdentify() + { + Path = path, + Guid = null, + Md5 = Utils.Md5(path) + }; + if (path.EndsWith(".prefab") || path.EndsWith(".unity")) + { + result[k] = new PackageNode() + { + Self = k, + }; + } + else + { + result[k] = new AssetNode() + { + Self = k, + }; + } + } + + return (k, result[k]); + } + + public bool Exclude(string path) => path.EndsWith(".meta"); + + public string GetTypeByExtension(string ext) + { + switch (ext.ToLowerInvariant()) + { + case ".a": + case ".dll": + case ".so": + case ".exe": + case ".dynlib": + return "Executable"; + case ".asmdef": + case ".asmref": + return "UnityAssembly"; + case ".cs": + case ".lua": + case ".js": + case ".ts": + case ".java": + case ".h": + case ".cpp": + case ".cxx": + case ".mm": + return "SourceFile"; + case ".json": + case ".json5": + return "JsonFile"; + case ".xml": + return "XmlFile"; + case ".dat": + return "DatFile"; + default: + return null; + } + } + } + + public class UnityDependencyAnalysis : IDependencyAnalysis + { + HashSet processed = new(); + + public void Analyze(string path, Dictionary result) + { + if (!processed.Add(path)) + { + return; + } + var dependencyAnalysis = (this as IDependencyAnalysis); + + var kv = dependencyAnalysis.GetOrCreateAssetNode(path, result); + var relatePath = path.ToUnityRelatePath(); + kv.id.Guid = AssetDatabase.AssetPathToGUID(relatePath); + var selfNode = kv.node; + if (dependencyAnalysis.GetTypeByExtension(Path.GetExtension(path)) is string assetType && assetType != null) + { + kv.id.AssetType = assetType; + selfNode.AssetType = assetType; + } + else + { + if (relatePath.EndsWith("Rock_01_Prefab.prefab")) + { + Console.WriteLine(); + } + Object mainObject = AssetDatabase.LoadMainAssetAtPath(relatePath); + if (mainObject != null) + { + var prefabType = PrefabUtility.GetPrefabAssetType(mainObject); + if (prefabType != PrefabAssetType.NotAPrefab) + { + selfNode.AssetType = prefabType.ToString(); + } + else + { + selfNode.AssetType = mainObject.GetType().Name; + } + kv.id.AssetType = selfNode.AssetType; + + string[] dependencies = AssetDatabase.GetDependencies(relatePath, false); + for (int i = 0; i < dependencies.Length; i++) + { + var dep = dependencies[i].ToUnityFullPath(); + var depkv = dependencyAnalysis.GetOrCreateAssetNode(dep, result); + depkv.node.Dependent.Add(selfNode.Self); + selfNode.Dependencies.Add(depkv.id); + Analyze(dep, result); + } + } + else + { + UnityEngine.Debug.LogWarning("unknown type:" + path); + } + } + } + + } + + public class FolderDependencyAnalysis : IDependencyAnalysis + { + public void Analyze(string path, Dictionary result) + { + var dependencyAnalysis = (this as IDependencyAnalysis); + var k = dependencyAnalysis.GetOrCreateFolderNode(path, result); + + Utils.TraverseDirectory(path, (p) => + { + p = p.ToUniversalPath(); + + if (dependencyAnalysis.Exclude(p)) + { + return; + } + + var selfNode = result[k.id]; + if (Directory.Exists(p)) + { + var kv = dependencyAnalysis.GetOrCreateFolderNode(p, result); + kv.node.Dependent.Add(selfNode.Self); + selfNode.Dependencies.Add(kv.id); + } + else if (File.Exists(p)) + { + var kv = dependencyAnalysis.GetOrCreateAssetNode(p, result); + + kv.node.Dependent.Add(selfNode.Self); + selfNode.Dependencies.Add(kv.id); + } + }, 1); + } + } + + internal class DependencyAnalyzer + { + private Dictionary, IDependencyAnalysis> dependencyAnalysisDic = new(); + private Dictionary assetIdentify2AssetNodeDic = new(); + + private bool Exclude(string path) => path.EndsWith(".meta"); + + public DependencyAnalyzer() + { + dependencyAnalysisDic.Add(new Predicate(path => !Directory.Exists(path)), new UnityDependencyAnalysis()); + dependencyAnalysisDic.Add(new Predicate(path => Directory.Exists(path)), new FolderDependencyAnalysis()); + } + + private void Visivt(string path) + { + path = path.ToUniversalPath(); + if (Exclude(path)) + { + return; + } + foreach (var item in dependencyAnalysisDic) + { + if (item.Key(path)) + { + item.Value.Analyze(path, assetIdentify2AssetNodeDic); + } + } + } + + public void Analyze(string rootFolder) + { + Stopwatch sw = Stopwatch.StartNew(); + sw.Start(); + Utils.TraverseDirectory(rootFolder, Visivt, -1); + sw.Stop(); + UnityEngine.Debug.Log($"分析引用耗时:{sw.ElapsedMilliseconds / 1000f}s"); + AssetDependencyGraphDB db = new AssetDependencyGraphDB("admin", "CCS20190109", "10.225.0.170"); + sw.Restart(); + db.Clean(); + Parallel.ForEach(assetIdentify2AssetNodeDic, item => + { + db.UpdateOrInsert(item.Value); + }); + sw.Stop(); + UnityEngine.Debug.Log($"更新数据库:{sw.ElapsedMilliseconds / 1000f}s"); + } + } +} diff --git a/Assets/AssetDependencyGraph/Editor/DependencyAnalysis.cs.meta b/Assets/AssetDependencyGraph/Editor/DependencyAnalysis.cs.meta new file mode 100644 index 0000000..e8b8232 --- /dev/null +++ b/Assets/AssetDependencyGraph/Editor/DependencyAnalysis.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: dfb4fe91c835f1a44853adfc3644470a +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/AssetDependencyGraph/Editor/Utils.cs b/Assets/AssetDependencyGraph/Editor/Utils.cs new file mode 100644 index 0000000..bcb39e7 --- /dev/null +++ b/Assets/AssetDependencyGraph/Editor/Utils.cs @@ -0,0 +1,75 @@ +using System; +using System.IO; +using UnityEngine; + +namespace AssetDependencyGraph +{ + public static class Utils + { + public static string Md5(string filename) + { + try + { + FileStream fs = new FileStream(filename, FileMode.Open); + System.Security.Cryptography.MD5 md5 = new System.Security.Cryptography.MD5CryptoServiceProvider(); + byte[] retVal = md5.ComputeHash(fs); + fs.Close(); + return BitConverter.ToString(retVal).ToLower().Replace("-", ""); + } + catch + { + throw; + } + } + + public static void TraverseDirectory(string path, Action action, int depth = 1) + { + if(depth == 0) + { + return; + } + + foreach (string file in Directory.EnumerateFiles(path)) + { + action.Invoke(file); + } + + foreach (string directory in Directory.EnumerateDirectories(path)) + { + action.Invoke(directory); + TraverseDirectory(directory, action, --depth); + } + } + + public static string ToUniversalPath(this string path) + { + return path.Replace("\\", "/"); + } + + public static string ToUnityRelatePath(this string path) + { + if(path.StartsWith(Application.dataPath.ToUniversalPath().Replace("Assets", "")) && !path.StartsWith(Application.dataPath.ToUniversalPath() + "/Assets")) + { + return path.Replace(Application.dataPath.ToUniversalPath().Replace("Assets", ""), ""); + } + return path.Replace(Application.dataPath.ToUniversalPath(), "Assets"); + } + + public static string ToUnityFullPath(this string path) + { + if(path.StartsWith("Packages")) + { + var fullPath = (Application.dataPath.ToUniversalPath().Replace("Assets", "") + path); + fullPath ??= (Application.dataPath.ToUniversalPath().Replace("Assets", "Library/PackageCache") + path); + if (!File.Exists(fullPath) && Directory.Exists(fullPath)) + { + Debug.LogWarning($"ToUnityFullPath failure:{path}"); + } + + return fullPath; + } + + return Application.dataPath.ToUniversalPath().Replace("Assets", "") + path; + } + } +} diff --git a/Assets/AssetDependencyGraph/Editor/Utils.cs.meta b/Assets/AssetDependencyGraph/Editor/Utils.cs.meta new file mode 100644 index 0000000..60025f2 --- /dev/null +++ b/Assets/AssetDependencyGraph/Editor/Utils.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: c90ae90b250ea244ca1b14d395893854 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/AssetDependencyGraph/Plugins.meta b/Assets/AssetDependencyGraph/Plugins.meta new file mode 100644 index 0000000..5f2d690 --- /dev/null +++ b/Assets/AssetDependencyGraph/Plugins.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: a251feda1c6acfa418d3cb94f0255dbe +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/AssetDependencyGraph/Plugins/AWSSDK.Core.dll b/Assets/AssetDependencyGraph/Plugins/AWSSDK.Core.dll new file mode 100644 index 0000000..53b57f8 Binary files /dev/null and b/Assets/AssetDependencyGraph/Plugins/AWSSDK.Core.dll differ diff --git a/Assets/AssetDependencyGraph/Plugins/AWSSDK.Core.dll.meta b/Assets/AssetDependencyGraph/Plugins/AWSSDK.Core.dll.meta new file mode 100644 index 0000000..7dc5726 --- /dev/null +++ b/Assets/AssetDependencyGraph/Plugins/AWSSDK.Core.dll.meta @@ -0,0 +1,81 @@ +fileFormatVersion: 2 +guid: 38356707733942742b1bd8da40abed2e +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 0 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + : Any + second: + enabled: 0 + settings: + Exclude Android: 1 + Exclude Editor: 0 + Exclude Linux64: 1 + Exclude OSXUniversal: 1 + Exclude Win: 1 + Exclude Win64: 1 + Exclude iOS: 1 + - first: + Android: Android + second: + enabled: 0 + settings: {} + - first: + Any: + second: + enabled: 0 + settings: {} + - first: + Editor: Editor + second: + enabled: 1 + settings: + CPU: AnyCPU + DefaultValueInitialized: true + OS: Windows + - first: + Standalone: Linux64 + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + Standalone: OSXUniversal + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + Standalone: Win + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + Standalone: Win64 + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + Windows Store Apps: WindowsStoreApps + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + iPhone: iOS + second: + enabled: 0 + settings: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/AssetDependencyGraph/Plugins/DnsClient.dll b/Assets/AssetDependencyGraph/Plugins/DnsClient.dll new file mode 100644 index 0000000..323f3e4 Binary files /dev/null and b/Assets/AssetDependencyGraph/Plugins/DnsClient.dll differ diff --git a/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/Plugins/Windows/libxess.dll.meta b/Assets/AssetDependencyGraph/Plugins/DnsClient.dll.meta similarity index 77% rename from Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/Plugins/Windows/libxess.dll.meta rename to Assets/AssetDependencyGraph/Plugins/DnsClient.dll.meta index 855c86c..2b4956a 100644 --- a/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/Plugins/Windows/libxess.dll.meta +++ b/Assets/AssetDependencyGraph/Plugins/DnsClient.dll.meta @@ -1,5 +1,5 @@ fileFormatVersion: 2 -guid: CylNsSn5V385rwZDZ0c3ZH2bVn7sAt4uXYM3ovG+CFkMBMj6NWTM5h0= +guid: f80f2e68fd0af0b4e86097f187a00ffa PluginImporter: externalObjects: {} serializedVersion: 2 @@ -18,11 +18,11 @@ PluginImporter: settings: Exclude Android: 1 Exclude Editor: 0 - Exclude Linux64: 0 - Exclude OSXUniversal: 0 - Exclude OpenHarmony: 1 + Exclude Linux64: 1 + Exclude OSXUniversal: 1 Exclude Win: 1 - Exclude Win64: 0 + Exclude Win64: 1 + Exclude iOS: 1 - first: Android: Android second: @@ -40,26 +40,19 @@ PluginImporter: second: enabled: 1 settings: - CPU: x86_64 + CPU: AnyCPU DefaultValueInitialized: true OS: Windows - - first: - OpenHarmony: OpenHarmony - second: - enabled: 0 - settings: - CPU: ARMv7 - OpenHarmonySharedLibraryType: Executable - first: Standalone: Linux64 second: - enabled: 1 + enabled: 0 settings: CPU: AnyCPU - first: Standalone: OSXUniversal second: - enabled: 1 + enabled: 0 settings: CPU: AnyCPU - first: @@ -71,9 +64,20 @@ PluginImporter: - first: Standalone: Win64 second: - enabled: 1 + enabled: 0 settings: CPU: AnyCPU + - first: + Windows Store Apps: WindowsStoreApps + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + iPhone: iOS + second: + enabled: 0 + settings: {} userData: assetBundleName: assetBundleVariant: diff --git a/Assets/AssetDependencyGraph/Plugins/Microsoft.Extensions.Logging.Abstractions.dll b/Assets/AssetDependencyGraph/Plugins/Microsoft.Extensions.Logging.Abstractions.dll new file mode 100644 index 0000000..1580585 Binary files /dev/null and b/Assets/AssetDependencyGraph/Plugins/Microsoft.Extensions.Logging.Abstractions.dll differ diff --git a/Assets/AssetDependencyGraph/Plugins/Microsoft.Extensions.Logging.Abstractions.dll.meta b/Assets/AssetDependencyGraph/Plugins/Microsoft.Extensions.Logging.Abstractions.dll.meta new file mode 100644 index 0000000..8cba679 --- /dev/null +++ b/Assets/AssetDependencyGraph/Plugins/Microsoft.Extensions.Logging.Abstractions.dll.meta @@ -0,0 +1,81 @@ +fileFormatVersion: 2 +guid: 8639b566b8d0cfd4daca122ad15c9c71 +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 0 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + : Any + second: + enabled: 0 + settings: + Exclude Android: 1 + Exclude Editor: 0 + Exclude Linux64: 1 + Exclude OSXUniversal: 1 + Exclude Win: 1 + Exclude Win64: 1 + Exclude iOS: 1 + - first: + Android: Android + second: + enabled: 0 + settings: {} + - first: + Any: + second: + enabled: 0 + settings: {} + - first: + Editor: Editor + second: + enabled: 1 + settings: + CPU: AnyCPU + DefaultValueInitialized: true + OS: Windows + - first: + Standalone: Linux64 + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + Standalone: OSXUniversal + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + Standalone: Win + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + Standalone: Win64 + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + Windows Store Apps: WindowsStoreApps + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + iPhone: iOS + second: + enabled: 0 + settings: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/AssetDependencyGraph/Plugins/MongoDB.Bson.dll b/Assets/AssetDependencyGraph/Plugins/MongoDB.Bson.dll new file mode 100644 index 0000000..067a7cb Binary files /dev/null and b/Assets/AssetDependencyGraph/Plugins/MongoDB.Bson.dll differ diff --git a/Assets/AssetDependencyGraph/Plugins/MongoDB.Bson.dll.meta b/Assets/AssetDependencyGraph/Plugins/MongoDB.Bson.dll.meta new file mode 100644 index 0000000..4a3f870 --- /dev/null +++ b/Assets/AssetDependencyGraph/Plugins/MongoDB.Bson.dll.meta @@ -0,0 +1,83 @@ +fileFormatVersion: 2 +guid: 1ead4ac145c227142af0602db4c79b87 +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 0 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + : Any + second: + enabled: 0 + settings: + Exclude Android: 1 + Exclude Editor: 0 + Exclude Linux64: 1 + Exclude OSXUniversal: 1 + Exclude Win: 1 + Exclude Win64: 1 + Exclude iOS: 1 + - first: + Android: Android + second: + enabled: 0 + settings: + AndroidSharedLibraryType: Executable + CPU: ARMv7 + - first: + Any: + second: + enabled: 0 + settings: {} + - first: + Editor: Editor + second: + enabled: 1 + settings: + CPU: AnyCPU + DefaultValueInitialized: true + OS: Windows + - first: + Standalone: Linux64 + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + Standalone: OSXUniversal + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + Standalone: Win + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + Standalone: Win64 + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + Windows Store Apps: WindowsStoreApps + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + iPhone: iOS + second: + enabled: 0 + settings: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/AssetDependencyGraph/Plugins/MongoDB.Driver.Core.dll b/Assets/AssetDependencyGraph/Plugins/MongoDB.Driver.Core.dll new file mode 100644 index 0000000..cea23cc Binary files /dev/null and b/Assets/AssetDependencyGraph/Plugins/MongoDB.Driver.Core.dll differ diff --git a/Assets/AssetDependencyGraph/Plugins/MongoDB.Driver.Core.dll.meta b/Assets/AssetDependencyGraph/Plugins/MongoDB.Driver.Core.dll.meta new file mode 100644 index 0000000..3870b88 --- /dev/null +++ b/Assets/AssetDependencyGraph/Plugins/MongoDB.Driver.Core.dll.meta @@ -0,0 +1,83 @@ +fileFormatVersion: 2 +guid: 78d79268cf082b846a2a63642acc37f4 +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 0 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + : Any + second: + enabled: 0 + settings: + Exclude Android: 1 + Exclude Editor: 0 + Exclude Linux64: 1 + Exclude OSXUniversal: 1 + Exclude Win: 1 + Exclude Win64: 1 + Exclude iOS: 1 + - first: + Android: Android + second: + enabled: 0 + settings: + AndroidSharedLibraryType: Executable + CPU: ARMv7 + - first: + Any: + second: + enabled: 0 + settings: {} + - first: + Editor: Editor + second: + enabled: 1 + settings: + CPU: AnyCPU + DefaultValueInitialized: true + OS: Windows + - first: + Standalone: Linux64 + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + Standalone: OSXUniversal + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + Standalone: Win + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + Standalone: Win64 + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + Windows Store Apps: WindowsStoreApps + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + iPhone: iOS + second: + enabled: 0 + settings: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/AssetDependencyGraph/Plugins/MongoDB.Driver.dll b/Assets/AssetDependencyGraph/Plugins/MongoDB.Driver.dll new file mode 100644 index 0000000..ad9affc Binary files /dev/null and b/Assets/AssetDependencyGraph/Plugins/MongoDB.Driver.dll differ diff --git a/Assets/AssetDependencyGraph/Plugins/MongoDB.Driver.dll.meta b/Assets/AssetDependencyGraph/Plugins/MongoDB.Driver.dll.meta new file mode 100644 index 0000000..3df741d --- /dev/null +++ b/Assets/AssetDependencyGraph/Plugins/MongoDB.Driver.dll.meta @@ -0,0 +1,81 @@ +fileFormatVersion: 2 +guid: 3de0577458e380243be22140907c0bc0 +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 0 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + : Any + second: + enabled: 0 + settings: + Exclude Android: 1 + Exclude Editor: 0 + Exclude Linux64: 1 + Exclude OSXUniversal: 1 + Exclude Win: 1 + Exclude Win64: 1 + Exclude iOS: 1 + - first: + Android: Android + second: + enabled: 0 + settings: {} + - first: + Any: + second: + enabled: 0 + settings: {} + - first: + Editor: Editor + second: + enabled: 1 + settings: + CPU: AnyCPU + DefaultValueInitialized: true + OS: Windows + - first: + Standalone: Linux64 + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + Standalone: OSXUniversal + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + Standalone: Win + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + Standalone: Win64 + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + Windows Store Apps: WindowsStoreApps + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + iPhone: iOS + second: + enabled: 0 + settings: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/AssetDependencyGraph/Plugins/MongoDB.Libmongocrypt.dll b/Assets/AssetDependencyGraph/Plugins/MongoDB.Libmongocrypt.dll new file mode 100644 index 0000000..f72b181 Binary files /dev/null and b/Assets/AssetDependencyGraph/Plugins/MongoDB.Libmongocrypt.dll differ diff --git a/Assets/AssetDependencyGraph/Plugins/MongoDB.Libmongocrypt.dll.meta b/Assets/AssetDependencyGraph/Plugins/MongoDB.Libmongocrypt.dll.meta new file mode 100644 index 0000000..ffb3bd5 --- /dev/null +++ b/Assets/AssetDependencyGraph/Plugins/MongoDB.Libmongocrypt.dll.meta @@ -0,0 +1,81 @@ +fileFormatVersion: 2 +guid: c945cad0736669340b6639d058b729c8 +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 0 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + : Any + second: + enabled: 0 + settings: + Exclude Android: 1 + Exclude Editor: 0 + Exclude Linux64: 1 + Exclude OSXUniversal: 1 + Exclude Win: 1 + Exclude Win64: 1 + Exclude iOS: 1 + - first: + Android: Android + second: + enabled: 0 + settings: {} + - first: + Any: + second: + enabled: 0 + settings: {} + - first: + Editor: Editor + second: + enabled: 1 + settings: + CPU: AnyCPU + DefaultValueInitialized: true + OS: Windows + - first: + Standalone: Linux64 + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + Standalone: OSXUniversal + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + Standalone: Win + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + Standalone: Win64 + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + Windows Store Apps: WindowsStoreApps + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + iPhone: iOS + second: + enabled: 0 + settings: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/AssetDependencyGraph/Plugins/SharpCompress.dll b/Assets/AssetDependencyGraph/Plugins/SharpCompress.dll new file mode 100644 index 0000000..e71466e Binary files /dev/null and b/Assets/AssetDependencyGraph/Plugins/SharpCompress.dll differ diff --git a/Assets/AssetDependencyGraph/Plugins/SharpCompress.dll.meta b/Assets/AssetDependencyGraph/Plugins/SharpCompress.dll.meta new file mode 100644 index 0000000..32c8073 --- /dev/null +++ b/Assets/AssetDependencyGraph/Plugins/SharpCompress.dll.meta @@ -0,0 +1,83 @@ +fileFormatVersion: 2 +guid: e44a450d127d0824cbc021fc238d7b80 +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 0 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + : Any + second: + enabled: 0 + settings: + Exclude Android: 1 + Exclude Editor: 0 + Exclude Linux64: 1 + Exclude OSXUniversal: 1 + Exclude Win: 1 + Exclude Win64: 1 + Exclude iOS: 1 + - first: + Android: Android + second: + enabled: 0 + settings: + AndroidSharedLibraryType: Executable + CPU: ARMv7 + - first: + Any: + second: + enabled: 0 + settings: {} + - first: + Editor: Editor + second: + enabled: 1 + settings: + CPU: AnyCPU + DefaultValueInitialized: true + OS: Windows + - first: + Standalone: Linux64 + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + Standalone: OSXUniversal + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + Standalone: Win + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + Standalone: Win64 + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + Windows Store Apps: WindowsStoreApps + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + iPhone: iOS + second: + enabled: 0 + settings: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/AssetDependencyGraph/Plugins/Snappier.dll b/Assets/AssetDependencyGraph/Plugins/Snappier.dll new file mode 100644 index 0000000..c4e4aba Binary files /dev/null and b/Assets/AssetDependencyGraph/Plugins/Snappier.dll differ diff --git a/Assets/AssetDependencyGraph/Plugins/Snappier.dll.meta b/Assets/AssetDependencyGraph/Plugins/Snappier.dll.meta new file mode 100644 index 0000000..ba77d34 --- /dev/null +++ b/Assets/AssetDependencyGraph/Plugins/Snappier.dll.meta @@ -0,0 +1,81 @@ +fileFormatVersion: 2 +guid: e1cd43f2c984df240a8c23991b2f1e1c +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 0 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + : Any + second: + enabled: 0 + settings: + Exclude Android: 1 + Exclude Editor: 0 + Exclude Linux64: 1 + Exclude OSXUniversal: 1 + Exclude Win: 1 + Exclude Win64: 1 + Exclude iOS: 1 + - first: + Android: Android + second: + enabled: 0 + settings: {} + - first: + Any: + second: + enabled: 0 + settings: {} + - first: + Editor: Editor + second: + enabled: 1 + settings: + CPU: AnyCPU + DefaultValueInitialized: true + OS: Windows + - first: + Standalone: Linux64 + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + Standalone: OSXUniversal + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + Standalone: Win + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + Standalone: Win64 + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + Windows Store Apps: WindowsStoreApps + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + iPhone: iOS + second: + enabled: 0 + settings: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/AssetDependencyGraph/Plugins/System.Runtime.CompilerServices.Unsafe.dll b/Assets/AssetDependencyGraph/Plugins/System.Runtime.CompilerServices.Unsafe.dll new file mode 100644 index 0000000..de9e124 Binary files /dev/null and b/Assets/AssetDependencyGraph/Plugins/System.Runtime.CompilerServices.Unsafe.dll differ diff --git a/Assets/AssetDependencyGraph/Plugins/System.Runtime.CompilerServices.Unsafe.dll.meta b/Assets/AssetDependencyGraph/Plugins/System.Runtime.CompilerServices.Unsafe.dll.meta new file mode 100644 index 0000000..7727784 --- /dev/null +++ b/Assets/AssetDependencyGraph/Plugins/System.Runtime.CompilerServices.Unsafe.dll.meta @@ -0,0 +1,87 @@ +fileFormatVersion: 2 +guid: 75990583b0a472b44bd9f0946b424361 +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 0 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + : Any + second: + enabled: 0 + settings: + Exclude Android: 1 + Exclude Editor: 0 + Exclude Linux64: 1 + Exclude OSXUniversal: 1 + Exclude Win: 1 + Exclude Win64: 1 + Exclude iOS: 1 + - first: + Android: Android + second: + enabled: 0 + settings: + AndroidSharedLibraryType: Executable + CPU: ARMv7 + - first: + Any: + second: + enabled: 0 + settings: {} + - first: + Editor: Editor + second: + enabled: 1 + settings: + CPU: AnyCPU + DefaultValueInitialized: true + OS: Windows + - first: + Standalone: Linux64 + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: OSXUniversal + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win64 + second: + enabled: 0 + settings: + CPU: None + - first: + Windows Store Apps: WindowsStoreApps + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + iPhone: iOS + second: + enabled: 0 + settings: + AddToEmbeddedBinaries: false + CPU: AnyCPU + CompileFlags: + FrameworkDependencies: + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/AssetDependencyGraph/Plugins/ZstdSharp.dll b/Assets/AssetDependencyGraph/Plugins/ZstdSharp.dll new file mode 100644 index 0000000..6eac618 Binary files /dev/null and b/Assets/AssetDependencyGraph/Plugins/ZstdSharp.dll differ diff --git a/Assets/AssetDependencyGraph/Plugins/ZstdSharp.dll.meta b/Assets/AssetDependencyGraph/Plugins/ZstdSharp.dll.meta new file mode 100644 index 0000000..c79c0f9 --- /dev/null +++ b/Assets/AssetDependencyGraph/Plugins/ZstdSharp.dll.meta @@ -0,0 +1,87 @@ +fileFormatVersion: 2 +guid: 83f2ea0e93026104faa9df07b11e4a1c +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 0 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + : Any + second: + enabled: 0 + settings: + Exclude Android: 1 + Exclude Editor: 0 + Exclude Linux64: 1 + Exclude OSXUniversal: 1 + Exclude Win: 1 + Exclude Win64: 1 + Exclude iOS: 1 + - first: + Android: Android + second: + enabled: 0 + settings: + AndroidSharedLibraryType: Executable + CPU: ARMv7 + - first: + Any: + second: + enabled: 0 + settings: {} + - first: + Editor: Editor + second: + enabled: 1 + settings: + CPU: AnyCPU + DefaultValueInitialized: true + OS: Windows + - first: + Standalone: Linux64 + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: OSXUniversal + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win + second: + enabled: 0 + settings: + CPU: None + - first: + Standalone: Win64 + second: + enabled: 0 + settings: + CPU: None + - first: + Windows Store Apps: WindowsStoreApps + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + iPhone: iOS + second: + enabled: 0 + settings: + AddToEmbeddedBinaries: false + CPU: AnyCPU + CompileFlags: + FrameworkDependencies: + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/GamePerformanceSdk.meta b/Assets/GamePerformanceSdk.meta new file mode 100644 index 0000000..87b40ce --- /dev/null +++ b/Assets/GamePerformanceSdk.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: WXgdsS2sVH9xLw8qkLUSbNyC4dSg6j4oqWPsSDV1FVxWrM8vTXd2QrY= +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Scenes/Cockpit/CockpitScene.scene b/Assets/Scenes/Cockpit/CockpitScene.unity similarity index 100% rename from Assets/Scenes/Cockpit/CockpitScene.scene rename to Assets/Scenes/Cockpit/CockpitScene.unity diff --git a/Assets/Scenes/Cockpit/CockpitScene.scene.meta b/Assets/Scenes/Cockpit/CockpitScene.unity.meta similarity index 100% rename from Assets/Scenes/Cockpit/CockpitScene.scene.meta rename to Assets/Scenes/Cockpit/CockpitScene.unity.meta diff --git a/Assets/Scenes/Cockpit/Scenes/ShipSetup.scene b/Assets/Scenes/Cockpit/Scenes/ShipSetup.unity similarity index 100% rename from Assets/Scenes/Cockpit/Scenes/ShipSetup.scene rename to Assets/Scenes/Cockpit/Scenes/ShipSetup.unity diff --git a/Assets/Scenes/Cockpit/Scenes/ShipSetup.scene.meta b/Assets/Scenes/Cockpit/Scenes/ShipSetup.unity.meta similarity index 100% rename from Assets/Scenes/Cockpit/Scenes/ShipSetup.scene.meta rename to Assets/Scenes/Cockpit/Scenes/ShipSetup.unity.meta diff --git a/Assets/Scenes/Oasis/Art/Environment/Textures/Cliff_Ramp.asset b/Assets/Scenes/Oasis/Art/Environment/Textures/Cliff_Ramp.asset index 1b48e8c..3749f1e 100644 --- a/Assets/Scenes/Oasis/Art/Environment/Textures/Cliff_Ramp.asset +++ b/Assets/Scenes/Oasis/Art/Environment/Textures/Cliff_Ramp.asset @@ -1,5 +1,5 @@ %YAML 1.1 -%TAG !u! tag:yousandi.cn,2023: +%TAG !u! tag:unity3d.com,2011: --- !u!114 &11400000 MonoBehaviour: m_ObjectHideFlags: 0 @@ -56,17 +56,11 @@ Texture2D: m_ForcedFallbackFormat: 4 m_DownscaleFallback: 0 m_IsAlphaChannelOptional: 0 - serializedVersion: 4 + serializedVersion: 2 m_Width: 64 m_Height: 1 m_CompleteImageSize: 508 m_MipsStripped: 0 - m_WebStreaming: 0 - m_PriorityLevel: 0 - m_UploadedMode: 0 - m_DataStreamData: - size: 0 - path: m_TextureFormat: 4 m_MipCount: 7 m_IsReadable: 1 @@ -97,6 +91,3 @@ Texture2D: offset: 0 size: 0 path: - m_OriginalWidth: 0 - m_OriginalHeight: 0 - m_OriginalAssetGuid: 00000000000000000000000000000000 diff --git a/Assets/Scenes/Oasis/OasisScene.scene b/Assets/Scenes/Oasis/OasisScene.unity similarity index 100% rename from Assets/Scenes/Oasis/OasisScene.scene rename to Assets/Scenes/Oasis/OasisScene.unity diff --git a/Assets/Scenes/Oasis/OasisScene.scene.meta b/Assets/Scenes/Oasis/OasisScene.unity.meta similarity index 100% rename from Assets/Scenes/Oasis/OasisScene.scene.meta rename to Assets/Scenes/Oasis/OasisScene.unity.meta diff --git a/Assets/Scenes/Terminal/TerminalScene.scene b/Assets/Scenes/Terminal/TerminalScene.unity similarity index 100% rename from Assets/Scenes/Terminal/TerminalScene.scene rename to Assets/Scenes/Terminal/TerminalScene.unity diff --git a/Assets/Scenes/Terminal/TerminalScene.scene.meta b/Assets/Scenes/Terminal/TerminalScene.unity.meta similarity index 100% rename from Assets/Scenes/Terminal/TerminalScene.scene.meta rename to Assets/Scenes/Terminal/TerminalScene.unity.meta diff --git a/Assets/Scenes/Test.cs b/Assets/Scenes/Test.cs index c1e0bef..01bfe56 100644 --- a/Assets/Scenes/Test.cs +++ b/Assets/Scenes/Test.cs @@ -125,8 +125,7 @@ public class Test : MonoBehaviour } if (xessOn) { - asset.superResolution = ESuperResolution.XESS13; - xess.SetSR(ESuperResolution.XESS13); + } else { diff --git a/Assets/Settings/Mobile/Mobile_High.asset b/Assets/Settings/Mobile/Mobile_High.asset index edc4346..30bd84b 100644 --- a/Assets/Settings/Mobile/Mobile_High.asset +++ b/Assets/Settings/Mobile/Mobile_High.asset @@ -1,5 +1,5 @@ %YAML 1.1 -%TAG !u! tag:yousandi.cn,2023: +%TAG !u! tag:unity3d.com,2011: --- !u!114 &11400000 MonoBehaviour: m_ObjectHideFlags: 0 @@ -28,7 +28,7 @@ MonoBehaviour: m_SupportsHDR: 1 m_HDRColorBufferPrecision: 0 m_MSAA: 1 - m_RenderScale: 0.58823526 + m_RenderScale: 1 m_UpscalingFilter: 0 m_FsrOverrideSharpness: 1 m_FsrSharpness: 1 @@ -114,5 +114,5 @@ MonoBehaviour: m_PrefilterNativeRenderPass: 1 m_ShaderVariantLogLevel: 0 m_ShadowCascades: 0 - superResolution: 5 + superResolution: 0 vrsRate: 0 diff --git a/Assets/Settings/Mobile/Mobile_High_Renderer.asset b/Assets/Settings/Mobile/Mobile_High_Renderer.asset index 870d7ec..68412dd 100644 --- a/Assets/Settings/Mobile/Mobile_High_Renderer.asset +++ b/Assets/Settings/Mobile/Mobile_High_Renderer.asset @@ -1,5 +1,5 @@ %YAML 1.1 -%TAG !u! tag:yousandi.cn,2023: +%TAG !u! tag:unity3d.com,2011: --- !u!114 &-8576419846133267094 MonoBehaviour: m_ObjectHideFlags: 0 @@ -27,6 +27,11 @@ MonoBehaviour: m_Name: DLSS m_EditorClassIdentifier: m_Active: 0 + quality: 0 + useOptimalSetting: 0 + sharpness: 0 + preExposure: 0 + mipMapBias: 0 --- !u!114 &-7390778553674367771 MonoBehaviour: m_ObjectHideFlags: 0 @@ -79,7 +84,7 @@ MonoBehaviour: m_Script: {fileID: 11500000, guid: a00dddc5b3ea7fe45953ccbd49b58b94, type: 3} m_Name: GSR m_EditorClassIdentifier: - m_Active: 1 + m_Active: 0 quality: 4 v1settings: EnableEdgeDirection: 1 diff --git a/Assets/SharedAssets/Benchmark/BenchmarkPanelSettings.asset b/Assets/SharedAssets/Benchmark/BenchmarkPanelSettings.asset index 2daa1b2..7b56ad4 100644 --- a/Assets/SharedAssets/Benchmark/BenchmarkPanelSettings.asset +++ b/Assets/SharedAssets/Benchmark/BenchmarkPanelSettings.asset @@ -1,5 +1,5 @@ %YAML 1.1 -%TAG !u! tag:yousandi.cn,2023: +%TAG !u! tag:unity3d.com,2011: --- !u!114 &11400000 MonoBehaviour: m_ObjectHideFlags: 0 diff --git a/Assets/SharedAssets/Meshes/ReferencePerson_01_Mesh.fbx.meta b/Assets/SharedAssets/Meshes/ReferencePerson_01_Mesh.fbx.meta index a433415..9c721f3 100644 --- a/Assets/SharedAssets/Meshes/ReferencePerson_01_Mesh.fbx.meta +++ b/Assets/SharedAssets/Meshes/ReferencePerson_01_Mesh.fbx.meta @@ -1,7 +1,7 @@ fileFormatVersion: 2 guid: 3bcc50adabc5941a1a221dceb9b7e299 ModelImporter: - serializedVersion: 21202 + serializedVersion: 22200 internalIDToNameTable: [] externalObjects: {} materials: @@ -40,6 +40,7 @@ ModelImporter: addColliders: 0 useSRGBMaterialColor: 1 sortHierarchyByName: 1 + importPhysicalCameras: 1 importVisibility: 1 importBlendShapes: 1 importCameras: 1 @@ -67,6 +68,7 @@ ModelImporter: secondaryUVMinObjectScale: 1 secondaryUVPackMargin: 4 useFileScale: 1 + strictVertexDataChecks: 0 tangentSpace: normalSmoothAngle: 60 normalImportMode: 0 @@ -99,6 +101,8 @@ ModelImporter: humanoidOversampling: 1 avatarSetup: 0 addHumanoidExtraRootOnlyWhenUsingAvatar: 1 + importBlendShapeDeformPercent: 0 + remapMaterialsIfMaterialImportModeIsNone: 1 additionalBone: 0 userData: assetBundleName: diff --git a/NativeRenderPlugin/.vscode/compile_commands.json b/NativeRenderPlugin/.vscode/compile_commands.json index 5851afc..293a83f 100644 --- a/NativeRenderPlugin/.vscode/compile_commands.json +++ b/NativeRenderPlugin/.vscode/compile_commands.json @@ -1,31 +1,31 @@ [ { "directory": "g:\\TJURP\\NativeRenderPlugin", - "arguments": ["D:\\tj\\2022.3.48t2\\Editor\\Data\\PlaybackEngines\\OpenHarmonyPlayer\\SDK\\12\\native\\llvm\\bin\\clang.exe", "-c", "-Qunused-arguments", "-D__MUSL__", "--target=aarch64-linux-ohos", "--sysroot=C:/Users/xinyt/AppData/Local/OpenHarmony/Sdk/12/native/sysroot", "-std=c++20", "-Igl3w", "-IUnity", "-DSUPPORT_OPENGL_UNIFIED=1", "-DSUPPORT_OPENGL_ES=1", "-DOHOS=1", "-IC:\\Program Files\\Huawei\\DevEco Studio\\sdk\\default\\hms\\native\\sysroot\\usr\\include", "-DMYCLANG", "-DOHOS_STL=c++_shared", "-fPIE", "-fPIC", "-o", "build\\.objs\\GfxPluginNativeRender\\harmonyos\\aarch64\\debug\\RenderAPI.cpp.o", "RenderAPI.cpp"], + "arguments": ["C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.38.33130\\bin\\HostX64\\x64\\cl.exe", "/c", "/nologo", "/std:c++20", "/Igl3w", "/IUnity", "/IC:\\VulkanSDK\\1.3.283.0\\Include", "/Iexternal\\include", "/DNOMINMAX", "/DSUPPORT_D3D11=1", "/DSUPPORT_D3D12=1", "/EHsc", "/Fobuild\\.objs\\GfxPluginNativeRender\\windows\\x64\\release\\RenderAPI.cpp.obj", "RenderAPI.cpp", "-imsvc", "C:\\Program Files (x86)\\Windows Kits\\10\\Include\\10.0.22621.0\\cppwinrt", "-imsvc", "C:\\Program Files (x86)\\Windows Kits\\10\\Include\\10.0.22621.0\\shared", "-imsvc", "C:\\Program Files (x86)\\Windows Kits\\10\\Include\\10.0.22621.0\\ucrt", "-imsvc", "C:\\Program Files (x86)\\Windows Kits\\10\\Include\\10.0.22621.0\\um", "-imsvc", "C:\\Program Files (x86)\\Windows Kits\\10\\Include\\10.0.22621.0\\winrt", "-imsvc", "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.38.33130\\include"], "file": "RenderAPI.cpp" }, { "directory": "g:\\TJURP\\NativeRenderPlugin", - "arguments": ["D:\\tj\\2022.3.48t2\\Editor\\Data\\PlaybackEngines\\OpenHarmonyPlayer\\SDK\\12\\native\\llvm\\bin\\clang.exe", "-c", "-Qunused-arguments", "-D__MUSL__", "--target=aarch64-linux-ohos", "--sysroot=C:/Users/xinyt/AppData/Local/OpenHarmony/Sdk/12/native/sysroot", "-std=c++20", "-Igl3w", "-IUnity", "-DSUPPORT_OPENGL_UNIFIED=1", "-DSUPPORT_OPENGL_ES=1", "-DOHOS=1", "-IC:\\Program Files\\Huawei\\DevEco Studio\\sdk\\default\\hms\\native\\sysroot\\usr\\include", "-DMYCLANG", "-DOHOS_STL=c++_shared", "-fPIE", "-fPIC", "-o", "build\\.objs\\GfxPluginNativeRender\\harmonyos\\aarch64\\debug\\RenderAPI_D3D11.cpp.o", "RenderAPI_D3D11.cpp"], + "arguments": ["C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.38.33130\\bin\\HostX64\\x64\\cl.exe", "/c", "/nologo", "/std:c++20", "/Igl3w", "/IUnity", "/IC:\\VulkanSDK\\1.3.283.0\\Include", "/Iexternal\\include", "/DNOMINMAX", "/DSUPPORT_D3D11=1", "/DSUPPORT_D3D12=1", "/EHsc", "/Fobuild\\.objs\\GfxPluginNativeRender\\windows\\x64\\release\\RenderAPI_D3D11.cpp.obj", "RenderAPI_D3D11.cpp", "-imsvc", "C:\\Program Files (x86)\\Windows Kits\\10\\Include\\10.0.22621.0\\cppwinrt", "-imsvc", "C:\\Program Files (x86)\\Windows Kits\\10\\Include\\10.0.22621.0\\shared", "-imsvc", "C:\\Program Files (x86)\\Windows Kits\\10\\Include\\10.0.22621.0\\ucrt", "-imsvc", "C:\\Program Files (x86)\\Windows Kits\\10\\Include\\10.0.22621.0\\um", "-imsvc", "C:\\Program Files (x86)\\Windows Kits\\10\\Include\\10.0.22621.0\\winrt", "-imsvc", "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.38.33130\\include"], "file": "RenderAPI_D3D11.cpp" }, { "directory": "g:\\TJURP\\NativeRenderPlugin", - "arguments": ["D:\\tj\\2022.3.48t2\\Editor\\Data\\PlaybackEngines\\OpenHarmonyPlayer\\SDK\\12\\native\\llvm\\bin\\clang.exe", "-c", "-Qunused-arguments", "-D__MUSL__", "--target=aarch64-linux-ohos", "--sysroot=C:/Users/xinyt/AppData/Local/OpenHarmony/Sdk/12/native/sysroot", "-std=c++20", "-Igl3w", "-IUnity", "-DSUPPORT_OPENGL_UNIFIED=1", "-DSUPPORT_OPENGL_ES=1", "-DOHOS=1", "-IC:\\Program Files\\Huawei\\DevEco Studio\\sdk\\default\\hms\\native\\sysroot\\usr\\include", "-DMYCLANG", "-DOHOS_STL=c++_shared", "-fPIE", "-fPIC", "-o", "build\\.objs\\GfxPluginNativeRender\\harmonyos\\aarch64\\debug\\RenderAPI_D3D12.cpp.o", "RenderAPI_D3D12.cpp"], + "arguments": ["C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.38.33130\\bin\\HostX64\\x64\\cl.exe", "/c", "/nologo", "/std:c++20", "/Igl3w", "/IUnity", "/IC:\\VulkanSDK\\1.3.283.0\\Include", "/Iexternal\\include", "/DNOMINMAX", "/DSUPPORT_D3D11=1", "/DSUPPORT_D3D12=1", "/EHsc", "/Fobuild\\.objs\\GfxPluginNativeRender\\windows\\x64\\release\\RenderAPI_D3D12.cpp.obj", "RenderAPI_D3D12.cpp", "-imsvc", "C:\\Program Files (x86)\\Windows Kits\\10\\Include\\10.0.22621.0\\cppwinrt", "-imsvc", "C:\\Program Files (x86)\\Windows Kits\\10\\Include\\10.0.22621.0\\shared", "-imsvc", "C:\\Program Files (x86)\\Windows Kits\\10\\Include\\10.0.22621.0\\ucrt", "-imsvc", "C:\\Program Files (x86)\\Windows Kits\\10\\Include\\10.0.22621.0\\um", "-imsvc", "C:\\Program Files (x86)\\Windows Kits\\10\\Include\\10.0.22621.0\\winrt", "-imsvc", "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.38.33130\\include"], "file": "RenderAPI_D3D12.cpp" }, { "directory": "g:\\TJURP\\NativeRenderPlugin", - "arguments": ["D:\\tj\\2022.3.48t2\\Editor\\Data\\PlaybackEngines\\OpenHarmonyPlayer\\SDK\\12\\native\\llvm\\bin\\clang.exe", "-c", "-Qunused-arguments", "-D__MUSL__", "--target=aarch64-linux-ohos", "--sysroot=C:/Users/xinyt/AppData/Local/OpenHarmony/Sdk/12/native/sysroot", "-std=c++20", "-Igl3w", "-IUnity", "-DSUPPORT_OPENGL_UNIFIED=1", "-DSUPPORT_OPENGL_ES=1", "-DOHOS=1", "-IC:\\Program Files\\Huawei\\DevEco Studio\\sdk\\default\\hms\\native\\sysroot\\usr\\include", "-DMYCLANG", "-DOHOS_STL=c++_shared", "-fPIE", "-fPIC", "-o", "build\\.objs\\GfxPluginNativeRender\\harmonyos\\aarch64\\debug\\RenderAPI_OpenGLCoreES.cpp.o", "RenderAPI_OpenGLCoreES.cpp"], + "arguments": ["C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.38.33130\\bin\\HostX64\\x64\\cl.exe", "/c", "/nologo", "/std:c++20", "/Igl3w", "/IUnity", "/IC:\\VulkanSDK\\1.3.283.0\\Include", "/Iexternal\\include", "/DNOMINMAX", "/DSUPPORT_D3D11=1", "/DSUPPORT_D3D12=1", "/EHsc", "/Fobuild\\.objs\\GfxPluginNativeRender\\windows\\x64\\release\\RenderAPI_OpenGLCoreES.cpp.obj", "RenderAPI_OpenGLCoreES.cpp", "-imsvc", "C:\\Program Files (x86)\\Windows Kits\\10\\Include\\10.0.22621.0\\cppwinrt", "-imsvc", "C:\\Program Files (x86)\\Windows Kits\\10\\Include\\10.0.22621.0\\shared", "-imsvc", "C:\\Program Files (x86)\\Windows Kits\\10\\Include\\10.0.22621.0\\ucrt", "-imsvc", "C:\\Program Files (x86)\\Windows Kits\\10\\Include\\10.0.22621.0\\um", "-imsvc", "C:\\Program Files (x86)\\Windows Kits\\10\\Include\\10.0.22621.0\\winrt", "-imsvc", "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.38.33130\\include"], "file": "RenderAPI_OpenGLCoreES.cpp" }, { "directory": "g:\\TJURP\\NativeRenderPlugin", - "arguments": ["D:\\tj\\2022.3.48t2\\Editor\\Data\\PlaybackEngines\\OpenHarmonyPlayer\\SDK\\12\\native\\llvm\\bin\\clang.exe", "-c", "-Qunused-arguments", "-D__MUSL__", "--target=aarch64-linux-ohos", "--sysroot=C:/Users/xinyt/AppData/Local/OpenHarmony/Sdk/12/native/sysroot", "-std=c++20", "-Igl3w", "-IUnity", "-DSUPPORT_OPENGL_UNIFIED=1", "-DSUPPORT_OPENGL_ES=1", "-DOHOS=1", "-IC:\\Program Files\\Huawei\\DevEco Studio\\sdk\\default\\hms\\native\\sysroot\\usr\\include", "-DMYCLANG", "-DOHOS_STL=c++_shared", "-fPIE", "-fPIC", "-o", "build\\.objs\\GfxPluginNativeRender\\harmonyos\\aarch64\\debug\\RenderAPI_Vulkan.cpp.o", "RenderAPI_Vulkan.cpp"], + "arguments": ["C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.38.33130\\bin\\HostX64\\x64\\cl.exe", "/c", "/nologo", "/std:c++20", "/Igl3w", "/IUnity", "/IC:\\VulkanSDK\\1.3.283.0\\Include", "/Iexternal\\include", "/DNOMINMAX", "/DSUPPORT_D3D11=1", "/DSUPPORT_D3D12=1", "/EHsc", "/Fobuild\\.objs\\GfxPluginNativeRender\\windows\\x64\\release\\RenderAPI_Vulkan.cpp.obj", "RenderAPI_Vulkan.cpp", "-imsvc", "C:\\Program Files (x86)\\Windows Kits\\10\\Include\\10.0.22621.0\\cppwinrt", "-imsvc", "C:\\Program Files (x86)\\Windows Kits\\10\\Include\\10.0.22621.0\\shared", "-imsvc", "C:\\Program Files (x86)\\Windows Kits\\10\\Include\\10.0.22621.0\\ucrt", "-imsvc", "C:\\Program Files (x86)\\Windows Kits\\10\\Include\\10.0.22621.0\\um", "-imsvc", "C:\\Program Files (x86)\\Windows Kits\\10\\Include\\10.0.22621.0\\winrt", "-imsvc", "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.38.33130\\include"], "file": "RenderAPI_Vulkan.cpp" }, { "directory": "g:\\TJURP\\NativeRenderPlugin", - "arguments": ["D:\\tj\\2022.3.48t2\\Editor\\Data\\PlaybackEngines\\OpenHarmonyPlayer\\SDK\\12\\native\\llvm\\bin\\clang.exe", "-c", "-Qunused-arguments", "-D__MUSL__", "--target=aarch64-linux-ohos", "--sysroot=C:/Users/xinyt/AppData/Local/OpenHarmony/Sdk/12/native/sysroot", "-std=c++20", "-Igl3w", "-IUnity", "-DSUPPORT_OPENGL_UNIFIED=1", "-DSUPPORT_OPENGL_ES=1", "-DOHOS=1", "-IC:\\Program Files\\Huawei\\DevEco Studio\\sdk\\default\\hms\\native\\sysroot\\usr\\include", "-DMYCLANG", "-DOHOS_STL=c++_shared", "-fPIE", "-fPIC", "-o", "build\\.objs\\GfxPluginNativeRender\\harmonyos\\aarch64\\debug\\RenderingPlugin.cpp.o", "RenderingPlugin.cpp"], + "arguments": ["C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.38.33130\\bin\\HostX64\\x64\\cl.exe", "/c", "/nologo", "/std:c++20", "/Igl3w", "/IUnity", "/IC:\\VulkanSDK\\1.3.283.0\\Include", "/Iexternal\\include", "/DNOMINMAX", "/DSUPPORT_D3D11=1", "/DSUPPORT_D3D12=1", "/EHsc", "/Fobuild\\.objs\\GfxPluginNativeRender\\windows\\x64\\release\\RenderingPlugin.cpp.obj", "RenderingPlugin.cpp", "-imsvc", "C:\\Program Files (x86)\\Windows Kits\\10\\Include\\10.0.22621.0\\cppwinrt", "-imsvc", "C:\\Program Files (x86)\\Windows Kits\\10\\Include\\10.0.22621.0\\shared", "-imsvc", "C:\\Program Files (x86)\\Windows Kits\\10\\Include\\10.0.22621.0\\ucrt", "-imsvc", "C:\\Program Files (x86)\\Windows Kits\\10\\Include\\10.0.22621.0\\um", "-imsvc", "C:\\Program Files (x86)\\Windows Kits\\10\\Include\\10.0.22621.0\\winrt", "-imsvc", "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.38.33130\\include"], "file": "RenderingPlugin.cpp" }] diff --git a/NativeRenderPlugin/RenderAPI.h b/NativeRenderPlugin/RenderAPI.h index 1d469a8..93472cb 100644 --- a/NativeRenderPlugin/RenderAPI.h +++ b/NativeRenderPlugin/RenderAPI.h @@ -21,7 +21,6 @@ enum GraphicsFeature METAL_FX_TEMPORAL_SR, VIVO_TEMPORAL_SR, QCOM_AFME, - XESS13, MAX_CNT }; @@ -93,12 +92,6 @@ public: virtual bool getFeatureSupport(GraphicsFeature feature); - virtual void enableXESS1(void* data) {} - virtual void doXESS1(void* data) {} - virtual void configXESS1(void* data) {} - virtual void disableXESS1() {} - - virtual bool getInputResolution(uint32_t outw, uint32_t outh, int quality, uint32_t& width, uint32_t& height) { return false; } virtual void SetVKPSOHook(bool enable) {} protected: virtual void initSupportFeature() = 0; diff --git a/NativeRenderPlugin/RenderAPI_D3D12.cpp b/NativeRenderPlugin/RenderAPI_D3D12.cpp index b8e3793..8acb7fd 100644 --- a/NativeRenderPlugin/RenderAPI_D3D12.cpp +++ b/NativeRenderPlugin/RenderAPI_D3D12.cpp @@ -19,8 +19,6 @@ #include #include -#include "xess1/xess.h" - #define ReturnOnFail(x, hr, OnFailureMsg, onFailureReturnValue) hr = x; if(FAILED(hr)){OutputDebugStringA(OnFailureMsg); return onFailureReturnValue;} #define D3D12_DEFAULT_HEAP_TRIANGLE_BUFFER_NAME L"Native Plugin Default Heap Triangle Vertex Buffer" @@ -99,16 +97,7 @@ public: virtual void initSupportFeature() override; - virtual void enableXESS1(void* data) override; - virtual void doXESS1(void* data) override; - virtual void disableXESS1() override; - virtual void configXESS1(void* data) override; - - virtual bool getInputResolution(uint32_t outw, uint32_t outh, int quality, uint32_t& width, uint32_t& height) override; - - IUnityGraphicsD3D12v7* s_d3d12; - XessV13* xess; static RenderAPI_D3D12* instance; }; RenderAPI_D3D12* RenderAPI_D3D12::instance = nullptr; @@ -150,7 +139,6 @@ void RenderAPI_D3D12::processDeviceEvent(UnityGfxDeviceEventType type, IUnityInt config_2.flags = kUnityD3D12EventConfigFlag_SyncWorkerThreads | kUnityD3D12EventConfigFlag_ModifiesCommandBuffersState | kUnityD3D12EventConfigFlag_EnsurePreviousFrameSubmission; config_2.ensureActiveRenderTextureIsBound = false; s_d3d12->ConfigureEvent(2, &config_2); - xess = new XessV13(s_d3d12->GetDevice()); initSupportFeature(); break; case kUnityGfxDeviceEventShutdown: @@ -254,44 +242,8 @@ void RenderAPI_D3D12::initSupportFeature() // 表示支持 2x4、4x2 和 4x4 } - - support_features[GraphicsFeature::XESS13] = true; } -void RenderAPI_D3D12::enableXESS1(void* data) -{ - xess->enable([](const char* msg) - { - unityLog(msg); - } - ); -} - -void RenderAPI_D3D12::doXESS1(void* data) -{ - UnityGraphicsD3D12RecordingState recordingState; - if (!s_d3d12->CommandRecordingState(&recordingState)) - { - return; - } - xess->execute(data, recordingState.commandList); -} - -void RenderAPI_D3D12::disableXESS1() -{ - xess->disable(); -} - -void RenderAPI_D3D12::configXESS1(void* data) -{ - //s_d3d12->GetCommandQueue()->Wait(s_d3d12->GetFrameFence(), 5); - xess->configxess(data); -} - -bool RenderAPI_D3D12::getInputResolution(uint32_t outw, uint32_t outh, int quality, uint32_t& width, uint32_t& height) -{ - return xess->get_input_resolution(outw, outh, quality, width, height); -} #undef ReturnOnFail diff --git a/NativeRenderPlugin/RenderingPlugin.cpp b/NativeRenderPlugin/RenderingPlugin.cpp index 80b606f..693d0b8 100644 --- a/NativeRenderPlugin/RenderingPlugin.cpp +++ b/NativeRenderPlugin/RenderingPlugin.cpp @@ -107,10 +107,6 @@ enum NativeRenderingEvent PostFGExtrapolation, DisableFGExtrapolation, SpatialUpScale, - EnableXESS1, - DoXESS1, - UpdateXESS1Config, - DisableXESS1, }; static void UNITY_INTERFACE_API OnRenderEventAndData(int eventID, void *data) @@ -159,31 +155,6 @@ static void UNITY_INTERFACE_API OnRenderEventAndData(int eventID, void *data) s_current_api->doFGExtrapolation(param->src, param->data, param->dst); break; } - case NativeRenderingEvent::EnableXESS1: - { - s_current_api->enableXESS1(data); - unityLog("enableXESS1"); - break; - } - case NativeRenderingEvent::DisableXESS1: - { - unityLog("disableXESS0"); - s_current_api->disableXESS1(); - unityLog("disableXESS1"); - break; - } - case NativeRenderingEvent::UpdateXESS1Config: - { - unityLog("configXESS1 0"); - s_current_api->configXESS1(data); - unityLog("configXESS1 1"); - break; - } - case NativeRenderingEvent::DoXESS1: - { - s_current_api->doXESS1(data); - break; - } default: break; } @@ -202,12 +173,6 @@ extern "C" UNITY_INTERFACE_EXPORT bool GetFeatureSupport(int feature) return s_current_api->getFeatureSupport((GraphicsFeature)feature); } -extern "C" UNITY_INTERFACE_EXPORT bool GetInputResolution(uint32_t outw, uint32_t outh, int quality, uint32_t& width, uint32_t& height) -{ - return s_current_api->getInputResolution(outw, outh, quality, width, height); -} - - extern "C" UNITY_INTERFACE_EXPORT void SetVKPSOHook(bool enable) { s_current_api->SetVKPSOHook(enable); diff --git a/NativeRenderPlugin/external/lib/libxess.dll b/NativeRenderPlugin/external/lib/libxess1.dll similarity index 100% rename from NativeRenderPlugin/external/lib/libxess.dll rename to NativeRenderPlugin/external/lib/libxess1.dll diff --git a/NativeRenderPlugin/external/lib/libxess.lib b/NativeRenderPlugin/external/lib/libxess1.lib similarity index 100% rename from NativeRenderPlugin/external/lib/libxess.lib rename to NativeRenderPlugin/external/lib/libxess1.lib diff --git a/NativeRenderPlugin/xmake.lua b/NativeRenderPlugin/xmake.lua index f70b7a2..fb75ed7 100644 --- a/NativeRenderPlugin/xmake.lua +++ b/NativeRenderPlugin/xmake.lua @@ -47,11 +47,10 @@ target("GfxPluginNativeRender") add_defines("SUPPORT_D3D12=1") add_includedirs("external/include") add_linkdirs("external/lib") - add_links("libxess") - add_includedirs("features/") - add_headerfiles("features/**.h") - add_files("features/**.cpp") + -- add_includedirs("features/") + -- add_headerfiles("features/**.h") + -- add_files("features/**.cpp") end end diff --git a/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/Passes/PostProcessPass.cs b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/Passes/PostProcessPass.cs index d5dda14..e94b492 100644 --- a/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/Passes/PostProcessPass.cs +++ b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/Passes/PostProcessPass.cs @@ -503,7 +503,6 @@ namespace UnityEngine.Rendering.Universal colorDescriptor.width = cameraData.camera.pixelWidth; colorDescriptor.height = cameraData.camera.pixelHeight; if (asset.SuperResolution == ESuperResolution.GSR2_COMPUTE - || asset.SuperResolution == ESuperResolution.XESS13 || asset.SuperResolution == ESuperResolution.DLSS1 || asset.SuperResolution == ESuperResolution.DLSS2 || asset.SuperResolution == ESuperResolution.DLSS3 @@ -512,11 +511,6 @@ namespace UnityEngine.Rendering.Universal { colorDescriptor.enableRandomWrite = true; } - colorDescriptor.enableRandomWrite = true; - if (asset.SuperResolution == ESuperResolution.XESS13) - { - colorDescriptor.graphicsFormat = GraphicsFormat.R16G16B16A16_SFloat; - } renderer.m_ColorBufferSystem.SetCameraSettings(colorDescriptor, FilterMode.Bilinear); diff --git a/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/Plugins/Windows/GfxPluginNativeRender.dll b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/Plugins/Windows/GfxPluginNativeRender.dll index 2318046..4919094 100644 Binary files a/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/Plugins/Windows/GfxPluginNativeRender.dll and b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/Plugins/Windows/GfxPluginNativeRender.dll differ diff --git a/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/Plugins/Windows/GfxPluginNativeRender.dll.meta b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/Plugins/Windows/GfxPluginNativeRender.dll.meta index 45e6305..c4327c9 100644 --- a/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/Plugins/Windows/GfxPluginNativeRender.dll.meta +++ b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/Plugins/Windows/GfxPluginNativeRender.dll.meta @@ -1,5 +1,5 @@ fileFormatVersion: 2 -guid: Ciwd4SukVHjmo3sbv6mbRQOAS8tMmDtogzuA8jtsvh3tUelT2TDaMkM= +guid: 5f2d1973ed81cfa48a2454937af74b84 PluginImporter: externalObjects: {} serializedVersion: 2 @@ -23,6 +23,7 @@ PluginImporter: Exclude OpenHarmony: 1 Exclude Win: 0 Exclude Win64: 0 + Exclude iOS: 1 - first: Android: Android second: @@ -74,6 +75,15 @@ PluginImporter: enabled: 1 settings: CPU: None + - first: + iPhone: iOS + second: + enabled: 0 + settings: + AddToEmbeddedBinaries: false + CPU: AnyCPU + CompileFlags: + FrameworkDependencies: userData: assetBundleName: assetBundleVariant: diff --git a/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/NatvieHelper/RenderingPlugin.cs b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/NatvieHelper/RenderingPlugin.cs index 19e7f21..1be5410 100644 --- a/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/NatvieHelper/RenderingPlugin.cs +++ b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/NatvieHelper/RenderingPlugin.cs @@ -77,7 +77,6 @@ namespace X.Rendering.Feature METAL_FX_TEMPORAL_SR, VIVO_TEMPORAL_SR, QCOM_AFME, - XESS13, MAX_CNT }; diff --git a/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/SR.cs b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/SR.cs index 60dec03..7f9059c 100644 --- a/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/SR.cs +++ b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/SR.cs @@ -1,7 +1,6 @@ using System; using System.Collections.Generic; using System.Runtime.InteropServices; -using UnityEngine; using UnityEngine.Rendering; using UnityEngine.Rendering.Universal; @@ -26,10 +25,10 @@ namespace X.Rendering.Feature DLSS3, STP,// Unity 6 空间-时间后处理中的 upscaling /// - /// Intel XeSS 1.3.1 - /// + /// Intel XeSS 2 + /// /// - XESS13, + XESS2, } public enum SrQuality diff --git a/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS.cs b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS.cs index f08a292..9d8d272 100644 --- a/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS.cs +++ b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS.cs @@ -247,18 +247,18 @@ namespace X.Rendering.Feature { switch (resolution) { - case ESuperResolution.XESS13: - { - SetActive(true); - needTurnOnXess = true; - } - break; - default: - { - SetActive(false); - needTurnOffXess = false; - } - break; + // case ESuperResolution.XESS13: + // { + // SetActive(true); + // needTurnOnXess = true; + // } + // break; + // default: + // { + // SetActive(false); + // needTurnOffXess = false; + // } + // break; } } diff --git a/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2.cs b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2.cs new file mode 100644 index 0000000..42f7c3f --- /dev/null +++ b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2.cs @@ -0,0 +1,59 @@ +using Intel; +using System; +using UnityEngine; +using UnityEngine.Rendering; +using UnityEngine.Rendering.Universal; + +namespace X.Rendering.Feature +{ + internal class XESS2 : ScriptableRendererFeature, ISuperResolutionFeature + { + private ProfilingSampler profiler; + private XeSS.xess_context_handle_t xessContext; + private bool xessCreated; + private bool xessInitialized; + + public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData) + { + } + + public override void Create() + { + profiler = new ProfilingSampler("Xess2"); + } + + public bool InitFeature() + { + if (!XeSS.IsFeatureSupported()) + { + Debug.LogWarning("XeSS not supported!"); + return false; + } + + XeSS.xess_result_t ret; + if ((ret = XeSS.xessCreateContext(ref xessContext)) != XeSS.xess_result_t.XESS_RESULT_SUCCESS) + { + xessCreated = false; + xessInitialized = false; + Debug.Log("XeSS context create failed:" + ret.ToString()); + return false; + } + + return true; + } + + + public void DoSR(CommandBuffer cmd, RTHandle source, RTHandle destination, RTHandle motionVector, ref RenderingData renderingData) + { + } + + public float GetRenderScale() + { + throw new NotImplementedException(); + } + + public void SetSR(ESuperResolution resolution) + { + } + } +} diff --git a/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2.cs.meta b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2.cs.meta new file mode 100644 index 0000000..f2231eb --- /dev/null +++ b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: beb28c5693a39894e85d538fac962200 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2.meta b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2.meta new file mode 100644 index 0000000..e6ee291 --- /dev/null +++ b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: c4301ccc37809a3448fefbc8de9ce5eb +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/Plugins.meta b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/Plugins.meta new file mode 100644 index 0000000..825d888 --- /dev/null +++ b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/Plugins.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 56fdb40150d59f34a8c3378fa82df160 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/Plugins/XeSSRenderingPlugin.dll b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/Plugins/XeSSRenderingPlugin.dll new file mode 100644 index 0000000..bf99ead Binary files /dev/null and b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/Plugins/XeSSRenderingPlugin.dll differ diff --git a/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/Plugins/XeSSRenderingPlugin.dll.meta b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/Plugins/XeSSRenderingPlugin.dll.meta new file mode 100644 index 0000000..32b578b --- /dev/null +++ b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/Plugins/XeSSRenderingPlugin.dll.meta @@ -0,0 +1,27 @@ +fileFormatVersion: 2 +guid: 109a6f5cf23637641961a8ed71f813b7 +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 0 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + Any: + second: + enabled: 1 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + DefaultValueInitialized: true + userData: + assetBundleName: + assetBundleVariant: diff --git a/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/Plugins/Windows/libxess.dll b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/Plugins/libxess.dll similarity index 68% rename from Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/Plugins/Windows/libxess.dll rename to Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/Plugins/libxess.dll index 50b9a94..9bd8b5d 100644 Binary files a/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/Plugins/Windows/libxess.dll and b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/Plugins/libxess.dll differ diff --git a/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/Plugins/libxess.dll.meta b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/Plugins/libxess.dll.meta new file mode 100644 index 0000000..2257c17 --- /dev/null +++ b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/Plugins/libxess.dll.meta @@ -0,0 +1,27 @@ +fileFormatVersion: 2 +guid: 87f82eba8f6e5fa4dabde39c2869c1d0 +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 0 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + Any: + second: + enabled: 1 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + DefaultValueInitialized: true + userData: + assetBundleName: + assetBundleVariant: diff --git a/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/Plugins/libxess_dx11.dll b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/Plugins/libxess_dx11.dll new file mode 100644 index 0000000..837fbdc Binary files /dev/null and b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/Plugins/libxess_dx11.dll differ diff --git a/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/Plugins/libxess_dx11.dll.meta b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/Plugins/libxess_dx11.dll.meta new file mode 100644 index 0000000..2687f8a --- /dev/null +++ b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/Plugins/libxess_dx11.dll.meta @@ -0,0 +1,27 @@ +fileFormatVersion: 2 +guid: 464b92b4db4ce5446a9d2445057c4a26 +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 0 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + Any: + second: + enabled: 1 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + DefaultValueInitialized: true + userData: + assetBundleName: + assetBundleVariant: diff --git a/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/XeSS.cs b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/XeSS.cs new file mode 100644 index 0000000..04bdbe3 --- /dev/null +++ b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/XeSS.cs @@ -0,0 +1,933 @@ +/******************************************************************************* + * Copyright 2024 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files(the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and / or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions : + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +using System; +using System.Runtime.InteropServices; +using UnityEngine; +using UnityEngine.Profiling; +using UnityEngine.Rendering; + +/// +/// Wrapper for Intel xess +/// +namespace Intel +{ + internal static class LibXeSSWrapper + { + [DllImport("libxess", EntryPoint = "xessGetVersion")] + public static extern XeSS.xess_result_t xessGetVersion(IntPtr pVersion); + + [DllImport("libxess", EntryPoint = "xessGetIntelXeFXVersion")] + public static extern XeSS.xess_result_t xessGetIntelXeFXVersion(IntPtr hContext, IntPtr pVersion); + + [DllImport("libxess", EntryPoint = "xessGetProperties")] + public static extern XeSS.xess_result_t xessGetProperties(IntPtr hContext, IntPtr pOutputResolution, IntPtr pBindingProperties); + + [DllImport("libxess", EntryPoint = "xessGetInputResolution")] + public static extern XeSS.xess_result_t xessGetInputResolution(IntPtr hContext, IntPtr pOutputResolution, XeSS.xess_quality_settings_t qualitySettings, IntPtr pInputResolution); + + [DllImport("libxess", EntryPoint = "xessGetOptimalInputResolution")] + public static extern XeSS.xess_result_t xessGetOptimalInputResolution(IntPtr hContext, IntPtr pOutputResolution, XeSS.xess_quality_settings_t qualitySettings, IntPtr pInputResolutionOptimal, IntPtr pInputResolutionMin, IntPtr pInputResolutionMax); + + [DllImport("libxess", EntryPoint = "xessGetJitterScale")] + public static extern XeSS.xess_result_t xessGetJitterScale(IntPtr hContext, IntPtr pX, IntPtr pY); + + [DllImport("libxess", EntryPoint = "xessGetVelocityScale")] + public static extern XeSS.xess_result_t xessGetVelocityScale(IntPtr hContext, IntPtr pX, IntPtr pY); + + [DllImport("libxess", EntryPoint = "xessDestroyContext")] + public static extern XeSS.xess_result_t xessDestroyContext(IntPtr hContext); + + [DllImport("libxess", EntryPoint = "xessSetJitterScale")] + public static extern XeSS.xess_result_t xessSetJitterScale(IntPtr hContext, float x, float y); + + [DllImport("libxess", EntryPoint = "xessSetVelocityScale")] + public static extern XeSS.xess_result_t xessSetVelocityScale(IntPtr hContext, float x, float y); + + [DllImport("libxess", EntryPoint = "xessSetLoggingCallback")] + public static extern XeSS.xess_result_t xessSetLoggingCallback(IntPtr hContext, XeSS.xess_logging_level_t loggingLevel, IntPtr loggingCallback); + + [DllImport("libxess", EntryPoint = "xessIsOptimalDriver")] + public static extern XeSS.xess_result_t xessIsOptimalDriver(IntPtr hContext); + } + + internal static class LibXeSSD3D11Wrapper + { + [DllImport("libxess_dx11", EntryPoint = "xessGetVersion")] + public static extern XeSS.xess_result_t xessGetVersion(IntPtr pVersion); + + [DllImport("libxess_dx11", EntryPoint = "xessGetIntelXeFXVersion")] + public static extern XeSS.xess_result_t xessGetIntelXeFXVersion(IntPtr hContext, IntPtr pVersion); + + [DllImport("libxess_dx11", EntryPoint = "xessGetProperties")] + public static extern XeSS.xess_result_t xessGetProperties(IntPtr hContext, IntPtr pOutputResolution, IntPtr pBindingProperties); + + [DllImport("libxess_dx11", EntryPoint = "xessGetInputResolution")] + public static extern XeSS.xess_result_t xessGetInputResolution(IntPtr hContext, IntPtr pOutputResolution, XeSS.xess_quality_settings_t qualitySettings, IntPtr pInputResolution); + + [DllImport("libxess_dx11", EntryPoint = "xessGetOptimalInputResolution")] + public static extern XeSS.xess_result_t xessGetOptimalInputResolution(IntPtr hContext, IntPtr pOutputResolution, XeSS.xess_quality_settings_t qualitySettings, IntPtr pInputResolutionOptimal, IntPtr pInputResolutionMin, IntPtr pInputResolutionMax); + + [DllImport("libxess_dx11", EntryPoint = "xessGetJitterScale")] + public static extern XeSS.xess_result_t xessGetJitterScale(IntPtr hContext, IntPtr pX, IntPtr pY); + + [DllImport("libxess_dx11", EntryPoint = "xessGetVelocityScale")] + public static extern XeSS.xess_result_t xessGetVelocityScale(IntPtr hContext, IntPtr pX, IntPtr pY); + + [DllImport("libxess_dx11", EntryPoint = "xessDestroyContext")] + public static extern XeSS.xess_result_t xessDestroyContext(IntPtr hContext); + + [DllImport("libxess_dx11", EntryPoint = "xessSetJitterScale")] + public static extern XeSS.xess_result_t xessSetJitterScale(IntPtr hContext, float x, float y); + + [DllImport("libxess_dx11", EntryPoint = "xessSetVelocityScale")] + public static extern XeSS.xess_result_t xessSetVelocityScale(IntPtr hContext, float x, float y); + + [DllImport("libxess_dx11", EntryPoint = "xessSetLoggingCallback")] + public static extern XeSS.xess_result_t xessSetLoggingCallback(IntPtr hContext, XeSS.xess_logging_level_t loggingLevel, IntPtr loggingCallback); + + [DllImport("libxess_dx11", EntryPoint = "xessIsOptimalDriver")] + public static extern XeSS.xess_result_t xessIsOptimalDriver(IntPtr hContext); + } + + internal static class LibXeSSUnityPluginWrapper + { + [DllImport("XeSSRenderingPlugin", EntryPoint = "RenderingPlugin_xessCreateContext")] + public static extern XeSS.xess_result_t RenderingPlugin_xessCreateContext(IntPtr phContext); + + [DllImport("XeSSRenderingPlugin", EntryPoint = "RenderingPlugin_xessBuildPipelines")] + public static extern XeSS.xess_result_t RenderingPlugin_xessBuildPipelines(IntPtr pContext, bool blocking, UInt32 initFlags); + + [DllImport("XeSSRenderingPlugin", EntryPoint = "RenderingPlugin_xessGetInitParams")] + public static extern XeSS.xess_result_t RenderingPlugin_xessGetInitParams(IntPtr pContext, IntPtr pInitParams); + + [DllImport("XeSSRenderingPlugin", EntryPoint = "RenderingPlugin_xessDestroyContext")] + public static extern XeSS.xess_result_t RenderingPlugin_xessDestroyContext(IntPtr pContext); + + [DllImport("XeSSRenderingPlugin", EntryPoint = "RenderingPlugin_GetXeSSInitializeEvent")] + public static extern IntPtr RenderingPlugin_GetXeSSInitializeEvent(); + + [DllImport("XeSSRenderingPlugin", EntryPoint = "RenderingPlugin_GetXeSSDestroyContextEvent")] + public static extern IntPtr RenderingPlugin_GetXeSSDestroyContextEvent(); + + [DllImport("XeSSRenderingPlugin", EntryPoint = "RenderingPlugin_GetXeSSExecuteEventFunc")] + public static extern IntPtr RenderingPlugin_GetXeSSExecuteEventFunc(); + + [DllImport("XeSSRenderingPlugin", EntryPoint = "UnityPluginLoaded")] + public static extern bool UnityPluginLoaded(); + + [DllImport("XeSSRenderingPlugin", EntryPoint = "RenderingPlugin_xessIsValid")] + public static extern bool RenderingPlugin_xessIsValid(IntPtr hContext); + }; + + internal static class XeSSShaderIDs + { + // Shader resource views, i.e. read-only bindings + internal static readonly int SrvInputColor = Shader.PropertyToID("r_xess_input_color_jittered"); + internal static readonly int SrvInputMotionVectors = Shader.PropertyToID("r_xess_input_motion_vectors"); + internal static readonly int SrvInputDepth = Shader.PropertyToID("r_xess_input_depth"); + internal static readonly int SrvInputExposure = Shader.PropertyToID("r_xess_input_exposure"); + + internal static readonly int UavUpscaledOutput = Shader.PropertyToID("rw_xess_upscaled_output"); + }; + + public static class XeSS + { + abstract internal class Processer + { + abstract internal xess_result_t GetIntelXeFXVersion(IntPtr hContext, IntPtr pVersion); + abstract internal xess_result_t GetProperties(IntPtr hContext, IntPtr pOutputResolution, IntPtr pBindingProperties); + abstract internal xess_result_t GetInputResolution(IntPtr hContext, IntPtr pOutputResolution, XeSS.xess_quality_settings_t qualitySettings, IntPtr pInputResolution); + abstract internal xess_result_t GetOptimalInputResolution(IntPtr hContext, IntPtr pOutputResolution, XeSS.xess_quality_settings_t qualitySettings, IntPtr pInputResolutionOptimal, IntPtr pInputResolutionMin, IntPtr pInputResolutionMax); + abstract internal xess_result_t GetJitterScale(IntPtr hContext, IntPtr pX, IntPtr pY); + abstract internal xess_result_t GetVelocityScale(IntPtr hContext, IntPtr pX, IntPtr pY); + abstract internal xess_result_t SetJitterScale(IntPtr hContext, float x, float y); + abstract internal xess_result_t SetVelocityScale(IntPtr hContext, float x, float y); + abstract internal xess_result_t SetLoggingCallback(IntPtr hContext, XeSS.xess_logging_level_t loggingLevel, IntPtr loggingCallback); + abstract internal xess_result_t IsOptimalDriver(IntPtr hContext); + abstract internal xess_result_t GetInitParams(XeSS.xess_context_handle_t hContext, out XeSS.xess_init_params_t pInitParams); + abstract internal xess_result_t Initialize(XeSS.xess_context_handle_t hContext, CommandBuffer commandBuffer, XeSS.xess_init_params_t pInitParams); + abstract internal xess_result_t Execute(XeSS.xess_context_handle_t hContext, CommandBuffer commandBuffer, XeSS.xess_execute_params_t pExecParams); + } + + /// + /// XeSS context. + /// + public class xess_context_handle_t + { + public IntPtr context; + + internal Processer processer = null; + + // internal pointer for init/exec/destroy + internal IntPtr[] pEventParams_internal = new IntPtr[2]; + internal IntPtr[] pNativeParams_internal = new IntPtr[2]; + + internal void AllocEventParam(int idx, int size) + { + if (pEventParams_internal[idx] == IntPtr.Zero) + { + pEventParams_internal[idx] = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(xess_event_params_t))); + } + if (pNativeParams_internal[idx] == IntPtr.Zero) + { + pNativeParams_internal[idx] = Marshal.AllocHGlobal(size); + } + } + + internal void FreeEventParams() + { + for (int i = 0; i < 2; i++) + { + if (pEventParams_internal[i] != IntPtr.Zero) + { + Marshal.FreeHGlobal(pEventParams_internal[i]); + pEventParams_internal[i] = IntPtr.Zero; + } + + if (pNativeParams_internal[i] != IntPtr.Zero) + { + Marshal.FreeHGlobal(pNativeParams_internal[i]); + pNativeParams_internal[i] = IntPtr.Zero; + } + } + } + + internal void InitEventParams() + { + for (int i = 0; i < 2; i++) + { + pEventParams_internal[i] = IntPtr.Zero; + pNativeParams_internal[i] = IntPtr.Zero; + } + } + + public xess_context_handle_t() + { + context = IntPtr.Zero; + InitEventParams(); + if (SystemInfo.graphicsDeviceType == GraphicsDeviceType.Direct3D12) + { + processer = new XeSSD3D12.Processer_D3D12(); + } + else if (SystemInfo.graphicsDeviceType == GraphicsDeviceType.Vulkan) + { + processer = new XeSSVK.Processer_VK(); + } + else if (SystemInfo.graphicsDeviceType == GraphicsDeviceType.Direct3D11) + { + processer = new XeSSD3D11.Processer_D3D11(); + } + } + + ~xess_context_handle_t() + { + FreeEventParams(); + } + }; + + /// + /// Set profiler sample for XeSS execution. + /// + /// Sampler for XeSS execution time. + static public void SetProfilerSampler(CustomSampler sampler) + { + XeSSSampler = sampler; + } + internal static CustomSampler XeSSSampler = null; + + /// + /// Check if the XeSS feature is supported. + /// + /// Whether the XeSS feature is supported. + static public bool IsFeatureSupported() + { + // D3D12 and Vulkan are full supported, and D3D11 is only supported on intel hardware + if (SystemInfo.graphicsDeviceType != GraphicsDeviceType.Direct3D12 && + SystemInfo.graphicsDeviceType != GraphicsDeviceType.Vulkan && + !(SystemInfo.graphicsDeviceType == GraphicsDeviceType.Direct3D11 && SystemInfo.graphicsDeviceVendorID == 0x8086)) + { + return false; + } + + if (!XeSS.xessPluginLoaded()) + { + return false; + } + + XeSS.xess_context_handle_t tryCreateXeSSContext = new XeSS.xess_context_handle_t(); + XeSS.xess_result_t ret; + if ((ret = XeSS.xessCreateContext(ref tryCreateXeSSContext)) != XeSS.xess_result_t.XESS_RESULT_SUCCESS) + { + return false; + } + XeSS.xessDestroyContext(tryCreateXeSSContext); + + return true; + } + + /// + /// XeSS version. + /// XeSS uses major.minor.patch version format and Numeric 90+ scheme for development stage builds. + /// + public struct xess_version_t + { + public UInt16 major; + public UInt16 minor; + public UInt16 patch; + public UInt16 reserved; + }; + + /// + /// 2D variable. + /// + public struct xess_2d_t + { + public xess_2d_t(UInt32 _x, UInt32 _y) + { + x = _x; + y = _y; + } + public UInt32 x; + public UInt32 y; + }; + + /// + /// 2D coordinates. + /// + public struct xess_coord_t + { + public xess_coord_t(UInt32 _x, UInt32 _y) + { + x = _x; + y = _y; + } + public UInt32 x; + public UInt32 y; + }; + + /// + /// XeSS quality settings. + /// + public enum xess_quality_settings_t + { + XESS_QUALITY_SETTING_ULTRA_PERFORMANCE = 100, + XESS_QUALITY_SETTING_PERFORMANCE = 101, + XESS_QUALITY_SETTING_BALANCED = 102, + XESS_QUALITY_SETTING_QUALITY = 103, + XESS_QUALITY_SETTING_ULTRA_QUALITY = 104, + XESS_QUALITY_SETTING_ULTRA_QUALITY_PLUS = 105, + XESS_QUALITY_SETTING_AA = 106, + }; + + /// + /// XeSS initialization flags. + /// + public enum xess_init_flags_t + { + XESS_INIT_FLAG_NONE = 0, + /** Use motion vectors at target resolution. */ + XESS_INIT_FLAG_HIGH_RES_MV = 1 << 0, + /** Use inverted (increased precision) depth encoding */ + XESS_INIT_FLAG_INVERTED_DEPTH = 1 << 1, + /** Use exposure texture to scale input color. */ + XESS_INIT_FLAG_EXPOSURE_SCALE_TEXTURE = 1 << 2, + /** Use responsive pixel mask texture. */ + XESS_INIT_FLAG_RESPONSIVE_PIXEL_MASK = 1 << 3, + /** Use velocity in NDC */ + XESS_INIT_FLAG_USE_NDC_VELOCITY = 1 << 4, + /** Use external descriptor heap */ + XESS_INIT_FLAG_EXTERNAL_DESCRIPTOR_HEAP = 1 << 5, + /** Disable tonemapping for input and output */ + XESS_INIT_FLAG_LDR_INPUT_COLOR = 1 << 6, + /** Remove jitter from input velocity*/ + XESS_INIT_FLAG_JITTERED_MV = 1 << 7, + /** Enable automatic exposure calculation. */ + XESS_INIT_FLAG_ENABLE_AUTOEXPOSURE = 1 << 8 + }; + + /// + /// Properties for internal XeSS resources. + /// + public struct xess_properties_t + { + /** Required amount of descriptors for XeSS */ + public UInt32 requiredDescriptorCount; + /** The heap size required by XeSS for temporary buffer storage. */ + public UInt64 tempBufferHeapSize; + /** The heap size required by XeSS for temporary texture storage. */ + public UInt64 tempTextureHeapSize; + }; + + /// + /// XeSS return codes. + /// + public enum xess_result_t + { + /** Warning. Folder to store dump data doesn't exist. Write operation skipped.*/ + XESS_RESULT_WARNING_NONEXISTING_FOLDER = 1, + /** An old or outdated driver. */ + XESS_RESULT_WARNING_OLD_DRIVER = 2, + /** XeSS operation was successful. */ + XESS_RESULT_SUCCESS = 0, + /** XeSS not supported on the GPU. An SM 6.4 capable GPU is required. */ + XESS_RESULT_ERROR_UNSUPPORTED_DEVICE = -1, + /** An unsupported driver. */ + XESS_RESULT_ERROR_UNSUPPORTED_DRIVER = -2, + /** Execute called without initialization. */ + XESS_RESULT_ERROR_UNINITIALIZED = -3, + /** Invalid argument such as descriptor handles. */ + XESS_RESULT_ERROR_INVALID_ARGUMENT = -4, + /** Not enough available GPU memory. */ + XESS_RESULT_ERROR_DEVICE_OUT_OF_MEMORY = -5, + /** Device function such as resource or descriptor creation. */ + XESS_RESULT_ERROR_DEVICE = -6, + /** The function is not implemented */ + XESS_RESULT_ERROR_NOT_IMPLEMENTED = -7, + /** Invalid context. */ + XESS_RESULT_ERROR_INVALID_CONTEXT = -8, + /** Operation not finished yet. */ + XESS_RESULT_ERROR_OPERATION_IN_PROGRESS = -9, + /** Operation not supported in current configuration. */ + XESS_RESULT_ERROR_UNSUPPORTED = -10, + /** The library cannot be loaded. */ + XESS_RESULT_ERROR_CANT_LOAD_LIBRARY = -11, + + /** The c# wrapper error. */ + XESS_RESULT_ERROR_CSHARP_WRAPPER = -100, + /** The invalid paramaters passed to c#. */ + XESS_RESULT_ERROR_CSHARP_INVALID_ARGUMENT = -101, + + /** Unknown internal failure */ + XESS_RESULT_ERROR_UNKNOWN = -1000, + }; + + /// + /// XeSS logging level + /// + public enum xess_logging_level_t + { + XESS_LOGGING_LEVEL_DEBUG = 0, + XESS_LOGGING_LEVEL_INFO = 1, + XESS_LOGGING_LEVEL_WARNING = 2, + XESS_LOGGING_LEVEL_ERROR = 3 + }; + + /// + /// Initialization parameters for XeSS. + /// + public struct xess_init_params_t + { + /** Output width and height. */ + public XeSS.xess_2d_t outputResolution; + /** Quality setting */ + public XeSS.xess_quality_settings_t qualitySetting; + /** Initialization flags. */ + public UInt32 initFlags; + /** Specifies the node mask for internally created resources on + * multi-adapter systems. */ + public UInt32 creationNodeMask; + /** Specifies the node visibility mask for internally created resources + * on multi-adapter systems. */ + public UInt32 visibleNodeMask; + }; + + /// + /// Execution parameters for XeSS + /// + public struct xess_execute_params_t + { + /** Input color texture.*/ + public Texture colorTexture; + /** Input motion vector texture.*/ + public Texture velocityTexture; + /** Optional depth texture. Required if XESS_INIT_FLAG_HIGH_RES_MV has not been specified.*/ + public Texture depthTexture; + /** Optional 1x1 exposure scale texture. Required if XESS_INIT_FLAG_EXPOSURE_TEXTURE has been + * specified.*/ + public Texture exposureScaleTexture; + /** Optional responsive pixel mask texture. Required if XESS_INIT_FLAG_RESPONSIVE_PIXEL_MASK + * has been specified.*/ + public Texture responsivePixelMaskTexture; + /** Output texture in target resolution.*/ + public Texture outputTexture; + + /** Jitter X coordinate in the range [-0.5, 0.5]. */ + public float jitterOffsetX; + /** Jitter Y coordinate in the range [-0.5, 0.5]. */ + public float jitterOffsetY; + /** Optional input color scaling. Default is 1. */ + public float exposureScale; + /** Resets the history accumulation in this frame. */ + public UInt32 resetHistory; + /** Input color width. */ + public UInt32 inputWidth; + /** Input color height. */ + public UInt32 inputHeight; + /** Base coordinate for the input color in the texture. Default is (0,0). */ + public XeSS.xess_coord_t inputColorBase; + /** Base coordinate for the input motion vector in the texture. Default is (0,0). */ + public XeSS.xess_coord_t inputMotionVectorBase; + /** Base coordinate for the input depth in the texture. Default is (0,0). */ + public XeSS.xess_coord_t inputDepthBase; + /** Base coordinate for the input responsive pixel mask in the texture. Default is (0,0). */ + public XeSS.xess_coord_t inputResponsiveMaskBase; + /** Reserved parameter. */ + public XeSS.xess_coord_t reserved0; + /** Base coordinate for the output color. Default is (0,0). */ + public XeSS.xess_coord_t outputColorBase; + }; + + /// + /// XeSS rendering event param for native plugin + /// + public struct xess_event_params_t + { + public IntPtr hContext; + public XeSS.xess_result_t result; + public IntPtr pParams; + }; + + /// + /// A logging callback provided by the application. + /// + /// message + /// login level + public delegate void xess_app_log_callback_t(string message, xess_logging_level_t loggingLevel); + + /// + /// Gets the XeSS version. This is baked into the XeSS SDK release. + /// + /// Returned XeSS version. + /// XeSS return status code. + public static xess_result_t xessGetVersion(out xess_version_t pVersion) + { + IntPtr pVersion_internal = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(xess_version_t))); + if (pVersion_internal != IntPtr.Zero) + { + xess_result_t ret; + if (SystemInfo.graphicsDeviceType == GraphicsDeviceType.Direct3D11) + ret = LibXeSSD3D11Wrapper.xessGetVersion(pVersion_internal); + else + ret = LibXeSSWrapper.xessGetVersion(pVersion_internal); + pVersion = (xess_version_t)Marshal.PtrToStructure(pVersion_internal, typeof(xess_version_t)); + Marshal.FreeHGlobal(pVersion_internal); + return ret; + } + pVersion.major = pVersion.minor = pVersion.patch = pVersion.reserved = 0; + return xess_result_t.XESS_RESULT_ERROR_UNKNOWN; + } + + /// + /// Check if the XeSS unity native plugin loaded. + /// + /// Is the plugin loaded + public static bool xessPluginLoaded() + { + return LibXeSSUnityPluginWrapper.UnityPluginLoaded(); + } + + /// + /// Gets the version of the loaded Intel XeFX library. When running on Intel platforms , + /// this function will return the version of the loaded Intel XeFX library, for other + /// platforms 0.0.0 will be returned. + /// + /// The XeSS context handle. + /// Returned Intel XeFX library version. + /// XeSS return status code. + public static xess_result_t xessGetIntelXeFXVersion(xess_context_handle_t hContext, out xess_version_t pVersion) + { + IntPtr pVersion_internal = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(xess_version_t))); + if (pVersion_internal != IntPtr.Zero) + { + xess_result_t ret = hContext.processer.GetIntelXeFXVersion(hContext.context, pVersion_internal); + pVersion = (xess_version_t)Marshal.PtrToStructure(pVersion_internal, typeof(xess_version_t)); + Marshal.FreeHGlobal(pVersion_internal); + return ret; + } + pVersion.major = pVersion.minor = pVersion.patch = pVersion.reserved = 0; + return xess_result_t.XESS_RESULT_ERROR_CSHARP_WRAPPER; + } + + /// + /// Gets XeSS internal resources properties. + /// + /// The XeSS context handle. + /// Output resolution to calculate properties for. + /// Returned properties. + /// XeSS return status code. + public static xess_result_t xessGetProperties(xess_context_handle_t hContext, xess_2d_t pOutputResolution, out xess_properties_t pBindingProperties) + { + IntPtr pBindingProperties_internal = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(xess_properties_t))); + IntPtr pOutputResolution_internal = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(xess_2d_t))); + if (pBindingProperties_internal != IntPtr.Zero && pOutputResolution_internal != IntPtr.Zero) + { + Marshal.StructureToPtr(pOutputResolution, pOutputResolution_internal, false); + xess_result_t ret = hContext.processer.GetProperties(hContext.context, pOutputResolution_internal, pBindingProperties_internal); + pBindingProperties = (xess_properties_t)Marshal.PtrToStructure(pBindingProperties_internal, typeof(xess_properties_t)); + Marshal.FreeHGlobal(pBindingProperties_internal); + Marshal.FreeHGlobal(pOutputResolution_internal); + return ret; + } + pBindingProperties.requiredDescriptorCount = 0; + pBindingProperties.tempBufferHeapSize = 0; + pBindingProperties.tempTextureHeapSize = 0; + return xess_result_t.XESS_RESULT_ERROR_CSHARP_WRAPPER; + } + + /// + /// Get the input resolution for a specified output resolution for a given quality setting. + /// X eSS expects all the input buffers except motion vectors to be in the returned resolution. + /// Motion vectors can be either in output resolution (XESS_INIT_FLAG_HIGH_RES_MV) or + /// returned resolution (default). + /// + /// The XeSS context handle. + /// Output resolution to calculate input resolution for. + /// Desired quality setting. + /// Required input resolution. + /// + public static xess_result_t xessGetInputResolution(xess_context_handle_t hContext, xess_2d_t pOutputResolution, xess_quality_settings_t qualitySettings, out xess_2d_t pInputResolution) + { + IntPtr pInputResolution_internal = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(xess_2d_t))); + IntPtr pOutputResolution_internal = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(xess_2d_t))); + if (pInputResolution_internal != IntPtr.Zero && pOutputResolution_internal != IntPtr.Zero) + { + Marshal.StructureToPtr(pOutputResolution, pOutputResolution_internal, false); + xess_result_t ret = hContext.processer.GetInputResolution(hContext.context, pOutputResolution_internal, qualitySettings, pInputResolution_internal); ; + pInputResolution = (xess_2d_t)Marshal.PtrToStructure(pInputResolution_internal, typeof(xess_2d_t)); + Marshal.FreeHGlobal(pInputResolution_internal); + Marshal.FreeHGlobal(pOutputResolution_internal); + return ret; + } + pInputResolution.x = pInputResolution.y = 0; + return xess_result_t.XESS_RESULT_ERROR_CSHARP_WRAPPER; + } + + /// + /// Get the optimal input resolution and possible range for a specified output resolution for a given quality setting. + /// X eSS expects all the input buffers except motion vectors to be in the returned resolution range + /// and all input buffers to be in the same resolution. + /// Motion vectors can be either in output resolution (XESS_INIT_FLAG_HIGH_RES_MV) or + /// in the same resolution as other input buffers (by default). + /// @note Aspect ratio of the input resolution must be the same as for the output resoulution. + /// + /// The XeSS context handle. + /// Output resolution to calculate input resolution for. + /// Desired quality setting. + /// Optimal input resolution. + /// Required minimal input resolution. + /// Required maximal input resolution. + /// XeSS return status code. + public static XeSS.xess_result_t xessGetOptimalInputResolution(xess_context_handle_t hContext, IntPtr pOutputResolution, XeSS.xess_quality_settings_t qualitySettings, out xess_2d_t pInputResolutionOptimal, out xess_2d_t pInputResolutionMin, out xess_2d_t pInputResolutionMax) + { + IntPtr pInputResolutionOptional_internal = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(xess_2d_t))); + IntPtr pInputResolutionMin_internal = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(xess_2d_t))); + IntPtr pInputResolutionMax_internal = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(xess_2d_t))); + IntPtr pOutputResolution_internal = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(xess_2d_t))); + if (pInputResolutionOptional_internal != IntPtr.Zero && pOutputResolution_internal != IntPtr.Zero && + pInputResolutionMin_internal != IntPtr.Zero && pInputResolutionMax_internal != IntPtr.Zero) + { + Marshal.StructureToPtr(pOutputResolution, pOutputResolution_internal, false); + xess_result_t ret = hContext.processer.GetOptimalInputResolution(hContext.context, pOutputResolution_internal, qualitySettings, pInputResolutionOptional_internal, pInputResolutionMin_internal, pInputResolutionMax_internal); ; + pInputResolutionOptimal = (xess_2d_t)Marshal.PtrToStructure(pInputResolutionOptional_internal, typeof(xess_2d_t)); + pInputResolutionMin = (xess_2d_t)Marshal.PtrToStructure(pInputResolutionMin_internal, typeof(xess_2d_t)); + pInputResolutionMax = (xess_2d_t)Marshal.PtrToStructure(pInputResolutionMax_internal, typeof(xess_2d_t)); + Marshal.FreeHGlobal(pInputResolutionOptional_internal); + Marshal.FreeHGlobal(pInputResolutionMin_internal); + Marshal.FreeHGlobal(pInputResolutionMax_internal); + Marshal.FreeHGlobal(pOutputResolution_internal); + return ret; + } + pInputResolutionOptimal.x = pInputResolutionOptimal.y = 0; + pInputResolutionMin.x = pInputResolutionMin.y = 0; + pInputResolutionMax.x = pInputResolutionMax.y = 0; + return xess_result_t.XESS_RESULT_ERROR_CSHARP_WRAPPER; + } + + /// + /// Gets jitter scale value. + /// + /// The XeSS context handle. + /// Jitter scale pointer for the X axis. + /// Jitter scale pointer for the Y axis. + /// XeSS return status code. + public static xess_result_t xessGetJitterScale(xess_context_handle_t hContext, out float pX, out float pY) + { + IntPtr pX_internal = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(float))); + IntPtr pY_internal = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(float))); + if (pX_internal != IntPtr.Zero && pY_internal != IntPtr.Zero) + { + xess_result_t ret = hContext.processer.GetJitterScale(hContext.context, pX_internal, pY_internal); + pX = (float)Marshal.PtrToStructure(pX_internal, typeof(float)); + pY = (float)Marshal.PtrToStructure(pY_internal, typeof(float)); + Marshal.FreeHGlobal(pX_internal); + Marshal.FreeHGlobal(pY_internal); + return ret; + } + pX = pY = 1.0f; + return xess_result_t.XESS_RESULT_ERROR_CSHARP_WRAPPER; + } + + /// + /// Gets velocity scale value. + /// + /// The XeSS context handle. + /// Velocity scale pointer for the X axis. + /// Velocity scale pointer for the Y axis. + /// XeSS return status code. + public static xess_result_t xessGetVelocityScale(xess_context_handle_t hContext, out float pX, out float pY) + { + IntPtr pX_internal = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(float))); + IntPtr pY_internal = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(float))); + if (pX_internal != IntPtr.Zero && pY_internal != IntPtr.Zero) + { + xess_result_t ret = hContext.processer.GetVelocityScale(hContext.context, pX_internal, pY_internal); + pX = (float)Marshal.PtrToStructure(pX_internal, typeof(float)); + pY = (float)Marshal.PtrToStructure(pY_internal, typeof(float)); + Marshal.FreeHGlobal(pX_internal); + Marshal.FreeHGlobal(pY_internal); + return ret; + } + pX = pY = 1.0f; + return xess_result_t.XESS_RESULT_ERROR_CSHARP_WRAPPER; + } + + /// + /// Initiates pipeline build process + /// This function can only be called between xessCreateContext and + /// xessInit + /// + /// + /// + /// + /// + public static xess_result_t xessBuildPipelines(xess_context_handle_t hContext, bool blocking, UInt32 initFlags) + { + return LibXeSSUnityPluginWrapper.RenderingPlugin_xessBuildPipelines(hContext.context, blocking, initFlags); + } + + /// + /// Create an XeSS context. + /// + /// Returned xess context handle. + /// XeSS return status code. + public static xess_result_t xessCreateContext(ref xess_context_handle_t hContext) + { + hContext.InitEventParams(); + IntPtr context_internal = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(IntPtr))); + if (context_internal != IntPtr.Zero) + { + xess_result_t ret = LibXeSSUnityPluginWrapper.RenderingPlugin_xessCreateContext(context_internal); + hContext.context = (IntPtr)Marshal.PtrToStructure(context_internal, typeof(IntPtr)); + Marshal.FreeHGlobal(context_internal); + return ret; + } + hContext.context = IntPtr.Zero; + return xess_result_t.XESS_RESULT_ERROR_CSHARP_WRAPPER; + } + + /// + /// Destroys the XeSS context. + /// May happen in main thread or rendering thread. + /// This function makes sure the pending command list has completed + /// Note: + /// If it is called in main thread, please make sure no pending command list is recorded in rendering thread by yourself + /// Normally we use the function in main thread just for checking if the XeSS feature is supported. + /// + /// The Xe SS context handle. + /// If the XeSS function happens in rendering thread. + /// Unity command buffer. + /// Xe SS return status code + public static xess_result_t xessDestroyContext(xess_context_handle_t hContext, bool callInRenderingThread = false, CommandBuffer commandBuffer = null) + { + hContext.FreeEventParams(); + if (!callInRenderingThread) + { + return LibXeSSUnityPluginWrapper.RenderingPlugin_xessDestroyContext(hContext.context); + } + else if (commandBuffer != null) + { + commandBuffer.IssuePluginEventAndData(LibXeSSUnityPluginWrapper.RenderingPlugin_GetXeSSDestroyContextEvent(), 1, hContext.context); + return XeSS.xess_result_t.XESS_RESULT_SUCCESS; + } + return XeSS.xess_result_t.XESS_RESULT_ERROR_CSHARP_INVALID_ARGUMENT; + } + + /// + /// Sets jitter scale value + /// + /// The XeSS context handle. + /// scale for the X axis + /// scale for the Y axis + /// XeSS return status code. + public static xess_result_t xessSetJitterScale(xess_context_handle_t hContext, float x, float y) + { + return hContext.processer.SetJitterScale(hContext.context, x, y); + } + + /// + /// Sets velocity scale value + /// + /// The XeSS context handle. + /// scale for the X axis + /// scale for the Y axis + /// XeSS return status code. + public static xess_result_t xessSetVelocityScale(xess_context_handle_t hContext, float x, float y) + { + return hContext.processer.SetVelocityScale(hContext.context, x, y); + } + + /// + /// Sets logging callback + /// + /// The XeSS context handle. + /// Minimum logging level for logging callback. + /// Logging callback + /// XeSS return status code. + public static xess_result_t xessSetLoggingCallback(xess_context_handle_t hContext, xess_logging_level_t loggingLevel, xess_app_log_callback_t loggingCallback) + { + IntPtr loggingCallback_internal = Marshal.GetFunctionPointerForDelegate(loggingCallback); + if (loggingCallback_internal != null) + { + return hContext.processer.SetLoggingCallback(hContext.context, loggingLevel, loggingCallback_internal); + } + return xess_result_t.XESS_RESULT_ERROR_CSHARP_WRAPPER; + } + + /// + /// Indicates if the installed driver supports best XeSS experience. + /// + /// The XeSS context handle. + /// xessIsOptimalDriver returns XESS_RESULT_SUCCESS, or XESS_RESULT_WARNING_OLD_DRIVER + /// if installed driver may result in degraded performance or visual quality. + /// xessD3D12CreateContext(..) will return XESS_RESULT_ERROR_UNSUPPORTED_DRIVER if driver does + /// not support X eSS at all. + public static xess_result_t xessIsOptimalDriver(xess_context_handle_t hContext) + { + return hContext.processer.IsOptimalDriver(hContext.context); + } + + /// + /// Check if the context is a valid context. + /// + /// + /// If the context is a valid context. Context may be remodestroied in plugin by device removed. + public static bool xessIsValid(xess_context_handle_t hContext) + { + return LibXeSSUnityPluginWrapper.RenderingPlugin_xessIsValid(hContext.context); + } + + /// + /// Get XeSS initialization parameters. + /// This function will return @ref XESS_RESULT_ERROR_UNINITIALIZED if @ref xessD3D12Init has not been called. + /// + /// The XeSS context handle. + /// Returned initialization parameters. + /// XeSS return status code. + public static XeSS.xess_result_t xessGetInitParams(XeSS.xess_context_handle_t hContext, out XeSS.xess_init_params_t pInitParams) + { + return hContext.processer.GetInitParams(hContext, out pInitParams); + } + + /// + /// Initialize XeSS. + /// Add initialization event to rendering thread. + /// In rendering thread: + /// This is a blocking call that initializes XeSS and triggers internal + /// resources allocation and JIT for the Xe SS kernels.The user must ensure that + /// any pending command lists are completed before re-initialization.When + /// During initialization, X eSS can create staging buffers and copy queues to + /// upload internal data.These will be destroyed at the end of initialization. + /// @note X eSS supports devices starting from D3D12_RESOURCE_HEAP_TIER_1, which means + /// that buffers and textures can not live in the same resource heap. + /// + /// The XeSS context handle. + /// Unity command buffer. + /// Initialization parameters. + /// XeSS return status code. + public static XeSS.xess_result_t xessInitialize(XeSS.xess_context_handle_t hContext, CommandBuffer commandBuffer, XeSS.xess_init_params_t pInitParams) + { + return hContext.processer.Initialize(hContext, commandBuffer, pInitParams); + } + + /// + /// Record XeSS upscaling commands into the command list. + /// Add execution event to rendering thread. + /// + /// The XeSS context handle. + /// Unity command buffer. + /// Execution parameters. + /// + public static XeSS.xess_result_t xessExecute(XeSS.xess_context_handle_t hContext, CommandBuffer commandBuffer, XeSS.xess_execute_params_t pExecParams) + { + return hContext.processer.Execute(hContext, commandBuffer, pExecParams); + } + + public static class Utility + { + static bool usingFixedJitterPhaseCount = true; + const int fixedJitterPhaseCount = 64; + + public static void SetUseFixedJitterPhaseCount(bool isUsingFixedJitterPhaseCount) + { + usingFixedJitterPhaseCount = isUsingFixedJitterPhaseCount; + } + + public static float GetMipmapBiasOffset(uint renderWidth, uint displayWidth) + { + return Mathf.Log((float)renderWidth / displayWidth, 2.0f); + } + + public static int GetJitterPhaseCount(uint renderWidth, uint displayWidth) + { + if (!usingFixedJitterPhaseCount) + { + const float basePhaseCount = 8.0f; + int jitterPhaseCount = (int)(basePhaseCount * Mathf.Pow((float)displayWidth / renderWidth, 2.0f)); + return jitterPhaseCount; + } + return fixedJitterPhaseCount; + } + + public static void GetJitterOffset(out float outX, out float outY, int index, int phaseCount) + { + outX = Halton((index % phaseCount) + 1, 2) - 0.5f; + outY = Halton((index % phaseCount) + 1, 3) - 0.5f; + } + + // Calculate halton number for index and base. + private static float Halton(int index, int @base) + { + float f = 1.0f, result = 0.0f; + + for (int currentIndex = index; currentIndex > 0;) + { + + f /= @base; + result += f * (currentIndex % @base); + currentIndex = (int)Mathf.Floor((float)currentIndex / @base); + } + + return result; + } + } + } +} diff --git a/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/XeSS.cs.meta b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/XeSS.cs.meta new file mode 100644 index 0000000..db69c4a --- /dev/null +++ b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/XeSS.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 884185e603e19604ca54c2274b68d74b +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/XeSSD3D11.cs b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/XeSSD3D11.cs new file mode 100644 index 0000000..b4bf63a --- /dev/null +++ b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/XeSSD3D11.cs @@ -0,0 +1,242 @@ +/******************************************************************************* + * Copyright 2024 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files(the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and / or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions : + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +using System; +using System.Collections; +using System.Collections.Generic; +using UnityEngine; +using UnityEngine.Rendering; +using System.Runtime.InteropServices; + +namespace Intel +{ + public static class XeSSD3D11 + { + internal class Processer_D3D11 : XeSS.Processer + { + internal override XeSS.xess_result_t GetIntelXeFXVersion(IntPtr hContext, IntPtr pVersion) + { + return LibXeSSD3D11Wrapper.xessGetIntelXeFXVersion(hContext, pVersion); + } + internal override XeSS.xess_result_t GetProperties(IntPtr hContext, IntPtr pOutputResolution, IntPtr pBindingProperties) + { + return LibXeSSD3D11Wrapper.xessGetProperties(hContext, pOutputResolution, pBindingProperties); + } + internal override XeSS.xess_result_t GetInputResolution(IntPtr hContext, IntPtr pOutputResolution, XeSS.xess_quality_settings_t qualitySettings, IntPtr pInputResolution) + { + return LibXeSSD3D11Wrapper.xessGetInputResolution(hContext, pOutputResolution, qualitySettings, pInputResolution); + } + internal override XeSS.xess_result_t GetOptimalInputResolution(IntPtr hContext, IntPtr pOutputResolution, XeSS.xess_quality_settings_t qualitySettings, IntPtr pInputResolutionOptimal, IntPtr pInputResolutionMin, IntPtr pInputResolutionMax) + { + return LibXeSSD3D11Wrapper.xessGetOptimalInputResolution(hContext, pOutputResolution, qualitySettings, pInputResolutionOptimal, pInputResolutionMin, pInputResolutionMax); + } + internal override XeSS.xess_result_t GetJitterScale(IntPtr hContext, IntPtr pX, IntPtr pY) + { + return LibXeSSD3D11Wrapper.xessGetJitterScale(hContext, pX, pY); + } + internal override XeSS.xess_result_t GetVelocityScale(IntPtr hContext, IntPtr pX, IntPtr pY) + { + return LibXeSSD3D11Wrapper.xessGetVelocityScale(hContext, pX, pY); + } + internal override XeSS.xess_result_t SetJitterScale(IntPtr hContext, float x, float y) + { + return LibXeSSD3D11Wrapper.xessSetJitterScale(hContext, x, y); + } + internal override XeSS.xess_result_t SetVelocityScale(IntPtr hContext, float x, float y) + { + return LibXeSSD3D11Wrapper.xessSetVelocityScale(hContext, x, y); + } + internal override XeSS.xess_result_t SetLoggingCallback(IntPtr hContext, XeSS.xess_logging_level_t loggingLevel, IntPtr loggingCallback) + { + return LibXeSSD3D11Wrapper.xessSetLoggingCallback(hContext, loggingLevel, loggingCallback); + } + internal override XeSS.xess_result_t IsOptimalDriver(IntPtr hContext) + { + return LibXeSSD3D11Wrapper.xessIsOptimalDriver(hContext); + } + internal override XeSS.xess_result_t GetInitParams(XeSS.xess_context_handle_t hContext, out XeSS.xess_init_params_t pInitParams) + { + IntPtr pInitParams_internal = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(xess_native_init_params_t))); + if (pInitParams_internal != IntPtr.Zero) + { + XeSS.xess_result_t ret = LibXeSSUnityPluginWrapper.RenderingPlugin_xessGetInitParams(hContext.context, pInitParams_internal); + xess_native_init_params_t pInitParams_native = (xess_native_init_params_t)Marshal.PtrToStructure(pInitParams_internal, typeof(xess_native_init_params_t)); + pInitParams = new XeSS.xess_init_params_t(); + pInitParams_native.to_xess_init_params_t(pInitParams); + Marshal.FreeHGlobal(pInitParams_internal); + return ret; + } + pInitParams = new XeSS.xess_init_params_t(); + return XeSS.xess_result_t.XESS_RESULT_ERROR_CSHARP_WRAPPER; + } + internal override XeSS.xess_result_t Initialize(XeSS.xess_context_handle_t hContext, CommandBuffer commandBuffer, XeSS.xess_init_params_t pInitParams) + { + if (commandBuffer != null) + { + hContext.AllocEventParam(0, Marshal.SizeOf(typeof(xess_native_init_params_t))); + if (hContext.pEventParams_internal[0] != IntPtr.Zero && hContext.pNativeParams_internal[0] != IntPtr.Zero) + { + // construct init params + xess_native_init_params_t pNativeInitParams = new xess_native_init_params_t(pInitParams); + Marshal.StructureToPtr(pNativeInitParams, hContext.pNativeParams_internal[0], false); + + // construct init event params + XeSS.xess_event_params_t pInitEventParams = new XeSS.xess_event_params_t(); + pInitEventParams.pParams = hContext.pNativeParams_internal[0]; + pInitEventParams.hContext = hContext.context; + pInitEventParams.result = XeSS.xess_result_t.XESS_RESULT_ERROR_UNKNOWN; + Marshal.StructureToPtr(pInitEventParams, hContext.pEventParams_internal[0], false); + + // xess init + commandBuffer.IssuePluginEventAndData(LibXeSSUnityPluginWrapper.RenderingPlugin_GetXeSSInitializeEvent(), 1, hContext.pEventParams_internal[0]); + + return XeSS.xess_result_t.XESS_RESULT_SUCCESS; + } + return XeSS.xess_result_t.XESS_RESULT_ERROR_CSHARP_WRAPPER; + } + + return XeSS.xess_result_t.XESS_RESULT_ERROR_CSHARP_INVALID_ARGUMENT; + } + internal override XeSS.xess_result_t Execute(XeSS.xess_context_handle_t hContext, CommandBuffer commandBuffer, XeSS.xess_execute_params_t pExecParams) + { + hContext.AllocEventParam(1, Marshal.SizeOf(typeof(xess_native_execute_params_t))); + + if (hContext.pEventParams_internal[1] != IntPtr.Zero && hContext.pNativeParams_internal[1] != IntPtr.Zero) + { + // construct exec params + xess_native_execute_params_t pNativeExecParams = new xess_native_execute_params_t(pExecParams); + Marshal.StructureToPtr(pNativeExecParams, hContext.pNativeParams_internal[1], false); + + // construct event params + XeSS.xess_event_params_t pExecEventParams = new XeSS.xess_event_params_t(); + pExecEventParams.pParams = hContext.pNativeParams_internal[1]; + pExecEventParams.hContext = hContext.context; + pExecEventParams.result = XeSS.xess_result_t.XESS_RESULT_ERROR_UNKNOWN; + Marshal.StructureToPtr(pExecEventParams, hContext.pEventParams_internal[1], false); + + // xess execute + if (XeSS.XeSSSampler != null) + { + commandBuffer.BeginSample(XeSS.XeSSSampler); + } + commandBuffer.IssuePluginEventAndData(LibXeSSUnityPluginWrapper.RenderingPlugin_GetXeSSExecuteEventFunc(), 1, hContext.pEventParams_internal[1]); + if (XeSS.XeSSSampler != null) + { + commandBuffer.EndSample(XeSS.XeSSSampler); + } + + return XeSS.xess_result_t.XESS_RESULT_SUCCESS; + } + return XeSS.xess_result_t.XESS_RESULT_ERROR_CSHARP_WRAPPER; + } + } + + internal struct xess_native_execute_params_t + { + public xess_native_execute_params_t(XeSS.xess_execute_params_t pExecParams) + { + colorTexture = pExecParams.colorTexture.GetNativeTexturePtr(); + velocityTexture = pExecParams.velocityTexture.GetNativeTexturePtr(); + depthTexture = pExecParams.depthTexture.GetNativeTexturePtr(); + exposureScaleTexture = pExecParams.exposureScaleTexture != null ? pExecParams.exposureScaleTexture.GetNativeTexturePtr() : IntPtr.Zero; + responsivePixelMaskTexture = pExecParams.responsivePixelMaskTexture != null ? pExecParams.responsivePixelMaskTexture.GetNativeTexturePtr() : IntPtr.Zero; + outputTexture = pExecParams.outputTexture.GetNativeTexturePtr(); + + jitterOffsetX = pExecParams.jitterOffsetX; + jitterOffsetY = pExecParams.jitterOffsetY; + exposureScale = pExecParams.exposureScale; + resetHistory = pExecParams.resetHistory; + inputWidth = pExecParams.inputWidth; + inputHeight = pExecParams.inputHeight; + inputColorBase = pExecParams.inputColorBase; + inputMotionVectorBase = pExecParams.inputMotionVectorBase; + inputDepthBase = pExecParams.inputDepthBase; + inputResponsiveMaskBase = pExecParams.inputResponsiveMaskBase; + reserved0 = pExecParams.reserved0; + outputColorBase = pExecParams.outputColorBase; + } + + /** Input color texture.*/ + public IntPtr colorTexture; + /** Input motion vector texture.*/ + public IntPtr velocityTexture; + /** Optional depth texture. Required if XESS_INIT_FLAG_HIGH_RES_MV has not been specified.*/ + public IntPtr depthTexture; + /** Optional 1x1 exposure scale texture. Required if XESS_INIT_FLAG_EXPOSURE_TEXTURE has been + * specified.*/ + public IntPtr exposureScaleTexture; + /** Optional responsive pixel mask texture. Required if XESS_INIT_FLAG_RESPONSIVE_PIXEL_MASK + * has been specified.*/ + public IntPtr responsivePixelMaskTexture; + /** Output texture in target resolution.*/ + public IntPtr outputTexture; + + /** Jitter X coordinate in the range [-0.5, 0.5]. */ + public float jitterOffsetX; + /** Jitter Y coordinate in the range [-0.5, 0.5]. */ + public float jitterOffsetY; + /** Optional input color scaling. Default is 1. */ + public float exposureScale; + /** Resets the history accumulation in this frame. */ + public UInt32 resetHistory; + /** Input color width. */ + public UInt32 inputWidth; + /** Input color height. */ + public UInt32 inputHeight; + /** Base coordinate for the input color in the texture. Default is (0,0). */ + public XeSS.xess_coord_t inputColorBase; + /** Base coordinate for the input motion vector in the texture. Default is (0,0). */ + public XeSS.xess_coord_t inputMotionVectorBase; + /** Base coordinate for the input depth in the texture. Default is (0,0). */ + public XeSS.xess_coord_t inputDepthBase; + /** Base coordinate for the input responsive pixel mask in the texture. Default is (0,0). */ + public XeSS.xess_coord_t inputResponsiveMaskBase; + /** Reserved parameter. */ + public XeSS.xess_coord_t reserved0; + /** Base coordinate for the output color. Default is (0,0). */ + public XeSS.xess_coord_t outputColorBase; + }; + + internal struct xess_native_init_params_t + { + public xess_native_init_params_t(XeSS.xess_init_params_t pInitParams) + { + outputResolution = pInitParams.outputResolution; + qualitySetting = pInitParams.qualitySetting; + initFlags = pInitParams.initFlags; + } + + public void to_xess_init_params_t(XeSS.xess_init_params_t pInitParams) + { + pInitParams.outputResolution = outputResolution; + pInitParams.qualitySetting = qualitySetting; + pInitParams.initFlags = initFlags; + } + + /** Output width and height. */ + public XeSS.xess_2d_t outputResolution; + /** Quality setting */ + public XeSS.xess_quality_settings_t qualitySetting; + /** Initialization flags. */ + public UInt32 initFlags; + } + } +} \ No newline at end of file diff --git a/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/XeSSD3D11.cs.meta b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/XeSSD3D11.cs.meta new file mode 100644 index 0000000..23615e8 --- /dev/null +++ b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/XeSSD3D11.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 76cba85ada28f244bb90cea9393d9eb4 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/XeSSD3D12.cs b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/XeSSD3D12.cs new file mode 100644 index 0000000..51d4207 --- /dev/null +++ b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/XeSSD3D12.cs @@ -0,0 +1,279 @@ +/******************************************************************************* + * Copyright 2024 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files(the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and / or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions : + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +using System; +using System.Collections; +using System.Collections.Generic; +using UnityEngine; +using UnityEngine.Rendering; +using System.Runtime.InteropServices; + +namespace Intel +{ + public static class XeSSD3D12 + { + internal class Processer_D3D12 : XeSS.Processer + { + internal override XeSS.xess_result_t GetIntelXeFXVersion(IntPtr hContext, IntPtr pVersion) + { + return LibXeSSWrapper.xessGetIntelXeFXVersion(hContext, pVersion); + } + internal override XeSS.xess_result_t GetProperties(IntPtr hContext, IntPtr pOutputResolution, IntPtr pBindingProperties) + { + return LibXeSSWrapper.xessGetProperties(hContext, pOutputResolution, pBindingProperties); + } + internal override XeSS.xess_result_t GetInputResolution(IntPtr hContext, IntPtr pOutputResolution, XeSS.xess_quality_settings_t qualitySettings, IntPtr pInputResolution) + { + return LibXeSSWrapper.xessGetInputResolution(hContext, pOutputResolution, qualitySettings, pInputResolution); + } + internal override XeSS.xess_result_t GetOptimalInputResolution(IntPtr hContext, IntPtr pOutputResolution, XeSS.xess_quality_settings_t qualitySettings, IntPtr pInputResolutionOptimal, IntPtr pInputResolutionMin, IntPtr pInputResolutionMax) + { + return LibXeSSWrapper.xessGetOptimalInputResolution(hContext, pOutputResolution, qualitySettings, pInputResolutionOptimal, pInputResolutionMin, pInputResolutionMax); + } + internal override XeSS.xess_result_t GetJitterScale(IntPtr hContext, IntPtr pX, IntPtr pY) + { + return LibXeSSWrapper.xessGetJitterScale(hContext, pX, pY); + } + internal override XeSS.xess_result_t GetVelocityScale(IntPtr hContext, IntPtr pX, IntPtr pY) + { + return LibXeSSWrapper.xessGetVelocityScale(hContext, pX, pY); + } + internal override XeSS.xess_result_t SetJitterScale(IntPtr hContext, float x, float y) + { + return LibXeSSWrapper.xessSetJitterScale(hContext, x, y); + } + internal override XeSS.xess_result_t SetVelocityScale(IntPtr hContext, float x, float y) + { + return LibXeSSWrapper.xessSetVelocityScale(hContext, x, y); + } + internal override XeSS.xess_result_t SetLoggingCallback(IntPtr hContext, XeSS.xess_logging_level_t loggingLevel, IntPtr loggingCallback) + { + return LibXeSSWrapper.xessSetLoggingCallback(hContext, loggingLevel, loggingCallback); + } + internal override XeSS.xess_result_t IsOptimalDriver(IntPtr hContext) + { + return LibXeSSWrapper.xessIsOptimalDriver(hContext); + } + internal override XeSS.xess_result_t GetInitParams(XeSS.xess_context_handle_t hContext, out XeSS.xess_init_params_t pInitParams) + { + IntPtr pInitParams_internal = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(xess_native_init_params_t))); + if (pInitParams_internal != IntPtr.Zero) + { + XeSS.xess_result_t ret = LibXeSSUnityPluginWrapper.RenderingPlugin_xessGetInitParams(hContext.context, pInitParams_internal); + xess_native_init_params_t pInitParams_native = (xess_native_init_params_t)Marshal.PtrToStructure(pInitParams_internal, typeof(xess_native_init_params_t)); + pInitParams = new XeSS.xess_init_params_t(); + pInitParams_native.to_xess_init_params_t(pInitParams); + Marshal.FreeHGlobal(pInitParams_internal); + return ret; + } + pInitParams = new XeSS.xess_init_params_t(); + return XeSS.xess_result_t.XESS_RESULT_ERROR_CSHARP_WRAPPER; + } + internal override XeSS.xess_result_t Initialize(XeSS.xess_context_handle_t hContext, CommandBuffer commandBuffer, XeSS.xess_init_params_t pInitParams) + { + if (commandBuffer != null) + { + hContext.AllocEventParam(0, Marshal.SizeOf(typeof(xess_native_init_params_t))); + if (hContext.pEventParams_internal[0] != IntPtr.Zero && hContext.pNativeParams_internal[0] != IntPtr.Zero) + { + // construct init params + xess_native_init_params_t pNativeInitParams = new xess_native_init_params_t(pInitParams); + Marshal.StructureToPtr(pNativeInitParams, hContext.pNativeParams_internal[0], false); + + // construct init event params + XeSS.xess_event_params_t pInitEventParams = new XeSS.xess_event_params_t(); + pInitEventParams.pParams = hContext.pNativeParams_internal[0]; + pInitEventParams.hContext = hContext.context; + pInitEventParams.result = XeSS.xess_result_t.XESS_RESULT_ERROR_UNKNOWN; + Marshal.StructureToPtr(pInitEventParams, hContext.pEventParams_internal[0], false); + + // xess init + commandBuffer.IssuePluginEventAndData(LibXeSSUnityPluginWrapper.RenderingPlugin_GetXeSSInitializeEvent(), 1, hContext.pEventParams_internal[0]); + + return XeSS.xess_result_t.XESS_RESULT_SUCCESS; + } + return XeSS.xess_result_t.XESS_RESULT_ERROR_CSHARP_WRAPPER; + } + + return XeSS.xess_result_t.XESS_RESULT_ERROR_CSHARP_INVALID_ARGUMENT; + } + internal override XeSS.xess_result_t Execute(XeSS.xess_context_handle_t hContext, CommandBuffer commandBuffer, XeSS.xess_execute_params_t pExecParams) + { + hContext.AllocEventParam(1, Marshal.SizeOf(typeof(xess_native_execute_params_t))); + + if (hContext.pEventParams_internal[1] != IntPtr.Zero && hContext.pNativeParams_internal[1] != IntPtr.Zero) + { + // construct exec params + xess_native_execute_params_t pNativeExecParams = new xess_native_execute_params_t(pExecParams); + Marshal.StructureToPtr(pNativeExecParams, hContext.pNativeParams_internal[1], false); + + // construct event params + XeSS.xess_event_params_t pExecEventParams = new XeSS.xess_event_params_t(); + pExecEventParams.pParams = hContext.pNativeParams_internal[1]; + pExecEventParams.hContext = hContext.context; + pExecEventParams.result = XeSS.xess_result_t.XESS_RESULT_ERROR_UNKNOWN; + Marshal.StructureToPtr(pExecEventParams, hContext.pEventParams_internal[1], false); + + // xess execute + if (XeSS.XeSSSampler != null) + { + commandBuffer.BeginSample(XeSS.XeSSSampler); + } + commandBuffer.IssuePluginEventAndData(LibXeSSUnityPluginWrapper.RenderingPlugin_GetXeSSExecuteEventFunc(), 1, hContext.pEventParams_internal[1]); + if (XeSS.XeSSSampler != null) + { + commandBuffer.EndSample(XeSS.XeSSSampler); + } + + return XeSS.xess_result_t.XESS_RESULT_SUCCESS; + } + return XeSS.xess_result_t.XESS_RESULT_ERROR_CSHARP_WRAPPER; + } + } + + internal struct xess_native_execute_params_t + { + public xess_native_execute_params_t(XeSS.xess_execute_params_t pExecParams) + { + pColorTexture = pExecParams.colorTexture.GetNativeTexturePtr(); + pVelocityTexture = pExecParams.velocityTexture.GetNativeTexturePtr(); + pDepthTexture = pExecParams.depthTexture.GetNativeTexturePtr(); + pExposureScaleTexture = pExecParams.exposureScaleTexture != null ? pExecParams.exposureScaleTexture.GetNativeTexturePtr() : IntPtr.Zero; + pResponsivePixelMaskTexture = pExecParams.responsivePixelMaskTexture != null ? pExecParams.responsivePixelMaskTexture.GetNativeTexturePtr() : IntPtr.Zero; + pOutputTexture = pExecParams.outputTexture.GetNativeTexturePtr(); + + jitterOffsetX = pExecParams.jitterOffsetX; + jitterOffsetY = pExecParams.jitterOffsetY; + exposureScale = pExecParams.exposureScale; + resetHistory = pExecParams.resetHistory; + inputWidth = pExecParams.inputWidth; + inputHeight = pExecParams.inputHeight; + inputColorBase = pExecParams.inputColorBase; + inputMotionVectorBase = pExecParams.inputMotionVectorBase; + inputDepthBase = pExecParams.inputDepthBase; + inputResponsiveMaskBase = pExecParams.inputResponsiveMaskBase; + reserved0 = pExecParams.reserved0; + outputColorBase = pExecParams.outputColorBase; + + pDescriptorHeap = IntPtr.Zero; + descriptorHeapOffset = descriptorHeapOffset = 0; + } + + /** Input color texture. Must be in NON_PIXEL_SHADER_RESOURCE state.*/ + public IntPtr pColorTexture; + /** Input motion vector texture. Must be in NON_PIXEL_SHADER_RESOURCE state.*/ + public IntPtr pVelocityTexture; + /** Optional depth texture. Required if XESS_INIT_FLAG_HIGH_RES_MV has not been specified. + * Must be in NON_PIXEL_SHADER_RESOURCE state.*/ + public IntPtr pDepthTexture; + /** Optional 1x1 exposure scale texture. Required if XESS_INIT_FLAG_EXPOSURE_TEXTURE has been + * specified. Must be in NON_PIXEL_SHADER_RESOURCE state */ + public IntPtr pExposureScaleTexture; + /** Optional responsive pixel mask texture. Required if XESS_INIT_FLAG_RESPONSIVE_PIXEL_MASK + * has been specified. Must be in NON_PIXEL_SHADER_RESOURCE state */ + public IntPtr pResponsivePixelMaskTexture; + /** Output texture in target resolution. Must be in UNORDERED_ACCESS state.*/ + public IntPtr pOutputTexture; + + /** Jitter X coordinate in the range [-0.5, 0.5]. */ + public float jitterOffsetX; + /** Jitter Y coordinate in the range [-0.5, 0.5]. */ + public float jitterOffsetY; + /** Optional input color scaling. Default is 1. */ + public float exposureScale; + /** Resets the history accumulation in this frame. */ + public UInt32 resetHistory; + /** Input color width. */ + public UInt32 inputWidth; + /** Input color height. */ + public UInt32 inputHeight; + /** Base coordinate for the input color in the texture. Default is (0,0). */ + public XeSS.xess_coord_t inputColorBase; + /** Base coordinate for the input motion vector in the texture. Default is (0,0). */ + public XeSS.xess_coord_t inputMotionVectorBase; + /** Base coordinate for the input depth in the texture. Default is (0,0). */ + public XeSS.xess_coord_t inputDepthBase; + /** Base coordinate for the input responsive pixel mask in the texture. Default is (0,0). */ + public XeSS.xess_coord_t inputResponsiveMaskBase; + /** Reserved parameter. */ + public XeSS.xess_coord_t reserved0; + /** Base coordinate for the output color. Default is (0,0). */ + public XeSS.xess_coord_t outputColorBase; + /** Optional external descriptor heap. */ + IntPtr pDescriptorHeap; + /** Offset in external descriptor heap in bytes.*/ + UInt32 descriptorHeapOffset; + }; + + internal struct xess_native_init_params_t + { + public xess_native_init_params_t(XeSS.xess_init_params_t pInitParams) + { + outputResolution = pInitParams.outputResolution; + qualitySetting = pInitParams.qualitySetting; + initFlags = pInitParams.initFlags; + creationNodeMask = pInitParams.creationNodeMask; + visibleNodeMask = pInitParams.visibleNodeMask; + pTempBufferHeap = IntPtr.Zero; + bufferHeapOffset = bufferHeapOffset = 0; + pTempTextureHeap = IntPtr.Zero; + textureHeapOffset = textureHeapOffset = 0; + pPipelineLibrary = IntPtr.Zero; + } + + public void to_xess_init_params_t(XeSS.xess_init_params_t pInitParams) + { + pInitParams.outputResolution = outputResolution; + pInitParams.qualitySetting = qualitySetting; + pInitParams.initFlags = initFlags; + pInitParams.creationNodeMask = creationNodeMask; + pInitParams.visibleNodeMask = visibleNodeMask; + } + + /** Output width and height. */ + public XeSS.xess_2d_t outputResolution; + /** Quality setting */ + public XeSS.xess_quality_settings_t qualitySetting; + /** Initialization flags. */ + public UInt32 initFlags; + /** Specifies the node mask for internally created resources on + * multi-adapter systems. */ + public UInt32 creationNodeMask; + /** Specifies the node visibility mask for internally created resources + * on multi-adapter systems. */ + public UInt32 visibleNodeMask; + /** Optional externally allocated buffer storage for XeSS. If NULL the + * storage is allocated internally. If allocated, the heap type must be + * D3D12_HEAP_TYPE_DEFAULT. This heap is not accessed by the CPU. */ + IntPtr pTempBufferHeap; + /** Offset in the externally allocated heap for temporary buffer storage. */ + UInt64 bufferHeapOffset; + /** Optional externally allocated texture storage for XeSS. If NULL the + * storage is allocated internally. If allocated, the heap type must be + * D3D12_HEAP_TYPE_DEFAULT. This heap is not accessed by the CPU. */ + IntPtr pTempTextureHeap; + /** Offset in the externally allocated heap for temporary texture storage. */ + UInt64 textureHeapOffset; + /** Pointer to pipeline library. If not NULL will be used for pipeline caching. */ + IntPtr pPipelineLibrary; + }; + } +} diff --git a/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/XeSSD3D12.cs.meta b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/XeSSD3D12.cs.meta new file mode 100644 index 0000000..7842354 --- /dev/null +++ b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/XeSSD3D12.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 3e568232073c20747bb6a35a6c3911ca +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/XeSSDebug.cs b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/XeSSDebug.cs new file mode 100644 index 0000000..fe0c2a3 --- /dev/null +++ b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/XeSSDebug.cs @@ -0,0 +1,166 @@ +/******************************************************************************* + * Copyright 2024 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files(the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and / or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions : + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +using System; +using System.Runtime.InteropServices; +using UnityEngine; + +/// +/// Wrapper for Intel xess +/// +namespace Intel +{ + internal static class LibXeSSDebugWrapper + { + [DllImport("libxess", EntryPoint = "xessSelectNetworkModel")] + public static extern XeSS.xess_result_t xessSelectNetworkModel(IntPtr hContext, XeSSDebug.xess_network_model_t network); + + [DllImport("libxess", EntryPoint = "xessStartDump")] + public static extern XeSS.xess_result_t xessStartDump(IntPtr hContext, IntPtr dump_parameters); + } + + public static class XeSSDebug + { + /// + /// XeSS network type. + /// + public enum xess_network_model_t + { + XESS_NETWORK_MODEL_KPSS = 0, + XESS_NETWORK_MODEL_SPLAT = 1, + }; + + /// + /// XeSS dump bits. + /// + public enum xess_dump_element_bits_t + { + XESS_DUMP_INPUT_COLOR = 0x01, + XESS_DUMP_INPUT_VELOCITY = 0x02, + XESS_DUMP_INPUT_DEPTH = 0x04, + XESS_DUMP_INPUT_EXPOSURE_SCALE = 0x08, + XESS_DUMP_INPUT_RESPONSIVE_PIXEL_MASK = 0x10, + XESS_DUMP_OUTPUT = 0x20, + XESS_DUMP_HISTORY = 0x40, + XESS_DUMP_EXECUTION_PARAMETERS = 0x80, ///< All parameters passed to xessExecute + XESS_DUMP_ALL_INPUTS = XESS_DUMP_INPUT_COLOR | XESS_DUMP_INPUT_VELOCITY | + XESS_DUMP_INPUT_DEPTH | XESS_DUMP_INPUT_EXPOSURE_SCALE | + XESS_DUMP_INPUT_RESPONSIVE_PIXEL_MASK | XESS_DUMP_EXECUTION_PARAMETERS, + XESS_DUMP_ALL = 0x7FFFFFFF, + }; + + /// + /// XeSS dump parameters + /// + public struct xess_dump_parameters_t + { + public string path; + /** Frame index. Will be used as start for frame sequence. */ + public UInt32 frame_idx; + /** Frame count to dump. Few frames less may be dumped due to possible frames in flight in + * application + */ + public UInt32 frame_count; + /** Bitset showing set of elements that must be dumped. Element will be dumped if it exist + * and corrseponding bit is not 0. + * Since it's meaningless to call Dump with empty set value of 0 will mean DUMP_ALL_INPUTS + */ + public UInt32 dump_elements_mask; + /** In case of depth render target with TYPELESS format it is not always possible + * to interpret depth values during dumping process. + */ + } + + internal struct xess_native_dump_parameters_t + { + public xess_native_dump_parameters_t(xess_dump_parameters_t dump_param) + { + path = IntPtr.Zero; + frame_idx = dump_param.frame_idx; + frame_count = dump_param.frame_count; + dump_elements_mask = dump_param.dump_elements_mask; + } + + public IntPtr path; + /** Frame index. Will be used as start for frame sequence. */ + public UInt32 frame_idx; + /** Frame count to dump. Few frames less may be dumped due to possible frames in flight in + * application + */ + public UInt32 frame_count; + /** Bitset showing set of elements that must be dumped. Element will be dumped if it exist + * and corrseponding bit is not 0. + * Since it's meaningless to call Dump with empty set value of 0 will mean DUMP_ALL_INPUTS + */ + public UInt32 dump_elements_mask; + /** In case of depth render target with TYPELESS format it is not always possible + * to interpret depth values during dumping process. + */ + } + + /// + /// Select network to be used by XeSS + /// Selects network model to use by XeSS. + /// After call to this function - XeSS init function *must* be called + /// + /// The XeSS context handle. + /// The network model. + /// XeSS return status code. + public static XeSS.xess_result_t xessSelectNetworkModel(XeSS.xess_context_handle_t hContext, xess_network_model_t network) + { + return LibXeSSDebugWrapper.xessSelectNetworkModel(hContext.context, network); + } + + /// + /// Dumps sequence of frames to the provided folder + /// Call to this function initiates a dump for selected elements. + /// X eSS SDK uses RAM cache to reduce dump overhead.Application should provide reasonable + /// value for @ref xess_dump_parameters_t::frame_count frames (about 50 megs needed per cached frame). + /// To enable several dumps per run application should provide correct + /// @ref xess_dump_parameters_t::frame_idx value.This value used as a start index for frame + /// dumping. + /// After call to this function - each call to @ref xessD3D12Execute will result in new frame dumped to + /// RAM cache. + /// After @ref xess_dump_parameters_t::frame_count frames application will be blocked on call to + /// @ref xessD3D12Execute in order to save cached frames to disk.This operation can take long time. + /// Repetetive calls to this function can result in XESS_RESULT_ERROR_OPERATION_IN_PROGRESS which means that + /// frame dump is in progress. + /// + /// XeSS context + /// dump configuration + /// operation status + public static XeSS.xess_result_t xessStartDump(XeSS.xess_context_handle_t hContext, xess_dump_parameters_t dump_parameters) + { + xess_native_dump_parameters_t pDumpParams_native = new xess_native_dump_parameters_t(dump_parameters); + IntPtr pDumpParams_internal = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(xess_native_dump_parameters_t))); + if (pDumpParams_internal != IntPtr.Zero) + { + pDumpParams_native.path = Marshal.StringToHGlobalAnsi(dump_parameters.path); + Marshal.StructureToPtr(pDumpParams_native, pDumpParams_internal, false); + XeSS.xess_result_t ret = LibXeSSDebugWrapper.xessStartDump(hContext.context, pDumpParams_internal); + Marshal.FreeHGlobal(pDumpParams_native.path); + Marshal.FreeHGlobal(pDumpParams_internal); + return ret; + } + return XeSS.xess_result_t.XESS_RESULT_ERROR_CSHARP_WRAPPER; + } + } +} \ No newline at end of file diff --git a/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/XeSSDebug.cs.meta b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/XeSSDebug.cs.meta new file mode 100644 index 0000000..ae1539c --- /dev/null +++ b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/XeSSDebug.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: d1cb92af04ece714aa1aca31247347f2 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/XeSSVK.cs b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/XeSSVK.cs new file mode 100644 index 0000000..f21d909 --- /dev/null +++ b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/XeSSVK.cs @@ -0,0 +1,271 @@ +/******************************************************************************* + * Copyright 2024 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files(the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and / or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions : + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +using System; +using System.Collections; +using System.Collections.Generic; +using UnityEngine; +using UnityEngine.Rendering; +using System.Runtime.InteropServices; + +namespace Intel +{ + public static class XeSSVK + { + internal class Processer_VK : XeSS.Processer + { + internal override XeSS.xess_result_t GetIntelXeFXVersion(IntPtr hContext, IntPtr pVersion) + { + return LibXeSSWrapper.xessGetIntelXeFXVersion(hContext, pVersion); + } + internal override XeSS.xess_result_t GetProperties(IntPtr hContext, IntPtr pOutputResolution, IntPtr pBindingProperties) + { + return LibXeSSWrapper.xessGetProperties(hContext, pOutputResolution, pBindingProperties); + } + internal override XeSS.xess_result_t GetInputResolution(IntPtr hContext, IntPtr pOutputResolution, XeSS.xess_quality_settings_t qualitySettings, IntPtr pInputResolution) + { + return LibXeSSWrapper.xessGetInputResolution(hContext, pOutputResolution, qualitySettings, pInputResolution); + } + internal override XeSS.xess_result_t GetOptimalInputResolution(IntPtr hContext, IntPtr pOutputResolution, XeSS.xess_quality_settings_t qualitySettings, IntPtr pInputResolutionOptimal, IntPtr pInputResolutionMin, IntPtr pInputResolutionMax) + { + return LibXeSSWrapper.xessGetOptimalInputResolution(hContext, pOutputResolution, qualitySettings, pInputResolutionOptimal, pInputResolutionMin, pInputResolutionMax); + } + internal override XeSS.xess_result_t GetJitterScale(IntPtr hContext, IntPtr pX, IntPtr pY) + { + return LibXeSSWrapper.xessGetJitterScale(hContext, pX, pY); + } + internal override XeSS.xess_result_t GetVelocityScale(IntPtr hContext, IntPtr pX, IntPtr pY) + { + return LibXeSSWrapper.xessGetVelocityScale(hContext, pX, pY); + } + internal override XeSS.xess_result_t SetJitterScale(IntPtr hContext, float x, float y) + { + return LibXeSSWrapper.xessSetJitterScale(hContext, x, y); + } + internal override XeSS.xess_result_t SetVelocityScale(IntPtr hContext, float x, float y) + { + return LibXeSSWrapper.xessSetVelocityScale(hContext, x, y); + } + internal override XeSS.xess_result_t SetLoggingCallback(IntPtr hContext, XeSS.xess_logging_level_t loggingLevel, IntPtr loggingCallback) + { + return LibXeSSWrapper.xessSetLoggingCallback(hContext, loggingLevel, loggingCallback); + } + internal override XeSS.xess_result_t IsOptimalDriver(IntPtr hContext) + { + return LibXeSSWrapper.xessIsOptimalDriver(hContext); + } + internal override XeSS.xess_result_t GetInitParams(XeSS.xess_context_handle_t hContext, out XeSS.xess_init_params_t pInitParams) + { + IntPtr pInitParams_internal = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(xess_native_init_params_t))); + if (pInitParams_internal != IntPtr.Zero) + { + XeSS.xess_result_t ret = LibXeSSUnityPluginWrapper.RenderingPlugin_xessGetInitParams(hContext.context, pInitParams_internal); + xess_native_init_params_t pInitParams_native = (xess_native_init_params_t)Marshal.PtrToStructure(pInitParams_internal, typeof(xess_native_init_params_t)); + pInitParams = new XeSS.xess_init_params_t(); + pInitParams_native.to_xess_init_params_t(pInitParams); + Marshal.FreeHGlobal(pInitParams_internal); + return ret; + } + pInitParams = new XeSS.xess_init_params_t(); + return XeSS.xess_result_t.XESS_RESULT_ERROR_CSHARP_WRAPPER; + } + internal override XeSS.xess_result_t Initialize(XeSS.xess_context_handle_t hContext, CommandBuffer commandBuffer, XeSS.xess_init_params_t pInitParams) + { + if (commandBuffer != null) + { + hContext.AllocEventParam(0, Marshal.SizeOf(typeof(xess_native_init_params_t))); + if (hContext.pEventParams_internal[0] != IntPtr.Zero && hContext.pNativeParams_internal[0] != IntPtr.Zero) + { + // construct init params + xess_native_init_params_t pNativeInitParams = new xess_native_init_params_t(pInitParams); + Marshal.StructureToPtr(pNativeInitParams, hContext.pNativeParams_internal[0], false); + + // construct init event params + XeSS.xess_event_params_t pInitEventParams = new XeSS.xess_event_params_t(); + pInitEventParams.pParams = hContext.pNativeParams_internal[0]; + pInitEventParams.hContext = hContext.context; + pInitEventParams.result = XeSS.xess_result_t.XESS_RESULT_ERROR_UNKNOWN; + Marshal.StructureToPtr(pInitEventParams, hContext.pEventParams_internal[0], false); + + // xess init + commandBuffer.IssuePluginEventAndData(LibXeSSUnityPluginWrapper.RenderingPlugin_GetXeSSInitializeEvent(), 1, hContext.pEventParams_internal[0]); + + return XeSS.xess_result_t.XESS_RESULT_SUCCESS; + } + return XeSS.xess_result_t.XESS_RESULT_ERROR_CSHARP_WRAPPER; + } + + return XeSS.xess_result_t.XESS_RESULT_ERROR_CSHARP_INVALID_ARGUMENT; + } + internal override XeSS.xess_result_t Execute(XeSS.xess_context_handle_t hContext, CommandBuffer commandBuffer, XeSS.xess_execute_params_t pExecParams) + { + hContext.AllocEventParam(1, Marshal.SizeOf(typeof(xess_native_execute_params_t))); + + if (hContext.pEventParams_internal[1] != IntPtr.Zero && hContext.pNativeParams_internal[1] != IntPtr.Zero) + { + // construct exec params + xess_native_execute_params_t pNativeExecParams = new xess_native_execute_params_t(pExecParams); + Marshal.StructureToPtr(pNativeExecParams, hContext.pNativeParams_internal[1], false); + + // construct event params + XeSS.xess_event_params_t pExecEventParams = new XeSS.xess_event_params_t(); + pExecEventParams.pParams = hContext.pNativeParams_internal[1]; + pExecEventParams.hContext = hContext.context; + pExecEventParams.result = XeSS.xess_result_t.XESS_RESULT_ERROR_UNKNOWN; + Marshal.StructureToPtr(pExecEventParams, hContext.pEventParams_internal[1], false); + + // xess execute + if (XeSS.XeSSSampler != null) + { + commandBuffer.BeginSample(XeSS.XeSSSampler); + } + commandBuffer.IssuePluginEventAndData(LibXeSSUnityPluginWrapper.RenderingPlugin_GetXeSSExecuteEventFunc(), 1, hContext.pEventParams_internal[1]); + if (XeSS.XeSSSampler != null) + { + commandBuffer.EndSample(XeSS.XeSSSampler); + } + + return XeSS.xess_result_t.XESS_RESULT_SUCCESS; + } + return XeSS.xess_result_t.XESS_RESULT_ERROR_CSHARP_WRAPPER; + } + } + internal struct xess_native_execute_params_t + { + public xess_native_execute_params_t(XeSS.xess_execute_params_t pExecParams) + { + colorTexture = pExecParams.colorTexture.GetNativeTexturePtr(); + velocityTexture = pExecParams.velocityTexture.GetNativeTexturePtr(); + depthTexture = pExecParams.depthTexture.GetNativeTexturePtr(); + exposureScaleTexture = pExecParams.exposureScaleTexture != null ? pExecParams.exposureScaleTexture.GetNativeTexturePtr() : IntPtr.Zero; + responsivePixelMaskTexture = pExecParams.responsivePixelMaskTexture != null ? pExecParams.responsivePixelMaskTexture.GetNativeTexturePtr() : IntPtr.Zero; + outputTexture = pExecParams.outputTexture.GetNativeTexturePtr(); + + jitterOffsetX = pExecParams.jitterOffsetX; + jitterOffsetY = pExecParams.jitterOffsetY; + exposureScale = pExecParams.exposureScale; + resetHistory = pExecParams.resetHistory; + inputWidth = pExecParams.inputWidth; + inputHeight = pExecParams.inputHeight; + inputColorBase = pExecParams.inputColorBase; + inputMotionVectorBase = pExecParams.inputMotionVectorBase; + inputDepthBase = pExecParams.inputDepthBase; + inputResponsiveMaskBase = pExecParams.inputResponsiveMaskBase; + reserved0 = pExecParams.reserved0; + outputColorBase = pExecParams.outputColorBase; + } + + /** Input color texture. Must be in VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL state.*/ + public IntPtr colorTexture; + /** Input motion vector texture. Must be in VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL state.*/ + public IntPtr velocityTexture; + /** Optional depth texture. Required if XESS_INIT_FLAG_HIGH_RES_MV has not been specified. + * Must be in VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL state.*/ + public IntPtr depthTexture; + /** Optional 1x1 exposure scale texture. Required if XESS_INIT_FLAG_EXPOSURE_TEXTURE has been + * specified. Must be in VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL state */ + public IntPtr exposureScaleTexture; + /** Optional responsive pixel mask texture. Required if XESS_INIT_FLAG_RESPONSIVE_PIXEL_MASK + * has been specified. Must be in VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL state */ + public IntPtr responsivePixelMaskTexture; + /** Output texture in target resolution. Must be in VK_IMAGE_LAYOUT_GENERAL state.*/ + public IntPtr outputTexture; + + /** Jitter X coordinate in the range [-0.5, 0.5]. */ + public float jitterOffsetX; + /** Jitter Y coordinate in the range [-0.5, 0.5]. */ + public float jitterOffsetY; + /** Optional input color scaling. Default is 1. */ + public float exposureScale; + /** Resets the history accumulation in this frame. */ + public UInt32 resetHistory; + /** Input color width. */ + public UInt32 inputWidth; + /** Input color height. */ + public UInt32 inputHeight; + /** Base coordinate for the input color in the texture. Default is (0,0). */ + public XeSS.xess_coord_t inputColorBase; + /** Base coordinate for the input motion vector in the texture. Default is (0,0). */ + public XeSS.xess_coord_t inputMotionVectorBase; + /** Base coordinate for the input depth in the texture. Default is (0,0). */ + public XeSS.xess_coord_t inputDepthBase; + /** Base coordinate for the input responsive pixel mask in the texture. Default is (0,0). */ + public XeSS.xess_coord_t inputResponsiveMaskBase; + /** Reserved parameter. */ + public XeSS.xess_coord_t reserved0; + /** Base coordinate for the output color. Default is (0,0). */ + public XeSS.xess_coord_t outputColorBase; + }; + + internal struct xess_native_init_params_t + { + public xess_native_init_params_t(XeSS.xess_init_params_t pInitParams) + { + outputResolution = pInitParams.outputResolution; + qualitySetting = pInitParams.qualitySetting; + initFlags = pInitParams.initFlags; + creationNodeMask = pInitParams.creationNodeMask; + visibleNodeMask = pInitParams.visibleNodeMask; + tempBufferHeap = IntPtr.Zero; + bufferHeapOffset = bufferHeapOffset = 0; + tempTextureHeap = IntPtr.Zero; + textureHeapOffset = textureHeapOffset = 0; + pipelineCache = IntPtr.Zero; + } + + public void to_xess_init_params_t(XeSS.xess_init_params_t pInitParams) + { + pInitParams.outputResolution = outputResolution; + pInitParams.qualitySetting = qualitySetting; + pInitParams.initFlags = initFlags; + pInitParams.creationNodeMask = creationNodeMask; + pInitParams.visibleNodeMask = visibleNodeMask; + } + + /** Output width and height. */ + public XeSS.xess_2d_t outputResolution; + /** Quality setting */ + public XeSS.xess_quality_settings_t qualitySetting; + /** Initialization flags. */ + public UInt32 initFlags; + /** Specifies the node mask for internally created resources on + * multi-adapter systems. */ + public UInt32 creationNodeMask; + /** Specifies the node visibility mask for internally created resources + * on multi-adapter systems. */ + public UInt32 visibleNodeMask; + /** Optional externally allocated buffer storage for XeSS. If NULL the + * storage is allocated internally. If allocated, the heap type must be + * VK_HEAP_TYPE_DEFAULT. This heap is not accessed by the CPU. */ + IntPtr tempBufferHeap; + /** Offset in the externally allocated heap for temporary buffer storage. */ + UInt64 bufferHeapOffset; + /** Optional externally allocated texture storage for XeSS. If NULL the + * storage is allocated internally. If allocated, the heap type must be + * VK_HEAP_TYPE_DEFAULT. This heap is not accessed by the CPU. */ + IntPtr tempTextureHeap; + /** Offset in the externally allocated heap for temporary texture storage. */ + UInt64 textureHeapOffset; + /** Pointer to pipeline cache. If not NULL will be used for pipeline creation. */ + IntPtr pipelineCache; + } + } +} \ No newline at end of file diff --git a/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/XeSSVK.cs.meta b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/XeSSVK.cs.meta new file mode 100644 index 0000000..a244fe6 --- /dev/null +++ b/Packages/com.unity.render-pipelines.universal@14.0.11/Runtime/SuperRendering/SR/Scripts/XESS2/XeSSVK.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: f5bfe3f3e2a73574fbe8c75249b2afe4 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Packages/packages-lock.json b/Packages/packages-lock.json index 0fd4168..34d2f13 100644 --- a/Packages/packages-lock.json +++ b/Packages/packages-lock.json @@ -8,7 +8,7 @@ "com.unity.mathematics": "1.2.1", "com.unity.modules.jsonserialize": "1.0.0" }, - "url": "https://packages.tuanjie.cn" + "url": "https://packages.unity.cn" }, "com.unity.cinemachine": { "version": "2.10.1", @@ -17,28 +17,28 @@ "dependencies": { "com.unity.test-framework": "1.1.31" }, - "url": "https://packages.tuanjie.cn" + "url": "https://packages.unity.cn" }, "com.unity.collab-proxy": { "version": "2.5.2", "depth": 0, "source": "registry", "dependencies": {}, - "url": "https://packages.tuanjie.cn" + "url": "https://packages.unity.cn" }, "com.unity.editorcoroutines": { "version": "1.0.0", "depth": 1, "source": "registry", "dependencies": {}, - "url": "https://packages.tuanjie.cn" + "url": "https://packages.unity.cn" }, "com.unity.ext.nunit": { "version": "1.0.6", "depth": 1, "source": "registry", "dependencies": {}, - "url": "https://packages.tuanjie.cn" + "url": "https://packages.unity.cn" }, "com.unity.ide.rider": { "version": "3.0.31", @@ -47,7 +47,7 @@ "dependencies": { "com.unity.ext.nunit": "1.0.6" }, - "url": "https://packages.tuanjie.cn" + "url": "https://packages.unity.cn" }, "com.unity.ide.visualstudio": { "version": "2.0.22", @@ -56,14 +56,14 @@ "dependencies": { "com.unity.test-framework": "1.1.9" }, - "url": "https://packages.tuanjie.cn" + "url": "https://packages.unity.cn" }, "com.unity.ide.vscode": { "version": "1.2.5", "depth": 0, "source": "registry", "dependencies": {}, - "url": "https://packages.tuanjie.cn" + "url": "https://packages.unity.cn" }, "com.unity.inputsystem": { "version": "1.11.0", @@ -72,7 +72,7 @@ "dependencies": { "com.unity.modules.uielements": "1.0.0" }, - "url": "https://packages.tuanjie.cn" + "url": "https://packages.unity.cn" }, "com.unity.learn.iet-framework": { "version": "3.1.3", @@ -82,14 +82,14 @@ "com.unity.editorcoroutines": "1.0.0", "com.unity.settings-manager": "1.0.3" }, - "url": "https://packages.tuanjie.cn" + "url": "https://packages.unity.cn" }, "com.unity.mathematics": { "version": "1.2.6", "depth": 1, "source": "registry", "dependencies": {}, - "url": "https://packages.tuanjie.cn" + "url": "https://packages.unity.cn" }, "com.unity.memoryprofiler": { "version": "1.1.1", @@ -98,7 +98,7 @@ "dependencies": { "com.unity.editorcoroutines": "1.0.0" }, - "url": "https://packages.tuanjie.cn" + "url": "https://packages.unity.cn" }, "com.unity.recorder": { "version": "4.0.3", @@ -107,7 +107,7 @@ "dependencies": { "com.unity.timeline": "1.0.0" }, - "url": "https://packages.tuanjie.cn" + "url": "https://packages.unity.cn" }, "com.unity.render-pipelines.core": { "version": "14.0.11", @@ -145,14 +145,14 @@ "depth": 2, "source": "registry", "dependencies": {}, - "url": "https://packages.tuanjie.cn" + "url": "https://packages.unity.cn" }, "com.unity.settings-manager": { "version": "2.0.1", "depth": 1, "source": "registry", "dependencies": {}, - "url": "https://packages.tuanjie.cn" + "url": "https://packages.unity.cn" }, "com.unity.shadergraph": { "version": "14.0.11", @@ -172,7 +172,7 @@ "com.unity.mathematics": "1.2.1", "com.unity.ugui": "1.0.0" }, - "url": "https://packages.tuanjie.cn" + "url": "https://packages.unity.cn" }, "com.unity.test-framework": { "version": "1.1.33", @@ -183,7 +183,7 @@ "com.unity.modules.imgui": "1.0.0", "com.unity.modules.jsonserialize": "1.0.0" }, - "url": "https://packages.tuanjie.cn" + "url": "https://packages.unity.cn" }, "com.unity.textmeshpro": { "version": "3.0.7", @@ -192,7 +192,7 @@ "dependencies": { "com.unity.ugui": "1.0.0" }, - "url": "https://packages.tuanjie.cn" + "url": "https://packages.unity.cn" }, "com.unity.timeline": { "version": "1.7.6", @@ -204,7 +204,7 @@ "com.unity.modules.audio": "1.0.0", "com.unity.modules.particlesystem": "1.0.0" }, - "url": "https://packages.tuanjie.cn" + "url": "https://packages.unity.cn" }, "com.unity.ugui": { "version": "1.0.0", @@ -237,10 +237,7 @@ "version": "1.0.0", "depth": 0, "source": "builtin", - "dependencies": { - "com.unity.modules.audio": "1.0.0", - "com.unity.modules.animation": "1.0.0" - } + "dependencies": {} }, "com.unity.modules.audio": { "version": "1.0.0",