protected override void  OnRenderCore(DrawingContext dc, RenderState state)
        {
            if (DataSource == null) return;
            var transform = Plotter2D.Viewport.Transform;

            Rect bounds = Rect.Empty;
            using (IPointEnumerator enumerator = DataSource.GetEnumerator(GetContext()))
            {
                Point point = new Point();
                while (enumerator.MoveNext())
                {
                    enumerator.GetCurrent(ref point);
                    enumerator.ApplyMappings(this);

                    Point zero = new Point(point.X, 0);
                    Point screenPoint = point.DataToScreen(transform);
                    Point screenZero = zero.DataToScreen(transform);

                    double height = screenPoint.Y = screenZero.Y;
                    height = (height >= 0) ? height : -height;

                    dc.DrawRectangle(Fill, new Pen(Stroke, StrokeThickness),
                                     new Rect(screenPoint.X - BarWidth / 2, screenZero.Y, BarWidth, height));

                    bounds = Rect.Union(bounds, point);
                }
            }

            ContentBounds = bounds;
        }

 public void StartEffect(string text, float duration)
 {
     _renderState = RenderState.Rendering;
     _sequense = null;
     _sequense = DOTween.Sequence();
     _animation = _textUI.DOText(text, duration);
     _sequense.Append(_animation);
     _sequense.AppendCallback(new TweenCallback(FinishDisplay));
 }

        /// <summary>
        /// Renders the control</summary>
        /// <param name="action">Render action</param>
        /// <param name="camera">Camera</param>
        /// <param name="state">Render state</param>
        /// <param name="transform">Transform</param>
        public void Render(IRenderAction action, Camera camera, RenderState state, Matrix4F transform)
        {
            float s1, s2, s3;

            // apply xform
            Gl.glPushMatrix();
            Util3D.glMultMatrixf(transform);

            CalcAxisLengths(camera, transform, out s1, out s2, out s3);

            bool drawX, drawY, drawZ;
            DecideArrowDrawing(transform, camera, out drawX, out drawY, out drawZ);

            if (drawX)
            {
                RenderXArrow(s1);
                RenderXAxis(s1);
            }
            if (drawY)
            {
                RenderYArrow(s2);
                RenderYAxis(s2);
            }
            if (drawZ)
            {
                RenderZArrow(s3);
                RenderZAxis(s3);
            }

            RenderXYSquare(s1 * SquareLength, s2 * SquareLength, true);
            RenderYZSquare(s2 * SquareLength, s3 * SquareLength, true);
            RenderXZSquare(s1 * SquareLength, s3 * SquareLength, true);
            
            Gl.glPopMatrix();
        }

 public Renderer(GraphicsDevice device, RenderState renderState)
 {
     RenderState  = renderState;
     Device = device;
     _effect = new BasicEffect(Device);
     _bufferedInstructions = new List<IEnumerable<RenderInstruction>>();
 }

        /// <summary>
        /// The method that is passed to the BitmapContext for rendering the image using OpenGl</summary>
        private void Paint()
        {
            // Setup render state. Copied from RenderCommands.DoCommand()'s RenderSmooth.
            RenderState rs = new RenderState();
            rs.RenderMode =
                RenderMode.Smooth |
                RenderMode.SolidColor |
                RenderMode.Lit |
                RenderMode.CullBackFace |
                RenderMode.Textured;
            rs.SolidColor = new Vec4F(1, 1, 1, 1);
            m_scene.StateStack.Push(rs);

            // Change some settings related to printing information text. We don't want it.
            string originalTitle = m_action.Title;
            m_action.Title = string.Empty;
            bool originalStatsEnabled = Util3D.RenderStats.Enabled;
            Util3D.RenderStats.Enabled = false;

            // Dispatch the scene
            m_action.Dispatch(m_scene, m_camera);

            // Restore some settings.
            m_action.Title = originalTitle;
            Util3D.RenderStats.Enabled = originalStatsEnabled;
        }

		protected override void PreRenderCode(RenderState state)
		{
			if (ShowMeasure)
				AddMeasure();
			IsGrey = true;

			base.PreRenderCode(state);
		}

 /// <summary>
 /// Constructor</summary>
 /// <param name="renderObject">RenderObject. A reference is held to this, so that IRenderObject.Dispatch
 /// can be called.</param>
 /// <param name="transform">Transform to use when dispatching the RenderObject; a reference is held</param>
 /// <param name="graphPath">Graph path leading to RenderObject; a reference is held</param>
 /// <param name="renderState">RenderState to use for RenderObject; is copied</param>
 public TraverseNode(
     IRenderObject renderObject,
     Matrix4F transform,
     Stack<SceneNode> graphPath,
     RenderState renderState)
 {
     Init(renderObject, transform, graphPath, renderState);
 }

 public GraphicsDevice()
 {
     BitmapCacheEnabled = true;
     RenderAtScale = 1;
     RenderState = new RenderState();
     PresentationParameters = new PresentationParameters();
     PresentationParameters.BackBufferFormat = SurfaceFormat.Canvas;
 }

    public void SetTemporaryRenderState(RenderState renderState, int value)
    {
      int oldState = _device.GetRenderState(renderState);
      if (oldState.Equals(value))
        return;

      _changedStates[renderState] = oldState;
      _device.SetRenderState(renderState, value);
    }

 public TextureBaker(GraphicsDevice graphicsDevice, int width, int height, RenderState state)
     : base(graphicsDevice)
 {
     _renderTarget = new RenderTarget2D(GraphicsDevice, width, height);
     GraphicsDevice.SetRenderTarget(_renderTarget);
     GraphicsDevice.Clear(Color.Transparent);
     Begin(SpriteSortMode.Immediate, BlendState.Opaque);
     SetState(state);
 }

        public async Task<Errorable<bool>> ProcessCustomElement(string elementName, RenderState state)
        {
            if (elementName != "cms-scheduled") return false;

            var err = await processScheduledElement(state).ConfigureAwait(continueOnCapturedContext: false);
            if (err.HasErrors) return err.Errors;

            return true;
        }

        public FontStyle( string fontName )
        {
            Font = _UI.Font.Get( fontName );
            RenderState = new RenderState( (int)E_Effect.IntensityAsAlpha_PMA, E_BlendState.AlphaBlend );

            TrackingPercentage = 0.0f;
            HeightPercentage = 1.0f;

            RenderPasses = new List< FontStyleRenderPass >();
        }

 // Init
 public void Init()
 {
     Texture.TextureIndex = 0;
     Texture.PUV = new Vector2( 0.0f );
     Texture.SUV = new Vector2( 1.0f );
     Color = 0xffffffff;
     AspectRatio = 1.0f;
     Scale = 1.0f;
     RenderState = new RenderState( (int)E_Effect.MultiTexture1, E_BlendState.AlphaBlend );
     LayerOffset = 0;
 }

 /// <summary>
 /// Initializes instance</summary>
 /// <param name="renderObject">RenderObject. A reference is held to this, so that IRenderObject.Dispatch
 /// can be called.</param>
 /// <param name="transform">Transform to use when dispatching the RenderObject; a reference is held</param>
 /// <param name="graphPath">Graph path leading to RenderObject; a reference is held</param>
 /// <param name="renderState">RenderState to use for RenderObject; is copied</param>
 public void Init(
     IRenderObject renderObject,
     Matrix4F transform,
     Stack<SceneNode> graphPath,
     RenderState renderState)
 {
     m_renderObject = renderObject;
     m_transform = transform;
     m_renderState.Init(renderState);
     m_graphPath = graphPath.ToArray();//faster to create every time than to cache!
 }

        private static bool RenderStatesDiffer(RenderState oldRenderState, RenderState newRenderState, RenderMode flag)
        {
            bool oldRenderStateNull = (oldRenderState == null);
            bool newFlag = ((newRenderState.RenderMode & flag) != 0);

            if (oldRenderStateNull)
                return true;

            bool oldFlag = ((oldRenderState.RenderMode & flag) != 0);

            return oldFlag != newFlag;
        }

        protected internal void Render(RenderState state)
        {
            for(int i=0;i<subBatchs.Count;i++)
                subBatchs[i].Render(state);

            Graphics.device.SetRenderTarget(backbuffer);
            state.spriteBatch.Begin(SpriteSortMode.BackToFront, BlendState.AlphaBlend);
            for (int i = 0; i < drawCalls.Count; i++)
                drawCalls[i].Render(state);
            state.spriteBatch.End();
            drawCalls.Clear();

            subBatchs.Clear();
        }

		protected override void PreRenderModule(RenderState state)
		{
			base.PreRenderModule(state);

			if (!ShowModuleShading)
				return;

			if (IsGrey)
			{
				Canvas.FillRectangle(Brushes.Gray, state.Location.X, Settings.TopMargin, (state.CurrentPattern.WideCount * Settings.WideWidth) + (state.CurrentPattern.NarrowCount * Settings.NarrowWidth), Canvas.VisibleClipBounds.Height);
			}
			IsGrey = !IsGrey;

		}

        private static void CommitSmooth(RenderState renderState, RenderState previousRenderState)
        {
            if ((renderState.RenderMode & RenderMode.Smooth) != 0)
            {
                if (RenderStatesDiffer(previousRenderState, renderState, RenderMode.Smooth))
                {
                    Gl.glShadeModel(Gl.GL_SMOOTH);
                    Gl.glPolygonMode(Gl.GL_FRONT_AND_BACK, Gl.GL_FILL);
                    Util3D.RenderStats.RenderStateChanges++;
                    //Console.WriteLine("CommitSmooth");
                }

                Vec4F color = renderState.SolidColor;
                Gl.glColor4f(color.X, color.Y, color.Z, color.W);
            }
        }

        /// <summary>
        /// Renders a renderable components and applies its required renderstate if necessary.
        /// </summary>
        void Render(ICamera camera, RenderComponent renderable) {
            RenderState desiredState = renderable.RenderState;

            if (desiredState != null) {
                if (_currentlyEnabledState != desiredState) {
                    if (_currentlyEnabledState != null) {
                        _currentlyEnabledState(false);
                    }

                    desiredState(true);

                    _currentlyEnabledState = desiredState;
                }
            }

            renderable.Render(camera);
        }

        /// <summary>
        /// LoadContent will be called once per game and is the place to load
        /// all of your content.
        /// </summary>
        public void LoadContent()
        {
            // Create a new SpriteBatch, which can be used to draw textures.
            _spriteBatch = new SpriteBatch(_gdm.GraphicsDevice);
            RenderState renderState = new RenderState(_spriteBatch.GetScreenDimensions());
            _renderer = new Renderer(_gdm.GraphicsDevice, renderState);

            _mouseCursorTexture = _content.Load<Texture2D>("cursor");
            _logFont            = _content.Load<SpriteFont>("LogFont");

            LoadFile("../../gamedata.haumea");

            foreach (IView view in _views)
            {
                view.LoadContent(_content);
            }
        }