public AddSpawnGenToMarkerCommand(WorldEditor appin, Waypoint parentin, int respawnTimein, uint numberOfSpawnsin, string templateNamein, float spawnRadiusin)
 {
     this.app = appin;
     this.parent = parentin;
     this.respawnTime = respawnTimein;
     this.numberOfSpawns = numberOfSpawnsin;
     this.templateName = templateNamein;
     this.spawnRadius = spawnRadiusin;
 }
 public AddWaypointParticleEffectCommand(Waypoint parent, WorldEditor app, string particleEffectName, float positionScale, float velocityScale, Quaternion orientation)
 {
     this.app = app;
     this.parent = parent;
     this.particleEffectName = particleEffectName;
     this.positionScale = positionScale;
     this.velocityScale = velocityScale;
     this.orientation = parent.Orientation;
 }
 public AddWaypointParticleEffectCommandFactory(WorldEditor worldEditor, Waypoint parentObject)
 {
     app = worldEditor;
     parent = parentObject;
 }
 public AddSpawnGenToMarkerCommandFactory(WorldEditor worldEditor, IWorldContainer parentObject)
 {
     this.app = worldEditor;
     this.parent = (Waypoint)parentObject;
 }
 public void Execute()
 {
     mark = new Waypoint(name, parent, app, pos, orient);
     parent.Add(mark);
 }
        protected void FromXml(XmlReader r, bool loadall)
        {
            string colfilename = "";
            string baseName = WorldFilePath.Substring(0, WorldFilePath.LastIndexOf('\\'));
            do
            {
                r.Read();
            } while ((r.NodeType != XmlNodeType.Element) || !(String.Equals(r.Name, "WorldObjectCollection")));

            while (r.Read())
            {
                // look for the start of an element
                if (r.NodeType == XmlNodeType.Whitespace)
                {
                    continue;
                }
                if (r.NodeType == XmlNodeType.EndElement)
                {
                    break;
                }
                if (r.NodeType == XmlNodeType.Element)
                {
                    switch (r.Name)
                    {
                        case "Road":
                            RoadObject road = new RoadObject(r, this, app);
                            Add(road);
                            break;

                        case "StaticObject":
                            StaticObject obj = new StaticObject(this, app, r);
                            Add(obj);
                            break;
                        case "Waypoint":
                            Waypoint wp = new Waypoint(r, this, app);
                            Add(wp);
                            break;
                        case "Boundary":
                            Boundary b = new Boundary(r, this, app);
                            Add(b);
                            break;
                        case "PointLight":
                            PointLight pl = new PointLight(app, this, app.Scene, r);
                            Add(pl);
                            break;
                        case "TerrainDecal":
                            TerrainDecal d = new TerrainDecal(app, this, r);
                            Add(d);
                            break;
                        case "WorldCollection":
                            string collectionName = null;
                            colfilename = "";
                            for (int i = 0; i < r.AttributeCount; i++)
                            {
                                r.MoveToAttribute(i);
                                switch (r.Name)
                                {
                                    case "Name":
                                        collectionName = r.Value;
                                        break;
                                    case "Filename":
                                        colfilename = r.Value;
                                        break;
                                }
                            }
                            baseName = this.Path;
                            if (!loadall)
                            {
                                if (colfilename != "")
                                {
                                    if (colfilename.EndsWith("~.mwc"))
                                    {
                                        string autofilepath = String.Format("{0}\\{1}", baseName, colfilename);
                                        string normalfilepath = String.Format("{0}\\{1}", baseName, colfilename.Remove(colfilename.LastIndexOf("~"), 1));
                                        if ((File.Exists(autofilepath) && File.Exists(normalfilepath) &&
                                            (new FileInfo(autofilepath)).LastWriteTime < (new FileInfo(normalfilepath).LastWriteTime))
                                            || (!File.Exists(autofilepath) && File.Exists(normalfilepath)))
                                        {
                                            colfilename = colfilename.Remove(filename.LastIndexOf("~"), 1);
                                        }
                                    }
                                    XmlReader childReader = XmlReader.Create(String.Format("{0}\\{1}", baseName, colfilename), app.XMLReaderSettings);
                                    WorldObjectCollection coll = new WorldObjectCollection(childReader, collectionName, this, app, baseName, false);
                                    while (colfilename.Contains("~"))
                                    {
                                        colfilename = colfilename.Remove(colfilename.LastIndexOf("~"),1);
                                    }
                                    coll.Filename = colfilename;
                                    Add(coll);
                                    childReader.Close();
                                }
                                else
                                {
                                    XmlReader childReader = XmlReader.Create(String.Format("{0}\\{1}.mwc", baseName, collectionName), app.XMLReaderSettings);
                                    WorldObjectCollection coll = new WorldObjectCollection(childReader, collectionName, this, app, baseName, false);
                                    coll.Filename = collectionName + ".mwc";
                                    Add(coll);
                                    childReader.Close();
                                }
                            }
                            else
                            {
                                if (colfilename != "")
                                {
                                    if (colfilename.EndsWith("~.mwc"))
                                    {
                                        string autofilepath = String.Format("{0}\\{1}", baseName, colfilename);
                                        string normalfilepath = String.Format("{0}\\{1}", baseName, colfilename.Remove(filename.LastIndexOf("~"), 1));
                                        if ((File.Exists(autofilepath) && File.Exists(normalfilepath) &&
                                            (new FileInfo(autofilepath)).LastWriteTime < (new FileInfo(normalfilepath).LastWriteTime))
                                            || (!File.Exists(autofilepath) && File.Exists(normalfilepath)))
                                        {
                                            colfilename = colfilename.Remove(colfilename.LastIndexOf("~"), 1);
                                        }
                                    }
                                    XmlReader childReader = XmlReader.Create(String.Format("{0}\\{1}", baseName, colfilename), app.XMLReaderSettings);
                                    WorldObjectCollection coll = new WorldObjectCollection(childReader, collectionName, this, app, baseName);
                                    while (colfilename.Contains("~"))
                                    {
                                        colfilename = colfilename.Remove(colfilename.LastIndexOf("~"), 1);
                                    }
                                    coll.Filename = colfilename;
                                    Add(coll);
                                    childReader.Close();
                                }
                                else
                                {
                                    XmlReader childReader = XmlReader.Create(String.Format("{0}\\{1}.mwc", baseName, collectionName), app.XMLReaderSettings);
                                    WorldObjectCollection coll = new WorldObjectCollection(childReader, collectionName, this, app, baseName);
                                    coll.Filename = collectionName + ".mwc";
                                    Add(coll);
                                    childReader.Close();
                                }
                            }

                            r.MoveToElement();

                            break;
                    }
                }
            }

            while(filename.Contains("~"))
            {
                filename = filename.Remove(filename.IndexOf("~"), 1);
            }
        }
 public void Execute()
 {
     if (!cancelled)
     {
         float scale = app.Config.MarkerPointScale;
         Vector3 scaleVec = new Vector3(scale, scale, scale);
         Vector3 rotVec = new Vector3(0, rotation, 0);
         if (placing)
         {
             // we need to place the object (which is handled asynchronously) before we can create it
             dragObject = new DisplayObject(name, app,"Drag", app.Scene, meshName, location, scaleVec, rotVec, null);
             dragObject.MaterialName = "directional_marker.orange";
             dragObject.ScaleWithCameraDistance = true;
             // set up mouse capture and callbacks for placing the object
             new DragHelper(app, new DragComplete(DragCallback), dragObject);
         }
         else
         {
             if (waypoint == null)
             {
                 // object has already been placed, so create it now
                 waypoint = new Waypoint(name, parent, app, location, rotVec);
             }
             parent.Add(waypoint);
             for (int i = app.SelectedObject.Count - 1; i >= 0; i--)
             {
                 app.SelectedObject[i].Node.UnSelect();
             }
             if (waypoint.Node != null)
             {
                 waypoint.Node.Select();
             }
         }
     }
 }
        private bool DragCallback(bool accept, Vector3 loc)
        {
            placing = false;

            dragObject.Dispose();

            if (accept)
            {
                location = loc;
                Vector3 rotVec = new Vector3(0, rotation, 0);
                waypoint = new Waypoint(name, parent, app, location, rotVec);
                parent.Add(waypoint);

                for (int i = app.SelectedObject.Count - 1; i >= 0; i--)
                {
                    app.SelectedObject[i].Node.UnSelect();
                }
                if (waypoint.Node != null)
                {
                    waypoint.Node.Select();
                }
            }
            else
            {
                cancelled = true;
            }

            return true;
        }
        protected void LoadOldWaypoint(XmlNode node, WorldObjectCollection collection)
        {
            string name = null;
            Vector3 pos = Vector3.Zero;

            // get everything but submeshes first
            foreach (XmlNode childNode in node.ChildNodes)
            {
                switch (childNode.Name)
                {
                    case "Name":
                        name = childNode.InnerText;
                        break;
                    case "Position":
                        pos = GetVectorAttributes(childNode);
                        break;
                    default:
                        break;
                }
            }

            Waypoint waypoint = new Waypoint(name, collection, this, pos, Vector3.Zero);
            collection.Add(waypoint);
        }
 public void Clone(IWorldContainer copyParent)
 {
     Waypoint clone = new Waypoint(name, copyParent, app, position, rotation);
     clone.Azimuth = azimuth;
     clone.Zenith = zenith;
     clone.TerrainOffset = terrainOffset;
     clone.AllowAdjustHeightOffTerrain = allowAdjustHeightOffTerrain;
     clone.NameValue = new NameValueObject(this.NameValue);
     foreach (IWorldObject child in children)
     {
         child.Clone(clone);
     }
     copyParent.Add(clone);
 }
 public DirectionAndMarker(CameraDirection dir, Waypoint obj)
 {
     this.dir = dir;
     this.obj = obj;
 }