private static void LayerDisposed(SceneLayer layer) { lock (staticMutationLock) { createdLayers.Remove(layer); UpdateEnabledLayers(); } }
public void ShouldCallEnableOnResourcesWhenConstructed() { SceneLayer testLayer = new SceneLayer("Test Layer"); TestLayerResource testResource = testLayer.GetResource <TestLayerResource>(); Assert.IsTrue(testResource.IsEnabled); testLayer.Dispose(); }
public void TestGetSetProperties() { // Define variables and constants const int PROP1 = 34; const string PROP2 = "Hello"; const bool PROP3 = false; const object PROP4 = null; SceneLayer testLayer = new SceneLayer("Test Layer"); // Set up context object prop3Added = null; testLayer.PropertySet += (layer, s, arg3) => { if (s == "prop3") { prop3Added = arg3; } }; testLayer.SetProperty("prop1", PROP1); testLayer["prop2"] = PROP2; testLayer.SetProperty("prop3", PROP3); testLayer["prop4"] = PROP4; // Execute Assert.AreEqual(PROP1, testLayer["prop1"]); Assert.AreEqual(PROP2, testLayer["prop2"]); Assert.AreEqual(PROP3, testLayer.GetProperty("prop3")); Assert.AreEqual(PROP4, testLayer.GetProperty("prop4")); Assert.AreEqual(PROP3, prop3Added); object prop1Removed = null; testLayer.PropertyRemoved += (layer, s, arg3) => { if (s == "prop1") { prop1Removed = arg3; } }; testLayer.RemoveProperty("prop1"); testLayer.RemoveProperty("prop3"); // Assert outcome Assert.AreEqual(PROP1, prop1Removed); Assert.IsFalse(testLayer.ContainsProperty("prop1")); Assert.AreEqual(PROP2, testLayer["prop2"]); Assert.AreEqual(PROP4, testLayer.GetProperty("prop4")); try { var obj = testLayer["prop3"]; Console.WriteLine(obj); Assert.Fail(); } catch (KeyNotFoundException) { } testLayer.Dispose(); }
/// <summary> /// Creates this scene layer resource, setting the given <see cref="OwningLayer"/>. /// </summary> /// <param name="owningLayer">The <see cref="SceneLayer"/> that this resource is being attached to. Never null.</param> protected SceneLayerResource(SceneLayer owningLayer) { if (owningLayer == null) { throw new ArgumentNullException("owningLayer"); } if (owningLayer.IsDisposed) { throw new ObjectDisposedException("owningLayer"); } OwningLayer = owningLayer; Logger.Debug("Created new " + this + "."); }
internal SceneLayer(string name) { if (name == null) { throw new ArgumentNullException("name"); } Name = name; lock (staticMutationLock) { for (uint i = 0; i < activeLayers.Length; ++i) { if (activeLayers[i] == null) { Index = i; goto slotFound; } } SceneLayer[] newMatArray = new SceneLayer[activeLayers.Length * 2]; Array.Copy(activeLayers, newMatArray, activeLayers.Length); Index = (uint)activeLayers.Length; activeLayers = newMatArray; slotFound : activeLayers[Index] = this; } foreach (Type resourceType in ReflectionUtils.GetChildTypes(typeof(SceneLayerResource))) { if (resourceType.IsInstantiable()) { ConstructorInfo sceneLayerCtor = resourceType.GetConstructor( BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public, null, new[] { typeof(SceneLayer) }, new[] { new ParameterModifier() } ); if (sceneLayerCtor == null) { Logger.Debug("Found instantiable scene layer resource type '" + resourceType.Name + "', but could not instantiate, " + "as no constructor with signature " + resourceType.Name + "(SceneLayer) was found."); } else { resources[resourceType] = (SceneLayerResource)sceneLayerCtor.Invoke(new object[] { this }); } } } OnLayerEnabled(); Logger.Debug("Created new " + this + "."); }
public void TestLayerCreatedEvent() { // Define variables and constants const string TEST_LAYER_NAME = "Test Layer"; SceneLayer createdLayer = null; // Set up context Scene.LayerCreated += layer => createdLayer = layer; // Execute Scene.CreateLayer(TEST_LAYER_NAME).Dispose(); // Assert outcome Assert.AreEqual(TEST_LAYER_NAME, createdLayer.Name); }
/// <summary> /// Creates a new <see cref="SceneLayer"/> and adds it to the scene. /// Scenes are created as disabled (e.g. <see cref="SceneLayer.IsEnabled"/> is false). /// </summary> /// <param name="layerName">The name for the layer. Must not be null.</param> /// <exception cref="InvalidOperationException">Thrown if a layer with the given name already exists in the scene.</exception> /// <returns>The newly created layer. The layer will also be added to the <see cref="AllLayers"/> collection, /// so you do not need to retain a reference to the returned object to keep it from becoming garbage.</returns> public static SceneLayer CreateLayer(string layerName) { lock (staticMutationLock) { if (createdLayers.Any(layer => layer.Name == layerName)) { throw new InvalidOperationException("An undisposed layer with the name '" + layerName + "' already exists in the scene."); } SceneLayer result = new SceneLayer(layerName); result.LayerDisposed += LayerDisposed; createdLayers.Add(result); if (layerCreated != null) { layerCreated(result); } UpdateEnabledLayers(); return(result); } }
public void TestEnableDisableDispose() { // Define variables and constants SceneLayer testLayer = new SceneLayer("Test Layer"); bool wasEnabled = false, wasDisabled = false, wasDisposed = false; // Set up context testLayer.LayerEnabled += layer => wasEnabled = true; testLayer.LayerDisabled += layer => wasDisabled = true; testLayer.LayerDisposed += layer => wasDisposed = true; // Execute testLayer.IsEnabled = false; testLayer.IsEnabled = true; testLayer.Dispose(); // Assert outcome Assert.IsTrue(wasEnabled); Assert.IsTrue(wasDisabled); Assert.IsTrue(wasDisposed); }
public void TestResources() { // Define variables and constants SceneLayer testLayer = new SceneLayer("Test Layer"); // Set up context TestLayerResource testResource = testLayer.GetResource <TestLayerResource>(); // Execute Assert.IsFalse(testResource.IsDisabled); testLayer.IsEnabled = false; Assert.IsTrue(testResource.IsDisabled); testLayer.IsEnabled = true; Assert.IsTrue(testResource.IsEnabled); Assert.AreEqual(testLayer.GetResource <TestLayerResource>(), testResource); Assert.IsFalse(testResource.IsDisposed); testLayer.Dispose(); Assert.IsTrue(testResource.IsDisposed); // Assert outcome }
public static SceneLayer GetLayerByIndex(uint index) { return(SceneLayer.GetLayerByIndex(index)); }
public TestLayerResource(SceneLayer owningLayer) : base(owningLayer) { }