private void MainForm_Load(object sender, EventArgs e)
        {
            renderView.ShowWorkingGrid(false);
            renderView.ExecuteCommand("ShadeWithEdgeMode");
            renderView.ShowCoordinateAxis(false);

            ColorValue clr = new ColorValue(33f / 255f, 40f / 255f, 48f / 255f, 1);
            renderView.SetBackgroundColor(clr, clr, clr);

            Renderer renderer = renderView.Renderer;

            // Customize the Axis
            ScreenWidget coodinateNode = new ScreenWidget();
            AxesWidget axesNode = new AxesWidget();
            axesNode.SetArrowText((int)EnumAxesDirection.Axes_Z, "");
            coodinateNode.SetNode(axesNode);
            coodinateNode.SetWidgetPosition(2);     
            renderer.SetCoordinateWidget(coodinateNode);

            // Set the fixed Top View
            renderer.SetStandardView(EnumStandardView.SV_Top);
            renderer.SetViewType(EnumStandardView.SV_Top);

            this.renderView.RequestDraw();

        }

        ///////////////////////////////////////////

        protected override void OnAttach()
        {
            base.OnAttach();

            //create window
            window = ControlDeclarationManager.Instance.CreateControl(
                "Gui\\RegisterWindow.gui");
            Controls.Add(window);

            MouseCover = true;
            BackColor = new ColorValue(0, 0, 0, .5f);

            RealName = (EditBox)window.Controls["RealName"];
            UserName = (EditBox)window.Controls["UserName"];
            
            //Age = (EditBox)window.Controls["Age"];
            //OfAge = (CheckBox)window.Controls["OfAge"];

            Pass1 = (PasswordBox)window.Controls["Pass1"];
            Pass2 = (PasswordBox)window.Controls["Pass2"];
            Email = (EditBox)window.Controls["Email"];

            ((Button)window.Controls["Exit"]).Click += Exit_Click;
            ((Button)window.Controls["Register"]).Click += Register_Click;
            ((Button)window.Controls["Cancel"]).Click += Cancel_Click;
        }

        protected override void OnAttach()
        {
            base.OnAttach();

            EControl window = ControlDeclarationManager.Instance.CreateControl( "Gui\\AntMenuWindow.gui" );
            Controls.Add( window );

            //( (EButton)window.Controls[ "Maps" ] ).Click += mapsButton_Click;
            ( (EButton)window.Controls[ "LoadSave" ] ).Click += loadSaveButton_Click;
            ( (EButton)window.Controls[ "Options" ] ).Click += optionsButton_Click;
            ( (EButton)window.Controls[ "PostEffects" ] ).Click += postEffectsButton_Click;
            ( (EButton)window.Controls[ "Debug" ] ).Click += debugButton_Click;
            ( (EButton)window.Controls[ "About" ] ).Click += aboutButton_Click;
            ( (EButton)window.Controls[ "ExitToMainMenu" ] ).Click += exitToMainMenuButton_Click;
            ( (EButton)window.Controls[ "Exit" ] ).Click += exitButton_Click;
            ( (EButton)window.Controls[ "Resume" ] ).Click += resumeButton_Click;

            if( GameWindow.Instance == null )
                window.Controls[ "ExitToMainMenu" ].Enable = false;

            if( GameNetworkServer.Instance != null || GameNetworkClient.Instance != null )
            {
                //window.Controls[ "Maps" ].Enable = false;
                window.Controls[ "LoadSave" ].Enable = false;
            }

            MouseCover = true;

            BackColor = new ColorValue( 0, 0, 0, .5f );
        }

        public void configurarLuces(MeshLightData mld)
        {
            Effect effect =  mld.mesh.Effect;
            ColorValue[] lightColors = new ColorValue[3];
            Vector4[] pointLightPositions = new Vector4[3];
            float[] pointLightIntensity = new float[3];
            float[] pointLightAttenuation = new float[3];
            float[] spotLightAngleCos = new float[3];
            float[] spotLightExponent = new float[3];
            Vector4[] spotLightDir = new Vector4[3];

            for (int i = 0; i < 3; i++)
            {
                lightColors[i] = ColorValue.FromColor(mld.lights[i].color);
                pointLightPositions[i] =  TgcParserUtils.vector3ToVector4(mld.lights[i].pos);
                spotLightDir[i] = TgcParserUtils.vector3ToVector4(mld.lights[i].direccion);
                pointLightIntensity[i] = mld.lights[i].intencidad;
                pointLightAttenuation[i] = mld.lights[i].atenuacion;
                spotLightExponent[i] = mld.lights[i].exp;
                spotLightAngleCos[i] = FastMath.ToRad(mld.lights[i].angleCos);
            }
            effect.SetValue("spotLightAngleCos", spotLightAngleCos);
            effect.SetValue("spotLightExponent", spotLightExponent);
            effect.SetValue("lightIntensity", pointLightIntensity);
            effect.SetValue("lightAttenuation", pointLightAttenuation);
            effect.SetValue("lightColor", lightColors);
            effect.SetValue("spotLightDir", spotLightDir);
            effect.SetValue("lightPosition", pointLightPositions);
        }

        public ColorValue[] States; // Modulate colors for all possible control states

        #endregion Fields

        #region Methods

        /// <summary>Blend the colors together</summary>
        public void Blend(ControlState state, float elapsedTime, float rate)
        {
            if ((States == null) || (States.Length == 0) )
                return; // Nothing to do

            ColorValue destColor = States[(int)state];
            Current = ColorOperator.Lerp(Current, destColor, 1.0f - (float)Math.Pow(rate, 30 * elapsedTime) );
        }

 public Popup2(RenderSystem rs, Texture tex, int x, int y, float duration, ColorValue modColor)
 {
     this.x = x;
     this.y = y;
     this.texture = tex;
     this.duration = duration;
     this.modColor = modColor;
 }

 /// <summary>Creates a new StringBlock</summary>
 /// <param name="text">Text to render</param>
 /// <param name="textBox">Text box to constrain text</param>
 /// <param name="alignment">Font alignment</param>
 /// <param name="size">Font size in pixels(max height of line)</param>
 /// <param name="color">Color</param>
 /// <param name="kerning">true to use kerning, false otherwise.</param>
 public StringBlock(string text, RectangleF textRect, Align alignment,
     float size, ColorValue color, bool kerning)
 {
     Text = text;
     TextRect = textRect;
     ViewportRect = textRect;
     Alignment = alignment;
     Size = size;
     Color = color;
     Kerning = kerning;
 }

        /// <summary>
        /// Gets the interpolated colour between two pixels from an image.
        /// Interpolate a texture pixel by hand. (fx, fy) are in texture coordinates,
        /// ranging [0-1] across the entire texture.
        /// Smooth blending is only done on the x coordinate.
        /// Wrapping is only supported on X as well.</summary>
        public static ColorValue GetInterpolatedColour(float fx, float fy, Bitmap img, bool wrapX)
        {
            if (img == null)
                return CaelumUtils.ColorWhite;

            // Get the image width
            int imgWidth = img.Width;
            int imgHeight = img.Height;

            // Calculate pixel y coord.
            int py = Convert.ToInt32( MathFunctions.Floor(Math.Abs(fy)*(imgHeight - 1) ));
            // Snap to py image bounds.
            py = Math.Max(0, Math.Min(py, imgHeight - 1));

            // Get the two closest pixels on x.
            // px1 and px2 are the closest integer pixels to px.
            float px = fx * (img.Width - 1);
            int px1 = Convert.ToInt32( MathFunctions.Floor(px));
            int px2 = Convert.ToInt32( Math.Ceiling(px));

            if (wrapX)
            {
                // Wrap x coords. The funny addition ensures that it does
                // "the right thing" for negative values.
                px1 = (px1 % imgWidth + imgWidth) % imgWidth;
                px2 = (px2 % imgWidth + imgWidth) % imgWidth;
            }
            else
            {
                px1 = Math.Max(0, Math.Min(px1, imgWidth - 1));
                px2 = Math.Max(0, Math.Min(px2, imgWidth - 1));
            }

            float R, G, B;

            // Gets (px1, py) pixel
            Color col = img.GetPixel(px1, py);
            R = col.R; G = col.G; B = col.B;
            ColorValue c1 = new ColorValue(R / 255, G / 255, B / 255);

            // Gets (px2, py) pixel
            col = img.GetPixel(px2, py);
            R = col.R; G = col.G; B = col.B;
            ColorValue c2 = new ColorValue(R / 255, G / 255, B / 255);

            // Blend the two pixels together.
            // diff is the weight between pixel 1 and pixel 2.
            float diff = px - px1;
            ColorValue cf = c1 * (1 - diff) + c2 * diff;

            return cf;
        }

        public ColorValue Current; // Current color

        /// <summary>Initialize the color blending</summary>
        public void Initialize(ColorValue defaultColor, ColorValue disabledColor, ColorValue hiddenColor)
        {
            // Create the array
            States = new ColorValue[(int)ControlState.LastState];
            for(int i = 0; i < States.Length; i++)
            {
                States[i] = defaultColor;
            }

            // Store the data
            States[(int)ControlState.Disabled] = disabledColor;
            States[(int)ControlState.Hidden] = hiddenColor;
            Current = hiddenColor;
        }

        protected Control()
        {

            //txtHint = TextRenderingHint.ClearTypeGridFit;
            modColor = ColorValue.White;

            controls = new List<Control>();

            //InputEngine = gameUI.InputEngine;

            //InputEngine.KeyStateChanged += this._OnKeyStateChanged;
            //InputEngine.MouseDown += this._OnMouseDown;
            //InputEngine.MouseMove += this._OnMouseMove;
            //InputEngine.MouseUp += this._OnMouseUp;
            //InputEngine.MouseWheel += this._OnMouseWheel;
        }

        public void R_FR()
        {
            TimeSpan ts = DateTime.Now - t_start;
            double t = ts.TotalSeconds;

            dev2.Clear(ClearFlags.Target | ClearFlags.ZBuffer, System.Drawing.Color.Blue, 1.0f, 0);
            dev2.BeginScene();

            System.Drawing.Color col = System.Drawing.Color.White;
            Direct3D.Material mtrl = new Direct3D.Material();
            mtrl.Diffuse = col;
            mtrl.Ambient = col;
            dev2.Material = mtrl;

            Vector4 lightdir = new Vector4((float)Math.Cos(Environment.TickCount / 550.0f), 1.0f, (float)Math.Sin(Environment.TickCount / 250.0f), 0);

            dev2.Transform.World = Matrix.RotationAxis(new Vector3((float)Math.Cos(t), 1, (float)Math.Sin(Environment.TickCount / 250.0f)), Environment.TickCount / 3000.0f);

            dev2.Transform.View = Matrix.LookAtLH(new Vector3(0.0f, 4.0f, -5.0f), new Vector3(0.0f, 0.0f, 0.0f), new Vector3(0.0f, 1.0f, 0.0f));

            dev2.Transform.Projection = Matrix.PerspectiveFovLH((float)Math.PI / 4.0f, 1.0f, 1.0f, 100.0f);

            ColorValue WhiteColor = new ColorValue(1.0f, 1.0f, 1.0f, 1.0f);
            ColorValue YellowColor = new ColorValue(1.0f, 1.0f, 0.0f, 1.0f);

            eff.SetValue("projectionMatrix", dev2.Transform.Projection);
            eff.SetValue("viewMatrix", dev2.Transform.View);
            eff.SetValue("worldMatrix", dev2.Transform.World);
            eff.SetValue("appTime", (float)t);

            //		eff.SetValue("g_MaterialDiffuseColor", WhiteColor);
            //		eff.SetValue("g_nNumLights", 1);

            dev2.SetStreamSource(0, vb, 0);
            dev2.VertexFormat = CustomVertex.PositionNormal.Format;

            eff.Begin(0);
            for (int p = 0; p < 4; p++)
            {
                eff.BeginPass(p);
                dev2.DrawPrimitives(PrimitiveType.TriangleList, 0, usteps * vsteps * 2 );
                eff.EndPass();
            }
            eff.End();
            dev2.EndScene();
            dev2.Present();
        }

        protected override void OnAttach()
        {
            base.OnAttach();

            Control window = ControlDeclarationManager.Instance.CreateControl("Gui\\AboutWindow.gui");
            Controls.Add(window);

            window.Controls["Version"].Text = EngineVersionInformation.Version;

            ((Button)window.Controls["Quit"]).Click += delegate(Button sender)
            {
                SetShouldDetach();
            };

            BackColor = new ColorValue(0, 0, 0, .5f);
            MouseCover = true;
        }

		public static void AddCircle(this GuiRenderer renderer, Vec2 center, ColorValue color, Vec2 radius, float startAngle = 0f, float endAngle = (float)Math.PI * 2f, float divisions = 16)
		{
			List<GuiRenderer.TriangleVertex> tris = new List<GuiRenderer.TriangleVertex>((int)(divisions * 3));
			float inc = (float)Math.PI / divisions;
			float cond = endAngle * (float)(1f - 1f / divisions);
			float curAngle;
			for (curAngle = startAngle; curAngle < cond; curAngle += inc)
			{
				tris.Add(new GuiRenderer.TriangleVertex(center, color));
				tris.Add(CircleVertex(curAngle, center, radius, color));
				tris.Add(CircleVertex(curAngle + inc, center, radius, color));
			}
			tris.Add(new GuiRenderer.TriangleVertex(center, color));
			tris.Add(CircleVertex(curAngle, center, radius, color));
			tris.Add(CircleVertex(endAngle, center, radius, color));
			renderer.AddTriangles(tris);
		}

        ///////////////////////////////////////////
        protected override void OnAttach()
        {
            base.OnAttach();

            //disable check for disconnection
            GameEngineApp.Instance.Client_AllowCheckForDisconnection = false;

            //register config fields
            EngineApp.Instance.Config.RegisterClassParameters( GetType() );

            //create window
            window = ControlDeclarationManager.Instance.CreateControl(
                "Gui\\MultiplayerLoginWindow.gui" );
            Controls.Add( window );

            MouseCover = true;
            BackColor = new ColorValue( 0, 0, 0, .5f );

            //initialize controls

            buttonCreateServer = (EButton)window.Controls[ "CreateServer" ];
            buttonCreateServer.Click += CreateServer_Click;

            buttonConnect = (EButton)window.Controls[ "Connect" ];
            buttonConnect.Click += Connect_Click;

            ( (EButton)window.Controls[ "Exit" ] ).Click += Exit_Click;

            //generate user name
            if( string.IsNullOrEmpty( userName ) )
            {
                EngineRandom random = new EngineRandom();
                userName = "Rabbit" + random.Next( 1000 ).ToString( "D03" );
            }

            editBoxUserName = (EEditBox)window.Controls[ "UserName" ];
            editBoxUserName.Text = userName;
            editBoxUserName.TextChange += editBoxUserName_TextChange;

            editBoxConnectTo = (EEditBox)window.Controls[ "ConnectTo" ];
            editBoxConnectTo.Text = connectToAddress;
            editBoxConnectTo.TextChange += editBoxConnectTo_TextChange;

            SetInfo( "", false );
        }

        public override void OnSetFaceColor(ColorValue clr)
        {
            if (clr.ToRGBA() == faceStyle.GetColor().ToRGBA())
                return;

            FaceStyle fs = null;
            if (!faceStyleDict.TryGetValue(clr.ToRGBA(), out fs))
            {
                fs = new FaceStyle();
                fs.SetColor(clr);
                faceStyleDict.Add(clr.ToRGBA(), fs);
            }

            faceStyle = fs;

            fileSys.WriteLine(String.Format("{0} {1} {2}", clr.R, clr.G, clr.B));
            fileSys.Flush();
        }

        ///////////////////////////////////////////
        protected override void OnAttach()
        {
            base.OnAttach();

            //create window
            window = ControlDeclarationManager.Instance.CreateControl( "Gui\\GUISamples3Window.gui" );
            Controls.Add( window );

            addressEditBox = (EditBox)window.Controls[ "Address" ];
            addressEditBox.PreKeyDown += addressEditBox_PreKeyDown;

            webBrowserControl = (Engine.UISystem.WebBrowserControl)window.Controls[ "WebBrowser" ];

            ( (Button)window.Controls[ "Close" ] ).Click += Close_Click;
            ( (Button)window.Controls[ "Go" ] ).Click += go_Click;

            BackColor = new ColorValue( 0, 0, 0, .5f );
            MouseCover = true;
        }

        protected override void OnAttach()
        {
            base.OnAttach();

            TopMost = true;

            EControl window = ControlDeclarationManager.Instance.CreateControl(
                "Gui\\MessageBoxWindow.gui" );
            Controls.Add( window );

            window.Controls[ "MessageText" ].Text = messageText;

            window.Text = caption;

            ( (EButton)window.Controls[ "OK" ] ).Click += OKButton_Click;

            BackColor = new ColorValue( 0, 0, 0, .5f );

            EngineApp.Instance.RenderScene();
        }

        ///////////////////////////////////////////

        protected override void OnAttach()
        {
            base.OnAttach();

            //create window
            window = ControlDeclarationManager.Instance.CreateControl("Gui\\MultiViewConfigurationWindow.gui");
            Controls.Add(window);

            //update views list box
            listBoxViews = (ListBox)window.Controls["ViewList"];
            listBoxViews.Items.Clear();
            foreach (ViewConfigurations configuration in Enum.GetValues(typeof(ViewConfigurations)))
                listBoxViews.Items.Add(configuration.ToString());
            listBoxViews.SelectedIndex = (int)lastViewsConfiguration;
            listBoxViews.SelectedIndexChange += listBoxViews_SelectedIndexChange;

            //showMainScene checkbox
            checkBoxShowMainScene = (CheckBox)window.Controls["ShowMainScene"];
            if (MultiViewRenderingManager.Instance != null)
                checkBoxShowMainScene.Checked = MultiViewRenderingManager.Instance.MainCameraDraw3DScene;
            checkBoxShowMainScene.CheckedChange += checkBoxShowMainScene_CheckedChange;
            checkBoxShowMainScene.Enable = listBoxViews.SelectedIndex != 0;

            //view opacity
            scrollBarViewsOpacity = (ScrollBar)window.Controls["ViewsOpacity"];
            if (MultiViewRenderingManager.Instance != null && MultiViewRenderingManager.Instance.Views.Count > 0)
                scrollBarViewsOpacity.Value = MultiViewRenderingManager.Instance.Views[0].Opacity;
            scrollBarViewsOpacity.ValueChange += scrollBarViewsOpacity_ValueChange;
            scrollBarViewsOpacity.Enable = listBoxViews.SelectedIndex != 0;

            checkBoxDrawDebugInfo = (CheckBox)window.Controls["DrawDebugInfo"];
            if (MultiViewRenderingManager.Instance != null)
                checkBoxDrawDebugInfo.Checked = MultiViewRenderingManager.Instance.DrawDebugInfo;
            checkBoxDrawDebugInfo.CheckedChange += checkBoxDrawDebugInfo_CheckedChange;
            checkBoxDrawDebugInfo.Enable = listBoxViews.SelectedIndex != 0;

            ((Button)window.Controls["Close"]).Click += Close_Click;

            BackColor = new ColorValue(0, 0, 0, .5f);
            MouseCover = true;
        }

        ///////////////////////////////////////////
        protected override void OnAttach()
        {
            base.OnAttach();

            //create window
            window = ControlDeclarationManager.Instance.CreateControl( "Gui\\GUISamples2Window.gui" );
            Controls.Add( window );

            sceneBox = (SceneBox)window.Controls[ "SceneBox" ];

            ( (Button)window.Controls[ "Close" ] ).Click += Close_Click;
            ( (Button)window.Controls[ "SceneBoxChangeModel" ] ).Click += SceneBoxChangeModel_Click;
            ( (Button)window.Controls[ "SceneBoxCreateParticle" ] ).Click += SceneBoxCreateParticle_Click;
            ( (Button)window.Controls[ "SceneBoxFullScreenEffect" ] ).Click += SceneBoxFullScreenEffect_Click;
            //( (Button)window.Controls[ "RenderToTextureTest" ] ).Click += RenderToTextureTest_Click;

            BackColor = new ColorValue( 0, 0, 0, .5f );
            MouseCover = true;

            renderToTexture.Create( window.Controls[ "RenderToTextureOutput" ] );
        }

        private void Fire()
        {
            if (!Visible)
                return;

            if (fireworkBulletType == null)
                return;

            Bullet bullet = (Bullet)Entities.Instance.Create(fireworkBulletType, Map.Instance);

            bullet.Position = GetInterpolatedPosition() + new Vec3(0, 0, .1f);

            EngineRandom random = World.Instance.Random;
            bullet.Rotation = Rotation *
                new Angles(random.NextFloatCenter() * 25, 90 + random.NextFloatCenter() * 25, 0).ToQuat();

            bullet.PostCreate();

            foreach (MapObjectAttachedObject attachedObject in bullet.AttachedObjects)
            {
                MapObjectAttachedRibbonTrail attachedRibbonTrail = attachedObject as MapObjectAttachedRibbonTrail;
                if (attachedRibbonTrail == null)
                    continue;

                ColorValue color;
                switch (random.Next(4))
                {
                    case 0: color = new ColorValue(1, 0, 0); break;
                    case 1: color = new ColorValue(0, 1, 0); break;
                    case 2: color = new ColorValue(0, 0, 1); break;
                    case 3: color = new ColorValue(1, 1, 0); break;
                    default: color = new ColorValue(0, 0, 0); break;
                }

                if (attachedRibbonTrail.RibbonTrail != null)
                    attachedRibbonTrail.RibbonTrail.Chains[0].InitialColor = color;
            }
        }