void ToggleImportModeVisibility(VisualElement fieldBlock, ImportState importState) { if (fieldBlock != null) { var unimportedMode = fieldBlock.Q(k_UnimportedMode); if (unimportedMode != null) { unimportedMode.style.display = (importState == ImportState.Unimported) ? DisplayStyle.Flex : DisplayStyle.None; } var versionCheckMode = fieldBlock.Q(k_VersionCheckMode); if (versionCheckMode != null) { versionCheckMode.style.display = (importState == ImportState.VersionCheck) ? DisplayStyle.Flex : DisplayStyle.None; } var upToDateMode = fieldBlock.Q(k_UpToDataMode); if (upToDateMode != null) { upToDateMode.style.display = (importState == ImportState.UpToDate) ? DisplayStyle.Flex : DisplayStyle.None; } var outOfDateMode = fieldBlock.Q(k_OutOfDateMode); if (outOfDateMode != null) { outOfDateMode.style.display = (importState == ImportState.OutOfDate) ? DisplayStyle.Flex : DisplayStyle.None; } } }
void ImportComplete(SerializationCompletionReason status, WorldAnchorTransferBatch anchorBatch) { if (status == SerializationCompletionReason.Succeeded) { if (anchorBatch.GetAllIds().Length > 0) { string first = anchorBatch.GetAllIds()[0]; if (SharingStage.Instance.ShowDetailedLogs) { Debug.Log("Anchor Manager: Sucessfully imported anchor " + first); } this.worldAnchor = anchorBatch.LockObject(first, gameObject); StatusTextDisplay.Instance.SetStatusText("synchronised"); } base.FireCompleted(true); } else { StatusTextDisplay.Instance.SetStatusText("retrying synchronisation"); Debug.LogError("Anchor Manager: Import failed"); currentState = ImportState.DataDownloadedReadyForImport; } }
public override void Initialise(List <MailFolder> folderList) { Status = MessageProcessorStatus.Initialising; _outlook = new Application(); var pstPath = Regex.Replace(_saveFolder + @"\" + _pstName + ".pst", @"\\+", @"\"); Logger.Info("Writing to PST " + pstPath); _pstHandle = PstHandle(_outlook.GetNamespace("MAPI"), pstPath, _pstName); _rootFolder = _pstHandle.GetRootFolder() as Folder; //_importFolder = GetCreateFolder(_rootFolder.FolderPath + @"\_zinkuba_import", _outlook); if (_createAllFolders) { foreach (var mailFolder in folderList) { GetCreateFolder(_rootFolder.FolderPath + @"\" + mailFolder.DestinationFolder, _outlook, true); } } _lastState = new ImportState(); _queue = new PCQueue <MsgDescriptor, ImportState>(Name + "-pstTarget") { ProduceMethod = ProcessMessage, InitialiseProducer = () => _lastState, ShutdownProducer = ShutdownQueue }; _queue.Start(); Status = MessageProcessorStatus.Initialised; Logger.Info("PstTarget Initialised"); }
void Update() { #if UNITY_WSA && !UNITY_EDITOR if (SharingStage.Instance.IsConnected) { switch (currentState) { case ImportState.Start: ConnectToRoom(); this.currentState = ImportState.ReadyToImport; break; case ImportState.ReadyToImport: MakeAnchorDataRequest(); break; case ImportState.DataDownloadedReadyForImport: // DataReady is set when the anchor download completes. currentState = ImportState.Importing; StatusTextDisplay.Instance.SetStatusText("importing synchronisation data"); WorldAnchorTransferBatch.ImportAsync(rawAnchorData, ImportComplete); break; } } #endif }
public override void Initialise(List <MailFolder> folderList) { Status = MessageProcessorStatus.Initialising; _mainFolderList = folderList; service = ExchangeHelper.ExchangeConnect(_hostname, _username, _password); //service.TraceEnabled = true; //service.TraceFlags = TraceFlags.All; folders = new List <ExchangeFolder>(); ExchangeHelper.GetAllSubFolders(service, new ExchangeFolder { Folder = Folder.Bind(service, WellKnownFolderName.MsgFolderRoot) }, folders, false); if (_createAllFolders) { // we need to create all folders which don't exist foreach (var mailFolder in _mainFolderList) { GetCreateFolder(mailFolder.DestinationFolder); } } _lastState = new ImportState(); _queue = new PCQueue <RawMessageDescriptor, ImportState>(Name + "-exchangeTarget") { ProduceMethod = ProcessMessage, InitialiseProducer = () => _lastState, ShutdownProducer = ShutdownQueue }; _queue.Start(); Status = MessageProcessorStatus.Initialised; }
public void Convert(ModelRoot gltf, PssgFile pssg) { // Get a list of nodes in the default scene as a flat list Dictionary <int, int> nodeBoneIndexMap = new Dictionary <int, int>(); var rootNode = gltf.DefaultScene.FindNode(n => n.Name.StartsWith("Scene Root")); if (rootNode is null) { throw new InvalidDataException("The default scene must have node name starting with `Scene Root`."); } // Determine libraries in which to store data var nodeLib = pssg.FindNodes("LIBRARY", "type", "NODE").First(); var rdsLib = pssg.FindNodes("LIBRARY", "type", "RENDERDATASOURCE").First(); var ribLib = pssg.FindNodes("LIBRARY", "type", "RENDERINTERFACEBOUND").First(); var state = new ImportState(ShaderInputInfo.CreateFromPssg(pssg).ToDictionary(si => si.ShaderGroupId)); // Clear out the libraries nodeLib.RemoveChildNodes(nodeLib.ChildNodes.Where(n => n.Name == "ROOTNODE")); rdsLib.RemoveChildNodes(rdsLib.ChildNodes.Where(n => n.Name == "RENDERDATASOURCE")); ribLib.RemoveChildNodes(ribLib.ChildNodes.Where(n => n.Name == "DATABLOCK")); // Write the scene graph, and collect mesh data ConvertSceneNodes(pssg, nodeLib, rootNode, state); }
public Wizard(Form form, String fileName, String yearMonth, DataRowView excelRow) { FileName = fileName; YearMonth = yearMonth; ExcelRow = excelRow; ImportErrors = new List<string>(); currentImportState = ImportState.None; validator = Validator.GetInstance(); validator.clear(); }
private void UpdateProgressMessage() { // Calculate base progress based on state float baseProgress = 0; float stateProgress = 0; string message = "Serializing translations..."; ImportState state = currentStatus.Value; if (state == ImportState.ReadFile) { // Get the CSV status CsvReader.ReadStatus.State csvState = csvReadStatus.CurrentState; if (csvState == CsvReader.ReadStatus.State.ReadingFileIntoRows) { // Report that we're reading the file. // Progress is not calculated here because we do not // check how long the CSV file is. message = "Parsing CSV file into text..."; } else { // Report the text is being split into cells message = "Splitting text into cells..."; // Calculate the progress baseProgress = (int)csvState; stateProgress = csvReadStatus.ProgressPercent; } } else { // Check the state if (state == ImportState.ConvertToTranslations) { // Report cells are being converted message = "Converting cells into translations..."; } // Calculate the progress baseProgress = ((int)state) + 1; stateProgress = progressReport.ProgressPercent; } // Calculate progress baseProgress /= TotalStates; stateProgress /= TotalStates; baseProgress += stateProgress; Progress = baseProgress; // Update message ProgressMessage.Clear(); ProgressMessage.Append(baseProgress.ToString("00%")); ProgressMessage.Append(": "); ProgressMessage.Append(message); }
protected virtual ICollection <IValidationRule> GetValidationRulesForState(ImportState state) { if (state == null) { throw new ArgumentNullException("state"); } var type = typeof(ISateValidationRule <>).MakeGenericType(state.GetType()); return(this._ruleFactory.GetValidationRules <ImportState>(s => this._dependencyResolver.ResolveAll(type)) .ToList()); }
public void ThreadPoolPageImportCallback(Object threadContext) { ImportState stateInfo = (ImportState)threadContext; Page page = stateInfo.page; //destinationView.Pages[threadIndex]; ManualResetEvent manualEvent = stateInfo.manualEvent; int threadIndex = stateInfo.threadIndex; Debug.Print("Thread started for page {0}...", page.Name); ImportPage(page); Debug.Print("Thread completed for page {0}...", page.Name); manualEvent.Set(); }
public void Convert(ModelRoot gltf, PssgFile pssg) { // Get a list of nodes in the default scene as a flat list Dictionary <int, int> nodeBoneIndexMap = new Dictionary <int, int>(); var rootNode = gltf.DefaultScene.FindNode(n => n.Name.StartsWith("Scene Root")); if (rootNode is null) { throw new InvalidDataException("The default scene must have node name starting with `Scene Root`."); } // Determine libraries in which to store data var nodeLib = pssg.FindNodes("LIBRARY", "type", "NODE").FirstOrDefault(); PssgNode rdsLib; PssgNode ribLib; if (nodeLib is not null) { rdsLib = pssg.FindNodes("LIBRARY", "type", "RENDERDATASOURCE").First(); ribLib = pssg.FindNodes("LIBRARY", "type", "RENDERINTERFACEBOUND").First(); } else { // F1 games use YYY, and put almost everything in this lib nodeLib = pssg.FindNodes("LIBRARY", "type", "YYY").FirstOrDefault(); if (nodeLib is null) { throw new InvalidDataException("Could not find library with scene nodes."); } rdsLib = nodeLib; ribLib = nodeLib; } var state = new ImportState(rdsLib, ribLib, ShaderInputInfo.CreateFromPssg(pssg).ToDictionary(si => si.ShaderGroupId)); // Clear out the libraries nodeLib.RemoveChildNodes(nodeLib.ChildNodes.Where(n => n.Name == "ROOTNODE")); rdsLib.RemoveChildNodes(rdsLib.ChildNodes.Where(n => n.Name == "RENDERDATASOURCE")); ribLib.RemoveChildNodes(ribLib.ChildNodes.Where(n => n.Name == "DATABLOCK")); // Write the scene graph, and collect mesh data ConvertSceneNodes(pssg, nodeLib, rootNode, state); // Seems in Dirt Rally 2.0 there is a bunch of useless data in lib SEGMENTSET // lets get rid of it var ssLibNode = pssg.FindNodes("LIBRARY", "type", "SEGMENTSET").FirstOrDefault(); if (ssLibNode is not null) { ssLibNode.ParentNode?.RemoveChild(ssLibNode); } }
/* Saves general file info in FileInfo collection */ public async Task SaveFileInfo(string session, int count, string filename, ImportState state, string description) { FileInformation fileInfo = new FileInformation { Session = session, UploadedFileName = filename, FinalState = state, Description = description, RecordCount = count }; await _fileRepository.InsertFileInfoDetails(fileInfo); }
void MakeAnchorDataRequest() { StatusTextDisplay.Instance.SetStatusText("requesting data"); if (roomManager.DownloadAnchor(currentRoom, currentRoom.GetAnchorName(0))) { currentState = ImportState.DataRequested; } else { Debug.LogError("Anchor Manager: Couldn't make the download request."); currentState = ImportState.Failed; } }
private void ShutdownQueue(ImportState state, Exception ex) { try { if (ex != null) { throw ex; } Status = MessageProcessorStatus.Completed; } catch (Exception e) { Logger.Error("Message Reader failed : " + e.Message, e); Status = MessageProcessorStatus.UnknownError; } Close(); }
private static PssgNode CreateRenderNode(PssgNode parent, Node gltfNode, ImportState state) { var node = new PssgNode(state.RenderNodeName, parent.File, parent); node.AddAttribute("stopTraversal", 0u); node.AddAttribute("nickname", gltfNode.Name); node.AddAttribute("id", gltfNode.Name); parent.ChildNodes.Add(node); state.MatShaderMapping.Clear(); // Now add a new mesh from mesh builder ConvertMesh(node, gltfNode, state); // Write the mesh data WriteMeshData(state); return(node); }
private static void CreateMatrixPaletteNode(PssgNode parent, ImportState state) { var node = new PssgNode("MATRIXPALETTENODE", parent.File, parent); node.AddAttribute("stopTraversal", 0u); node.AddAttribute("id", $"x{state.LodNumber}_MPN"); parent.ChildNodes.Add(node); var transformNode = new PssgNode("TRANSFORM", node.File, node); transformNode.Value = GetTransform(Matrix4x4.Identity); node.ChildNodes.Add(transformNode); var bboxNode = new PssgNode("BOUNDINGBOX", node.File, node); bboxNode.Value = GetBoundingBoxData(Vector3.Zero, Vector3.Zero); node.ChildNodes.Add(bboxNode); foreach (var shader in state.MatShaderMapping.Values) { var rsiNode = new PssgNode("MATRIXPALETTERENDERINSTANCE", node.File, node); rsiNode.AddAttribute("jointCount", (uint)shader.JointNames.Count); rsiNode.AddAttribute("sourceCount", 1u); rsiNode.AddAttribute("indices", $"#{shader.Rds.Name}"); rsiNode.AddAttribute("streamCount", 0u); rsiNode.AddAttribute("shader", $"#{shader.ShaderInstanceName}"); rsiNode.AddAttribute("id", shader.Rds.Name.Replace("RDS", "RSI")); node.ChildNodes.Add(rsiNode); var risNode = new PssgNode("RENDERINSTANCESOURCE", rsiNode.File, rsiNode); risNode.AddAttribute("source", $"#{shader.Rds.Name}"); rsiNode.ChildNodes.Add(risNode); foreach (var jointName in shader.JointNames) { var mpsjNode = new PssgNode("MATRIXPALETTESKINJOINT", rsiNode.File, rsiNode); mpsjNode.AddAttribute("joint", $"#{jointName}"); rsiNode.ChildNodes.Add(mpsjNode); } } }
/// <summary>Initialize the importer</summary> /// <remarks>Called by host to have an importer prepare for a load and to pass in importer initialization parameters /// (SQL Server name, target database, etc).</remarks> /// <param name="Filemask">Path to the file(s) to import. May be a filemask</param> /// <param name="connString">Database connection string</param> /// <param name="Server">SQL Server name</param> /// <param name="UseWindowsAuth">Whether to use an integrated/trusted SQL connection</param> /// <param name="SQLLogin">SQL login name (implies <c>UseWindowsAuth</c>==false)</param> /// <param name="SQLPassword">SQL password (implies <c>UseWindowsAuth</c>==false)</param> /// <param name="DatabaseName">Target database name</param> /// <param name="Logger"><c>ILogger</c> instance - use to communicate status/debug messages back to host</param> /// <returns>void</returns> public void Initialize(string Filemask, string connString, string Server, bool UseWindowsAuth, string SQLLogin, string SQLPassword, string DatabaseName, ILogger Logger) { // Persist inputs from host this.traceFileSpec = Filemask; this.connStr = connString; this.sqlServer = Server; this.sqlLogin = SQLLogin; this.sqlPassword = SQLPassword; this.database = DatabaseName; this.useWindowsAuth = UseWindowsAuth; this.logger = Logger; // Init status members state = ImportState.Idle; is_cancelled = false; knownRowsets = new ArrayList(); this.totalLinesProcessed = 0; this.totalRowsInserted = 0; if (null == this.linuxPerfImporter) { return; } }
void OnAnchorDonwloadCompleted( bool successful, AnchorDownloadRequest request, XString failureReason) { // If we downloaded anchor data successfully we should import the data. if (successful) { StatusTextDisplay.Instance.SetStatusText( "synchronisation data downloaded"); int datasize = request.GetDataSize(); if (SharingStage.Instance.ShowDetailedLogs) { Debug.LogFormat("Anchor Manager: Anchor size: {0} bytes.", datasize.ToString()); } rawAnchorData = new byte[datasize]; request.GetData(rawAnchorData, datasize); currentState = ImportState.DataDownloadedReadyForImport; } else { StatusTextDisplay.Instance.SetStatusText( "retrying synchronisation request"); // If we failed, we can ask for the data again. Debug.LogWarning("Anchor Manager: Anchor DL failed " + failureReason); #if UNITY_WSA && !UNITY_EDITOR MakeAnchorDataRequest(); #endif } }
/// <summary>Initialize the importer</summary> /// <remarks>Called by host to have an importer prepare for a load and to pass in importer initialization parameters /// (SQL Server name, target database, etc).</remarks> /// <param name="Filemask">Path to the file(s) to import. May be a filemask</param> /// <param name="connString">Database connection string</param> /// <param name="Server">SQL Server name</param> /// <param name="UseWindowsAuth">Whether to use an integrated/trusted SQL connection</param> /// <param name="SQLLogin">SQL login name (implies <c>UseWindowsAuth</c>==false)</param> /// <param name="SQLPassword">SQL password (implies <c>UseWindowsAuth</c>==false)</param> /// <param name="DatabaseName">Target database name</param> /// <param name="Logger"><c>ILogger</c> instance - use to communicate status/debug messages back to host</param> /// <returns>void</returns> public void Initialize(string Filemask, string connString, string Server, bool UseWindowsAuth, string SQLLogin, string SQLPassword, string DatabaseName, ILogger Logger) { // Persist inputs from host this.traceFileSpec = Filemask; this.connStr = connString; this.sqlServer = Server; this.sqlLogin = SQLLogin; this.sqlPassword = SQLPassword; this.database = DatabaseName; this.useWindowsAuth = UseWindowsAuth; this.logger = Logger; // Init status members state = ImportState.Idle; canceled = false; knownRowsets = new ArrayList(); this.totalLinesProcessed = 0; this.totalRowsInserted = 0; if (null == this.readTracePath) { FindReadTraceExe(); } Util.Logger.LogMessage(@"ReadTrace.exe Path: " + (null == this.readTracePath ? "(NOT FOUND)" : this.readTracePath)); return; }
/// <inheritdoc /> public ImportResult ImportFromSplitwise() { lock (SplitwiseManager.lockObj) { if (SplitwiseManager.importStatus == ImportState.Running) { return(ImportResult.AlreadyRunning); } SplitwiseManager.importStatus = ImportState.Running; } var lastRan = this.Context.SynchronizationTimes .Single() .SplitwiseLastRun; // Get the new and updated expenses from Splitwise. var timestamp = DateTime.UtcNow; var newExpenses = this.splitwiseContext.GetExpenses(lastRan); var newExpenseIds = newExpenses.Select(t => t.Id).ToSet(); // Load relevant entities and store them in a dictionary. var splitwiseTransactionsById = this.Context.SplitwiseTransactions .IncludeAll() .Where(t => newExpenseIds.Contains(t.Id)) .AsEnumerable() .ToDictionary(t => t.Id); var transactionsBySplitwiseId = this.Context.Transactions .IncludeAll() .Where(t => t.SplitwiseTransactionId.HasValue) .Where(t => newExpenseIds.Contains(t.SplitwiseTransactionId.Value)) .AsEnumerable() .ToDictionary(t => t.SplitwiseTransactionId.Value); this.ConcurrentInvoke(() => { var processor = new TransactionProcessor(this.Context, this.splitwiseContext); this.Context.SetSplitwiseSynchronizationTime(timestamp); foreach (var newExpense in newExpenses) { var splitwiseTransactionMaybe = splitwiseTransactionsById.TryGetValue(newExpense.Id); if (splitwiseTransactionMaybe.IsSome && splitwiseTransactionMaybe.Value.UpdatedAt == newExpense.UpdatedAt) { // The last updated at is equal to the one stored, meaning that the latest update was // triggered by this application and is already handled. continue; } // The new expense is not known and the user has no share, so it's irrelevant. if (splitwiseTransactionMaybe.IsNone && !newExpense.HasShare) { continue; } var transaction = transactionsBySplitwiseId.TryGetValue(newExpense.Id); // Revert the transaction before updating values, don't send the update to Splitwise again. if (transaction.IsSome) { processor.RevertIfProcessed(transaction.Value, true); // Remove the transaction, it is re-added if needed. this.Context.Transactions.Remove(transaction.Value); } // Update the values of the Splitwise transaction, or create a new one. var splitwiseTransaction = splitwiseTransactionMaybe.Match( st => { this.Context.SplitDetails.RemoveRange(st.SplitDetails); st.UpdateValues(newExpense); st.SplitDetails = newExpense.Splits.Select(s => s.ToSplitDetailEntity()).ToList(); return(st); }, () => { var st = newExpense.ToSplitwiseTransactionEntity(); this.Context.SplitwiseTransactions.Add(st); return(st); }); // Remove the Splitwise transaction if it is irrelevant if (!splitwiseTransaction.HasShare) { this.Context.SplitwiseTransactions.Remove(splitwiseTransaction); continue; } // If the Splitwise transaction was already completely imported and is importable after the update, // then try to update the transaction. if (transaction.IsSome && splitwiseTransaction.Importable && // If the account or category is now obsolete, then the Splitwise transaction has to be re-imported. !transaction.Value.Account.IsObsolete && !transaction.Value.Category.IsObsolete) { transaction = splitwiseTransaction.ToTransaction( transaction.Value.Account, transaction.Value.Category); this.Context.Transactions.Add(transaction.Value); processor.ProcessIfNeeded(transaction.Value); } } this.Context.SaveChanges(); }); SplitwiseManager.importStatus = ImportState.NotRunning; return(ImportResult.Completed); }
public void nextState() { currentImportState = currentImportState + 1; }
private static void ConvertSceneNodes(PssgFile pssg, PssgNode parent, Node gltfNode, ImportState state) { PssgNode node; if (gltfNode.Name.StartsWith("Scene Root", StringComparison.InvariantCulture)) { node = new PssgNode("ROOTNODE", parent.File, parent); node.AddAttribute("stopTraversal", 0u); node.AddAttribute("nickname", "Scene Root"); node.AddAttribute("id", "Scene Root"); parent.ChildNodes.Add(node); } else if (gltfNode.Mesh is not null) { _ = CreateRenderNode(parent, gltfNode, state); return; } else { node = new PssgNode("NODE", parent.File, parent); node.AddAttribute("stopTraversal", 0u); node.AddAttribute("nickname", gltfNode.Name); node.AddAttribute("id", gltfNode.Name); parent.ChildNodes.Add(node); } var transformNode = new PssgNode("TRANSFORM", node.File, node) { Value = GetTransform(gltfNode.LocalMatrix) }; node.ChildNodes.Add(transformNode); var bboxNode = new PssgNode("BOUNDINGBOX", node.File, node) { Value = GetBoundingBoxData(Vector3.Zero, Vector3.Zero) }; node.ChildNodes.Add(bboxNode); foreach (var child in gltfNode.VisualChildren) { ConvertSceneNodes(pssg, node, child, state); } }
public static void SetProgress(string session, ImportState state, int percentage) { ImportStateResponse resp = new ImportStateResponse(state, percentage); sessionMap[session] = resp; }
private static void CreateMatrixPaletteJointNode(PssgNode parent, Node gltfNode, ImportState state) { var node = new PssgNode("MATRIXPALETTEJOINTNODE", parent.File, parent); node.AddAttribute("stopTraversal", 0u); node.AddAttribute("nickname", gltfNode.Name); node.AddAttribute("id", gltfNode.Name); node.AddAttribute("jointID", state.JointId); node.AddAttribute("matrixPalette", $"#x{state.LodNumber}_MPN"); parent.ChildNodes.Add(node); // Now add a new mesh from mesh builder ConvertMesh(node, gltfNode, state); state.JointId++; }
private static PssgNode CreateMatrixPaletteBundleNode(PssgNode parent, Node gltfNode, int lodNumber, ImportState state) { PssgNode node = new PssgNode("MATRIXPALETTEBUNDLENODE", parent.File, parent); node.AddAttribute("stopTraversal", 0u); node.AddAttribute("nickname", $"LOD{lodNumber}_"); node.AddAttribute("id", $"LOD{lodNumber}_"); parent.ChildNodes.Add(node); var transformNode = new PssgNode("TRANSFORM", node.File, node); transformNode.Value = GetTransform(gltfNode.LocalMatrix); node.ChildNodes.Add(transformNode); var bboxNode = new PssgNode("BOUNDINGBOX", node.File, node); bboxNode.Value = GetBoundingBoxData(Vector3.Zero, Vector3.Zero); node.ChildNodes.Add(bboxNode); state.LodNumber = lodNumber; state.MatShaderMapping.Clear(); foreach (var child in gltfNode.VisualChildren) { if (child.Mesh is null) { continue; } if (child.Mesh.Primitives.Count == 0) { continue; } CreateMatrixPaletteJointNode(node, child, state); } CreateMatrixPaletteNode(node, state); // Write the mesh data WriteMeshData(state); return(node); }
/// <summary> /// Start the conversion process /// </summary> public void Convert() { #region Debug stopwatch = new System.Diagnostics.Stopwatch(); stopwatch.Start(); System.Diagnostics.Debug.Print(DateTime.Now + " : " + "Table-to-form GUID creation initiated. Elapsed: " + stopwatch.Elapsed.TotalSeconds.ToString()); #endregion // Debug int artifacts = 0; if (SetStatus != null) { SetStatus("Getting data..."); } DT = sourceDriver.GetTableData(tableName, columnNames); artifacts = (DT.Rows.Count * destinationView.Pages.Count) + DT.Rows.Count; if (SetMaxProgressBarValue != null) { SetMaxProgressBarValue((double)artifacts); } #region Set up global record ID values if (SetStatus != null) { SetStatus("Starting global record ID generation..."); } DT.Columns.Add(new DataColumn("GlobalRecordId", typeof(string))); int currentRow = 0; foreach (DataRow row in DT.Rows) { string GUID = System.Guid.NewGuid().ToString(); row["GlobalRecordId"] = GUID; currentRow++; } System.Diagnostics.Debug.Print(DateTime.Now + " : " + "All GUIDs generated. Starting GUID assignment. Elapsed: " + stopwatch.Elapsed.TotalSeconds.ToString()); // set PK DataColumn[] parentPrimaryKeyColumns = new DataColumn[1]; parentPrimaryKeyColumns[0] = DT.Columns["GlobalRecordId"]; DT.PrimaryKey = parentPrimaryKeyColumns; int min = 0; int max = DT.Rows.Count; int q = max / 4; int Q1 = min + q; int Q2 = Q1 + q; int Q3 = max - q; conn = destinationDriver.GetConnection(); conn.Open(); doneEvents = new ManualResetEvent[4]; Debug.Print("Launching 4 GUID assignment tasks..."); GUIDState guidStateInfo; doneEvents[0] = new ManualResetEvent(false); guidStateInfo = new GUIDState(doneEvents[0], 0, 0, Q1); ThreadPool.QueueUserWorkItem(new WaitCallback(ThreadPoolGUIDAssignCallback), guidStateInfo); doneEvents[1] = new ManualResetEvent(false); guidStateInfo = new GUIDState(doneEvents[1], 1, Q1, Q2); ThreadPool.QueueUserWorkItem(new WaitCallback(ThreadPoolGUIDAssignCallback), guidStateInfo); doneEvents[2] = new ManualResetEvent(false); guidStateInfo = new GUIDState(doneEvents[2], 2, Q2, Q3); ThreadPool.QueueUserWorkItem(new WaitCallback(ThreadPoolGUIDAssignCallback), guidStateInfo); doneEvents[3] = new ManualResetEvent(false); guidStateInfo = new GUIDState(doneEvents[3], 3, Q3, max); ThreadPool.QueueUserWorkItem(new WaitCallback(ThreadPoolGUIDAssignCallback), guidStateInfo); WaitHandle.WaitAll(doneEvents); #endregion // Set up global record ID values doneEvents = null; if (SetStatus != null) { SetStatus("Populating field data..."); } System.Diagnostics.Debug.Print(DateTime.Now + " : " + "All GUIDs assigned. Starting page data import. Elapsed: " + stopwatch.Elapsed.TotalSeconds.ToString()); int pageCount = destinationView.Pages.Count; doneEvents = new ManualResetEvent[pageCount]; Debug.Print("Launch {0} tasks...", pageCount); ImportState stateInfo; for (int i = 0; i < pageCount; i++) { doneEvents[i] = new ManualResetEvent(false); stateInfo = new ImportState(destinationView.Pages[i], doneEvents[i], i); ThreadPool.QueueUserWorkItem(new WaitCallback(ThreadPoolPageImportCallback), stateInfo); } WaitHandle.WaitAll(doneEvents); conn.Close(); conn.Dispose(); conn = null; stopwatch.Stop(); System.Diagnostics.Debug.Print(DateTime.Now + " : " + "Processing complete. Elapsed: " + stopwatch.Elapsed.TotalSeconds.ToString()); }
private static void ConvertSceneNodes(PssgFile pssg, PssgNode parent, Node gltfNode, ImportState state) { PssgNode node; Match lodMatch; if (gltfNode.Name.StartsWith("Scene Root")) { node = new PssgNode("ROOTNODE", parent.File, parent); node.AddAttribute("stopTraversal", 0u); node.AddAttribute("nickname", "Scene Root"); node.AddAttribute("id", "Scene Root"); parent.ChildNodes.Add(node); } else if ((lodMatch = state.LodMatcher.Match(gltfNode.Name)).Success) { var lodNumber = int.Parse(lodMatch.Groups[1].Value); node = CreateMatrixPaletteBundleNode(parent, gltfNode, lodNumber, state); return; } else { node = new PssgNode("NODE", parent.File, parent); node.AddAttribute("stopTraversal", 0u); node.AddAttribute("nickname", gltfNode.Name); node.AddAttribute("id", gltfNode.Name); parent.ChildNodes.Add(node); } var transformNode = new PssgNode("TRANSFORM", node.File, node); transformNode.Value = GetTransform(gltfNode.LocalMatrix); node.ChildNodes.Add(transformNode); var bboxNode = new PssgNode("BOUNDINGBOX", node.File, node); bboxNode.Value = GetBoundingBoxData(Vector3.Zero, Vector3.Zero); node.ChildNodes.Add(bboxNode); foreach (var child in gltfNode.VisualChildren) { ConvertSceneNodes(pssg, node, child, state); } }
private void ImportField(GFF.FieldDefinition def, KeyValue data, long offset, ref long newOffset, ImportState state) { var output = this.Data; output.Seek(offset + def.Offset, SeekOrigin.Begin); if (def.IsList == true) { if (def.IsReference == true && (data.Value != null || def.Type != GFF.FieldType.Generic)) { throw new NotSupportedException(); } var list = (IList)data.Value; if (list == null) { output.WriteValueU32(0xFFFFFFFF, LittleEndian); } else { output.WriteValueU32((uint)newOffset, LittleEndian); output.Seek(newOffset, SeekOrigin.Begin); output.WriteValueS32(list.Count, LittleEndian); newOffset += 4; uint itemSize; if (def.Type == GFF.FieldType.Structure) { var subdef = this.Structures[def.StructureId]; itemSize = subdef.DataSize; } else { itemSize = GFF.Builtin.SizeOf(def.Type); } newOffset += list.Count * itemSize; switch (def.Type) { case GFF.FieldType.String: { throw new NotImplementedException(); } case GFF.FieldType.Structure: { var subdef = this.Structures[def.StructureId]; long itemOffset = output.Position; foreach (var item in list) { this.ImportStructure( subdef, (KeyValue)item, itemOffset, ref newOffset, state); itemOffset += itemSize; } break; } default: { if (def.Type == GFF.FieldType.UInt8 && list.GetType() == typeof(byte[])) { var bytes = (byte[])list; output.Write(bytes, 0, bytes.Length); } else { long itemOffset = output.Position; foreach (var item in list) { GFF.Builtin.Serialize(output, def.Type, item, LittleEndian); itemOffset += itemSize; } } break; } } } } else { if (def.IsReference == true && def.Type != GFF.FieldType.Structure) { throw new NotSupportedException(); } switch (def.Type) { case GFF.FieldType.String: { var s = data.As<string>(); if (s == null || s.Length == 0) { output.WriteValueU32(0xFFFFFFFF, LittleEndian); } else { var length = s.Length + 1; output.WriteValueU32((uint)newOffset, LittleEndian); output.Seek(newOffset, SeekOrigin.Begin); output.WriteValueS32(length, LittleEndian); output.WriteString(s, LittleEndian ? Encoding.Unicode : Encoding.BigEndianUnicode); output.WriteValueU16(0, LittleEndian); newOffset += 4 + (2 * length); } break; } case GFF.FieldType.TalkString: { var s = data.As<GFF.Builtins.TalkString>(); output.WriteValueU32(s.Id, LittleEndian); if (s.String == null) { output.WriteValueU32(0xFFFFFFFF, LittleEndian); } else if (s.String.Length == 0) { output.WriteValueU32(0, LittleEndian); } else { var length = s.String.Length + 1; output.WriteValueU32((uint)newOffset, LittleEndian); output.Seek(newOffset, SeekOrigin.Begin); output.WriteValueS32(length, LittleEndian); output.WriteString(s.String, LittleEndian ? Encoding.Unicode : Encoding.BigEndianUnicode); output.WriteValueU16(0, LittleEndian); newOffset += 4 + (2 * length); } break; } case GFF.FieldType.Structure: { if (def.IsReference == true) { if (data == null || data.Values == null) { output.WriteValueU32(0xFFFFFFFF, LittleEndian); } else { output.WriteValueU32((uint)newOffset, LittleEndian); output.Seek(newOffset, SeekOrigin.Begin); var subdef = this.Structures[def.StructureId]; newOffset += subdef.DataSize; this.ImportStructure( subdef, data, output.Position, ref newOffset, state); } } else { var subdef = this.Structures[def.StructureId]; this.ImportStructure( subdef, data, output.Position, ref newOffset, state); } break; } default: { GFF.Builtin.Serialize(output, def.Type, data.Value, LittleEndian); break; } } } }
private ImportState ProcessMessage(RawMessageDescriptor msg, ImportState importState) { //pool.QueueWorkItem(() => ImportRunner(msg)); ImportBulk(msg); return(importState); }
private static void ConvertMesh(PssgNode mpjnNode, Node gltfNode, ImportState state) { var mesh = gltfNode.Mesh; if (mesh.Primitives.Any(p => p.Material == null)) { throw new NotImplementedException($"The converter does not support primitives ({mesh.Name}) with a null material."); } var transformNode = new PssgNode("TRANSFORM", mpjnNode.File, mpjnNode); transformNode.Value = GetTransform(gltfNode.LocalMatrix); mpjnNode.ChildNodes.Add(transformNode); var bboxNode = new PssgNode("BOUNDINGBOX", mpjnNode.File, mpjnNode); mpjnNode.ChildNodes.Add(bboxNode); // Add to the material shader mapping var gltfMats = mesh.Primitives.Select(p => p.Material); ConvertMaterials(gltfMats, mpjnNode.File, state); // Export Vertices, Normals, TexCoords, VertexWeights and Faces Mesh gltfMesh = gltfNode.Mesh; var meshDecoder = gltfMesh.Decode(); Vector3 minExtent = new Vector3(float.MaxValue); Vector3 maxExtent = new Vector3(float.MinValue); foreach (var p in meshDecoder.Primitives) { // skip primitives that aren't tris if (!p.TriangleIndices.Any()) { continue; } // Get the new material index in grn int faceMatId = p.Material.LogicalIndex; ShaderInstanceData shaderData; if (state.MatShaderMapping.ContainsKey(faceMatId)) { shaderData = state.MatShaderMapping[faceMatId]; } else { throw new InvalidDataException($"Mesh ({gltfMesh.Name}) has an invalid material id " + faceMatId + "."); } var rds = shaderData.Rds; var tris = p.TriangleIndices.ToArray(); var baseVertexIndex = rds.Positions.Count; var mpriNode = new PssgNode("MATRIXPALETTERENDERINSTANCE", mpjnNode.File, mpjnNode); mpriNode.AddAttribute("streamOffset", (uint)(rds.Positions.Count)); mpriNode.AddAttribute("elementCountFromOffset", (uint)(p.VertexCount)); mpriNode.AddAttribute("indexOffset", (uint)(rds.Indices.Count)); mpriNode.AddAttribute("indicesCountFromOffset", (uint)(tris.Length * 3)); mpriNode.AddAttribute("sourceCount", 1u); mpriNode.AddAttribute("indices", $"#{rds.Name}"); mpriNode.AddAttribute("streamCount", 0u); mpriNode.AddAttribute("shader", $"#{shaderData.ShaderInstanceName}"); mpriNode.AddAttribute("id", $"MPJRI{state.MpjriCount}"); state.MpjriCount++; mpjnNode.ChildNodes.Add(mpriNode); var risNode = new PssgNode("RENDERINSTANCESOURCE", mpriNode.File, mpriNode); risNode.AddAttribute("source", $"#{shaderData.Rds.Name}"); mpriNode.ChildNodes.Add(risNode); var texCoordSet = GetDiffuseBaseColorTexCoord(p.Material); string texCoordAccessorName = $"TEXCOORD_{texCoordSet}"; // Make sure we have all the necessary data if (p.VertexCount < 3) { throw new InvalidDataException($"Mesh ({gltfMesh.Name}) must have at least 3 positions."); } if (p.TexCoordsCount <= texCoordSet) { throw new InvalidDataException($"Mesh ({gltfMesh.Name}) must have tex coord set {texCoordSet}."); } // Grab the data for (int i = 0; i < p.VertexCount; ++i) { var pos = p.GetPosition(i); var color = p.GetColor(i, 0); // Compute extents for bounding box minExtent.X = Math.Min(pos.X, minExtent.X); minExtent.Y = Math.Min(pos.Y, minExtent.Y); minExtent.Z = Math.Min(pos.Z, minExtent.Z); maxExtent.X = Math.Max(pos.X, maxExtent.X); maxExtent.Y = Math.Max(pos.Y, maxExtent.Y); maxExtent.Z = Math.Max(pos.Z, maxExtent.Z); rds.Positions.Add(pos); rds.Normals.Add(p.GetNormal(i)); rds.Tangents.Add(p.GetTangent(i)); rds.TexCoords0.Add(p.GetTextureCoord(i, texCoordSet)); rds.Colors.Add(color); rds.SkinIndices.Add(state.JointId); } foreach (var tri in p.TriangleIndices) { var a = tri.A + baseVertexIndex; var b = tri.B + baseVertexIndex; var c = tri.C + baseVertexIndex; rds.Indices.Add((ushort)a); rds.Indices.Add((ushort)b); rds.Indices.Add((ushort)c); } } bboxNode.Value = GetBoundingBoxData(minExtent, maxExtent);
// This method is called from the ImportConflictWindow class after the user // has chosen what should happen with newly imported files. public static void HandleFileReplacements(bool replaceOld) { if (replaceOld) { if (mWasConfigFileUpdated == ImportState.RENAMED) { if (AssetDatabase.DeleteAsset( QCARUtilities.GlobalVars.CONFIG_XML_PATH)) { string renameError = AssetDatabase.RenameAsset( mUnwantedConfigXMLPath, "config"); if (renameError != "") { Debug.LogError("Rename operation returns: " + renameError); } } else { Debug.LogError("Could not delete asset with name: " + QCARUtilities.GlobalVars.CONFIG_XML_PATH); } mWasConfigFileUpdated = ImportState.ADDED; } if (mWasDATFileUpdated == ImportState.RENAMED) { if (AssetDatabase.DeleteAsset( QCARUtilities.GlobalVars.DAT_PATH)) { string renameError = AssetDatabase.RenameAsset( mUnwantedDATPath, "qcar-resources"); if (renameError != "") { Debug.LogError("Rename operation returns: " + renameError); } } else { Debug.LogError("Could not delete asset with name: " + QCARUtilities.GlobalVars.DAT_PATH); } mWasDATFileUpdated = ImportState.ADDED; } } else { if (mWasConfigFileUpdated == ImportState.RENAMED) { AssetDatabase.DeleteAsset(mUnwantedConfigXMLPath); mWasConfigFileUpdated = ImportState.ADDED; } if (mWasDATFileUpdated == ImportState.RENAMED) { AssetDatabase.DeleteAsset(mUnwantedDATPath); mWasDATFileUpdated = ImportState.ADDED; } } mUnwantedConfigXMLPath = null; mUnwantedDATPath = null; SceneManager.Instance.FilesUpdated(mWasConfigFileUpdated, mWereTexturesUpdated, mWasDATFileUpdated); mProcessingReplacement = false; }
// This method is called by Unity whenever assets are updated (deleted, // moved or added). public static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths) { // We ignore new requests until we finished replacement actions. if (mProcessingReplacement) { return; } mWasConfigFileUpdated = ImportState.NONE; mWereTexturesUpdated = ImportState.NONE; mWasDATFileUpdated = ImportState.NONE; bool replacementDetected = false; // We are using regular expression to determine if a file has been // renamed by Unity. Regex configFileRegex = new Regex( QCARUtilities.GlobalVars.REGEXED_CONFIG_XML_PATH, RegexOptions.IgnoreCase); Regex datFileRegex = new Regex( QCARUtilities.GlobalVars.REGEXED_DAT_PATH, RegexOptions.IgnoreCase); // Check if there are relevant files that have been imported. foreach (string importedAsset in importedAssets) { if (importedAsset.IndexOf( QCARUtilities.GlobalVars.CONFIG_XML_PATH, System.StringComparison.OrdinalIgnoreCase) != -1) { mWasConfigFileUpdated = ImportState.ADDED; } else if (importedAsset.IndexOf( QCARUtilities.GlobalVars.PATH_TO_TARGET_TEXTURES, System.StringComparison.OrdinalIgnoreCase) != -1) { mWereTexturesUpdated = ImportState.ADDED; } else if (importedAsset.IndexOf( QCARUtilities.GlobalVars.DAT_PATH, System.StringComparison.OrdinalIgnoreCase) != -1) { mWasDATFileUpdated = ImportState.ADDED; } else if (configFileRegex.IsMatch(importedAsset)) { replacementDetected = true; mWasConfigFileUpdated = ImportState.RENAMED; mUnwantedConfigXMLPath = importedAsset; } else if (datFileRegex.IsMatch(importedAsset)) { replacementDetected = true; mWasDATFileUpdated = ImportState.RENAMED; mUnwantedDATPath = importedAsset; } } // Check if there are relevant files that have been deleted. foreach (string deletedAsset in deletedAssets) { if (deletedAsset.IndexOf( QCARUtilities.GlobalVars.CONFIG_XML_PATH, System.StringComparison.OrdinalIgnoreCase) != -1) { mWasConfigFileUpdated = ImportState.DELETED; } else if (deletedAsset.IndexOf( QCARUtilities.GlobalVars.PATH_TO_TARGET_TEXTURES, System.StringComparison.OrdinalIgnoreCase) != -1) { mWereTexturesUpdated = ImportState.DELETED; } else if (deletedAsset.IndexOf( QCARUtilities.GlobalVars.DAT_PATH, System.StringComparison.OrdinalIgnoreCase) != -1) { mWasDATFileUpdated = ImportState.DELETED; } } // If a file needs to be replaced we delay the update callback call // until the user has made a decision between keeping the old or the // new files. if (replacementDetected) { mProcessingReplacement = true; ImportConflictWindow.ShowWindow(); } else { bool filesUpdated = ((mWasConfigFileUpdated != ImportState.NONE) || (mWereTexturesUpdated != ImportState.NONE) || (mWasDATFileUpdated != ImportState.NONE)); // We only alert the SceneManager if files have actually been // changed. if (filesUpdated) { SceneManager.Instance.FilesUpdated(mWasConfigFileUpdated, mWereTexturesUpdated, mWasDATFileUpdated); } } }
private static PssgNode CreateMatrixPaletteBundleNode(PssgNode parent, Node gltfNode, int lodNumber, ImportState state) { PssgNode node = new PssgNode("MATRIXPALETTEBUNDLENODE", parent.File, parent); node.AddAttribute("stopTraversal", 0u); node.AddAttribute("nickname", $"LOD{lodNumber}_"); node.AddAttribute("id", $"LOD{lodNumber}_"); parent.ChildNodes.Add(node); var transformNode = new PssgNode("TRANSFORM", node.File, node); transformNode.Value = GetTransform(gltfNode.LocalMatrix); node.ChildNodes.Add(transformNode); var bboxNode = new PssgNode("BOUNDINGBOX", node.File, node); bboxNode.Value = GetBoundingBoxData(Vector3.Zero, Vector3.Zero); node.ChildNodes.Add(bboxNode); state.LodNumber = lodNumber; state.JointId = 0; state.MatShaderMapping.Clear(); List <string> jointNames = new List <string>(); foreach (var child in gltfNode.VisualChildren) { if (child.Mesh is null) { continue; } if (child.Mesh.Primitives.Count == 0) { continue; } CreateMatrixPaletteJointNode(node, child, state); jointNames.Add(node.ChildNodes.Last().Attributes["id"].GetValue <string>()); } CreateMatrixPaletteNode(node, jointNames, state); // Write the mesh data var rdsLib = node.File.FindNodes("LIBRARY", "type", "RENDERDATASOURCE").First(); var ribLib = node.File.FindNodes("LIBRARY", "type", "RENDERINTERFACEBOUND").First(); WriteMeshData(rdsLib, ribLib, state); return(node); }
private void ImportStructure(GFF.StructureDefinition def, KeyValue data, long offset, ref long newOffset, ImportState state) { foreach (var fieldDef in def.Fields) { if (fieldDef.Id == 16208) { } KeyValue value; if (data.Values.ContainsKey(fieldDef.Id) == false) { //throw new InvalidOperationException(); value = new KeyValue(fieldDef.Type, null); } else { value = data[fieldDef.Id]; } this.ImportField(fieldDef, value, offset, ref newOffset, state); } }
public WizardController(String mfileName) { currentImportState = ImportState.None; fileName = mfileName; }
public ImportStateModel(ImportState state) { Session = state.Session.ToString(); Completed = state.Completed; ErrorMessage = state.ErrorMsg; }
private static void ConvertMesh(PssgNode renderNode, Node gltfNode, ImportState state) { var mesh = gltfNode.Mesh; if (mesh.Primitives.Any(p => p.Material == null)) { throw new NotImplementedException($"The converter does not support primitives ({mesh.Name}) with a null material."); } var transformNode = new PssgNode("TRANSFORM", renderNode.File, renderNode) { Value = GetTransform(gltfNode.LocalMatrix) }; renderNode.ChildNodes.Add(transformNode); var bboxNode = new PssgNode("BOUNDINGBOX", renderNode.File, renderNode); renderNode.ChildNodes.Add(bboxNode); // Add to the material shader mapping var gltfMats = mesh.Primitives.Select(p => p.Material); ConvertMaterials(gltfMats, renderNode.File, state); // Export Vertices, Normals, TexCoords, VertexWeights and Faces var gltfMesh = gltfNode.Mesh; var meshDecoder = gltfMesh.Decode(); var minExtent = new Vector3(float.MaxValue); var maxExtent = new Vector3(float.MinValue); foreach (var p in meshDecoder.Primitives) { // skip primitives that aren't tris if (!p.TriangleIndices.Any()) { continue; } // Get the new material index in grn var faceMatId = p.Material.LogicalIndex; ShaderInstanceData shaderData; if (state.MatShaderMapping.ContainsKey(faceMatId)) { shaderData = state.MatShaderMapping[faceMatId]; } else { throw new InvalidDataException($"Mesh ({gltfMesh.Name}) has an invalid material id " + faceMatId + "."); } var rds = shaderData.Rds; var tris = p.TriangleIndices.ToArray(); var baseVertexIndex = rds.Positions.Count; var rsiNode = new PssgNode("RENDERSTREAMINSTANCE", renderNode.File, renderNode); rsiNode.AddAttribute("sourceCount", 1u); rsiNode.AddAttribute("indices", $"#{rds.Name}"); rsiNode.AddAttribute("streamCount", 0u); rsiNode.AddAttribute("shader", $"#{shaderData.ShaderInstanceName}"); rsiNode.AddAttribute("id", $"!RSI{state.RenderStreamInstanceCount}"); state.RenderStreamInstanceCount++; renderNode.ChildNodes.Add(rsiNode); var risNode = new PssgNode("RENDERINSTANCESOURCE", rsiNode.File, rsiNode); risNode.AddAttribute("source", $"#{shaderData.Rds.Name}"); rsiNode.ChildNodes.Add(risNode); var texCoordSet0 = GetDiffuseBaseColorTexCoord(p.Material); var texCoordSet1 = GetOcclusionTexCoord(p.Material); var texCoordSet2 = GetEmissiveTexCoord(p.Material); var texCoordSet3 = GetNormalTexCoord(p.Material); if (state.IsF1) { // F1 stores spec occ first, then diffuse var temp = texCoordSet0; texCoordSet0 = texCoordSet1; texCoordSet1 = temp; } // Make sure we have all the necessary data if (p.VertexCount < 3) { throw new InvalidDataException($"Mesh ({gltfMesh.Name}) must have at least 3 positions."); } // Grab the data for (var i = 0; i < p.VertexCount; ++i) { var pos = p.GetPosition(i); var color = p.GetColor(i, 0); // Compute extents for bounding box minExtent.X = Math.Min(pos.X, minExtent.X); minExtent.Y = Math.Min(pos.Y, minExtent.Y); minExtent.Z = Math.Min(pos.Z, minExtent.Z); maxExtent.X = Math.Max(pos.X, maxExtent.X); maxExtent.Y = Math.Max(pos.Y, maxExtent.Y); maxExtent.Z = Math.Max(pos.Z, maxExtent.Z); rds.Positions.Add(pos); rds.Normals.Add(p.GetNormal(i)); rds.Tangents.Add(p.GetTangent(i)); rds.TexCoords0.Add(p.GetTextureCoord(i, texCoordSet0)); rds.TexCoords1.Add(p.GetTextureCoord(i, texCoordSet1)); rds.TexCoords2.Add(p.GetTextureCoord(i, texCoordSet2)); rds.TexCoords3.Add(p.GetTextureCoord(i, texCoordSet3)); rds.Colors.Add(color); rds.SkinIndices.Add(0); } foreach (var(A, B, C) in p.TriangleIndices) { var a = A + baseVertexIndex; var b = B + baseVertexIndex; var c = C + baseVertexIndex; rds.Indices.Add((ushort)a); rds.Indices.Add((ushort)b); rds.Indices.Add((ushort)c); } } bboxNode.Value = GetBoundingBoxData(minExtent, maxExtent);
public void previousState() { currentImportState = currentImportState - 1; }