C# GuiRenderer.AddText方法代码示例

        void PerspectiveViewControl_RenderUI(GuiRenderer renderer)
        {
            if (_camera != null)
                Nameplates.RenderObjectsTips(renderer, _camera);
            string text = "FPS: " + Perspective.Fps
                        + "    loc: " + renderTarget.CameraPosition.ToString(0)
                        + "    dir: " + renderTarget.CameraDirection.ToString(0)
                        + "    mouse: " + _mouseIntersection.ToString(2)
                        + "    over: " + _worldViewModel.MouseOverEntity;

            renderer.AddText(text, new Vec2(.01f, .01f), HorizontalAlign.Left,
                VerticalAlign.Top, new ColorValue(1, 1, 1));
        }

        public void DrawDebug(Rect r, GuiRenderer renderer)
        {
            Rect[] rs = new Rect[5];
            rs[0] = new Rect(Utils.TR(r, new Vec2(0.05f, 0.375f)), Utils.TR(r, new Vec2(0.30f, 0.625f)));
            rs[4] = new Rect(Utils.TR(r, new Vec2(0.05f, 0.05f)), Utils.TR(r, new Vec2(0.30f, 0.30f)));
            rs[2] = new Rect(Utils.TR(r, new Vec2(0.05f, 0.70f)), Utils.TR(r, new Vec2(0.30f, 0.95f)));
            rs[3] = new Rect(Utils.TR(r, new Vec2(0.375f, 0.375f)), Utils.TR(r, new Vec2(0.625f, 0.625f)));
            rs[1] = new Rect(Utils.TR(r, new Vec2(0.70f, 0.375f)), Utils.TR(r, new Vec2(0.95f, 0.625f)));

            for (int i = 0; i < aerofoils.Length; i++)
                aerofoils[i].DrawDebug(rs[i], renderer);

            float speed = awesomeAircraft.mainBody.LinearVelocity.Length();
            renderer.AddText("speed:" + speed.ToString(), r.LeftTop);
        }

        /// <summary>
        /// To draw some information of a player
        /// </summary>
        /// <param name="renderer"></param>
        void DrawPlayerInformation( GuiRenderer renderer )
        {
            if( GetRealCameraType() == CameraType.Free )
                return;

            if( IsCutSceneEnabled() )
                return;

            //debug draw an influences.
            {
                float posy = .8f;

                foreach( Entity entity in GetPlayerUnit().Children )
                {
                    Influence influence = entity as Influence;
                    if( influence == null )
                        continue;

                    renderer.AddText( influence.Type.Name, new Vec2( .7f, posy ),
                        HorizontalAlign.Left, VerticalAlign.Center );

                    int count = (int)( (float)influence.RemainingTime * 2.5f );
                    if( count > 50 )
                        count = 50;
                    string str = "";
                    for( int n = 0; n < count; n++ )
                        str += "I";

                    renderer.AddText( str, new Vec2( .85f, posy ),
                        HorizontalAlign.Left, VerticalAlign.Center );

                    posy -= .025f;
                }
            }
        }

        protected override void OnRenderUI( GuiRenderer renderer )
        {
            base.OnRenderUI( renderer );

            //Draw some HUD information
            if( GetPlayerUnit() != null )
            {
                if( GetRealCameraType() != CameraType.Free && !IsCutSceneEnabled() &&
                    GetActiveObserveCameraArea() == null )
                {
                    DrawTarget( renderer );
                }

                DrawPlayerInformation( renderer );

                bool activeConsole = EngineConsole.Instance != null && EngineConsole.Instance.Active;

                if( EngineApp.Instance.IsKeyPressed( EKeys.Tab ) && !activeConsole )
                    DrawPlayersStatistics( renderer );

                if( GameNetworkServer.Instance != null || GameNetworkClient.Instance != null )
                {
                    renderer.AddText( "\"Tab\" for players statistics", new Vec2( .01f, .1f ),
                        HorizontalAlign.Left, VerticalAlign.Top, new ColorValue( 1, 1, 1, .5f ) );
                }
            }

            //Game is paused on server
            if( EntitySystemWorld.Instance.IsClientOnly() && !EntitySystemWorld.Instance.Simulation )
            {
                renderer.AddText( "Game is paused on server", new Vec2( .5f, .5f ),
                    HorizontalAlign.Center, VerticalAlign.Center, new ColorValue( 1, 0, 0 ) );
            }
        }

 private void renderTargetUserControl1_RenderUI(RenderTargetUserControl sender, GuiRenderer renderer)
 {
     string text = "NeoAxis 3D Engine " + EngineVersionInformation.Version;
     renderer.AddText(text, new Vec2(.01f, .01f), HorizontalAlign.Left,
          VerticalAlign.Top, new ColorValue(1, 1, 1));
 }

        /// <summary>
        /// Draw a target at center of screen
        /// </summary>
        /// <param name="renderer"></param>
        void DrawTarget(GuiRenderer renderer)
        {
            renderer.AddText("o", new Vec2(.5f, .5f), HorizontalAlign.Center, VerticalAlign.Center);

            Ray lookRay = RendererWorld.Instance.DefaultCamera.GetCameraToViewportRay(
                new Vec2(.5f, .5f));

            Body body = null;

            Vec3 lookFrom = lookRay.Origin;
            Vec3 lookDir = Vec3.Normalize(lookRay.Direction);
            float distance = 1000.0f;

            Unit playerUnit = GetPlayerUnit();

            RayCastResult[] piercingResult = PhysicsWorld.Instance.RayCastPiercing(
                new Ray(lookFrom, lookDir * distance), (int)ContactGroup.CastOnlyContact);

            foreach (RayCastResult result in piercingResult)
            {
                bool ignore = false;

                MapObject obj = MapSystemWorld.GetMapObjectByBody(result.Shape.Body);

                Dynamic dynamic = obj as Dynamic;
                if (dynamic != null && playerUnit != null && dynamic.GetParentUnit() == GetPlayerUnit())
                    ignore = true;

                if (!ignore)
                {
                    body = result.Shape.Body;
                    break;
                }
            }

            //renderer.AddText("[  ]", new Vec2(.5f, .5f), HorizontalAlign.Center, VerticalAlign.Center);

            if (body != null && body == null)
            {
                MapObject obj = MapSystemWorld.GetMapObjectByBody(body);

                if (obj != null && !(obj is StaticMesh) && !(obj is GameGuiObject))
                {
                    renderer.AddText(obj.Type.Name, new Vec2(.5f, .525f),
                        HorizontalAlign.Center, VerticalAlign.Center);

                    Dynamic dynamic = obj as Dynamic;
                    if (dynamic != null)
                    {
                        if (dynamic.Type.LifeMax != 0)
                        {
                            renderer.AddText("XXXX", new Vec2(.5f - .04f, .55f), HorizontalAlign.Left,
                                VerticalAlign.Center, new ColorValue(.5f, .5f, .5f, .5f));

                            float lifecoef = dynamic.Life / dynamic.Type.LifeMax;

                            renderer.AddText("IIIIIIIIII", new Vec2(.5f - .04f, .55f), HorizontalAlign.Left,
                                VerticalAlign.Center, new ColorValue(.5f, .5f, .5f, .5f));

                            float count = lifecoef * 10;
                            String s = "";
                            for (int n = 0; n < count; n++)
                                s += "I";

                            renderer.AddText(s, new Vec2(.5f - .04f, .55f),
                                HorizontalAlign.Left, VerticalAlign.Center, new ColorValue(0, 1, 0, 1));
                        }

                        if (dynamic.PhysicsModel != null)
                        {
                            float mass = 0;
                            foreach (Body s in dynamic.PhysicsModel.Bodies)
                                mass += s.Mass;
                            string ss = string.Format("mass {0}", mass);
                            renderer.AddText(ss, new Vec2(.5f - .04f, .6f),
                                HorizontalAlign.Left, VerticalAlign.Center, new ColorValue(0, 1, 0, 1));
                        }
                    }
                }

            }
        }

        protected override void OnRenderUI( GuiRenderer renderer )
        {
            base.OnRenderUI( renderer );

            Vec2I size = GetNeededSize();

            if( browser == null )
                CreateBrowser();

            //update brower engine and texture
            if( browser != null )
            {
                if( viewSize != size /*&& !browser.IsResizing */)
                {
                    var oldSize = viewSize;
                    viewSize = size;
                    OnResized( oldSize, viewSize );
                }

                //create texture
                if( texture == null || textureSize != size )
                {
                    if( texture != null )
                    {
                        texture.Dispose();
                        texture = null;
                    }

                    textureSize = size;

                    string textureName = TextureManager.Instance.GetUniqueName( "WebBrowserControl" );
                    texture = TextureManager.Instance.Create( textureName, Texture.Type.Type2D, textureSize,
                        1, 0, PixelFormat.A8R8G8B8, Texture.Usage.DynamicWriteOnlyDiscardable );
                    forceUpdateTexture = true;
                }

                //update texture
                if( /*browser.IsDirty ||*/ forceUpdateTexture )
                {
                    if( texture != null )
                        UpdateTexture();
                    forceUpdateTexture = false;
                }
            }

            //draw texture
            {
                bool backColorZero = BackColor == new ColorValue( 0, 0, 0, 0 );

                ColorValue color = backColorZero ? new ColorValue( 1, 1, 1 ) : BackColor;
                if( texture == null )
                    color = new ColorValue( 0, 0, 0, color.Alpha );
                color *= GetTotalColorMultiplier();

                color.Clamp( new ColorValue( 0, 0, 0, 0 ), new ColorValue( 1, 1, 1, 1 ) );

                Rect rect;
                GetScreenRectangle( out rect );

                if( renderer.IsScreen && !renderer._OutGeometryTransformEnabled )
                {
                    //screen per pixel accuracy

                    Vec2 viewportSize = renderer.ViewportForScreenGuiRenderer.DimensionsInPixels.Size.ToVec2();

                    Vec2 leftTop = rect.LeftTop;
                    leftTop *= viewportSize;
                    leftTop = new Vec2( (int)( leftTop.X + .9999f ), (int)( leftTop.Y + .9999f ) );
                    if( RenderSystem.Instance.IsDirect3D() )
                        leftTop -= new Vec2( .5f, .5f );
                    leftTop /= viewportSize;

                    Vec2 rightBottom = rect.RightBottom;
                    rightBottom *= viewportSize;
                    rightBottom = new Vec2( (int)( rightBottom.X + .9999f ), (int)( rightBottom.Y + .9999f ) );
                    if( RenderSystem.Instance.IsDirect3D() )
                        rightBottom -= new Vec2( .5f, .5f );
                    rightBottom /= viewportSize;

                    Rect fixedRect = new Rect( leftTop, rightBottom );

                    renderer.AddQuad( fixedRect, new Rect( 0, 0, 1, 1 ), texture, color, true );
                }
                else
                {
                    renderer.AddQuad( rect, new Rect( 0, 0, 1, 1 ), texture, color, true );
                }
            }

            if( !IsSupportedByThisPlatform() )
            {
                renderer.AddText( string.Format( "WebBrowserControl: {0} is not supported.", PlatformInfo.Platform ),
                    new Vec2( .5f, .5f ), Renderer.HorizontalAlign.Center, Renderer.VerticalAlign.Center, new ColorValue( 1, 0, 0 ) );
            }
        }

		public override void OnRenderScreenUI( GuiRenderer renderer )
		{
			base.OnRenderScreenUI( renderer );

			if( drawTextOnScreen )
			{
				renderer.AddText( "Add-on Example!", new Vec2( .5f, .9f ), HorizontalAlign.Center, VerticalAlign.Top,
					new ColorValue( 1, 0, 0 ) );
				renderer.AddQuad( new Rect( .3f, .94f, .7f, .95f ), new ColorValue( 1, 1, 0 ) );
			}
		}

        void renderTargetUserControl1_RenderUI( RenderTargetUserControl sender, GuiRenderer renderer )
        {
            string text = "NeoAxis 3D Engine " + EngineVersionInformation.Version;
            renderer.AddText( text, new Vec2( .01f, .01f ), HorizontalAlign.Left,
                 VerticalAlign.Top, new ColorValue( 1, 1, 1 ) );

            renderer.AddText( "Camera control: W A S D, right mouse", new Vec2( .99f, .99f ),
                HorizontalAlign.Right, VerticalAlign.Bottom, new ColorValue( 1, 1, 1 ) );
        }

        public static void RenderObjectsTips(GuiRenderer renderer, Camera camera)
        {
            Contract.Requires<ArgumentNullException>(camera != null);
            Contract.Requires<ArgumentNullException>(renderer != null);

            if (!showObjectsTips)
                return;

            Vec3 cameraPosition = camera.Position;

            //generate visible objects list 
            Map.Instance.GetObjectsByScreenRectangle(camera, new Rect(0, 0, 1, 1), delegate(MapObject obj)
            {
                if (!obj.Visible)
                    return;
                if (!obj.EditorSelectable)
                    return;

                float lengthSqr = (obj.Position - cameraPosition).LengthSqr();
                if (lengthSqr > visibleDistance * visibleDistance)
                    return;

                TempObjects.Add(obj);
            });

            //sort objects by distance 
            //_tempObjects.Sort( delegate( MapObject obj1, MapObject obj2 ) 
            ListUtils.SelectionSort(TempObjects, delegate(MapObject obj1, MapObject obj2)
            {
                float distanceSqr1 = (obj1.Position - cameraPosition).LengthSqr();
                float distanceSqr2 = (obj2.Position - cameraPosition).LengthSqr();

                if (distanceSqr1 < distanceSqr2)
                    return 1;
                if (distanceSqr1 > distanceSqr2)
                    return -1;
                return 0;
            });

            //render objects 
            foreach (MapObject obj in TempObjects.Where(x => !string.IsNullOrEmpty(x.TextUserData)))
            {
                Vec2 screenPos;
                camera.ProjectToScreenCoordinates(obj.Position + new Vec3(0, 0, obj.MapBounds.GetSize().Z + 0.2f), out screenPos);
                if (!new Rect(.001f, .001f, .999f, .999f).IsContainsPoint(screenPos))
                    continue;

                float length = (obj.Position - cameraPosition).LengthFast();

                float alpha = 1;
                if (length > visibleDistance * .9f)
                    alpha = (visibleDistance - length) / (visibleDistance * .1f);

                var textColor = new ColorValue(0.8f, 0.8f, 1, 1);
                textColor.Alpha *= alpha;

                Font font = FontManager.Instance.LoadFont("Default", 0.02f) ?? renderer.DefaultFont;

                string text = obj.TextUserData;
                if (text.Length != 0)
                {
                    float textLength = font.GetTextLength(renderer, text) / renderer.AspectRatio;

                    if (screenPos.X < textLength * .5f)
                    {
                        float visibleArea = 1.0f - (textLength * .5f - screenPos.X) /
                           (textLength * .5f);
                        MathFunctions.Clamp(ref visibleArea, 0, 1);
                        textColor.Alpha *= visibleArea;
                        alpha *= visibleArea;
                    }
                    if (screenPos.X > 1.0f - textLength * .5f)
                    {
                        float visibleArea = 1.0f - (screenPos.X - (1.0f - textLength * .5f)) /
                           (textLength * .5f);
                        MathFunctions.Clamp(ref visibleArea, 0, 1);
                        textColor.Alpha *= visibleArea;
                        alpha *= visibleArea;
                    }

                    renderer.AddText(font, text, screenPos, HorizontalAlign.Center,
                       VerticalAlign.Center, textColor);
                }

                /*** icon rendering
                 * outside loop float aspectRatioInv = 1.0f / camera.AspectRatio;
                if (!string.IsNullOrEmpty(tipItem.Icon))
                {
                    Vec2 size = new Vec2(tipItem.IconSize * aspectRatioInv, tipItem.IconSize);
                    Rect rectangle = new Rect(screenPos - size * .5f, screenPos + size * .5f);

                    if (textLength == 0)
                    {
                        if (rectangle.Right < size.X)
                        {
                            float v = (rectangle.Right - size.X * .5f) / (size.X * .5f);
                            MathFunctions.Clamp(ref v, 0, 1);
                            alpha *= v;
                        }
                        if (rectangle.Left > 1.0 - size.X)
//.........这里部分代码省略.........

        void DrawPlayersStatistics( GuiRenderer renderer )
        {
            if( IsCutSceneEnabled() )
                return;

            if( PlayerManager.Instance == null )
                return;

            renderer.AddQuad( new Rect( .1f, .2f, .9f, .8f ), new ColorValue( 0, 0, 1, .5f ) );

            renderer.AddText( "Players statistics", new Vec2( .5f, .25f ),
                HorizontalAlign.Center, VerticalAlign.Center );

            if( EntitySystemWorld.Instance.IsServer() || EntitySystemWorld.Instance.IsSingle() )
            {
                float posy = .3f;
                ICollection<Entity> icol = Entities.Instance.EntitiesCollection;
                String fact = "";
                foreach( PlayerManager.ServerOrSingle_Player player in
                    PlayerManager.Instance.ServerOrSingle_Players )
                {
                    foreach (Entity ent in icol)
                    {
                        Console.WriteLine(ent.UIN + " : "+ent.NetworkUIN+" : "+ent.Name);
                        Console.WriteLine(player.Identifier + " : " + " : " + player.User.Identifier + " : " + player.Name);

                        if (ent.Name.ToString().Contains("Human"))
                        {
                            fact = "Human";
                        }
                        if (ent.Name.ToString().Contains("Statue") && ent.NetworkUIN.Equals(player.User.Identifier))
                        {
                            fact = "Statue";
                        }

                    }

                    string text = string.Format("{0},   Frags: {1},  Faction: {3},  Ping: {2} ms", player.Name,
                        player.Frags, (int)( player.Ping * 1000 ), fact );
                    renderer.AddText( text, new Vec2( .2f, posy ), HorizontalAlign.Left,
                        VerticalAlign.Center );

                    posy += .025f;
                }
            }

            if( EntitySystemWorld.Instance.IsClientOnly() )
            {
                float posy = .3f;
                ICollection<Entity> icol = Entities.Instance.EntitiesCollection;
                String fact = "";
                foreach( PlayerManager.Client_Player player in PlayerManager.Instance.Client_Players )
                {
                    foreach (Entity ent in icol)
                    {
                        if (ent.Name.ToString().Contains("Human") && ent.UIN.Equals(player.User.Identifier))
                        {
                            fact = "Human";
                        }
                        if (ent.Name.ToString().Contains("Statue") && ent.UIN.Equals(player.User.Identifier))
                        {
                            fact = "Statue";
                        }
                    }

                    string text = string.Format("{0},   Frags: {1},  Faction: {3}, ID: {4}, Ping: {2} ms", player.Name,
                        player.Frags, (int)( player.Ping * 1000 ),  fact, player.Identifier );
                    renderer.AddText( text, new Vec2( .2f, posy ), HorizontalAlign.Left,
                        VerticalAlign.Center );

                    posy += .025f;
                }
            }
        }

        public void DoRenderUI( GuiRenderer renderer )
        {
            if( transparency == 0.0f )
                return;

            if( firstRender )
            {
                texture = TextureManager.Instance.Load( "Gui\\Various\\Console.dds",
                    Texture.Type.Type2D, 0 );
                font = FontManager.Instance.LoadFont( "Default", .025f );

                firstRender = false;
            }

            if( font == null )
                return;

            Rect textureRect = new Rect( 0, 0, 1, 1 );
            textureRect += textureOffset;

            renderer.AddQuad( new Rect( 0, 0, 1, .5f ), textureRect, texture,
                new ColorValue( 1, 1, 1, transparency ), false, new Rect( 0, 0, 1, 1 ) );
            renderer.AddQuad( new Rect( 0, .495f, 1, .5f ),
                new ColorValue( .8f, .8f, .8f, transparency ) );

            string staticText = "Version " + EngineVersionInformation.Version;
            if( staticText != null && staticText != "" )
            {
                renderer.AddText( font, staticText, new Vec2( .99f, .5f - font.Height ),
                    HorizontalAlign.Right, VerticalAlign.Center, new ColorValue( 1, 1, 1, transparency ) );
            }

            float fontheight = font.Height;

            float x = .01f;

            float y = .5f - fontheight;

            string str;
            if( stringDownPosition != strings.Count - 1 )
            {
                str = "- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -" +
                    " - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -" +
                    " - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -" +
                    " - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -" +
                    " - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -";
            }
            else
                str = currentString + "_";

            renderer.AddText( font, str, new Vec2( x, y ), HorizontalAlign.Left,
                VerticalAlign.Center, new ColorValue( 1, 1, 1, transparency ) );

            y -= fontheight + fontheight * .5f;

            int startpos = stringDownPosition;
            if( startpos > strings.Count - 1 )
                startpos = strings.Count - 1;
            for( int n = startpos; n >= 0 && y - fontheight > 0; n-- )
            {
                renderer.AddText( font, strings[ n ].text, new Vec2( x, y ), HorizontalAlign.Left,
                    VerticalAlign.Center, strings[ n ].color * new ColorValue( 1, 1, 1, transparency ) );
                y -= fontheight;
            }
        }

        protected override void OnRenderUI(GuiRenderer renderer)
        {
            base.OnRenderUI(renderer);

            //Draw some HUD information
            if (GetPlayerUnit() != null)
            {
                UpdateHuds();

                if (GetRealCameraType() != CameraType.Free && !IsCutSceneEnabled() &&
                    GetActiveObserveCameraArea() == null)
                {
                    DrawTarget(renderer);

                    if (GetPlayerUnit() as AKunit != null || GetPlayerUnit() as Unit != null || GetPlayerUnit() as PlayerCharacter != null)
                    {
                        drawRadar(renderer);
                        UpdateAKunitHUD(renderer);
                    }
                }

                DrawPlayerInformation(renderer);

                if (EngineApp.Instance.IsKeyPressed(EKeys.F1) && !EngineConsole.Instance.Active)
                    DrawPlayersStatistics(renderer);

                if (GameNetworkServer.Instance != null || GameNetworkClient.Instance != null)
                {
                    renderer.AddText("\"F1\" for players statistics", new Vec2(.01f, .1f),
                        HorizontalAlign.Left, VerticalAlign.Top, new ColorValue(1, 1, 1, .5f));
                }
            }

            //Game is paused on server
            if (EntitySystemWorld.Instance.IsClientOnly() && !EntitySystemWorld.Instance.Simulation)
            {
                renderer.AddText("Game is paused on server", new Vec2(.5f, .5f),
                    HorizontalAlign.Center, VerticalAlign.Center, new ColorValue(1, 0, 0));
            }

            //screenMessages
            {
                Vec2 pos = new Vec2(.01f, .65f);
                for (int n = screenMessages.Count - 1; n >= 0; n--)
                {
                    ScreenMessage message = screenMessages[n];

                    ColorValue color = new ColorValue(1, 1, 1, message.timeRemaining);
                    if (color.Alpha > 1)
                        color.Alpha = 1;

                    renderer.AddText(message.text, pos, HorizontalAlign.Left, VerticalAlign.Top,
                        color);
                    pos.Y -= renderer.DefaultFont.Height;
                }
            }
        }

//.........这里部分代码省略.........
                bool ignore = false;

                MapObject obj = MapSystemWorld.GetMapObjectByBody(result.Shape.Body);

                Dynamic dynamic = obj as Dynamic;
                Unit Dunit = obj as Unit;
                if (dynamic != null && playerUnit != null && dynamic.GetParentUnit() == GetPlayerUnit())
                    ignore = true;

                if (dynamic != null && dynamic.GetParentUnit() != GetPlayerUnit())
                {
                    targetgizmo(true);
                    if (Dunit != null && akunit != null)
                    {
                        if ((Dunit.Intellect != null && Dunit.Intellect.Faction != akunit.Intellect.Faction)
                           || (EngineApp.Instance.IsKeyPressed(EKeys.Q))

                           )
                            akunit.CurrentReticuleTarget = Dunit;
                    }
                    else if (Dunit != null && playerunit != null)
                    {
                        if ((Dunit.Intellect != null && Dunit.Intellect.Faction != playerunit.Intellect.Faction)
                           || (EngineApp.Instance.IsKeyPressed(EKeys.Q))

                           )
                            playerunit.CurrentReticuleTarget = Dunit;
                    }
                }
                else
                {
                    targetgizmo(false);
                }

                if (!ignore)
                {
                    body = result.Shape.Body;
                    break;
                }
            }

            if (akunit == null)
            {
                renderer.AddText("¤", new Vec2(.5f, .5f), HorizontalAlign.Center, VerticalAlign.Center);
                renderer.AddText("(  )", new Vec2(.5f, .5f), HorizontalAlign.Center, VerticalAlign.Center);
            }

            if (playerunit == null)
            {
                renderer.AddText("¤", new Vec2(.5f, .5f), HorizontalAlign.Center, VerticalAlign.Center);
                renderer.AddText("(  )", new Vec2(.5f, .5f), HorizontalAlign.Center, VerticalAlign.Center);
            }

            //if (body != null)
            //{
            //    MapObject obj = MapSystemWorld.GetMapObjectByBody(body);
            //    if (obj != null && (obj as GameGuiObject) == null)
            //    {
            //        renderer.AddText(obj.Type.Name, new Vec2(.5f, .525f),
            //            HorizontalAlign.Center, VerticalAlign.Center);

            //        Dynamic dynamic = obj as Dynamic;
            //        if (dynamic != null)
            //        {
            //            if (dynamic.Type.LifeMax != 0)
            //            {
            //                float lifecoef = dynamic.Life / dynamic.Type.LifeMax;

            //                renderer.AddText("||||||||||", new Vec2(.5f - .04f, .55f), HorizontalAlign.Left,
            //                    VerticalAlign.Center, new ColorValue(.5f, .5f, .5f, .5f));

            //                float count = lifecoef * 10;
            //                String s = "";
            //                for (int n = 0; n < count; n++)
            //                    s += "|";

            //                renderer.AddText(s, new Vec2(.5f - .04f, .55f),
            //                    HorizontalAlign.Left, VerticalAlign.Center, new ColorValue(0, 1, 0, 1));
            //            }
            //            // we dont need to show mass

            //            //if (dynamic.PhysicsModel != null)
            //            //{
            //            //    float mass = 0;
            //            //    foreach (Body s in dynamic.PhysicsModel.Bodies)
            //            //        mass += s.Mass;
            //            //    string ss = string.Format("mass {0}", mass);
            //            //    renderer.AddText(ss, new Vec2(.5f - .04f, .6f),
            //            //        HorizontalAlign.Left, VerticalAlign.Center, new ColorValue(0, 1, 0, 1));
            //            //}
            //        }
            //    }
            //}

            //Tank specific
            DrawTankGunTarget(renderer);

            //AKunit spesific
            //DrawAKunitGunTarget(renderer);
        }

        void DrawPlayersStatistics( GuiRenderer renderer )
        {
            if( IsCutSceneEnabled() )
                return;

            if( PlayerManager.Instance == null )
                return;

            renderer.AddQuad( new Rect( .1f, .2f, .9f, .8f ), new ColorValue( 0, 0, 1, .5f ) );

            renderer.AddText( "Players statistics", new Vec2( .5f, .25f ),
                HorizontalAlign.Center, VerticalAlign.Center );

            if( EntitySystemWorld.Instance.IsServer() || EntitySystemWorld.Instance.IsSingle() )
            {
                float posy = .3f;

                foreach( PlayerManager.ServerOrSingle_Player player in
                    PlayerManager.Instance.ServerOrSingle_Players )
                {
                    string text = string.Format( "{0},   Frags: {1},   Ping: {2} ms", player.Name,
                        player.Frags, (int)( player.Ping * 1000 ) );
                    renderer.AddText( text, new Vec2( .2f, posy ), HorizontalAlign.Left,
                        VerticalAlign.Center );

                    posy += .025f;
                }
            }

            if( EntitySystemWorld.Instance.IsClientOnly() )
            {
                float posy = .3f;

                foreach( PlayerManager.Client_Player player in PlayerManager.Instance.Client_Players )
                {
                    string text = string.Format( "{0},   Frags: {1},   Ping: {2} ms", player.Name,
                        player.Frags, (int)( player.Ping * 1000 ) );
                    renderer.AddText( text, new Vec2( .2f, posy ), HorizontalAlign.Left,
                        VerticalAlign.Center );

                    posy += .025f;
                }
            }
        }