示例#1
0
 private void fromXml(System.Xml.XmlReader r)
 {
     // Parse sub-elements
     while (r.Read())
     {
         if (r.NodeType == XmlNodeType.Whitespace)
         {
             continue;
         }
         // look for the start of an element
         if (r.NodeType == XmlNodeType.Element)
         {
             // parse that element
             // save the name of the element
             string elementName = r.Name;
             switch (elementName)
             {
             case "Color":
                 color = XmlHelperClass.ParseColorAttributes(r);
                 break;
             }
         }
         else if (r.NodeType == XmlNodeType.EndElement)
         {
             break;
         }
     }
 }
示例#2
0
        private void fromXml(XmlReader r)
        {
            // first parse the attributes
            for (int i = 0; i < r.AttributeCount; i++)
            {
                r.MoveToAttribute(i);

                // set the field in this object based on the element we just read
                switch (r.Name)
                {
                case "Far":
                    this.far = float.Parse(r.Value);
                    break;

                case "Near":
                    this.near = float.Parse(r.Value);
                    break;
                }
            }
            r.MoveToElement(); //Moves the reader back to the element node.

            // now parse the sub-elements
            while (r.Read())
            {
                // look for the start of an element
                if (r.NodeType == XmlNodeType.Element)
                {
                    // parse that element
                    // save the name of the element
                    string elementName = r.Name;
                    switch (elementName)
                    {
                    case "Color":
                        color = XmlHelperClass.ParseColorAttributes(r);
                        break;
                    }
                }
                else if (r.NodeType == XmlNodeType.EndElement)
                {
                    break;
                }
            }
        }
        private void fromXml(XmlReader r)
        {
            // Parse sub-elements
            parseOrientation(r);
            while (r.Read())
            {
                if (r.NodeType == XmlNodeType.Whitespace)
                {
                    continue;
                }
                // look for the start of an element
                if (r.NodeType == XmlNodeType.Element)
                {
                    // parse that element
                    // save the name of the element
                    string elementName = r.Name;
                    switch (elementName)
                    {
                    case "Direction":
                        this.lightDirection = XmlHelperClass.ParseVectorAttributes(r);
                        break;

                    case "Diffuse":
                        diffuse = XmlHelperClass.ParseColorAttributes(r);
                        break;

                    case "Specular":
                        specular = XmlHelperClass.ParseColorAttributes(r);
                        break;
                    }
                }
                else if (r.NodeType == XmlNodeType.EndElement)
                {
                    break;
                }
            }
        }
示例#4
0
        protected void FromXml(XmlReader r)
        {
            // first parse the attributes
            for (int i = 0; i < r.AttributeCount; i++)
            {
                r.MoveToAttribute(i);

                // set the field in this object based on the element we just read
                switch (r.Name)
                {
                case "DisplayOcean":
                    displayOcean = (r.Value == "True");
                    break;

                case "UseParams":
                    useParams = (r.Value == "True");
                    break;

                case "WaveHeight":
                    waveHeight = float.Parse(r.Value);
                    break;

                case "SeaLevel":
                    seaLevel = float.Parse(r.Value);
                    break;

                case "BumpScale":
                    bumpScale = float.Parse(r.Value);
                    break;

                case "BumpSpeedX":
                    bumpSpeedX = float.Parse(r.Value);
                    break;

                case "BumpSpeedZ":
                    bumpSpeedZ = float.Parse(r.Value);
                    break;

                case "TextureScaleX":
                    textureScaleX = float.Parse(r.Value);
                    break;

                case "TextureScaleZ":
                    textureScaleZ = float.Parse(r.Value);
                    break;

                default:
                    break;
                }
            }
            r.MoveToElement(); //Moves the reader back to the element node.

            if (!r.IsEmptyElement)
            {
                // now parse the sub-elements
                while (r.Read())
                {
                    // look for the start of an element
                    if (r.NodeType == XmlNodeType.Element)
                    {
                        // parse that element
                        // save the name of the element
                        string elementName = r.Name;
                        switch (elementName)
                        {
                        case "DeepColor":
                            deepColor = XmlHelperClass.ParseColorAttributes(r);
                            break;

                        case "ShallowColor":
                            shallowColor = XmlHelperClass.ParseColorAttributes(r);
                            break;
                        }
                    }
                    else if (r.NodeType == XmlNodeType.EndElement)
                    {
                        break;
                    }
                }
            }
            if (!displayOcean)
            {
                Axiom.SceneManagers.Multiverse.TerrainManager.Instance.ShowOcean = displayOcean;
            }
        }
        protected void FromXml(XmlReader r)
        {
            // first parse the attributes

            bool adjustHeightFound = false;

            for (int i = 0; i < r.AttributeCount; i++)
            {
                r.MoveToAttribute(i);

                // set the field in this object based on the element we just read
                switch (r.Name)
                {
                case "Name":
                    this.name = r.Value;
                    break;

                //case "Sound":
                //    this.soundAssetName = r.Value;
                //    break;
                case "TerrainOffset":
                    offsetFound   = true;
                    terrainOffset = float.Parse(r.Value);
                    break;

                case "AllowHeightAdjustment":
                    adjustHeightFound = true;
                    if (String.Equals(r.Value.ToLower(), "false"))
                    {
                        allowAdjustHeightOffTerrain = false;
                    }
                    break;

                case "Azimuth":
                    azimuth = float.Parse(r.Value);
                    break;

                case "Zenith":
                    zenith = float.Parse(r.Value);
                    break;

                case "WorldViewSelect":
                    worldViewSelectable = bool.Parse(r.Value);
                    break;
                }
            }
//            this.nameValuePairs = new NameValueObject();
            r.Read();
            do
            {
                if (r.NodeType == XmlNodeType.Whitespace)
                {
                    continue;
                }
                if (r.NodeType == XmlNodeType.Element)
                {
                    switch (r.Name)
                    {
                    case "Position":
                        this.position = XmlHelperClass.ParseVectorAttributes(r);
                        break;

                    case "Orientation":
                        orientation = XmlHelperClass.ParseQuaternion(r);
                        break;

                    case "NameValuePairs":
                        this.nameValuePairs = new NameValueObject(r);
                        break;

                    case "ParticleEffect":
                        ParticleEffect particle = new ParticleEffect(r, this, app);
                        Add(particle);
                        break;

                    case "SpawnGen":
                        SpawnGen mob = new SpawnGen(r, app, this);
                        Add(mob);
                        break;

                    case "Sound":
                        Sound sound = new Sound(r, this, app);
                        Add(sound);
                        break;

                    case "Color":
                        Color = XmlHelperClass.ParseColorAttributes(r);
                        break;
                    }
                }
                else if (r.NodeType == XmlNodeType.EndElement)
                {
                    break;
                }
            } while (r.Read());
            if (!adjustHeightFound)
            {
                allowAdjustHeightOffTerrain = true;
            }
            if (!offsetFound)
            {
                terrainOffset = this.Position.y - app.GetTerrainHeight(position.x, position.z);
            }

            if (orientation != null && disp != null)
            {
                disp.SetOrientation(orientation);
                foreach (IWorldObject obj in children)
                {
                    if (obj is ParticleEffect)
                    {
                        (obj as ParticleEffect).Orientation = this.orientation;
                    }
                }
            }
        }
示例#6
0
        protected void fromXML(XmlReader r)
        {
            bool offsetFound       = false;
            bool adjustHeightFound = false;

            for (int i = 0; i < r.AttributeCount; i++)
            {
                r.MoveToAttribute(i);
                switch (r.Name)
                {
                case "Name":
                    name = r.Value;
                    break;

                case "AttenuationRange":
                    attenuationRange = float.Parse(r.Value);
                    break;

                case "AttenuationConstant":
                    attenuationConstant = float.Parse(r.Value);
                    break;

                case "AttenuationLinear":
                    attenuationLinear = float.Parse(r.Value);
                    break;

                case "AttenuationQuadratic":
                    attenuationQuadratic = float.Parse(r.Value);
                    break;

                case "TerrainOffset":
                    offsetFound   = true;
                    terrainOffset = float.Parse(r.Value);
                    offsetFound   = true;
                    break;

                case "AllowHeightAdjustment":
                    adjustHeightFound = true;
                    if (String.Equals(r.Value.ToLower(), "false"))
                    {
                        allowAdjustHeightOffTerrain = false;
                    }
                    break;

                case "WorldViewSelect":
                    worldViewSelectable = bool.Parse(r.Value);
                    break;
                }
            }
            r.MoveToElement();
            while (r.Read())
            {
                if (r.NodeType == XmlNodeType.EndElement)
                {
                    break;
                }
                if (r.NodeType == XmlNodeType.Whitespace)
                {
                    continue;
                }
                switch (r.Name)
                {
                case "Position":
                    position = XmlHelperClass.ParseVectorAttributes(r);
                    break;

                case "Specular":
                    specular = XmlHelperClass.ParseColorAttributes(r);
                    break;

                case "Diffuse":
                    diffuse = XmlHelperClass.ParseColorAttributes(r);
                    break;
                }
            }
            if (!adjustHeightFound)
            {
                allowAdjustHeightOffTerrain = true;
            }
            if (!offsetFound)
            {
                terrainOffset = position.y - app.GetTerrainHeight(position.x, position.z);
            }
        }