Ejemplo n.º 1
0
        public SimpleCanvas(int view_width, int view_height)
        {
            FillColor   = Color.Black;
            StrokeColor = Color.Black;

            //dimension
            _view_width  = view_width;
            _view_height = view_height;
            _max         = Math.Max(view_width, view_height);
            //------------
            //matrix
            ////square viewport
            _orthoView        = MyMat4.ortho(0, _max, 0, _max, 0, 1);
            _flipVerticalView = MyMat4.scale(1, -1) * MyMat4.translate(new OpenTK.Vector3(0, -_max, 0));
            _orthoAndFlip     = _orthoView * _flipVerticalView;
            //-----------------------------------------------------------------------
            //shader
            _shaderRes           = new CanvasToShaderSharedResource();
            _shaderRes.OrthoView = _orthoView;
            //
            _fillShader = new GlyphFillShader(_shaderRes);
            //------------
            //tools
            Tesselate.Tesselator tt = new Tesselate.Tesselator();
            _tessTool       = new TessTool(tt);
            _curveFlattener = new SimpleCurveFlattener();
            ClearColor      = Color.White;
            //--------
            //set blend mode
            GL.Enable(EnableCap.Blend);
            GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
        }
Ejemplo n.º 2
0
        protected override void OnTimerTick(object sender, EventArgs e)
        {
            if (!isGLInit)
            {
                return;
            }


            float dt = 0.5f;

            mRotation = (float)fmod(mRotation + (dt * 40.0f), 360.0f);
            //Matrix4 perspectiveMatrix = Matrix4::perspective(60.0f, float(getWindow()->getWidth()) / getWindow()->getHeight(),
            //                                                 1.0f, 20.0f);
            MyMat4 perspectiveMat = MyMat4.perspective(60.0f, (float)Width / (float)Height, 1.0f, 20.0f);
            //Matrix4 modelMatrix = Matrix4::translate(Vector3(0.0f, 0.0f, -2.0f)) *
            //                      Matrix4::rotate(mRotation, Vector3(1.0f, 0.0f, 1.0f));

            MyMat4 modelMat = MyMat4.translate(new Vector3(0f, 0f, -2f)) *
                              MyMat4.rotate(mRotation, new Vector3(1, 0, 1));
            MyMat4 viewMatrix = MyMat4.GetIdentityMat();
            MyMat4 mvpMatrix  = perspectiveMat * viewMatrix * modelMat;

            //// Load the matrices
            //glUniformMatrix4fv(mMVPMatrixLoc, 1, GL_FALSE, mvpMatrix.data);
            GL.UniformMatrix4(mMVPMatrixLoc, 1, false, mvpMatrix.data);
        }
Ejemplo n.º 3
0
        void SetupGL()
        {
            EAGLContext.SetCurrentContext(context);

            LoadShaders();
            //--------------------------------------------------------------------------------
            GL.Enable(EnableCap.Blend);
            GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
            GL.ClearColor(1, 1, 1, 1);
            //setup viewport size

            int ww_w = view_width;
            int ww_h = view_height;
            int max  = Math.Max(ww_w, ww_h);

            //square viewport
            GL.Viewport(0, 0, max, max);
            orthoView = MyMat4.ortho(0, max, 0, max, 0, 1);
            //--------------------------------------------------------------------------------
            shaderProgram.UseProgram();
        }
Ejemplo n.º 4
0
        protected override void OnInitGLProgram(object sender, EventArgs args)
        {
            string vs = @"                   
            attribute vec4 a_position; 
            attribute vec4 a_color;            

            uniform mat4 u_mvpMatrix;
            uniform vec4 u_solidColor;
            uniform int u_useSolidColor;              
            uniform float u_linewidth;

            varying vec4 v_color; 
            varying float v_distance;
            varying float p0;
            
            void main()
            {   
                
                float rad = a_position[3];
                v_distance= a_position[2];

                float n_x = sin(rad); 
                float n_y = cos(rad);  

                vec4 delta;
                if(v_distance <1.0){                                         
                    delta = vec4(-n_x * u_linewidth,n_y * u_linewidth,0,0);                       
                }else{                      
                    delta = vec4(n_x * u_linewidth,-n_y * u_linewidth,0,0);
                }
    
                if(u_linewidth <= 0.5){
                    p0 = 0.5;      
                }else if(u_linewidth <=1.0){
                    p0 = 0.45;  
                }else if(u_linewidth>1.0 && u_linewidth<3.0){
                    
                    p0 = 0.25;  
                }else{
                    p0= 0.1;
                }
                
                vec4 pos = vec4(a_position[0],a_position[1],0,1) + delta;                 
                gl_Position = u_mvpMatrix* pos;                

                if(u_useSolidColor !=0)
                {
                    v_color= u_solidColor;
                }
                else
                {
                    v_color = a_color;
                }
            }
            ";
            //fragment source
            string fs = @"
                precision mediump float;
                varying vec4 v_color;  
                varying float v_distance;
                varying float p0;                
                void main()
                {
                    float d0= v_distance; 
                    float p1= 1.0-p0;
                    float factor= 1.0 /p0;
            
                    if(d0 < p0){                        
                        gl_FragColor =vec4(v_color[0],v_color[1],v_color[2], v_color[3] *(d0 * factor));
                    }else if(d0> p1){                         
                        gl_FragColor =vec4(v_color[0],v_color[1],v_color[2], v_color[3] *((1.0-d0)* factor));
                    }
                    else{
                        gl_FragColor =v_color;
                    } 
                }
            ";

            if (!shaderProgram.Build(vs, fs))
            {
                throw new NotSupportedException();
            }


            a_position      = shaderProgram.GetVtxAttrib("a_position");
            a_color         = shaderProgram.GetVtxAttrib("a_color");
            u_matrix        = shaderProgram.GetUniformMat4("u_mvpMatrix");
            u_useSolidColor = shaderProgram.GetUniform1("u_useSolidColor");
            u_solidColor    = shaderProgram.GetUniform4("u_solidColor");
            u_linewidth     = shaderProgram.GetUniform1("u_linewidth");
            //--------------------------------------------------------------------------------
            GL.Enable(EnableCap.Blend);
            GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
            GL.ClearColor(1, 1, 1, 1);
            //setup viewport size
            int max = Math.Max(this.Width, this.Height);

            //square viewport
            GL.Viewport(0, 0, max, max);
            orthoView = MyMat4.ortho(0, max, 0, max, 0, 1);
            //--------------------------------------------------------------------------------

            //load image
        }
Ejemplo n.º 5
0
        protected override void OnReadyForInitGLShaderProgram()
        {
            //----------------
            //vertex shader source
            string vs = @"        
            precision mediump float;
            attribute vec2 a_position;
            attribute vec3 a_color; 
            attribute vec2 a_texcoord;
            
            uniform mat4 u_mvpMatrix;
            uniform vec4 u_solidColor;
            uniform int u_useSolidColor;            

            varying vec4 v_color;
            varying vec2 v_texcoord;
             
            void main()
            {
                
                gl_Position = u_mvpMatrix* vec4(a_position[0],a_position[1],0.0,1.0);
                if(u_useSolidColor !=0)
                {
                    v_color= u_solidColor;                                       
                }
                else
                {
                    v_color = vec4(a_color,1.0);
                } 
                v_texcoord= a_texcoord;
            }
            ";
            //fragment source
            string fs = @"
                precision mediump float;
                varying vec4 v_color; 
                varying vec2 v_texcoord;                 
                void main()
                {       
                    
                    //gl_FragColor = vec4(1,v_texcoord.y,0,1);
                    gl_FragColor= v_color;
                }
            ";

            if (!shaderProgram.Build(vs, fs))
            {
                throw new NotSupportedException();
            }


            a_position      = shaderProgram.GetAttrV2f("a_position");
            a_color         = shaderProgram.GetAttrV3f("a_color");
            a_textureCoord  = shaderProgram.GetAttrV2f("a_texcoord");
            u_matrix        = shaderProgram.GetUniformMat4("u_mvpMatrix");
            u_useSolidColor = shaderProgram.GetUniform1("u_useSolidColor");
            u_solidColor    = shaderProgram.GetUniform4("u_solidColor");
            //--------------------------------------------------------------------------------
            GL.Enable(EnableCap.Blend);
            GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
            GL.ClearColor(1, 1, 1, 1);
            //setup viewport size
            int max = Math.Max(this.Width, this.Height);

            //square viewport
            GL.Viewport(0, 0, max, max);
            orthoView = MyMat4.ortho(0, max, 0, max, 0, 1);
            //--------------------------------------------------------------------------------

            //load image
        }
Ejemplo n.º 6
0
        protected override void OnInitGLProgram(object sender, EventArgs handler)
        {
            //--------------------------------------------------------------------------
            string vs = @"
                attribute vec4 a_position;
                attribute vec2 a_texCoord;
                uniform mat4 u_mvpMatrix; 
                varying vec2 v_texCoord;
                void main()
                {
                    gl_Position = u_mvpMatrix* a_position;
                    v_texCoord =  a_texCoord;
                 }	 
                ";
            //in fs, angle on windows
            //we need to switch color component
            //because we store value in memory as BGRA
            //and gl expect input in RGBA
            string fs = @"
                      precision mediump float;
                      varying vec2 v_texCoord;
                      uniform sampler2D s_texture;
                      void main()
                      {
                         vec4 c = texture2D(s_texture, v_texCoord);                            
                         gl_FragColor =  vec4(c[2],c[1],c[0],c[3]);
                      }
                ";

            mProgram = ES2Utils.CompileProgram(vs, fs);
            if (mProgram == 0)
            {
                //return false
            }

            // Get the attribute locations
            mPositionLoc = GL.GetAttribLocation(mProgram, "a_position");
            mTexCoordLoc = GL.GetAttribLocation(mProgram, "a_texCoord");
            u_matrix     = GL.GetUniformLocation(mProgram, "u_mvpMatrix");
            // Get the sampler location
            mSamplerLoc = GL.GetUniformLocation(mProgram, "s_texture");
            //// Load the texture
            //System.Drawing.Bitmap bmp = new System.Drawing.Bitmap("d:\\WImageTest\\test001.png");
            System.Drawing.Bitmap bmp = new System.Drawing.Bitmap("d:\\WImageTest\\test001.png");
            int bmpW = bmp.Width;
            int bmpH = bmp.Height;

            mTexture = LoadTexture(bmp);
            GL.ClearColor(0, 0, 0, 0);
            //================================================================================

            GL.Enable(EnableCap.Blend);
            GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
            GL.ClearColor(1, 1, 1, 1);
            //setup viewport size
            int max = Math.Max(this.Width, this.Height);

            orthoViewMat = MyMat4.ortho(0, max, 0, max, 0, 1).data;
            //square viewport
            GL.Viewport(0, 0, max, max);
            imgVertices = new float[]
            {
                0, bmpH, 0,
                0, 0,
                //---------------------
                0, 0, 0,
                0, 1,
                //---------------------
                bmpW, bmpH, 0,
                1, 0,
                //---------------------
                bmpW, 0, 0,
                1, 1
            };
        }
 internal void SetViewMatrix(MyMat4 mat)
 {
     scanlineShader.ViewMatrix = mat;
 }
Ejemplo n.º 8
0
        public static void Start()
        {
            if (!Glfw.Init())
            {
                Console.WriteLine("can't init glfw");
                return;
            }
            //---------------------------------------------------
            //at this, point no opengl func binding
            //---------------------------------------------------
            //1. we specific which verision we want,
            //here => OpenGLES  2.0
            Glfw.WindowHint(WindowHint.GLFW_CLIENT_API, (int)OpenGLAPI.OpenGLESAPI);
            Glfw.WindowHint(WindowHint.GLFW_CONTEXT_CREATION_API, (int)OpenGLContextCreationAPI.GLFW_EGL_CONTEXT_API);
            Glfw.WindowHint(WindowHint.GLFW_CONTEXT_VERSION_MAJOR, 3);
            Glfw.WindowHint(WindowHint.GLFW_CONTEXT_VERSION_MINOR, 0);
            //---------------------------------------------------

            OpenTK.Platform.Factory.GetCustomPlatformFactory = () => OpenTK.Platform.Egl.EglAngle.NewFactory();
            OpenTK.Toolkit.Init(new OpenTK.ToolkitOptions
            {
                Backend = OpenTK.PlatformBackend.PreferNative,
            });
            OpenTK.Graphics.PlatformAddressPortal.GetAddressDelegate = OpenTK.Platform.Utilities.CreateGetAddress();


            GlfwMonitorPtr monitor  = new GlfwMonitorPtr(); //default monitor
            GlfwWindowPtr  winPtr   = new GlfwWindowPtr();  //default window
            GlfwWindowPtr  glWindow = Glfw.CreateWindow(800, 600, "Test Glfw", monitor, winPtr);

            /* Make the window's context current */
            Glfw.MakeContextCurrent(glWindow);
            Glfw.SwapInterval(1);
            GlfwWindowPtr currentContext = Glfw.GetCurrentContext();
            var           contextHandler = new OpenTK.ContextHandle(currentContext.inner_ptr);
            //faster: create external context
            var glfwContext = new GLFWContextForOpenTK(contextHandler);
            var context     = OpenTK.Graphics.GraphicsContext.CreateExternalContext(glfwContext);
            //---------------------------
            //slow ... use create dummy context
            //var context = OpenTK.Graphics.GraphicsContext.CreateDummyContext(contextHandler);
            //and you need to load gles2 binding points manaually (below)

            bool isCurrent = context.IsCurrent;

            PixelFarm.GlfwWinInfo winInfo = new PixelFarm.GlfwWinInfo(glWindow);
            context.MakeCurrent(winInfo);
            //--------------------------------------
            //bind open gl funcs here..
            //this not need if we use glfwcontext for opentk
            //new OpenTK.Graphics.ES20.GL().LoadEntryPoints();
            //--------------------------------------
            //create shader program
            var shaderProgram = new MiniShaderProgram();
            //--------------------------------------

            ShaderVtxAttrib3f    a_position;
            ShaderVtxAttrib4f    a_color;
            ShaderUniformMatrix4 u_matrix;
            ShaderUniformVar1    u_useSolidColor;
            ShaderUniformVar4    u_solidColor;

            MyMat4 orthoView;

            string vs = @"        
                attribute vec3 a_position;
                attribute vec4 a_color;  

                uniform mat4 u_mvpMatrix;
                uniform vec4 u_solidColor;
                uniform int u_useSolidColor;              

                varying vec4 v_color;
                varying vec4 a_position_output;
                void main()
                {

                    a_position_output =  u_mvpMatrix* vec4(a_position[0],a_position[1],0,1);
                    gl_Position = a_position_output;
                    v_color=  vec4(1,0,0,1); 
                }
                ";
            //fragment source
            //            string fs = @"void main()
            //                {
            //                    gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0);
            //                }
            //            ";
            string fs = @"
                    precision mediump float;
                    varying vec4 v_color;  
                    varying vec4 a_position_output;
                    void main()
                    {
                        if(a_position_output[1]>0.5){
                            gl_FragColor = vec4(0,1,1,1);
                        }else{
                            gl_FragColor= vec4(0,1,0,1); 
                        }
                    }
                ";

            if (!shaderProgram.Build(vs, fs))
            {
                throw new NotSupportedException();
            }


            a_position = shaderProgram.GetAttrV3f("a_position");
            a_color    = shaderProgram.GetAttrV4f("a_color");

            u_matrix        = shaderProgram.GetUniformMat4("u_mvpMatrix");
            u_useSolidColor = shaderProgram.GetUniform1("u_useSolidColor");
            u_solidColor    = shaderProgram.GetUniform4("u_solidColor");

            //--------------------------------------------------------------------------------
            GL.Enable(EnableCap.Blend);
            GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
            GL.ClearColor(1, 1, 1, 1);
            //setup viewport size
            int ww_w = 800;
            int ww_h = 600;
            int max  = Math.Max(ww_w, ww_h);

            //square viewport
            GL.Viewport(0, 0, max, max);
            orthoView = MyMat4.ortho(0, max, 0, max, 0, 1);
            //--------------------------------------------------------------------------------

            //load image

            /* Loop until the user closes the window */
            //int width, height;
            //Glfw.GetFramebufferSize(glWindow, out width, out height);
            //float ratio = (float)width / (float)height;

            GL.Viewport(0, 0, 800, 600);
            shaderProgram.UseProgram();


            while (!Glfw.WindowShouldClose(glWindow))
            {
                //set clear color to white
                GL.ClearColor(1f, 1, 1, 1);
                GL.Clear(ClearBufferMask.ColorBufferBit);
                //---------------------------------
                //---------------------------------------------------------
                u_matrix.SetData(orthoView.data);
                //---------------------------------------------------------

                //DrawLines(0, 0, 300, 300);
                float x1 = 50, y1 = 20,
                      x2 = 300, y2 = 20;


                float[] vtxs = new float[] {
                    x1, y1, 1,
                    x2, y2, 1,
                    50, 300, 1
                };

                u_useSolidColor.SetValue(1);
                u_solidColor.SetValue(1f, 0f, 0f, 1f);//use solid color
                a_position.LoadPureV3f(vtxs);
                GL.DrawArrays(BeginMode.Triangles, 0, 3);

                //---------------------------------------------------------
                //GL.MatrixMode(MatrixMode.Modelview);
                //GL.LoadIdentity();
                //GL.Begin(BeginMode.Triangles);
                //GL.Color3(1f, 0, 0);
                //GL.Vertex3(-0.6f, -0.4f, 0f);
                //GL.Color3(0f, 1f, 0);
                //GL.Vertex3(0.6f, -0.4f, 0f);
                //GL.Color3(0f, 0, 1f);
                //GL.Vertex3(0.0f, 0.6f, 0f);
                //GL.End();

                //---------------------------------
                /* Render here */
                /* Swap front and back buffers */
                Glfw.SwapBuffers(glWindow);
                /* Poll for and process events */
                Glfw.PollEvents();
            }
            Glfw.Terminate();
        }
Ejemplo n.º 9
0
        public static void Start()
        {
            if (!Glfw.Init())
            {
                Console.WriteLine("can't init glfw");
                return;
            }
            //---------------------------------------------------
            //specific OpenGLES
            //Glfw.WindowHint(WindowHint.GLFW_CLIENT_API, (int)OpenGLAPI.OpenGLESAPI);
            //Glfw.WindowHint(WindowHint.GLFW_CONTEXT_CREATION_API, (int)OpenGLContextCreationAPI.GLFW_EGL_CONTEXT_API);
            //Glfw.WindowHint(WindowHint.GLFW_CONTEXT_VERSION_MAJOR, 2);
            //Glfw.WindowHint(WindowHint.GLFW_CONTEXT_VERSION_MINOR, 0);
            //---------------------------------------------------
            GlfwMonitorPtr monitor  = new GlfwMonitorPtr();
            GlfwWindowPtr  winPtr   = new GlfwWindowPtr();
            GlfwWindowPtr  glWindow = Glfw.CreateWindow(800, 600, "Test Glfw", monitor, winPtr);

            /* Make the window's context current */
            Glfw.MakeContextCurrent(glWindow);
            Glfw.SwapInterval(1);
            GL.Hello();

            //--------------------------------------
            //create shader program
            var shaderProgram = new MiniShaderProgram();

            ShaderVtxAttrib3f    a_position;
            ShaderVtxAttrib4f    a_color;
            ShaderUniformMatrix4 u_matrix;
            ShaderUniformVar1    u_useSolidColor;
            ShaderUniformVar4    u_solidColor;

            MyMat4 orthoView;

            string vs = @"        
                attribute vec3 a_position;
                attribute vec4 a_color;  

                uniform mat4 u_mvpMatrix;
                uniform vec4 u_solidColor;
                uniform int u_useSolidColor;              

                varying vec4 v_color;
                varying vec4 a_position_output;
                void main()
                {

                    a_position_output =  u_mvpMatrix* vec4(a_position[0],a_position[1],0,1);
                    gl_Position = a_position_output;
                    v_color=  vec4(1,0,0,1); 
                }
                ";
            //fragment source
            //            string fs = @"void main()
            //                {
            //                    gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0);
            //                }
            //            ";
            string fs = @"
                    //precision mediump float; //need for OpenGLES2
                    varying vec4 v_color;  
                    varying vec4 a_position_output;
                    void main()
                    {
                        if(a_position_output[1]>0.5){
                            gl_FragColor = vec4(0,1,1,1);
                        }else{
                            gl_FragColor= vec4(0,1,0,1); 
                        }
                    }
                ";

            if (!shaderProgram.Build(vs, fs))
            {
                throw new NotSupportedException();
            }


            a_position = shaderProgram.GetAttrV3f("a_position");
            a_color    = shaderProgram.GetAttrV4f("a_color");

            u_matrix        = shaderProgram.GetUniformMat4("u_mvpMatrix");
            u_useSolidColor = shaderProgram.GetUniform1("u_useSolidColor");
            u_solidColor    = shaderProgram.GetUniform4("u_solidColor");

            //--------------------------------------------------------------------------------
            GL.Enable(EnableCap.Blend);
            GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
            GL.ClearColor(1, 1, 1, 1);
            //setup viewport size
            int ww_w = 800;
            int ww_h = 600;
            int max  = Math.Max(ww_w, ww_h);

            //square viewport
            GL.Viewport(0, 0, max, max);
            orthoView = MyMat4.ortho(0, max, 0, max, 0, 1);
            //--------------------------------------------------------------------------------

            //load image

            /* Loop until the user closes the window */
            int width, height;

            Glfw.GetFramebufferSize(glWindow, out width, out height);
            float ratio = (float)width / (float)height;

            GL.Viewport(0, 0, 800, 600);
            shaderProgram.UseProgram();


            while (!Glfw.WindowShouldClose(glWindow))
            {
                //set clear color to white
                GL.ClearColor(1f, 1, 1, 1);
                GL.Clear(ClearBufferMask.ColorBufferBit);
                //---------------------------------
                //---------------------------------------------------------
                u_matrix.SetData(orthoView.data);
                //---------------------------------------------------------

                //DrawLines(0, 0, 300, 300);
                float x1 = 50, y1 = 20,
                      x2 = 300, y2 = 20;


                float[] vtxs = new float[] {
                    x1, y1, 1,
                    x2, y2, 1,
                    50, 300, 1
                };

                u_useSolidColor.SetValue(1);
                u_solidColor.SetValue(1f, 0f, 0f, 1f);//use solid color
                a_position.LoadPureV3f(vtxs);
                GL.DrawArrays(BeginMode.Triangles, 0, 3);

                //---------------------------------------------------------
                //GL.MatrixMode(MatrixMode.Modelview);
                //GL.LoadIdentity();
                //GL.Begin(BeginMode.Triangles);
                //GL.Color3(1f, 0, 0);
                //GL.Vertex3(-0.6f, -0.4f, 0f);
                //GL.Color3(0f, 1f, 0);
                //GL.Vertex3(0.6f, -0.4f, 0f);
                //GL.Color3(0f, 0, 1f);
                //GL.Vertex3(0.0f, 0.6f, 0f);
                //GL.End();

                //---------------------------------
                /* Render here */
                /* Swap front and back buffers */
                Glfw.SwapBuffers(glWindow);
                /* Poll for and process events */
                Glfw.PollEvents();
            }
            Glfw.Terminate();
        }