/// <summary>
 /// Initialize a new instance of the ViewContext class.
 /// </summary>
 /// <param name="control">Control associated with rendering.</param>
 /// <param name="alignControl">Control used for aligning elements.</param>
 /// <param name="graphics">Graphics instance for drawing.</param>
 /// <param name="renderer">Rendering provider.</param>
 public ViewContext(Control control,
                    Control alignControl,
                    Graphics graphics,
                    IRenderer renderer)
     : this(null, control, alignControl, graphics, renderer)
 {
 }

        private void HandleCollision(IHungryCreature creature, IRenderer renderer)
        {
            List<GameFieldCoords> creatureElements = new List<GameFieldCoords>();

            foreach (GameFieldCoords element in creature.GetPosition())
            {
                creatureElements.Add(element);
            }

            foreach (GameFieldCoords element in creatureElements)
            {
                if (element.Row >= renderer.GameFieldSize.Row || element.Row < 0
                    || element.Col >= renderer.GameFieldSize.Col || element.Col < 0)
                {
                    creature.IsDestroyed = true;
                }
            }

            for (int element = 0; element < creatureElements.Count - 1; element++)
            {
                if (creatureElements.Last().Row == creatureElements[element].Row
                    && creatureElements.Last().Col == creatureElements[element].Col)
                {
                    creature.IsDestroyed = true;
                }
            }
        }

 public void RegisterFactory(string[] blocks, IRenderer renderer)
 {
     foreach (var block in blocks)
     {
         RegisterFactory(block, renderer);
     }
 }

 public GameController(IGameEngine gameEngine, IInputHandler inputReader, IRenderer renderer)
 {
     this.gameEngine = gameEngine;
     this.inputReader = inputReader;
     this.renderer = renderer;
     this.currentCmd = null;
 }

 public Engine(IRenderer renderer, int screenWidth, int screenHeight)
 {
     this.Renderer = renderer;
     this.ScreenWidth = screenWidth;
     this.ScreenHeight = screenHeight;
     this.Initialize();
 }

 public void Configure(IRenderer renderer)
 {
   foreach (var resource in _resources)
   {
     resource.Configure(renderer);
   }
 }

        public int FrameCountPerRender { get; set; } //number of frames per render (default = 1);


        public DrawingSurfaceSCBP(IRenderer renderer)
        {
            this.FrameCountPerRender = 1;

            //this.InitializeComponent();

            //if (!hasInitializedSurface)
            //{
            //    //effectRenderer = new EffectRenderer();

            //    var fpsRenderer = new FpsRenderer();

            //    d2dTarget = new SwapChainBackgroundPanelTarget(root);
            //    d2dTarget.OnRender += effectRenderer.Render;
            //    d2dTarget.OnRender += fpsRenderer.Render;

            //    deviceManager = new DeviceManager();
            //    deviceManager.OnInitialize += d2dTarget.Initialize;
            //    deviceManager.OnInitialize += effectRenderer.Initialize;
            //    deviceManager.OnInitialize += fpsRenderer.Initialize;

            //    deviceManager.Initialize(DisplayProperties.LogicalDpi);
            //    effectRenderer.InitializeUI(root, root);

            //    // Setup rendering callback
            //    CompositionTarget.Rendering += CompositionTarget_Rendering;

            //    if (_assetUri != string.Empty) effectRenderer.LoadLocalAsset(_assetUri);
            //}
        }

 public virtual void Configure(IRenderer renderer)
 {
   foreach (var textureParameter in _textureParameters)
   {
     _shader.SetTextureParameter(textureParameter.Key, textureParameter.Value);
   } 
 }

        public FeatureElement(Feature f, IRenderer renderer)
        {
            this.ClipBox = Rectangle2D.Empty;
            this.pathIsInvalid = true;
            if (f == null)
            {
                throw new ArgumentNullException("f");
            }
            this.feature = new WeakReference(f);

            if (renderer != null && (f.GetValue(Clusterer.ClusterProperty) == null))
            {
                this.GeoStyle = renderer.GetStyle(f) ?? generateDefaultSyle(f);
            }//renderer的优先级高于Feature自我的
            else
            {
                this.GeoStyle = f.Style ?? generateDefaultSyle(f);
            }
            f.SetBoundedStyle(this.GeoStyle);

            if (this.GeoStyle != null)
            {
                base.Template = this.GeoStyle.ControlTemplate;
            }

            this.Geometry = f.Geometry;
        }

        /// <summary>
        /// Initialize a new instance of the VisualPopupGroup class.
        /// </summary>
        /// <param name="ribbon">Reference to owning ribbon control.</param>
        /// <param name="ribbonGroup">Reference to ribbon group for display.</param>
        /// <param name="renderer">Drawing renderer.</param>
        public VisualPopupGroup(KryptonRibbon ribbon,
                                KryptonRibbonGroup ribbonGroup,
                                IRenderer renderer)
            : base(renderer, true)
        {
            Debug.Assert(ribbon != null);
            Debug.Assert(ribbonGroup != null);

            // Remember references needed later
            _ribbon = ribbon;
            _ribbonGroup = ribbonGroup;

            // Create a view element for drawing the group
            _viewGroup = new ViewDrawRibbonGroup(ribbon, ribbonGroup, NeedPaintDelegate);
            _viewGroup.Collapsed = false;

            // Create the background that will contain the actual group instance
            _viewBackground = new ViewDrawRibbonGroupsBorder(ribbon, true, NeedPaintDelegate);
            _viewBackground.Add(_viewGroup);

            // Attach the root to the view manager instance
            ViewManager = new ViewRibbonPopupGroupManager(this, ribbon, _viewBackground, _viewGroup, NeedPaintDelegate);

            // Create and add a hidden button to act as the focus target
            _hiddenFocusTarget = new Button();
            _hiddenFocusTarget.TabStop = false;
            _hiddenFocusTarget.Location = new Point(-_hiddenFocusTarget.Width, -_hiddenFocusTarget.Height);
            CommonHelper.AddControlToParent(this, _hiddenFocusTarget);
        }

    public CompositeWindow(IController controller, IRenderer renderer, double frameRate)
    {
      if (controller == null) throw new ArgumentNullException("controller");
      if (renderer == null) throw new ArgumentNullException("renderer");
      _controller = controller;
      _renderer = renderer;
      _frameRate = frameRate;
      Width = controller.Width;
      Height = controller.Height;
      if (_controller.IsFullScreen)
        WindowState = WindowState.Maximized;
      Title = controller.Name;

      InitializeComponent();
      if (_controller.HasUserInterface)
      {
        if(_controller.CentralView != null)
          MainGrid.Children.Add((UIElement)_controller.CentralView);
        if (_controller.LeftView != null)
          LeftGrid.Children.Add((UIElement)_controller.LeftView);
        if (_controller.RightView != null)
          RightGrid.Children.Add((UIElement)_controller.RightView);
        if (_controller.TopView != null)
          TopGrid.Children.Add((UIElement)_controller.TopView);
        if (_controller.BottomView != null)
          BottomGrid.Children.Add((UIElement)_controller.BottomView);
        
      }
      Loaded += OnLoaded;
      SizeChanged += OnSizeChanged;
      
    }

 /// <summary>
 /// Initializes a new instance of the <see cref="GameEngine" /> class.
 /// </summary>
 /// <param name="renderer">The game renderer.</param>
 /// <param name="inputMethod">The user input method.</param>
 public GameEngine(IRenderer renderer, IInputMethod inputMethod)
 {
     this.gameRenderer = renderer;
     this.inputMethod = inputMethod;
     this.scores = new HighScores(MaxTopPlayers);
     this.cmdExecutor = new DefaultGameCommandExecutor(this.gameRenderer, this.inputMethod, this.scores);
 }

 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="player">Player instance</param>
 /// <param name="renderer">IRender instance</param>
 /// <param name="controller">IControler instance</param>
 /// <param name="scoreBoard">Scoreboard instance</param>
 public Engine(Player player, IRenderer renderer, IController controller, ScoreBoard scoreBoard)
 {
     this.Player = player;
     this.Renderer = renderer;
     this.Controller = controller;
     this.ScoreBoard = scoreBoard;
 }

        public Tube( IRenderer renderer )
        {
            ReferenceVertices = new GLVector3d[ 4 ];

            ReferenceVertices[0] = new GLVector3d( 0.5, -0.5, 0 );
            ReferenceVertices[1] = new GLVector3d( 0.5, 0.5, 0 );
            ReferenceVertices[2] = new GLVector3d( -0.5, 0.5, 0 );
            ReferenceVertices[3] = new GLVector3d( -0.5, -0.5, 0 );

            iFirstOuterFace = 0;
            iLastOuterFace = 3;

            iNumberFaces = 4;

            bShowCut = false;
            bShowHollow = false;

            iCutStart = 0;
            iCutEnd = MaxCut;

            this.renderer = renderer;
            SendRendererCallbacksToCrossSections();

            rotationalextrusionpath.UpdatePath();
            BuildFaces();
        }

        public MatchRunner(IMatch match, string playerOneFolder, string playerTwoFolder, IRenderer renderer, bool consoleLoggingDisabled, bool consoleLoggingMustScroll, string replayFolder)
        {
            Match = match;
            Renderer = renderer;

            string runFilename = Environment.OSVersion.Platform == PlatformID.Unix ? Settings.Default.BotRunFilenameLinux : Settings.Default.BotRunFilename;
            _players = new BotRunner[2];
            _players[0] = new BotRunner(
                1,
                playerOneFolder,
                runFilename
                );
            _players[1] = new BotRunner(
                2,
                playerTwoFolder,
                runFilename
                );

            match.SetPlayerName(1, _players[0].PlayerName);
            match.SetPlayerName(2, _players[1].PlayerName);

            _replayLogger = new ReplayLogger(replayFolder);

            SetupLogging(consoleLoggingDisabled, consoleLoggingMustScroll);
        }

 public Form1(IRenderer renderer)
 {
     m_Renderer = renderer;
     InitializeComponent();
     string handle = panel1.Handle.ToString();
     m_Renderer.CreateRenderWindow(handle);
 }

 public void Render(IRenderer renderer)
 {
     foreach (var position in this.elements)
     {
         renderer.Render(position.x, position.y, 'o');
     }
 }

 public GameEngine(IReader reader, IRenderer renderer)
 {
     Reader = reader;
     Renderer = renderer;
     this.creepsList = new List<Npc>();
     this.items = new List<Item>();
 }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="container"></param>
        /// <param name="renderer"></param>
        /// <returns></returns>
        private static Viewbox ToViewbox(Container container, IRenderer renderer)
        {
            var visual = new DrawingVisual();

            using (var dc = visual.RenderOpen())
            {
                renderer.Draw(dc, container, container.Properties, null);
            }

            visual.Drawing.Freeze();

            var host = new VisualHost()
            {
                Width = container.Width,
                Height = container.Height
            };

            host.Visuals.Add(visual);

            var vb = new Viewbox()
            {
                Stretch = Stretch.Uniform
            };

            vb.Child = host;

            return vb;
        }

        public virtual void Draw(ScrollbarButton Button, IRenderer Renderer)
        {
            ILineStyleInfo TopLeft;
            ILineStyleInfo BottomRight;

            if (Button.State == ScrollbarButton.ButtonState.Normal)
            {
                TopLeft = LightBorder;
                BottomRight = DarkBorder;
            }
            else
            {
                TopLeft = DarkBorder;
                BottomRight = LightBorder;
            }

            Rect R = Button.Bounds;
            int x1 = R.Location.X;
            int y1 = R.Location.Y;
            int x2 = R.Right;
            int y2 = R.Bottom;

            DrawBackground(Button, Renderer);

            Renderer.DrawOperations.DrawLine(x1, y1, x2, y1, TopLeft);
            Renderer.DrawOperations.DrawLine(x1, y1, x1, y2, TopLeft);
            Renderer.DrawOperations.DrawLine(x2, y1, x2, y2, BottomRight);
            Renderer.DrawOperations.DrawLine(x1, y2, x2 + 1, y2, BottomRight);
        }