예제 #1
0
        public void Render(ShaderBlob toRender, UniformValues uniforms, Size s)
        {
            Gl.Viewport(0, 0, s.Width, s.Height);
            Gl.Clear(ClearBufferMask.ColorBufferBit);

            // Select the program for drawing
            Gl.UseProgram(toRender.Program.ProgramName);

            Gl.UseProgram(toRender.Program.ProgramName);

            SetUniforms(toRender.Program.UniformLocations, uniforms);

            if (toRender.CreationArguments.Type.UseTexture)
            {
                Gl.BindTexture(TextureTarget.Texture2d, toRender.TextureName);
            }

            // Use the vertex array
            Gl.BindVertexArray(toRender.VertexArray.ArrayName);
            GlErrorLogger.Check();
            // Draw triangle
            if (toRender.CreationArguments.Type.UseIndexing)
            {
                Gl.DrawElements(PrimitiveType.Triangles, toRender.VertexArray.Count, DrawElementsType.UnsignedInt, IntPtr.Zero);
            }
            else
            {
                Gl.DrawArrays(PrimitiveType.Triangles, 0, toRender.VertexArray.Count);
            }
            GlErrorLogger.Check();
        }
예제 #2
0
        public void Create()
        {
            TextureName = Gl.GenTexture();
            Gl.BindTexture(TextureTarget.Texture2d, TextureName);
            GlErrorLogger.Check();

            //Gl.TextureParameter(TextureName, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);
            //GlErrorLogger.Check();
            //Gl.TextureParameter(TextureName, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
            //GlErrorLogger.Check();

            //Gl.TextureParameter(TextureName, TextureParameterName.TextureWrapS, (int)TextureWrapMode.ClampToEdge);
            //GlErrorLogger.Check();
            //Gl.TextureParameter(TextureName, TextureParameterName.TextureWrapT, (int)TextureWrapMode.ClampToEdge);
            //GlErrorLogger.Check();

            GlErrorLogger.Check();
            Gl.BindTexture(TextureTarget.Texture2d, TextureName);

            BitmapData data = null;

            try
            {
                data = bitmap.LockBits(new Rectangle(0, 0, WidthInPixels, HeightInPixels), System.Drawing.Imaging.ImageLockMode.ReadOnly, bitmap.PixelFormat);
                Gl.TexImage2D(TextureTarget.Texture2d, 0, InternalFormat.Rgba, WidthInPixels, HeightInPixels, 0, this.format, PixelType.UnsignedByte, data.Scan0);
            }
            finally
            {
                if (data != null)
                {
                    bitmap.UnlockBits(data);
                }
            }

            GlErrorLogger.Check();

            Gl.GenerateMipmap(TextureTarget.Texture2d);

            this.Created = true;
        }
예제 #3
0
        private ShaderBlob BuildProgramInternal(ShaderCreationArguments args)
        {
            try
            {
                StaticLogger.Logger.DebugFormat("Starting Creation of {0}", args.ConvenientName());

                PngTexture texture = null;

                if (args.Type.UseTexture)
                {
                    texture = new PngTexture(args.TexturePath);
                    texture.Load();
                    texture.Create();
                    GlErrorLogger.Check();

                    // Do I even need this?
                    Gl.BindTexture(TextureTarget.Texture2d, texture.TextureName);
                    GlErrorLogger.Check();
                }

                var vertexSource = VertexShaderSource.VertexSourceLookup(args.Type.VertexFormat, args.Type.VertexShaderVersion);

                var _Program = new ShaderProgram(args.FragmentShaderSource, vertexSource, args.Type.Uniforms, args.Type.VertexFormat);
                GlErrorLogger.Check();

                _Program.Link();
                GlErrorLogger.Check();

                IVertexArray _VertexArray = BuildVertexArray(_Program.VertexLocations, args);

                GlErrorLogger.Check();

                return(new ShaderBlob()
                {
                    DisplayName = args.ConvenientName(),
                    CreationArguments = args,
                    TreatAsGood = true,
                    Program = _Program,
                    VertexArray = _VertexArray,
                    TextureName = !args.Type.UseTexture ? 0 : texture.TextureName,
                });
            }
            catch (Exception e)
            {
                StaticLogger.Logger.ErrorFormat("{1} - Shader Error {0}", args.SimpleName, e.ToString());

                if (BadShader == null)
                {
                    throw new InvalidOperationException("Could not build BadShader!");
                }

                return(new ShaderBlob()
                {
                    DisplayName = args.ConvenientName(),
                    CreationArguments = BadShader.CreationArguments,
                    TreatAsGood = false,
                    ErrorMessage = e.ToString(),
                    Program = BadShader.Program,
                    VertexArray = BadShader.VertexArray
                });
            }
        }