Example #1
0
        private void UpdateSplines()
        {
            if (mCurrentSpline != null)
            {
                mCurrentSpline.CalculateVelocities();
                mCurrentSpline.CalculateAccelerations();

                mCurrentSpline.Sort();
            }


            foreach (Spline spline in EditorData.SplineList)
            {
                spline.PointFrequency = .15f;
                spline.UpdateShapes();
            }
        }
Example #2
0
        /// <summary>
        ///  Creates a runtime object and adds the LoadedFile to the element.
        /// </summary>
        /// <param name="objectToLoad"></param>
        /// <param name="container"></param>
        /// <param name="elementRuntime"></param>
        /// <param name="objectType"></param>
        /// <param name="objectJustLoaded"></param>
        /// <param name="newElementRuntime"></param>
        /// <param name="toAddTo"></param>
        /// <param name="layerToAddTo"></param>
        /// <param name="rfs"></param>
        /// <param name="pullsFromEntireNamedObject"></param>
        /// <returns></returns>
        private static LoadedFile CreateRuntimeObjectForNamedObject(NamedObjectSave objectToLoad,
                                                                    IElement container, ElementRuntime elementRuntime, string objectType,
                                                                    LoadedFile objectJustLoaded,
                                                                    ElementRuntime newElementRuntime,
                                                                    object toAddTo,
                                                                    Layer layerToAddTo, ReferencedFileSave rfs, bool pullsFromEntireNamedObject)
        {
            var fileName = ElementRuntime.ContentDirectory + objectToLoad.SourceFile;


            bool       shouldClone = rfs != null && (rfs.IsSharedStatic && !(container is ScreenSave)) && !pullsFromEntireNamedObject;
            LoadedFile toReturn    = null;

            // This could have a ( in the name in a file like .scnx, so use the last (
            //int indexOfType = objectToLoad.SourceName.IndexOf("(");
            int indexOfType = objectToLoad.SourceName.LastIndexOf("(");

            string objectName = objectToLoad.SourceName.Substring(0, indexOfType - 1);

            switch (objectType)
            {
            case "Scene":
            {
                Scene scene = objectJustLoaded.RuntimeObject as Scene;

                foreach (Text text in scene.Texts)
                {
                    text.AdjustPositionForPixelPerfectDrawing = true;
                    if (ObjectFinder.Self.GlueProject.UsesTranslation)
                    {
                        text.DisplayText = LocalizationManager.Translate(text.DisplayText);
                    }
                }

                if (shouldClone)
                {
                    scene = scene.Clone();
                    elementRuntime.EntireScenes.Add(objectToLoad.SourceFile, scene);

                    var loadedFile = new LoadedFile();
                    loadedFile.RuntimeObject      = scene;
                    loadedFile.FilePath           = objectToLoad.SourceFile;
                    loadedFile.ReferencedFileSave = rfs;
                    toReturn = loadedFile;

                    newElementRuntime.ReferencedFileRuntimeList.Add(loadedFile);

                    scene.AddToManagers(layerToAddTo);
                }
            }
            break;


            case "Sprite":
            {
                Sprite loadedSprite = null;
                Scene  scene        = objectJustLoaded.RuntimeObject as Scene;
                if (scene != null)
                {
                    loadedSprite = scene.Sprites.FindByName(objectName);
                }

                if (loadedSprite == null)
                {
                    System.Windows.Forms.MessageBox.Show("There is a missing Sprite called\n\n" + objectName + "\n\n" +
                                                         "in the object\n\n" + elementRuntime.Name + "\n\n" +
                                                         "This probably happened if someone changed the name of a Sprite in a .scnx file but didn't update " +
                                                         "the associated object in Glue", "Missing Sprite");
                }
                else
                {
                    if (shouldClone)
                    {
                        loadedSprite = loadedSprite.Clone();
                        (toAddTo as Scene).Sprites.Add(loadedSprite);
                        SpriteManager.AddToLayer(loadedSprite, layerToAddTo);

                        var loadedFile = new LoadedFile();

                        loadedFile.RuntimeObject      = loadedSprite;
                        loadedFile.FilePath           = objectJustLoaded.FilePath;
                        loadedFile.DataModel          = objectJustLoaded.DataModel;
                        loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;

                        toReturn = loadedFile;
                    }
                }
            }
            break;


            case "SpriteFrame":
            {
                Scene       scene             = objectJustLoaded.RuntimeObject as Scene;
                SpriteFrame loadedSpriteFrame = scene.SpriteFrames.FindByName(objectName);
                if (loadedSpriteFrame != null)
                {
                    if (shouldClone)
                    {
                        loadedSpriteFrame = loadedSpriteFrame.Clone();
                        (toAddTo as Scene).SpriteFrames.Add(loadedSpriteFrame);
                        SpriteManager.AddToLayer(loadedSpriteFrame, layerToAddTo);

                        var loadedFile = new LoadedFile();

                        loadedFile.RuntimeObject      = loadedSpriteFrame;
                        loadedFile.FilePath           = objectJustLoaded.FilePath;
                        loadedFile.DataModel          = objectJustLoaded.DataModel;
                        loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
                        toReturn = loadedFile;
                    }
                }
            }
            break;

            case "SpriteGrid":
            {
                Scene      scene      = objectJustLoaded.RuntimeObject as Scene;
                SpriteGrid spriteGrid = null;
                for (int i = 0; i < scene.SpriteGrids.Count; i++)
                {
                    if (scene.SpriteGrids[i].Name == objectName)
                    {
                        spriteGrid = scene.SpriteGrids[i];
                        break;
                    }
                }
                if (spriteGrid != null)
                {
                    if (shouldClone)
                    {
                        spriteGrid = spriteGrid.Clone();
                        (toAddTo as Scene).SpriteGrids.Add(spriteGrid);
                        spriteGrid.Layer = layerToAddTo;
                        spriteGrid.PopulateGrid();
                        spriteGrid.RefreshPaint();
                        spriteGrid.Manage();

                        var loadedFile = new LoadedFile();

                        loadedFile.RuntimeObject      = spriteGrid;
                        loadedFile.FilePath           = objectJustLoaded.FilePath;
                        loadedFile.DataModel          = objectJustLoaded.DataModel;
                        loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
                        toReturn = loadedFile;
                    }
                }
            }
            break;

            case "Text":
            {
                Scene scene = objectJustLoaded.RuntimeObject as Scene;

                Text loadedText = scene.Texts.FindByName(objectName);
                if (loadedText != null)
                {
                    if (shouldClone)
                    {
                        loadedText = loadedText.Clone();
                        (toAddTo as Scene).Texts.Add(loadedText);

                        TextManager.AddToLayer(loadedText, layerToAddTo);

                        var loadedFile = new LoadedFile();

                        loadedFile.RuntimeObject      = loadedText;
                        loadedFile.FilePath           = objectJustLoaded.FilePath;
                        loadedFile.DataModel          = objectJustLoaded.DataModel;
                        loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
                        toReturn = loadedFile;
                    }
                    loadedText.AdjustPositionForPixelPerfectDrawing = true;
                    if (LocalizationManager.HasDatabase)
                    {
                        loadedText.DisplayText = LocalizationManager.Translate(loadedText.DisplayText);
                    }
                }
            }
            break;

            case "ShapeCollection":
            {
                ShapeCollection shapeCollection = objectJustLoaded.RuntimeObject as ShapeCollection;

                if (shouldClone)
                {
                    shapeCollection = shapeCollection.Clone();
                    elementRuntime.EntireShapeCollections.Add(objectToLoad.SourceFile, shapeCollection);

                    newElementRuntime.ReferencedFileRuntimeList.LoadedShapeCollections.Add(shapeCollection);

                    shapeCollection.AddToManagers(layerToAddTo);

                    var loadedFile = new LoadedFile();

                    loadedFile.RuntimeObject      = shapeCollection;
                    loadedFile.FilePath           = objectJustLoaded.FilePath;
                    loadedFile.DataModel          = objectJustLoaded.DataModel;
                    loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
                    toReturn = loadedFile;
                }
                // Most cases are handled below in an AttachTo method, but
                // ShapeCollection isn't a PositionedObject so we have to do it manually here
                if (objectToLoad.AttachToContainer)
                {
                    shapeCollection.AttachTo(elementRuntime, true);
                }
            }
            break;

            case "AxisAlignedCube":
            {
                ShapeCollection shapeCollection       = objectJustLoaded.RuntimeObject as ShapeCollection;
                AxisAlignedCube loadedAxisAlignedCube = shapeCollection.AxisAlignedCubes.FindByName(objectName);


                if (shouldClone)
                {
                    loadedAxisAlignedCube = loadedAxisAlignedCube.Clone();
                    (toAddTo as ShapeCollection).AxisAlignedCubes.Add(loadedAxisAlignedCube);
                    ShapeManager.AddToLayer(loadedAxisAlignedCube, layerToAddTo);

                    var loadedFile = new LoadedFile();

                    loadedFile.RuntimeObject      = loadedAxisAlignedCube;
                    loadedFile.FilePath           = objectJustLoaded.FilePath;
                    loadedFile.DataModel          = objectJustLoaded.DataModel;
                    loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
                    toReturn = loadedFile;
                }
            }
            break;


            case "AxisAlignedRectangle":
            {
                ShapeCollection      shapeCollection            = objectJustLoaded.RuntimeObject as ShapeCollection;
                AxisAlignedRectangle loadedAxisAlignedRectangle = shapeCollection.AxisAlignedRectangles.FindByName(objectName);


                if (shouldClone)
                {
                    loadedAxisAlignedRectangle = loadedAxisAlignedRectangle.Clone();
                    (toAddTo as ShapeCollection).AxisAlignedRectangles.Add(loadedAxisAlignedRectangle);
                    ShapeManager.AddToLayer(loadedAxisAlignedRectangle, layerToAddTo);

                    var loadedFile = new LoadedFile();

                    loadedFile.RuntimeObject      = loadedAxisAlignedRectangle;
                    loadedFile.FilePath           = objectJustLoaded.FilePath;
                    loadedFile.DataModel          = objectJustLoaded.DataModel;
                    loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
                    toReturn = loadedFile;
                }
            }
            break;

            case "Circle":
            {
                ShapeCollection shapeCollection = objectJustLoaded.RuntimeObject as ShapeCollection;
                Circle          loadedCircle    = shapeCollection.Circles.FindByName(objectName);


                if (shouldClone)
                {
                    loadedCircle = loadedCircle.Clone();
                    (toAddTo as ShapeCollection).Circles.Add(loadedCircle);
                    ShapeManager.AddToLayer(loadedCircle, layerToAddTo);

                    var loadedFile = new LoadedFile();

                    loadedFile.RuntimeObject      = loadedCircle;
                    loadedFile.FilePath           = objectJustLoaded.FilePath;
                    loadedFile.DataModel          = objectJustLoaded.DataModel;
                    loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
                    toReturn = loadedFile;
                }
            }
            break;

            case "Polygon":
            {
                ShapeCollection shapeCollection = objectJustLoaded.RuntimeObject as ShapeCollection;
                Polygon         loadedPolygon   = shapeCollection.Polygons.FindByName(objectName);


                if (shouldClone)
                {
                    loadedPolygon = loadedPolygon.Clone();
                    (toAddTo as ShapeCollection).Polygons.Add(loadedPolygon);
                    ShapeManager.AddToLayer(loadedPolygon, layerToAddTo);

                    var loadedFile = new LoadedFile();

                    loadedFile.RuntimeObject      = loadedPolygon;
                    loadedFile.FilePath           = objectJustLoaded.FilePath;
                    loadedFile.DataModel          = objectJustLoaded.DataModel;
                    loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
                    toReturn = loadedFile;
                }
            }
            break;

            case "Sphere":
            {
                ShapeCollection shapeCollection = objectJustLoaded.RuntimeObject as ShapeCollection;
                Sphere          loadedSphere    = shapeCollection.Spheres.FindByName(objectName);


                if (shouldClone)
                {
                    loadedSphere = loadedSphere.Clone();
                    (toAddTo as ShapeCollection).Spheres.Add(loadedSphere);
                    ShapeManager.AddToLayer(loadedSphere, layerToAddTo);

                    var loadedFile = new LoadedFile();

                    loadedFile.RuntimeObject      = loadedSphere;
                    loadedFile.FilePath           = objectJustLoaded.FilePath;
                    loadedFile.DataModel          = objectJustLoaded.DataModel;
                    loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
                    toReturn = loadedFile;
                }
            }
            break;

            case "Capsule2D":
            {
                ShapeCollection shapeCollection = objectJustLoaded.RuntimeObject as ShapeCollection;
                Capsule2D       loadedCapsule2D = shapeCollection.Capsule2Ds.FindByName(objectName);


                if (shouldClone)
                {
                    loadedCapsule2D = loadedCapsule2D.Clone();
                    (toAddTo as ShapeCollection).Capsule2Ds.Add(loadedCapsule2D);
                    ShapeManager.AddToLayer(loadedCapsule2D, layerToAddTo);

                    var loadedFile = new LoadedFile();

                    loadedFile.RuntimeObject      = loadedCapsule2D;
                    loadedFile.FilePath           = objectJustLoaded.FilePath;
                    loadedFile.DataModel          = objectJustLoaded.DataModel;
                    loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
                    toReturn = loadedFile;
                }
            }
            break;

            case "Emitter":
            {
                EmitterList emitterList   = objectJustLoaded.RuntimeObject as EmitterList;
                Emitter     loadedEmitter = emitterList.FindByName(objectName);

                if (shouldClone && loadedEmitter != null)
                {
                    loadedEmitter = loadedEmitter.Clone();
                    (toAddTo as EmitterList).Add(loadedEmitter);
                    SpriteManager.AddEmitter(loadedEmitter, layerToAddTo);

                    var loadedFile = new LoadedFile();

                    loadedFile.RuntimeObject      = loadedEmitter;
                    loadedFile.FilePath           = objectJustLoaded.FilePath;
                    loadedFile.DataModel          = objectJustLoaded.DataModel;
                    loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
                    toReturn = loadedFile;
                }
            }
            break;

            case "EmitterList":
            {
                EmitterList emitterList = objectJustLoaded.RuntimeObject as EmitterList;

                if (shouldClone && emitterList != null)
                {
                    emitterList = emitterList.Clone();

                    foreach (var item in emitterList)
                    {
                        SpriteManager.AddEmitter(item);
                    }

                    var loadedFile = new LoadedFile();

                    loadedFile.RuntimeObject      = emitterList;
                    loadedFile.FilePath           = objectJustLoaded.FilePath;
                    loadedFile.DataModel          = objectJustLoaded.DataModel;
                    loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
                    toReturn = loadedFile;
                }
            }
            break;

            case "NodeNetwork":
            {
                NodeNetwork nodeNetwork = objectJustLoaded.RuntimeObject as NodeNetwork;

                if (shouldClone)
                {
                    nodeNetwork = nodeNetwork.Clone();

                    elementRuntime.EntireNodeNetworks.Add(objectToLoad.SourceFile, nodeNetwork);

                    newElementRuntime.ReferencedFileRuntimeList.LoadedNodeNetworks.Add(nodeNetwork);

                    var loadedFile = new LoadedFile();

                    loadedFile.RuntimeObject      = nodeNetwork;
                    loadedFile.FilePath           = objectJustLoaded.FilePath;
                    loadedFile.DataModel          = objectJustLoaded.DataModel;
                    loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
                    toReturn = loadedFile;
                }
            }
            break;

            case "SplineList":
            {
                SplineList splineList = objectJustLoaded.RuntimeObject as SplineList;

                if (shouldClone)
                {
                    splineList = splineList.Clone();

                    elementRuntime.EntireSplineLists.Add(splineList.Name, splineList);

                    foreach (var spline in splineList)
                    {
                        spline.CalculateVelocities();
                        spline.CalculateAccelerations();
                    }

                    splineList.AddToManagers();


                    splineList[0].UpdateShapes();

                    var loadedFile = new LoadedFile();

                    loadedFile.RuntimeObject      = splineList;
                    loadedFile.FilePath           = objectJustLoaded.FilePath;
                    loadedFile.DataModel          = objectJustLoaded.DataModel;
                    loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
                    toReturn = loadedFile;
                }
            }
            break;

            case "Spline":
            {
                SplineList splineList = objectJustLoaded.RuntimeObject as SplineList;
                Spline     spline     = splineList.FirstOrDefault(item => item.Name == objectName);


                if (shouldClone && spline != null)
                {
                    spline = spline.Clone();
                    (toAddTo as SplineList).Add(spline);

                    // Eventually support layers?
                    //ShapeManager.AddToLayer(spline, layerToAddTo);

                    var loadedFile = new LoadedFile();

                    loadedFile.RuntimeObject      = spline;
                    loadedFile.FilePath           = objectJustLoaded.FilePath;
                    loadedFile.DataModel          = objectJustLoaded.DataModel;
                    loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
                    toReturn = loadedFile;
                }
                spline.CalculateVelocities();
                spline.CalculateAccelerations();
            }
            break;
            }

            if (toReturn == null)
            {
                foreach (var manager in ReferencedFileRuntimeList.FileManagers)
                {
                    var objectFromFile = manager.TryGetObjectFromFile(elementRuntime.ReferencedFileRuntimeList.LoadedRfses, rfs, objectType, objectName);

                    if (objectFromFile != null)
                    {
                        var runtimeObject = objectFromFile;

                        var loadedFile = new LoadedFile();

                        loadedFile.RuntimeObject      = runtimeObject;
                        loadedFile.FilePath           = objectJustLoaded.FilePath;
                        loadedFile.DataModel          = objectJustLoaded.DataModel;
                        loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
                        toReturn = loadedFile;


                        break;
                    }
                }
            }


            if (toReturn != null && objectToLoad.AttachToContainer)
            {
                if (toReturn.RuntimeObject is PositionedObject)
                {
                    // If the object is already attached to something, that means it
                    // came from a file, so we don't want to re-attach it.
                    PositionedObject asPositionedObject = toReturn.RuntimeObject as PositionedObject;
                    if (asPositionedObject.Parent == null)
                    {
                        asPositionedObject.AttachTo(elementRuntime, true);
                    }
                }
                else if (toReturn.RuntimeObject is Scene)
                {
                    ((Scene)toReturn.RuntimeObject).AttachAllDetachedTo(elementRuntime, true);
                }
                else if (toReturn.RuntimeObject is ShapeCollection)
                {
                    ((ShapeCollection)toReturn.RuntimeObject).AttachAllDetachedTo(elementRuntime, true);
                }
            }


            return(toReturn);
        }
Example #3
0
        internal void AddSplinePoint()
        {
            Spline spline = EditorData.EditorLogic.CurrentSpline;

            if (spline == null)
            {
                MessageBox.Show("Select a spline to add points to");
            }
            else
            {
                SplinePoint newSplinePoint = new SplinePoint();
                if (spline.Count > 1)
                {
                    SplinePoint pointBefore = spline[spline.Count - 1];

                    newSplinePoint.Time = pointBefore.Time + 1;

                    if (spline.Count == 1)
                    {
                        newSplinePoint.Position    = pointBefore.Position;
                        newSplinePoint.Position.X += 30 / SpriteManager.Camera.PixelsPerUnitAt(newSplinePoint.Position.Z);
                    }
                    else
                    {
                        SplinePoint pointBeforePointBefore = spline[spline.Count - 2];

                        Vector3 difference = pointBefore.Position - pointBeforePointBefore.Position;

                        if (difference == Vector3.Zero)
                        {
                            newSplinePoint.Position    = pointBefore.Position;
                            newSplinePoint.Position.X += 30 / Camera.Main.PixelsPerUnitAt(0);
                        }
                        else
                        {
                            newSplinePoint.Position = pointBefore.Position + difference;
                        }
                    }
                }
                else
                {
                    newSplinePoint.Position.X = SpriteManager.Camera.X;
                    newSplinePoint.Position.Y = SpriteManager.Camera.Y;

                    if (spline.Count > 0)
                    {
                        newSplinePoint.Time = spline[0].Time + 1;

                        newSplinePoint.Position    = spline[0].Position;
                        newSplinePoint.Position.X += 30 / Camera.Main.PixelsPerUnitAt(0);
                    }
                }
                spline.Add(newSplinePoint);
                spline.CalculateVelocities();
                spline.CalculateAccelerations();
                spline.CalculateDistanceTimeRelationships(.1f);

                GuiData.PropertyGrid.Refresh();
                GuiData.SplineListDisplay.UpdateToList();
            }
            //if (AfterNewPointAdded != null)
            //{
            //    AfterNewPointAdded(this);
            //}
        }