internal static void InitDefaultContent() { const string VirtualContentPath = ContentProvider.VirtualContentPath + "DrawTechnique:"; const string ContentDir_SmoothAnim = VirtualContentPath + "SmoothAnim:"; const string ContentPath_Solid = VirtualContentPath + "Solid"; const string ContentPath_Mask = VirtualContentPath + "Mask"; const string ContentPath_Add = VirtualContentPath + "Add"; const string ContentPath_Alpha = VirtualContentPath + "Alpha"; const string ContentPath_SharpMask = VirtualContentPath + "SharpAlpha"; const string ContentPath_Multiply = VirtualContentPath + "Multiply"; const string ContentPath_Light = VirtualContentPath + "Light"; const string ContentPath_Invert = VirtualContentPath + "Invert"; const string ContentPath_Picking = VirtualContentPath + "Picking"; const string ContentPath_SmoothAnim_Solid = ContentDir_SmoothAnim + "Solid"; const string ContentPath_SmoothAnim_Mask = ContentDir_SmoothAnim + "Mask"; const string ContentPath_SmoothAnim_Add = ContentDir_SmoothAnim + "Add"; const string ContentPath_SmoothAnim_Alpha = ContentDir_SmoothAnim + "Alpha"; const string ContentPath_SmoothAnim_Multiply = ContentDir_SmoothAnim + "Multiply"; const string ContentPath_SmoothAnim_Light = ContentDir_SmoothAnim + "Light"; const string ContentPath_SmoothAnim_Invert = ContentDir_SmoothAnim + "Invert"; ContentProvider.AddContent(ContentPath_Solid, new DrawTechnique(BlendMode.Solid)); ContentProvider.AddContent(ContentPath_Mask, new DrawTechnique(BlendMode.Mask)); ContentProvider.AddContent(ContentPath_Add, new DrawTechnique(BlendMode.Add)); ContentProvider.AddContent(ContentPath_Alpha, new DrawTechnique(BlendMode.Alpha)); ContentProvider.AddContent(ContentPath_Multiply, new DrawTechnique(BlendMode.Multiply)); ContentProvider.AddContent(ContentPath_Light, new DrawTechnique(BlendMode.Light)); ContentProvider.AddContent(ContentPath_Invert, new DrawTechnique(BlendMode.Invert)); ContentProvider.AddContent(ContentPath_Picking, new DrawTechnique(BlendMode.Mask, ShaderProgram.Picking)); ContentProvider.AddContent(ContentPath_SharpMask, new DrawTechnique(BlendMode.Alpha, ShaderProgram.SharpAlpha)); ContentProvider.AddContent(ContentPath_SmoothAnim_Solid, new DrawTechnique(BlendMode.Solid, ShaderProgram.SmoothAnim, VertexType_C1P3T4A1)); ContentProvider.AddContent(ContentPath_SmoothAnim_Mask, new DrawTechnique(BlendMode.Mask, ShaderProgram.SmoothAnim, VertexType_C1P3T4A1)); ContentProvider.AddContent(ContentPath_SmoothAnim_Add, new DrawTechnique(BlendMode.Add, ShaderProgram.SmoothAnim, VertexType_C1P3T4A1)); ContentProvider.AddContent(ContentPath_SmoothAnim_Alpha, new DrawTechnique(BlendMode.Alpha, ShaderProgram.SmoothAnim, VertexType_C1P3T4A1)); ContentProvider.AddContent(ContentPath_SmoothAnim_Multiply, new DrawTechnique(BlendMode.Multiply, ShaderProgram.SmoothAnim, VertexType_C1P3T4A1)); ContentProvider.AddContent(ContentPath_SmoothAnim_Light, new DrawTechnique(BlendMode.Light, ShaderProgram.SmoothAnim, VertexType_C1P3T4A1)); ContentProvider.AddContent(ContentPath_SmoothAnim_Invert, new DrawTechnique(BlendMode.Invert, ShaderProgram.SmoothAnim, VertexType_C1P3T4A1)); Solid = ContentProvider.RequestContent <DrawTechnique>(ContentPath_Solid); Mask = ContentProvider.RequestContent <DrawTechnique>(ContentPath_Mask); Add = ContentProvider.RequestContent <DrawTechnique>(ContentPath_Add); Alpha = ContentProvider.RequestContent <DrawTechnique>(ContentPath_Alpha); Multiply = ContentProvider.RequestContent <DrawTechnique>(ContentPath_Multiply); Light = ContentProvider.RequestContent <DrawTechnique>(ContentPath_Light); Invert = ContentProvider.RequestContent <DrawTechnique>(ContentPath_Invert); Picking = ContentProvider.RequestContent <DrawTechnique>(ContentPath_Picking); SharpAlpha = ContentProvider.RequestContent <DrawTechnique>(ContentPath_SharpMask); SmoothAnim_Solid = ContentProvider.RequestContent <DrawTechnique>(ContentPath_SmoothAnim_Solid); SmoothAnim_Mask = ContentProvider.RequestContent <DrawTechnique>(ContentPath_SmoothAnim_Mask); SmoothAnim_Add = ContentProvider.RequestContent <DrawTechnique>(ContentPath_SmoothAnim_Add); SmoothAnim_Alpha = ContentProvider.RequestContent <DrawTechnique>(ContentPath_SmoothAnim_Alpha); SmoothAnim_Multiply = ContentProvider.RequestContent <DrawTechnique>(ContentPath_SmoothAnim_Multiply); SmoothAnim_Light = ContentProvider.RequestContent <DrawTechnique>(ContentPath_SmoothAnim_Light); SmoothAnim_Invert = ContentProvider.RequestContent <DrawTechnique>(ContentPath_SmoothAnim_Invert); }
internal static void InitDefaultContent() { const string VirtualContentPath = ContentProvider.VirtualContentPath + "Material:"; const string ContentPath_SolidWhite = VirtualContentPath + "SolidWhite"; const string ContentPath_InvertWhite = VirtualContentPath + "InvertWhite"; const string ContentPath_DualityIcon = VirtualContentPath + "DualityIcon"; const string ContentPath_DualityIconB = VirtualContentPath + "DualityIconB"; const string ContentPath_DualityLogoBig = VirtualContentPath + "DualityLogoBig"; const string ContentPath_DualityLogoMedium = VirtualContentPath + "DualityLogoMedium"; const string ContentPath_DualityLogoSmall = VirtualContentPath + "DualityLogoSmall"; const string ContentPath_Checkerboard = VirtualContentPath + "Checkerboard"; ContentProvider.AddContent(ContentPath_SolidWhite, new Material(DrawTechnique.Solid, ColorRgba.White)); ContentProvider.AddContent(ContentPath_InvertWhite, new Material(DrawTechnique.Invert, ColorRgba.White)); ContentProvider.AddContent(ContentPath_DualityIcon, new Material(DrawTechnique.Mask, ColorRgba.White, Texture.DualityIcon)); ContentProvider.AddContent(ContentPath_DualityIconB, new Material(DrawTechnique.Mask, ColorRgba.White, Texture.DualityIconB)); ContentProvider.AddContent(ContentPath_DualityLogoBig, new Material(DrawTechnique.Alpha, ColorRgba.White, Texture.DualityLogoBig)); ContentProvider.AddContent(ContentPath_DualityLogoMedium, new Material(DrawTechnique.Alpha, ColorRgba.White, Texture.DualityLogoMedium)); ContentProvider.AddContent(ContentPath_DualityLogoSmall, new Material(DrawTechnique.Alpha, ColorRgba.White, Texture.DualityLogoSmall)); ContentProvider.AddContent(ContentPath_Checkerboard, new Material(DrawTechnique.Solid, ColorRgba.White, Texture.Checkerboard)); SolidWhite = ContentProvider.RequestContent <Material>(ContentPath_SolidWhite); InvertWhite = ContentProvider.RequestContent <Material>(ContentPath_InvertWhite); DualityIcon = ContentProvider.RequestContent <Material>(ContentPath_DualityIcon); DualityIconB = ContentProvider.RequestContent <Material>(ContentPath_DualityIconB); DualityLogoBig = ContentProvider.RequestContent <Material>(ContentPath_DualityLogoBig); DualityLogoMedium = ContentProvider.RequestContent <Material>(ContentPath_DualityLogoMedium); DualityLogoSmall = ContentProvider.RequestContent <Material>(ContentPath_DualityLogoSmall); Checkerboard = ContentProvider.RequestContent <Material>(ContentPath_Checkerboard); }
internal static void InitDefaultContent() { const string VirtualContentPath = ContentProvider.VirtualContentPath + "Texture:"; const string ContentPath_DualityIcon = VirtualContentPath + "DualityIcon"; const string ContentPath_DualityIconB = VirtualContentPath + "DualityIconB"; const string ContentPath_DualityLogoBig = VirtualContentPath + "DualityLogoBig"; const string ContentPath_DualityLogoMedium = VirtualContentPath + "DualityLogoMedium"; const string ContentPath_DualityLogoSmall = VirtualContentPath + "DualityLogoSmall"; const string ContentPath_White = VirtualContentPath + "White"; const string ContentPath_Checkerboard = VirtualContentPath + "Checkerboard"; ContentProvider.AddContent(ContentPath_DualityIcon, new Texture(Pixmap.DualityIcon)); ContentProvider.AddContent(ContentPath_DualityIconB, new Texture(Pixmap.DualityIconB)); ContentProvider.AddContent(ContentPath_DualityLogoBig, new Texture(Pixmap.DualityLogoBig)); ContentProvider.AddContent(ContentPath_DualityLogoMedium, new Texture(Pixmap.DualityLogoMedium)); ContentProvider.AddContent(ContentPath_DualityLogoSmall, new Texture(Pixmap.DualityLogoSmall)); ContentProvider.AddContent(ContentPath_White, new Texture(Pixmap.White)); ContentProvider.AddContent(ContentPath_Checkerboard, new Texture( Pixmap.Checkerboard, SizeMode.Default, TextureMagFilter.Nearest, TextureMinFilter.Nearest, TextureWrapMode.Repeat, TextureWrapMode.Repeat)); DualityIcon = ContentProvider.RequestContent <Texture>(ContentPath_DualityIcon); DualityIconB = ContentProvider.RequestContent <Texture>(ContentPath_DualityIconB); DualityLogoBig = ContentProvider.RequestContent <Texture>(ContentPath_DualityLogoBig); DualityLogoMedium = ContentProvider.RequestContent <Texture>(ContentPath_DualityLogoMedium); DualityLogoSmall = ContentProvider.RequestContent <Texture>(ContentPath_DualityLogoSmall); White = ContentProvider.RequestContent <Texture>(ContentPath_White); Checkerboard = ContentProvider.RequestContent <Texture>(ContentPath_Checkerboard); }
internal static void InitDefaultContent() { const string VirtualContentPath = ContentProvider.VirtualContentPath + "AudioData:"; const string ContentPath_Beep = VirtualContentPath + "Beep"; ContentProvider.AddContent(ContentPath_Beep, new AudioData(DefaultContent.Beep)); Beep = ContentProvider.RequestContent <AudioData>(ContentPath_Beep); }
internal static void InitDefaultContent() { const string VirtualContentPath = ContentProvider.VirtualContentPath + "Sound:"; const string ContentPath_Beep = VirtualContentPath + "Beep"; ContentProvider.AddContent(ContentPath_Beep, new Sound(AudioData.Beep)); Beep = ContentProvider.RequestContent <Sound>(ContentPath_Beep); }
public override bool ApplyNameToPath(out string conflictingPath) { conflictingPath = null; if (this.ReadOnly) { return(false); } string oldPath = this.NodePath; string oldDirName = Path.GetFileName(oldPath); string newPathBase = oldPath.Remove(oldPath.Length - oldDirName.Length, oldDirName.Length); string newPath = newPathBase + this.Text; bool equalsCaseInsensitive = newPath.ToUpper() == oldPath.ToUpper(); if (Directory.Exists(newPath) && !equalsCaseInsensitive) { conflictingPath = newPath; return(false); } try { if (equalsCaseInsensitive) { // As Windows doesn't properly apply renames that change character casing // and nothing else, we'll do a two-step rename using a temp path. string tempPath = newPath + "_sSJencn83rhfSHhfn3ns456omvmvs28fndDN84ns"; Directory.Move(oldPath, tempPath); Directory.Move(tempPath, newPath); } else { Directory.Move(oldPath, newPath); } } catch (Exception e) { Logs.Editor.WriteError("Error moving directory from '{0}' to '{1}': {2}", oldPath, newPath, e); return(false); } // Between performing the move event and it being received by the FileEventManager there will be a // short window of inconsistency where the existing Resource is still registered under its old name // but the file is already renamed to the new name. To prevent loading the Resource twice, we'll pre-register // it under its new name. foreach (ResourceNode resNode in this.NodesDeep.OfType <ResourceNode>()) { if (resNode.ResLink.ResWeak != null) { ContentProvider.AddContent(resNode.NodePath.Replace(oldPath, newPath), resNode.ResLink.ResWeak); } } this.NodePath = newPath; return(true); }
[Test] public void AddRemoveContent() { Pixmap resource = new Pixmap(); string alias = "Foo"; // Register the new resource with the provider ContentProvider.AddContent(alias, resource); // Expect it to be registered and show up in all relevant API calls Assert.IsTrue(ContentProvider.HasContent(alias)); Assert.AreSame(resource, ContentProvider.RequestContent <Pixmap>(alias).Res); Assert.AreSame(resource, ContentProvider.RequestContent(alias).Res); CollectionAssert.Contains(ContentProvider.GetLoadedContent <Pixmap>(), (ContentRef <Pixmap>)resource); // Expect it to not show up in specialized API calls that have nothing to do with the registered resource CollectionAssert.DoesNotContain(ContentProvider.GetDefaultContent <Pixmap>(), (ContentRef <Pixmap>)resource); CollectionAssert.DoesNotContain(ContentProvider.GetAvailableContent <Pixmap>(), (ContentRef <Pixmap>)resource); // Expect the resource itself to reference back to its new primary path Assert.AreEqual(alias, resource.Path); Assert.IsFalse(resource.IsRuntimeResource); // Un-register the new resource, but don't dispose it ContentProvider.RemoveContent(alias, false); // Expect the resource to still be valid Assert.IsFalse(resource.Disposed); // Expect it to no longer show up in any of the relevant API calls Assert.IsFalse(ContentProvider.HasContent(alias)); Assert.IsNull(ContentProvider.RequestContent <Pixmap>(alias).Res); Assert.IsNull(ContentProvider.RequestContent(alias).Res); CollectionAssert.DoesNotContain(ContentProvider.GetLoadedContent <Pixmap>(), (ContentRef <Pixmap>)resource); // Expect the resource itself to no longer back-reference to its former path Assert.IsNull(resource.Path); Assert.IsTrue(resource.IsRuntimeResource); // Re-register the resource, and immediately unregister-dispose it afterwards ContentProvider.AddContent(alias, resource); ContentProvider.RemoveContent(alias, true); // Expect the resource to be disposed and no longer show up in API calls Assert.IsTrue(resource.Disposed); Assert.IsFalse(ContentProvider.HasContent(alias)); Assert.IsNull(ContentProvider.RequestContent <Pixmap>(alias).Res); Assert.IsNull(ContentProvider.RequestContent(alias).Res); CollectionAssert.DoesNotContain(ContentProvider.GetLoadedContent <Pixmap>(), (ContentRef <Pixmap>)resource); // Expect the resource path to remain unchanged, in order to allow reload-recovery Assert.AreEqual(alias, resource.Path); Assert.IsFalse(resource.IsRuntimeResource); }
private static void RestoreTemporaryData(WorkerInterface workInterface, Stream strScene, Stream strData) { StreamReader strDataReader = new StreamReader(strData); string scenePath = strDataReader.ReadLine(); workInterface.MainForm.Invoke((Action)(() => workInterface.TempScene = Resource.Load <Scene>(strScene, scenePath))); if (!workInterface.TempScene.IsRuntimeResource) { // Register the reloaded Scene in the ContentProvider, if it wasn't just a temporary one. workInterface.MainForm.Invoke((Action)(() => ContentProvider.AddContent(scenePath, workInterface.TempScene))); } }
private void RetrieveResources() { if (!this.bigFont.IsAvailable) { Font bigFontRes = new Font(); bigFontRes.Family = System.Drawing.FontFamily.GenericSansSerif.Name; bigFontRes.Size = 32; bigFontRes.Kerning = true; bigFontRes.ReloadData(); ContentProvider.AddContent(bigFont.Path, bigFontRes); } }
internal static void InitDefaultContent() { const string VirtualContentPath = ContentProvider.VirtualContentPath + "VertexShader:"; const string ContentPath_Minimal = VirtualContentPath + "Minimal"; const string ContentPath_SmoothAnim = VirtualContentPath + "SmoothAnim"; ContentProvider.AddContent(ContentPath_Minimal, new VertexShader(DefaultRes.MinimalVert)); ContentProvider.AddContent(ContentPath_SmoothAnim, new VertexShader(DefaultRes.SmoothAnimVert)); Minimal = ContentProvider.RequestContent <VertexShader>(ContentPath_Minimal); SmoothAnim = ContentProvider.RequestContent <VertexShader>(ContentPath_SmoothAnim); }
internal static void InitDefaultContent() { const string VirtualContentPath = ContentProvider.VirtualContentPath + "Sound:"; const string ContentPath_Beep = VirtualContentPath + "Beep"; const string ContentPath_DroneLoop = VirtualContentPath + "DroneLoop"; const string ContentPath_LogoJingle = VirtualContentPath + "LogoJingle"; ContentProvider.AddContent(ContentPath_Beep, new Sound(AudioData.Beep)); ContentProvider.AddContent(ContentPath_DroneLoop, new Sound(AudioData.DroneLoop)); ContentProvider.AddContent(ContentPath_LogoJingle, new Sound(AudioData.LogoJingle)); Beep = ContentProvider.RequestContent <Sound>(ContentPath_Beep); DroneLoop = ContentProvider.RequestContent <Sound>(ContentPath_DroneLoop); LogoJingle = ContentProvider.RequestContent <Sound>(ContentPath_LogoJingle); }
public override bool ApplyNameToPath(out string conflictingPath) { conflictingPath = null; if (this.ReadOnly) { return(false); } string oldPath = this.NodePath; string oldDirName = Path.GetFileName(oldPath); string newPathBase = oldPath.Remove(oldPath.Length - oldDirName.Length, oldDirName.Length); string newPath = newPathBase + this.Text; bool equalsCaseInsensitive = newPath.ToUpper() == oldPath.ToUpper(); if (Directory.Exists(newPath) && !equalsCaseInsensitive) { conflictingPath = newPath; return(false); } if (equalsCaseInsensitive) { string tempPath = newPath + "_sSJencn83rhfSHhfn3ns456omvmvs28fndDN84ns"; Directory.Move(oldPath, tempPath); Directory.Move(tempPath, newPath); } else { Directory.Move(oldPath, newPath); } // Between performing the move event and it being received by the FileEventManager there will be a // short window of inconsistency where the existing Resource is still registered under its old name // but the file is already renamed to the new name. To prevent loading the Resource twice, we'll pre-register // it under its new name. foreach (ResourceNode resNode in this.NodesDeep.OfType <ResourceNode>()) { if (resNode.ResLink.ResWeak != null) { ContentProvider.AddContent(resNode.NodePath.Replace(oldPath, newPath), resNode.ResLink.ResWeak); } } this.NodePath = newPath; return(true); }
internal static void InitDefaultContent() { const string VirtualContentPath = ContentProvider.VirtualContentPath + "FragmentShader:"; const string ContentPath_Minimal = VirtualContentPath + "Minimal"; const string ContentPath_Picking = VirtualContentPath + "Picking"; const string ContentPath_SmoothAnim = VirtualContentPath + "SmoothAnim"; const string ContentPath_SharpMask = VirtualContentPath + "SharpAlpha"; ContentProvider.AddContent(ContentPath_Minimal, new FragmentShader(DefaultRes.MinimalFrag)); ContentProvider.AddContent(ContentPath_Picking, new FragmentShader(DefaultRes.PickingFrag)); ContentProvider.AddContent(ContentPath_SmoothAnim, new FragmentShader(DefaultRes.SmoothAnimFrag)); ContentProvider.AddContent(ContentPath_SharpMask, new FragmentShader(DefaultRes.SharpAlphaFrag)); Minimal = ContentProvider.RequestContent <FragmentShader>(ContentPath_Minimal); Picking = ContentProvider.RequestContent <FragmentShader>(ContentPath_Picking); SmoothAnim = ContentProvider.RequestContent <FragmentShader>(ContentPath_SmoothAnim); SharpAlpha = ContentProvider.RequestContent <FragmentShader>(ContentPath_SharpMask); }
internal static void InitDefaultContent() { const string VirtualContentPath = ContentProvider.VirtualContentPath + "Material:"; const string ContentPath_SolidWhite = VirtualContentPath + "SolidWhite"; const string ContentPath_SolidBlack = VirtualContentPath + "SolidBlack"; const string ContentPath_InvertWhite = VirtualContentPath + "InvertWhite"; const string ContentPath_Checkerboard = VirtualContentPath + "Checkerboard"; ContentProvider.AddContent(ContentPath_SolidWhite, new Material(DrawTechnique.Solid, ColorRgba.White)); ContentProvider.AddContent(ContentPath_SolidBlack, new Material(DrawTechnique.Solid, ColorRgba.Black)); ContentProvider.AddContent(ContentPath_InvertWhite, new Material(DrawTechnique.Invert, ColorRgba.White)); ContentProvider.AddContent(ContentPath_Checkerboard, new Material(DrawTechnique.Solid, ColorRgba.White, Texture.Checkerboard)); SolidWhite = ContentProvider.RequestContent <Material>(ContentPath_SolidWhite); SolidBlack = ContentProvider.RequestContent <Material>(ContentPath_SolidBlack); InvertWhite = ContentProvider.RequestContent <Material>(ContentPath_InvertWhite); Checkerboard = ContentProvider.RequestContent <Material>(ContentPath_Checkerboard); }
[Test] public void AddOverwritesContent() { Pixmap resourceA = new Pixmap(); Pixmap resourceB = new Pixmap(); string alias = "Foo"; // Register both first and second resource on the same alias ContentProvider.AddContent(alias, resourceA); ContentProvider.AddContent(alias, resourceB); // Expect the first resource to be disposed, and the second to be properly registered Assert.IsTrue(resourceA.Disposed); Assert.AreEqual(alias, resourceA.Path); Assert.IsTrue(ContentProvider.HasContent(alias)); Assert.AreSame(resourceB, ContentProvider.RequestContent <Pixmap>(alias).Res); Assert.AreSame(resourceB, ContentProvider.RequestContent(alias).Res); CollectionAssert.Contains(ContentProvider.GetLoadedContent <Pixmap>(), (ContentRef <Pixmap>)resourceB); }
internal static void InitDefaultContent() { const string VirtualContentPath = ContentProvider.VirtualContentPath + "ShaderProgram:"; const string ContentPath_Minimal = VirtualContentPath + "Minimal"; const string ContentPath_Picking = VirtualContentPath + "Picking"; const string ContentPath_SmoothAnim = VirtualContentPath + "SmoothAnim"; const string ContentPath_SharpMask = VirtualContentPath + "SharpAlpha"; ContentProvider.AddContent(ContentPath_Minimal, new ShaderProgram(VertexShader.Minimal, FragmentShader.Minimal)); ContentProvider.AddContent(ContentPath_Picking, new ShaderProgram(VertexShader.Minimal, FragmentShader.Picking)); ContentProvider.AddContent(ContentPath_SmoothAnim, new ShaderProgram(VertexShader.SmoothAnim, FragmentShader.SmoothAnim)); ContentProvider.AddContent(ContentPath_SharpMask, new ShaderProgram(VertexShader.Minimal, FragmentShader.SharpAlpha)); Minimal = ContentProvider.RequestContent <ShaderProgram>(ContentPath_Minimal); Picking = ContentProvider.RequestContent <ShaderProgram>(ContentPath_Picking); SmoothAnim = ContentProvider.RequestContent <ShaderProgram>(ContentPath_SmoothAnim); SharpAlpha = ContentProvider.RequestContent <ShaderProgram>(ContentPath_SharpMask); }
[Test] public void TransformHierarchyPrefabSceneBug(bool childPrefab) { // Tests for https://github.com/AdamsLair/duality/issues/53 string prefabName = "TestPrefab"; string parentName = "Parent"; string childName = "Child"; Vector3 parentPos = new Vector3(100, 0, 0); Vector3 childPos = new Vector3(200, 0, 0); // Create object hierarchy as described Scene scene = new Scene(); GameObject parent = new GameObject(parentName); parent.AddComponent <Transform>(); parent.Transform.Pos = parentPos; GameObject child = new GameObject(childName, parent); child.AddComponent <Transform>(); child.Transform.Pos = childPos; scene.AddObject(parent); // Create a Prefab from this hierarchy, make it available and link to it Prefab prefab = new Prefab(childPrefab ? child : parent); ContentProvider.AddContent(prefabName, prefab); (childPrefab ? child : parent).LinkToPrefab(prefab); // Save the Scene and reload it using (MemoryStream stream = new MemoryStream()) { scene.Save(stream); stream.Position = 0; scene = Resource.Load <Scene>(stream); } // Gather new object references parent = scene.FindGameObject(parentName); child = scene.FindGameObject(childName); // Check if positions are correct Assert.AreEqual(parentPos, parent.Transform.Pos); Assert.AreEqual(childPos, child.Transform.Pos); }
internal static void InitDefaultContent() { const string VirtualContentPath = ContentProvider.VirtualContentPath + "Texture:"; const string ContentPath_White = VirtualContentPath + "White"; const string ContentPath_Checkerboard = VirtualContentPath + "Checkerboard"; ContentProvider.AddContent(ContentPath_White, new Texture(Pixmap.White, keepPixmapDataResident: true)); ContentProvider.AddContent(ContentPath_Checkerboard, new Texture( Pixmap.Checkerboard, SizeMode.Default, TextureMagFilter.Nearest, TextureMinFilter.Nearest, TextureWrapMode.Repeat, TextureWrapMode.Repeat, keepPixmapDataResident: true)); White = ContentProvider.RequestContent <Texture>(ContentPath_White); Checkerboard = ContentProvider.RequestContent <Texture>(ContentPath_Checkerboard); }
[Test] public void RenameContent() { Pixmap resource = new Pixmap(); string aliasA = "Foo"; string aliasB = "Bar"; // Register the resource with one alias, then rename it to use another ContentProvider.AddContent(aliasA, resource); ContentProvider.RenameContent(aliasA, aliasB); // Expect the resource to use the second alias only, and the first to be unused Assert.AreEqual(aliasB, resource.Path); Assert.IsTrue(ContentProvider.HasContent(aliasB)); Assert.AreSame(resource, ContentProvider.RequestContent <Pixmap>(aliasB).Res); Assert.AreSame(resource, ContentProvider.RequestContent(aliasB).Res); Assert.IsFalse(ContentProvider.HasContent(aliasA)); Assert.IsNull(ContentProvider.RequestContent <Pixmap>(aliasA).Res); Assert.IsNull(ContentProvider.RequestContent(aliasA).Res); CollectionAssert.Contains(ContentProvider.GetLoadedContent <Pixmap>(), (ContentRef <Pixmap>)resource); }
private static void RestoreTemporaryData(WorkerInterface workInterface, Stream strScene, Stream strData) { StreamReader strDataReader = new StreamReader(strData); // Read back current scene path, account for Write/ReadLine transforming // null values into an empty string. string scenePath = strDataReader.ReadLine(); if (string.IsNullOrEmpty(scenePath)) { scenePath = null; } workInterface.MainForm.Invoke((Action)(() => workInterface.TempScene = Resource.Load <Scene>(strScene, scenePath))); if (!workInterface.TempScene.IsRuntimeResource) { // Register the reloaded Scene in the ContentProvider, if it wasn't just a temporary one. workInterface.MainForm.Invoke((Action)(() => ContentProvider.AddContent(scenePath, workInterface.TempScene))); } }
[Test] public void DisposeRemovesContent() { Pixmap resource = new Pixmap(); string alias = "Foo"; // Register the new resource with the provider ContentProvider.AddContent(alias, resource); // Dispose the resource resource.Dispose(); // Expect the resource to be disposed and no longer show up in API calls Assert.IsTrue(resource.Disposed); Assert.IsFalse(ContentProvider.HasContent(alias)); Assert.IsNull(ContentProvider.RequestContent <Pixmap>(alias).Res); Assert.IsNull(ContentProvider.RequestContent(alias).Res); CollectionAssert.DoesNotContain(ContentProvider.GetLoadedContent <Pixmap>(), (ContentRef <Pixmap>)resource); // Expect the resource path to remain unchanged, in order to allow reload-recovery Assert.AreEqual(alias, resource.Path); }
[Test] public void RemoveContentTree() { Pixmap resource1 = new Pixmap(); Pixmap resource2 = new Pixmap(); Pixmap resource3 = new Pixmap(); string dirA = "Foo"; string dirB = "Bar"; string alias1 = dirA + "/" + "Resource1"; string alias2 = dirA + "/" + "Resource2"; string alias3 = dirB + "/" + "Resource3"; // Register all resources, then remove one of their directories ContentProvider.AddContent(alias1, resource1); ContentProvider.AddContent(alias2, resource2); ContentProvider.AddContent(alias3, resource3); ContentProvider.RemoveContentTree(dirA, true); // Expect the resources from the removed directory to be disposed, but not any other resource Assert.AreEqual(alias1, resource1.Path); Assert.AreEqual(alias2, resource2.Path); Assert.AreEqual(alias3, resource3.Path); Assert.IsFalse(ContentProvider.HasContent(alias1)); Assert.IsFalse(ContentProvider.HasContent(alias2)); Assert.IsTrue(ContentProvider.HasContent(alias3)); Assert.IsNull(ContentProvider.RequestContent <Pixmap>(alias1).Res); Assert.IsNull(ContentProvider.RequestContent <Pixmap>(alias2).Res); Assert.AreSame(resource3, ContentProvider.RequestContent <Pixmap>(alias3).Res); Assert.IsNull(ContentProvider.RequestContent(alias1).Res); Assert.IsNull(ContentProvider.RequestContent(alias2).Res); Assert.AreSame(resource3, ContentProvider.RequestContent(alias3).Res); Assert.IsFalse(ContentProvider.HasContent(alias1)); Assert.IsFalse(ContentProvider.HasContent(alias2)); Assert.IsTrue(ContentProvider.HasContent(alias3)); CollectionAssert.DoesNotContain(ContentProvider.GetLoadedContent <Pixmap>(), (ContentRef <Pixmap>)resource1); CollectionAssert.DoesNotContain(ContentProvider.GetLoadedContent <Pixmap>(), (ContentRef <Pixmap>)resource2); CollectionAssert.Contains(ContentProvider.GetLoadedContent <Pixmap>(), (ContentRef <Pixmap>)resource3); }
[Test] public void RenameContentTree() { Pixmap resource1 = new Pixmap(); Pixmap resource2 = new Pixmap(); string dirA = "Foo"; string dirB = "Bar"; // Let's choose some tricky path names that would break when doing a path-unaware string replace string alias1A = PathOp.Combine(dirA, "Foo", "Resource1"); string alias2A = PathOp.Combine(dirA, "Bar", "Resource2"); string alias1B = PathOp.Combine(dirB, "Foo", "Resource1"); string alias2B = PathOp.Combine(dirB, "Bar", "Resource2"); // Register the resources with their first alias, then rename their directory ContentProvider.AddContent(alias1A, resource1); ContentProvider.AddContent(alias2A, resource2); ContentProvider.RenameContentTree(dirA, dirB); // Expect the resources to use their second alias only, and the first to be unused Assert.AreEqual(alias1B, resource1.Path); Assert.AreEqual(alias2B, resource2.Path); Assert.IsTrue(ContentProvider.HasContent(alias1B)); Assert.IsTrue(ContentProvider.HasContent(alias2B)); Assert.AreSame(resource1, ContentProvider.RequestContent <Pixmap>(alias1B).Res); Assert.AreSame(resource2, ContentProvider.RequestContent <Pixmap>(alias2B).Res); Assert.AreSame(resource1, ContentProvider.RequestContent(alias1B).Res); Assert.AreSame(resource2, ContentProvider.RequestContent(alias2B).Res); Assert.IsFalse(ContentProvider.HasContent(alias1A)); Assert.IsFalse(ContentProvider.HasContent(alias2A)); Assert.IsNull(ContentProvider.RequestContent <Pixmap>(alias1A).Res); Assert.IsNull(ContentProvider.RequestContent <Pixmap>(alias2A).Res); Assert.IsNull(ContentProvider.RequestContent(alias1A).Res); Assert.IsNull(ContentProvider.RequestContent(alias2A).Res); CollectionAssert.Contains(ContentProvider.GetLoadedContent <Pixmap>(), (ContentRef <Pixmap>)resource1); CollectionAssert.Contains(ContentProvider.GetLoadedContent <Pixmap>(), (ContentRef <Pixmap>)resource2); }
private void AddTempContent(string path, Resource res) { ContentProvider.AddContent(path, res); localTempContent.Add(res); }
private static void PerformPluginReload(ref WorkerInterface workInterface, ref bool fullRestart) { Stream strScene; Stream strData; string tempDir = Path.Combine(Path.GetTempPath(), "Duality"); string tempScenePath = Path.Combine(tempDir, "ReloadPluginBackup" + Scene.FileExt); string tempDataPath = Path.Combine(tempDir, "ReloadPluginBackup.dat"); if (!Directory.Exists(tempDir)) { Directory.CreateDirectory(tempDir); } if (!workInterface.RecoverMode) { // No full restart scheduled? Well, check if it should be! if (!fullRestart) { fullRestart = workInterface.ReloadSched.Any(asmFile => asmFile.EndsWith(".editor.dll", StringComparison.InvariantCultureIgnoreCase) || !DualityApp.IsLeafPlugin(asmFile)); } if (fullRestart) { strScene = File.Create(tempScenePath); strData = File.Create(tempDataPath); } else { strScene = new MemoryStream(1024 * 1024 * 10); strData = new MemoryStream(512); } // Save current data Log.Editor.Write("Saving data..."); StreamWriter strDataWriter = new StreamWriter(strData); strDataWriter.WriteLine(Scene.CurrentPath); strDataWriter.Flush(); workInterface.MainForm.Invoke((Action) delegate() { // Save all data DualityEditorApp.SaveAllProjectData(); Scene.Current.Save(strScene); }); workInterface.Progress += 0.4f; Thread.Sleep(20); if (!fullRestart) { // Reload core plugins Log.Editor.Write("Reloading core plugins..."); Log.Editor.PushIndent(); int count = workInterface.ReloadSched.Count; while (workInterface.ReloadSched.Count > 0) { string curPath = workInterface.ReloadSched[0]; workInterface.MainForm.Invoke((Action <string>)DualityApp.ReloadPlugin, curPath); workInterface.Progress += 0.15f / (float)count; Thread.Sleep(20); string xmlDocFile = curPath.Replace(".dll", ".xml"); if (File.Exists(xmlDocFile)) { workInterface.MainForm.Invoke((Action <string>)HelpSystem.LoadXmlCodeDoc, xmlDocFile); } workInterface.ReloadSched.RemoveAt(0); workInterface.ReloadDone.Add(curPath); workInterface.Progress += 0.05f / (float)count; } Log.Editor.PopIndent(); strScene.Seek(0, SeekOrigin.Begin); strData.Seek(0, SeekOrigin.Begin); } else { strScene.Close(); strData.Close(); bool debug = System.Diagnostics.Debugger.IsAttached; // Close old form and wait for it to be closed workInterface.Shutdown = true; workInterface.MainForm.Invoke(new CloseMainFormDelegate(CloseMainForm), workInterface.MainForm); while (workInterface.MainForm.Visible) { Thread.Sleep(20); } Process newEditor = Process.Start(Application.ExecutablePath, "recover" + (debug ? " debug" : "")); return; } } else { strScene = File.OpenRead(tempScenePath); strData = File.OpenRead(tempDataPath); workInterface.Progress = 0.6f; } // Reload data Log.Editor.Write("Restoring data..."); StreamReader strDataReader = new StreamReader(strData); string scenePath = strDataReader.ReadLine(); workInterface.TempScene = Resource.Load <Scene>(strScene, scenePath); if (!workInterface.TempScene.IsRuntimeResource) { // Register the reloaded Scene in the ContentProvider, if it wasn't just a temporary one. ContentProvider.AddContent(scenePath, workInterface.TempScene); } strScene.Close(); strData.Close(); workInterface.Progress = 1.0f; workInterface.Finished = true; }