public GlobalAmbientLight(IWorldContainer parentContainer,WorldEditor worldEditor, SceneManager sceneManager, ColorEx lightColor)
 {
     this.parent = parentContainer;
     this.app = worldEditor;
     this.scene = sceneManager;
     this.color = lightColor;
 }

			public Element( Vector3 position, float width, float texCoord, ColorEx color )
			{
				this.position = position;
				this.width = width;
				this.texCoord = texCoord;
				this.color = color;
			}

			public Element( Vector3 position, float width, float texCoord, ColorEx color )
			{
				Position = position;
				Width = width;
				TexCoord = texCoord;
				Color = color;
			}

 public AddFogCommand(WorldEditor app, Boundary parent, ColorEx color, float nearin, float farin)
 {
     this.app = app;
     this.parent = parent;
     this.color = color;
     this.near = nearin;
     this.far = farin;
 }

 public GlobalDirectionalLight(WorldEditor worldEditor, IWorldContainer parent, Vector3 lightDir, ColorEx diff, ColorEx spec)
 {
     this.app = worldEditor;
     this.parent = parent;
     this.lightDirection = lightDir;
     this.diffuse = diff;
     this.specular = spec;
 }

 public DirectionalLight(WorldEditor worldEditor, Boundary parent, Vector3 lightDir, ColorEx diff, ColorEx spec)
 {
     this.app = worldEditor;
     this.parent = parent;
     this.lightDirection = lightDir;
     this.diffuse = diff;
     this.specular = spec;
     this.name = String.Format("{0}-{1}", this.parent.Name, "DirectionalLight");
 }

        public MultiLights(SceneManager pSceneManager, SceneNode pCamNode, MovingObject pPlayerShip, Int32 pNumberOfLights)
        {
            oldCamLightColor = CamLightColor = new ColorEx(0.13f, 0.1f, 0.05f);
            PlayerLightColor = ColorEx.White;
            camLights = new List<Light>(pNumberOfLights);

            innerLights = (Int32)Math.Round(pNumberOfLights / 3.0f, MidpointRounding.AwayFromZero);
            outerLights = pNumberOfLights - innerLights;

            // create the playership's light.
            playerLight = pSceneManager.CreateLight("playerSpotLight");
            playerLight.Type = LightType.Spotlight;
            playerLight.Diffuse = PlayerLightColor;
            playerLight.Specular = ColorEx.White;
            playerLight.SetSpotlightRange(0.0f, 120.0f);
            playerLight.Direction = Vector3.NegativeUnitZ;

            playerLightNode = pPlayerShip.Node.CreateChildSceneNode();
            playerLightNode.AttachObject(playerLight);
            playerLightNode.Position = new Vector3(0, 0, 0);
            playerLightNode.SetDirection(new Vector3(1, 0, 0), TransformSpace.Local);

            // create the camera spotlights around the camera's direction.
            camInnerLightNode = pCamNode.CreateChildSceneNode();
            camInnerLightNode.Position = new Vector3(0, 0, 0);
            camOuterLightNode = pCamNode.CreateChildSceneNode();
            camOuterLightNode.Position = new Vector3(0, 0, 0);

            for (var i = 0; i < innerLights; i++)
            {
                var light = pSceneManager.CreateLight("camInnerLight " + (i + 1));
                light.Type = LightType.Spotlight;
                light.Diffuse = CamLightColor;
                light.Specular = ColorEx.White;
                light.SetSpotlightRange(0.0f, 25.0f);
                light.Direction = Quaternion.FromAngleAxis(360.0 * i / innerLights * Constants.DegreesToRadians, Vector3.UnitZ) *
                    Quaternion.FromAngleAxis(10.0 * Constants.DegreesToRadians, Vector3.UnitX) *
                    Vector3.NegativeUnitZ;

                camLights.Add(light);
                camInnerLightNode.AttachObject(light);
            }
            for (var i = 0; i < outerLights; i++)
            {
                var light = pSceneManager.CreateLight("camOuterLight " + (i + 1));
                light.Type = LightType.Spotlight;
                light.Diffuse = CamLightColor;
                light.Specular = ColorEx.White;
                light.SetSpotlightRange(0.0f, 25.0f);
                light.Direction = Quaternion.FromAngleAxis(360.0 * i / outerLights * Constants.DegreesToRadians, Vector3.UnitZ) *
                    Quaternion.FromAngleAxis(20.0 * Constants.DegreesToRadians, Vector3.UnitX) *
                    Vector3.NegativeUnitZ;

                camLights.Add(light);
                camOuterLightNode.AttachObject(light);
            }
        }

        public ColorInterpolatorAffector()
        {
            this.type = "ColourInterpolator";

            for( int i = 0; i < MAX_STAGES; ++i ) {
                colorAdj[i] = new ColorEx(0.5f, 0.5f, 0.5f, 0.0f);
                timeAdj[i] = 1.0f;
            }
        }

        /// <summary>
        ///		Parses an array of params and returns a color from it.
        /// </summary>
        /// <param name="val"></param>
        public static ColorEx ParseColor(string[] values)
        {
            ColorEx color = new ColorEx();
            color.r = ParseFloat(values[0]);
            color.g = ParseFloat(values[1]);
            color.b = ParseFloat(values[2]);
            color.a = (values.Length > 3) ? ParseFloat(values[3]) : 1.0f;

            return color;
        }

 /// <summary>
 ///		Normal constructor. Should not be called directly, but rather the SceneManager.CreateLight method should be used.
 /// </summary>
 /// <param name="name"></param>
 public TextureLight(string name, BspSceneManager creator)
     : base(name)
 {
     this.creator = creator;
     isTextureLight = true;
     diffuse = ColorEx.White;
     textureColor = ColorEx.White;
     intensity = LightIntensity.Normal;
     priority = 100;
 }

 public AddDirectionalLightCommand(WorldEditor worldEditor, IWorldContainer parentObject, String objectName, string meshName, ColorEx specular, ColorEx diffuse)
 {
     this.app = worldEditor;
     this.parent =  (Boundary) parentObject;
     this.name = objectName;
     this.meshName = meshName;
     this.specular = specular;
     this.diffuse = diffuse;
     this.scene = app.Scene;
 }

 public PointLight(WorldEditor worldEditor, IWorldContainer parent, SceneManager scene, string name, ColorEx specular, ColorEx diffuse, Vector3 position)
 {
     this.app = worldEditor;
     this.parent = parent;
     this.scene = scene;
     this.name = name;
     this.position = position;
     this.specular = specular;
     this.diffuse = diffuse;
     this.terrainOffset = app.Config.DefaultPointLightHeight;
 }

        public static Trail NewTrail(MovingObject pObjectToFollow, Single pMaxWidth, ColorEx pColor)
        {
            if (freeTrails.Count == 0)
            {
                return new Trail(pObjectToFollow, pMaxWidth, pColor);
            }

            var trail = freeTrails.Dequeue();
            trail.Relaunch(pObjectToFollow, pMaxWidth, pColor);
            return trail;
        }

 public AddPointLightCommand(WorldEditor worldEditor, IWorldContainer parentObject, String objectName, string meshName, ColorEx specular, ColorEx diffuse)
 {
     this.app = worldEditor;
     this.parent = parentObject;
     this.name = objectName;
     this.meshName = meshName;
     this.specular = specular;
     this.diffuse = diffuse;
     this.scene = app.Scene;
     placing = true;
 }

        /// <summary>
        ///    Basic constructor, internal since it should only be created by factories.
        /// </summary>
        /// <param name="name"></param>
        internal TextArea(string name)
            : base(name)
        {
            isTransparent = false;
            alignment = HorizontalAlignment.Left;

            colorTop = ColorEx.White;
            colorBottom = ColorEx.White;
            haveColorsChanged = true;

            charHeight = 0.02f;
            pixelCharHeight = 12;
        }

        public Trail(MovingObject pObjectToFollow, Single pMaxWidth, ColorEx pColor)
        {
            LoopResultStates = new LoopResultStates();

            Chain = new BillboardChain(Methods.GenerateUniqueID.ToString(CultureInfo.InvariantCulture));
            Chain.Material.SetSceneBlending(SceneBlendType.Replace);
            Chain.Material.DepthCheck = false;
            Chain.Material.DepthWrite = false;
            Chain.NumberOfChains = 1;
            Chain.IsVisible = false;
            World.Instance.SceneManager.RootSceneNode.AttachObject(Chain);

            Relaunch(pObjectToFollow, pMaxWidth, pColor);
        }

 public PlantType(WorldEditor app, Grass parent, uint instances, string name, string imageName, float scaleWidthLow, float scaleWidthHi, float scaleHeightLow, float scaleHeightHi, ColorEx color, float colorMultLow, float colorMultHi, float windMagnitude)
 {
     this.app = app;
     this.parent = parent;
     this.instances = instances;
     this.name = name;
     this.imageName = imageName;
     this.scaleWidthLow = scaleWidthLow;
     this.scaleWidthHi = scaleWidthHi;
     this.scaleHeightLow = scaleHeightLow;
     this.scaleHeightHi = scaleHeightHi;
     this.color = color;
     this.colorMultLow = colorMultLow;
     this.colorMultHi = colorMultHi;
     this.windMagnitude = windMagnitude;
 }

        public SceneManager()
            : base("MVSceneManager")
        {
            //
            // TODO: Add constructor logic here
            //

            // set up default shadow parameters
            SetShadowTextureSettings(1024, 1, Axiom.Media.PixelFormat.FLOAT32_R);
            shadowColor = new ColorEx(0.75f, 0.75f, 0.75f);
            shadowFarDistance = 20000;
            shadowDirLightExtrudeDist = 100000;
            ShadowCasterRenderBackFaces = false;

            fogConfig = new FogConfig(this);
            ambientLightConfig = new AmbientLightConfig(this);
        }

        public AddPlantTypeCommand(WorldEditor worldEditorin, Grass parentin, uint instancesin, string namein,
			string imageNamein, float scaleWidthHiin, float scaleWidthLowin, float scaleHeightHiin, float scaleHeightLowin,
			ColorEx colorin, float colorMultHiin, float colorMultLowin, float windMagnitudein)
        {
            this.app = worldEditorin;
            this.parent = parentin;
            this.instances = instancesin;
            this.name = namein;
            this.imageName = imageNamein;
            this.scaleWidthHi = scaleWidthHiin;
            this.scaleWidthLow = scaleWidthLowin;
            this.scaleHeightHi = scaleHeightHiin;
            this.scaleHeightLow = scaleHeightLowin;
            this.colorRGB = colorin;
            this.colorMultHi = colorMultHiin;
            this.colorMultLow = colorMultLowin;
            this.windMagnitude = windMagnitudein;
        }

        public Request(string url, string textureName, TextureFetchDone doneHandler, int destWidth, int destHeight, bool keepAspect, ColorEx fillColor, string authUser, string authPW, string authDomain)
        {
            this.url = url;
            if (!url.StartsWith("http:"))
            {
                log.ErrorFormat("TextureFetch: only http urls supported: {0}", url);
                throw new Exception("TextureFetch: only http urls supported: " + url);
            }
            this.textureName = textureName;
            this.doneHandler = doneHandler;
            this.destWidth = destWidth;
            this.destHeight = destHeight;
            this.keepAspect = keepAspect;
            this.fillColor = fillColor;

            this.authUser = authUser;
            this.authPW = authPW;
            this.authDomain = authDomain;
        }