source: branches/HeuristicLab.Problems.GaussianProcessTuning/ILNumerics.2.14.4735.573/Drawing/Platform/OpenGL/ILOGLWorldRenderer.cs @ 9102

///
///    This file is part of ILNumerics Community Edition.
///
///    ILNumerics Community Edition - high performance computing for applications.
///    Copyright (C) 2006 - 2012 Haymo Kutschbach, http://ilnumerics.net
///
///    ILNumerics Community Edition is free software: you can redistribute it and/or modify
///    it under the terms of the GNU General Public License version 3 as published by
///    the Free Software Foundation.
///
///    ILNumerics Community Edition is distributed in the hope that it will be useful,
///    but WITHOUT ANY WARRANTY; without even the implied warranty of
///    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
///    GNU General Public License for more details.
///
///    You should have received a copy of the GNU General Public License
///    along with ILNumerics Community Edition. See the file License.txt in the root
///    of your distribution package. If not, see <http://www.gnu.org/licenses/>.
///
///    In addition this software uses the following components and/or licenses: 
///
///    =================================================================================
///    The Open Toolkit Library License
///    
///    Copyright (c) 2006 - 2009 the Open Toolkit library.
///    
///    Permission is hereby granted, free of charge, to any person obtaining a copy
///    of this software and associated documentation files (the "Software"), to deal
///    in the Software without restriction, including without limitation the rights to 
///    use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
///    the Software, and to permit persons to whom the Software is furnished to do
///    so, subject to the following conditions:
///
///    The above copyright notice and this permission notice shall be included in all
///    copies or substantial portions of the Software.
///
///    =================================================================================
///    

using System;
using System.Text;
using System.Drawing;  
using System.Collections.Generic;
using ILNumerics.Drawing.Interfaces; 
using OpenTK; 
using OpenTK.Graphics;
using OpenTK.Graphics.OpenGL; 
using OpenTK.Graphics.OpenGL.Enums; 
using ILNumerics.Drawing; 
using ILNumerics.Drawing.Labeling;  

namespace ILNumerics.Drawing.Platform.OpenGL {
    /// <summary>
    /// Basic OpenGL implementation for IILTextRenderer
    /// </summary>
    [ILRenderer(GraphicDeviceType.OpenGL,"Outline","OpenGL cached, outlined textures, world coords",true,CoordSystem.World3D)] 
    public class ILOGLWorldRenderer : IILTextRenderer {

        #region event handling
        /// <summary>
        /// fires when the texture storage has been cleared 
        /// </summary>
        public event EventHandler CacheCleared; 
        void m_textureManager_TextureCacheCleared(object sender, EventArgs e) {
            if (CacheCleared != null) 
                CacheCleared(this,null);
        }
        #endregion

        #region member / properties
        ILTextureManager m_textureManager; 
        float[] m_curPosition = new float[16];
        Color m_colorOverride; 
        #endregion

        #region constructors

        public ILOGLWorldRenderer (ILPanel panel) {
            m_textureManager = panel.TextureManager;
            m_textureManager.TextureCacheCleared += new EventHandler(m_textureManager_TextureCacheCleared);
        }
           
        #endregion

        #region IILTextRenderer Member
        
        public CoordSystem CoordSystem {
            get { return CoordSystem.World3D; }
        }

        public bool Cached { 
            get {
                return true; 
            }
        }

        public string Name {
            get { return "Outline fonts"; }
        }

        public string NameLong {
            get { return "OpenGL outline fonts (OpenTK)"; }
        }

        public GraphicDeviceType DeviceType {
            get { return GraphicDeviceType.OpenGL; }
        }

        public bool DrawAfterBufferSwapped {
            get { return false; }
        }

        public void Begin(ILRenderProperties p) {
            if (GraphicsContext.CurrentContext == null)
                throw new GraphicsContextException("No GraphicsContext is current in the calling thread.");

            GL.PushAttrib(AttribMask.TextureBit | AttribMask.EnableBit | AttribMask.ColorBufferBit);

            GL.Enable(EnableCap.Texture2D);
            GL.Enable(EnableCap.Blend);
            GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
            GL.Disable(EnableCap.DepthTest);
        }
        public void Begin (ILRenderProperties p, ref double[] modelview) {
            if (modelview == null || modelview.Length < 12) {
                modelview = new double[16]; 
            }
            GL.GetDouble(GetPName.ModelviewMatrix,modelview);
            Begin(p); 
        }

        public void End(ILRenderProperties p) {
            GL.PopAttrib();
        }
        #endregion

        #region IILTextRenderer Member
        /// <summary>
        /// Place a new item into the texture cache 
        /// </summary>
        /// <param name="key">unique key to identify the item for later reference</param>
        /// <param name="bmp">bitmap containing the item data</param>
        /// <param name="rect">area in <paramref name="bmp"/> containing the item's data</param>
        public void Cache(string key, Bitmap bmp, RectangleF rect) {
            m_textureManager.StoreTextureItem(key,bmp,rect); 
        }

        /// <summary>
        /// Test if the cache contains an item with a specific key
        /// </summary>
        /// <param name="key">key</param>
        /// <returns>true if the item was cached, false otherwise</returns>
        public bool ExistsKey(string key) {
            return m_textureManager.Exists(key); 
        }

        /// <summary>
        /// try to get the size (screen pixels) of an item
        /// </summary>
        /// <param name="key">unique key identifying the item</param>
        /// <param name="size">[output] size of the item (if found)</param>
        /// <returns>true, if the item was found, false otherwise</returns>
        public bool TryGetSize(string key, ref Size size) {
            ILTextureData item; 
            if (m_textureManager.TryGetTextureItem(key,out item)) {
                size = new Size(item.Width,item.Height); 
                return true; 
            } else {
                return false; 
            }
        }

        /// <summary>
        /// Draws all items contained in a given render queue
        /// </summary>
        /// <param name="queue">render queue</param>
        /// <param name="x1">x1-position</param>
        /// <param name="y1">y1-position</param>
        /// <param name="z1">z1-position</param>
        /// <param name="x2">x2-position</param>
        /// <param name="y2">y2-position</param>
        /// <param name="z2">z2-position</param>
        /// <param name="color">base color for items not containing individual colors</param>
        /// <remarks><para>The render queue must contain only keys for already cached items!</para>
        /// <para>The color parameter serves as a global color definition. It may be overwritten 
        /// by individual color specifications of the queue items.</para>
        /// <para>Use this function to draw the render queue in world coords. The position parameters mark the upper left 
        /// and lower right corner of the quads to contain the render queue content.</para>
        /// </remarks>
        public void Draw(ILRenderQueue queue, 
                        float x1, float y1, float z1, float x2, float y2, float z2, 
                        Color color) {
            float x, y, xm, ym;

            xm = (x2 - x1)/(queue.Size.Width);
            ym = (y2 - y1)/(queue.Size.Height); 
            x = 0.5f; y = 0.5f; 
            int lineHeight = 0; 
            m_textureManager.Reset(); 
            GLColor3(color); 
            
            foreach (ILRenderQueueItem item in queue) {
                // special symbols & control sequences 
                switch (item.Key) {
                case "\r":
                    x = 0.5f; 
                    break; 
                case "\n": 
                    x = 0.5f; 
                    y += lineHeight; 
                    lineHeight = 0; 
                    break; 
                default: 
                    //since textures (may) lay on different sheets in GL memory,
                    // we cannot switch them in between Begin() and End(), 
                    // we must start a new Begin with each Quad :(
                    // possible workaround: If only one sheet is used, draw all 
                    // quads at once.
                    ILTextureData textData = m_textureManager.GetTextureItem(item.Key,true); 
                    if (item.Color != Color.Empty) {
                        GLColor3(item.Color); 
                    } else {
                        GLColor3(color); 
                    }
                    GL.Begin(BeginMode.Quads); 
                    RectangleF rectF = textData.TextureRectangle; 
                    GL.TexCoord2(rectF.Left,rectF.Bottom);   
                    GL.Vertex3(x*xm + x1,(y + textData.Height + item.Offset.Y-1)*ym+y1,z1);      // ul
                    GL.TexCoord2(rectF.Left,rectF.Top); 
                    GL.Vertex3(x*xm + x1,(y+ item.Offset.Y)*ym+y1,z1);                    // bl
                    x += textData.Width-1; 
                    GL.TexCoord2(rectF.Right,rectF.Top); 
                    GL.Vertex3(x*xm + x1,(y+ item.Offset.Y)*ym+y1,z1);                    // br
                    GL.TexCoord2(rectF.Right,rectF.Bottom); 
                    GL.Vertex3(x*xm + x1,(y + textData.Height+ item.Offset.Y-1)*ym+y1,z1);      // tr
                    if (textData.Height > lineHeight)
                        lineHeight = textData.Height; 
                    GL.End(); 
#if BOUNDINGBOXES_ITEM
            //// define DEBUG symbol to draw bounding box around each item (debug feature)
            // todo: modify to draw in world coords if needed!!
            //GL.Color3(Color.Red); 
            //GL.Begin(BeginMode.LineLoop); 
            //    w-= textData.Width; 
            //    GL.Vertex2(w,h + textData.Height);      // ul
            //    GL.Vertex2(w,h);                    // bl
            //    w += textData.Width; 
            //    GL.Vertex2(w,h);                    // br
            //    GL.Vertex2(w,h + textData.Height);      // tr
            //GL.End();
#endif
                    break; 
                }
            }
#if BOUNDINGBOXES
            //// define debugsymbol "BOUNDINGBOXES", to draw bounding box around whole expression
            // todo: modify to draw in world coords if needed!!
            //GL.Disable(EnableCap.Texture2D); 
            //GL.Color3(Color.Red); 
            //GL.LineWidth(1); 
            //GL.Begin(BeginMode.LineLoop); 
            //    GL.Vertex2(0,0);      // ul
            //    GL.Vertex2(0,queue.Size.Height);                    // bl
            //    GL.Vertex2(queue.Size.Width,queue.Size.Height);                    // br
            //    GL.Vertex2(queue.Size.Width,0);      // tr
            //GL.End();
            //GL.Enable(EnableCap.Texture2D); 
#endif
        }

        public void Draw(ILRenderQueue renderQueue, Point position, TextOrientation orientation, Color color) {
            Draw(renderQueue,position.X,position.Y,0,position.X + renderQueue.Size.Width,position.Y+renderQueue.Size.Height,0,color); 
        }

        public Color ColorOverride {
            get {
                return m_colorOverride;
            }
            set {
                m_colorOverride = value;
            }
        }

        #endregion

        private void GLColor3(Color color) {
            if (m_colorOverride.IsEmpty) {
                GL.Color3(color);
            } else {
                GL.Color3(m_colorOverride);
            }
        }

    }
}