public static void ImportClouds() { if (EditorUtility.DisplayDialog("Import clouds", string.Format( "Folders are setup in Resources/ExplodedPrefs asset\n\n" + "Incoming: {0}\n" + "Imported: {1}", Prefs.IncomingPath, Prefs.ImportedPath ), "Import", "Cancel")) { // get a list of incoming .cloud files string[] clouds = Directory.GetFiles(Prefs.IncomingPath, "*.cloud"); // see if the list isn't empty if (clouds.Length == 0) { Debug.LogWarning(string.Format("No cloud files at incoming path: {0}", Prefs.IncomingPath)); return; } Progressor prog = new Progressor("Importing clouds"); using(new AssetEditBatch() ) { foreach(string cloud_path in prog.Iterate(clouds )) { // derive .prefab / .bin paths from .cloud path string bin_path = Prefs.IncomingBin(cloud_path); string prefab_path = Prefs.ImportedCloudPrefab(cloud_path); // Sanity check: there should be a corresponding .bin next to the cloud if (!File.Exists(bin_path)) { Debug.LogError(string.Format("No .bin file found for '{0}'", cloud_path)); continue; } // Safety: don't overwrite prefabs string[] sentinels = { prefab_path, Prefs.ImportedBin(cloud_path), Prefs.ImportedCloud(cloud_path)}; bool hitSentinel = false; foreach(string sentinel in sentinels) { if (File.Exists( sentinel )) { Debug.LogWarning(string.Format("'{0}' is in the way when importing '{1}'", sentinel, cloud_path)); hitSentinel = true; } } if (hitSentinel) continue; // ready to import CloudImporter importer = new CloudImporter(prog.Sub()); importer.ImportCloud(cloud_path, bin_path, prefab_path); } } } }
public void DistinctProgressor() { var source = new Progressor<int>(new[] { 0, 0, 1, 1, 2, 0, 1, 3, 4, 4, 4, 4, 5, 5, 5, 0, 1, 3 }); var progresor = Progressor<int>.CreateDistinct(source); int indexA = 0; int indexB = 0; progresor.SubscribeAction ( value => { Assert.AreEqual(value, indexB); indexB++; } ); int item; while (progresor.TryTake(out item)) { Assert.AreEqual(item, indexA); indexA++; } Assert.AreEqual(6, indexA); Assert.AreEqual(indexA, indexB); }
public void CreatedFilteredConverted() { var source = new Progressor<int>(new[] { 0, 8, 1, 8, 2, 3, 4, 8, 5 }); var progresor = Progressor<string>.CreatedFilteredConverted(source, input => input != 8, input => input.ToString(CultureInfo.InvariantCulture)); int indexA = 0; int indexB = 0; progresor.SubscribeAction ( value => { Assert.AreEqual(value, indexB.ToString(CultureInfo.InvariantCulture)); indexB++; } ); string item; while (progresor.TryTake(out item)) { Assert.AreEqual(item, indexA.ToString(CultureInfo.InvariantCulture)); indexA++; } Assert.AreEqual(6, indexA); Assert.AreEqual(indexA, indexB); }
public void EnumerableProgressor() { var source = new[] { 0, 1, 2, 3, 4, 5 }; var progresor = new Progressor<int>(source); int indexA = 0; int indexB = 0; progresor.SubscribeAction ( value => { Assert.AreEqual(value, indexB); indexB++; } ); int item; while (progresor.TryTake(out item)) { Assert.AreEqual(item, indexA); indexA++; } Assert.AreEqual(6, indexA); Assert.AreEqual(indexA, indexB); }
public void TryTakeProgressor() { var source = new Queue<int>(); source.Enqueue(0); source.Enqueue(1); source.Enqueue(2); source.Enqueue(3); source.Enqueue(4); source.Enqueue(5); var progresor = new Progressor<int> ( (out int value) => { try { value = source.Dequeue(); return true; } catch (Exception) { value = 0; return false; } }, false ); int indexA = 0; int indexB = 0; progresor.SubscribeAction ( value => { Assert.AreEqual(value, indexB); indexB++; } ); int item; while (progresor.TryTake(out item)) { Assert.AreEqual(item, indexA); indexA++; } Assert.AreEqual(6, indexA); Assert.AreEqual(indexA, indexB); }
public void ThreadedUseWithPreface() { var source = new Progressor<int>( new List<int> {7, 7, 7, 7, 7}, new Progressor<int>(new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 })).AsEnumerable(); var handle = new ManualResetEvent(false); int[] count = { 0, 0, 0 }; var work = new WaitCallback ( _ => { Interlocked.Increment(ref count[0]); handle.WaitOne(); foreach (var item in source) { GC.KeepAlive(item); Interlocked.Increment(ref count[2]); } Interlocked.Increment(ref count[1]); } ); ThreadPool.QueueUserWorkItem(work); ThreadPool.QueueUserWorkItem(work); while (Thread.VolatileRead(ref count[0]) != 2) { Thread.Sleep(0); } handle.Set(); while (Thread.VolatileRead(ref count[1]) != 2) { Thread.Sleep(0); } Assert.AreEqual(15, Thread.VolatileRead(ref count[2])); handle.Close(); }
public void FilteredProgressor() { var source = new Progressor<int>(new[] { 0, 8, 1, 8, 2, 3, 4, 8, 5 }); var progresor = Progressor<int>.CreatedFiltered(source, input => input != 8); int indexA = 0; int indexB = 0; progresor.SubscribeAction ( value => { Assert.AreEqual(value, indexB); indexB++; } ); int item; while (progresor.TryTake(out item)) { Assert.AreEqual(item, indexA); indexA++; } Assert.AreEqual(6, indexA); Assert.AreEqual(indexA, indexB); }
public void Progressor_ThreadedUse() { var source = new Progressor<int>(new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }).AsEnumerable(); var handle = new ManualResetEvent(false); int[] count = { 0, 0, 0 }; Action work = () => { Interlocked.Increment(ref count[0]); handle.WaitOne(); foreach (var item in source) { GC.KeepAlive(item); Interlocked.Increment(ref count[2]); } Interlocked.Increment(ref count[1]); }; Task.Factory.StartNew(work); Task.Factory.StartNew(work); while (Thread.VolatileRead(ref count[0]) != 2) { Thread.Sleep(0); } handle.Set(); while (Thread.VolatileRead(ref count[1]) != 2) { Thread.Sleep(0); } Assert.AreEqual(10, Thread.VolatileRead(ref count[2])); handle.Close(); }
void CutToBoxes(GameObject cloud_go) { // using linked list so we can change order on the fly ImportedCloud iCloud = cloud_go.GetComponent<ImportedCloud>(); slices = new LinkedList<Slice>( iCloud.slices ); maxTodoCount = cutBoxes.Count * Prefs.MaxCompactSize; done = 0; portionCount = 0; Progressor prog = new Progressor ("Cutting " + cloud_go.name + " according to boxes"); // open the original file for reading origReader = new CloudStream.Reader( new FileStream( Prefs.ImportedBin(cloud_go.name) , FileMode.Open, FileAccess.Read)); try { // since we get rid of full boxes and exhausted slices ... while( cutBoxHelpers.Count > 0 && slices.Count > 0 ) { // iterate over remaining slices LinkedListNode<Slice> slice_iter = slices.First; do { // deal with this once slice ... SortSlicePortion(slice_iter, cutBoxHelpers, shadowBoxHelpers); prog.Progress( (float)done/(float)maxTodoCount, "Sorting..."); } while (cutBoxHelpers.Count > 0 && (slice_iter = slice_iter.Next) != null); portionCount++; } // close remaining boxes foreach (BoxHelper box in cutBoxHelpers) box.Finish (); foreach (BoxHelper box in shadowBoxHelpers) box.Finish (); } finally { prog.Done(); } }
CloudImporter(Progressor _prog) { prog = _prog; meshConv = new CloudMeshConvertor( Prefs.OrigPreviewSize ); }
/// <summary> Set the Progressor reference that will get updates when this SceneLoader loads a scene </summary> /// <param name="progressor"> The Progressor that will get updates when this SceneLoader loads a scene </param> public SceneLoader SetProgressor(Progressor progressor) { Progressor = progressor; return(this); }
public void Shuffle(FileStream stream, Progressor prog) { int byteCount = pointCount * CloudStream.pointRecSize; byte[] wholeThing = new byte[byteCount]; Progressor subProg = prog.Sub(0f, 0.1f); subProg.Progress(0.01f, "Reading into memory..."); stream.Seek(0, SeekOrigin.Begin); stream.Read( wholeThing, 0, byteCount ); subProg.Progress(1f, "Reading into memory... done"); byte[] tmp = new byte[CloudStream.pointRecSize]; subProg = prog.Sub(0.1f, 0.9f); ShuffleUtility.WithSwap(pointCount, (i, j) => { /* * This is the fastest way I found to swap 16-byte long chunks in memory (tried MemoryStream and * byte-by-byte swap loop). */ System.Buffer.BlockCopy(wholeThing, i * CloudStream.pointRecSize, tmp, 0, CloudStream.pointRecSize); System.Buffer.BlockCopy(wholeThing, j * CloudStream.pointRecSize, wholeThing, i * CloudStream.pointRecSize, CloudStream.pointRecSize); System.Buffer.BlockCopy(tmp, 0, wholeThing, j * CloudStream.pointRecSize, CloudStream.pointRecSize); // 'i' runs backwards from pointCount-1 to 0 subProg.Progress((float)(pointCount - i) / pointCount, "Shuffling '{0}' in memory. ETA: {eta}", name); }); subProg = prog.Sub(0.9f, 1f); subProg.Progress(0.01f, "Writing to disk..."); stream.Seek(0, SeekOrigin.Begin); stream.Write( wholeThing, 0, byteCount ); subProg.Progress(1f, "Writing to disk... done"); }