CODEWITHSUNDEEP
c#openglshaderfragment-shaderopentk
user2431727
user2431727

Reputation: 907

Rotate an image in openTK

I want to rotate an image which is shown in my GLControl to 10 degree. For that I have rotated the bitmap using c# code and passed this rotated bitmap to opengl shader code. But the resulted image is seems like the rotated part is hiding/cut like below. Shall I need to do any changes on it's view port while rotating? or is it good to rotate the image in shader code itself?

     public void DrawImage(int image, int glcontrolWidth, int glcontrolHeight,Matrix4 **transformMatrix**)
    {
        GL.Viewport(new Rectangle(0, 0, glcontrolWidth, glcontrolHeight));    
        GL.MatrixMode(MatrixMode.Projection);
        GL.PushMatrix();
        GL.LoadIdentity();

        GL.MatrixMode(MatrixMode.Modelview);
        GL.PushMatrix();
        GL.LoadIdentity();

        GL.Disable(EnableCap.Lighting);
        GL.Enable(EnableCap.Texture2D);

        GL.ActiveTexture(TextureUnit.Texture0);
        GL.BindTexture(TextureTarget.Texture2D, image);
        GL.Uniform1(positionLocation1, 0);

        RunShaders();
       
        GL.Disable(EnableCap.Texture2D);
        GL.PopMatrix();

        GL.MatrixMode(MatrixMode.Projection);
        GL.PopMatrix();

        GL.MatrixMode(MatrixMode.Modelview);        

    }
    public void RunShaders()
    {
        GL.UseProgram(program);
        **GL.UniformMatrix4(transformLocation, false, ref transformMatrix);**
        GL.DrawArrays(PrimitiveType.Triangles, 0, vertices.Length / 3);
        ErrorCode ec = GL.GetError();
        if (ec != 0)
            System.Console.WriteLine(ec.ToString());
        Console.Read();
    }
    public void Init()
    {
        CreateShaders();
        CreateProgram();        
        InitBuffers();
    }
    public void CreateProgram()
    {
        program = GL.CreateProgram();
        GL.AttachShader(program, vertShader);
        GL.AttachShader(program, fragShader);
        GL.LinkProgram(program);       
    }
    public void InitBuffers()
    {
        buffer = GL.GenBuffer();
        positionLocation = GL.GetAttribLocation(program, "a_position");
        positionLocation1 = GL.GetUniformLocation(program, "sTexture");
        **transformLocation = GL.GetUniformLocation(program, "u_transform");**      
        GL.EnableVertexAttribArray(positionLocation);
        GL.BindBuffer(BufferTarget.ArrayBuffer, buffer);
        GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(vertices.Length * sizeof(float)), vertices, BufferUsageHint.StaticDraw);
        GL.VertexAttribPointer(positionLocation, 3, VertexAttribPointerType.Float, false, 0, 0);

    }
    public void CreateShaders()
    {
        /***********Vert Shader********************/
        vertShader = GL.CreateShader(ShaderType.VertexShader);
        GL.ShaderSource(vertShader, @"attribute vec3 a_position;
                                varying vec2 vTexCoord;
                           **uniform mat4 u_transform;**
                                void main() {
                                vTexCoord = (a_position.xy+1)/2 ;  
                                **gl_Position = u_transform * vec4(a_position, 1);**
                                }");
        GL.CompileShader(vertShader);

        /***********Frag Shader ****************/
        fragShader = GL.CreateShader(ShaderType.FragmentShader);
        GL.ShaderSource(fragShader, @"precision highp float;
  uniform sampler2D sTexture_2;varying vec2 vTexCoord; 
          void main ()
         {
     vec4 color = texture2D (sTexture_2, vec2(vTexCoord.x, vTexCoord.y));
     gl_FragColor =color;

   }"); GL.CompileShader(fragShader);

    }

Degree Ten

Upvotes: 1

Views: 605

Answers (1)

Rabbid76
Rabbid76

Reputation: 210918

Do not rotate the image, but rotate and scale the vertex coordinates.

Add a transformation matrix to the vertex shader:

attribute vec3 a_position;
varying vec2 vTexCoord;
uniform mat4 u_transform;

void main()
{
    vTexCoord = (a_position.xy+1)/2;
    gl_Position = u_transform * vec4(a_position, 1);
}

Get the location of the transformation matrix uniform (``u_transform´) (after the program is linked).

int transformLocation = GL.GetUniformLocation(program, "u_transform");

Compute the scale dependent on the angle:

double diagonal = Math.Sqrt(bmp.Width * bmp.Width + bmp.Height * bmp.Height);
double dia_angle1 = Math.Atan2(bmp.Height, bmp.Width) + angle * Math.PI / 180;
double dia_angle2 = Math.Atan2(bmp.Height, -bmp.Width) + angle * Math.PI / 180;
double rot_w = Math.Max(Math.Abs(diagonal * Math.Cos(dia_angle1)), Math.Abs(diagonal * Math.Cos(dia_angle2)));
double rot_h = Math.Max(Math.Abs(diagonal * Math.Sin(dia_angle1)), Math.Abs(diagonal * Math.Sin(dia_angle2)));
double scale = Math.Min(bmp.Width / rot_w, bmp.Height / rot_h);

Define a transformation matrix that scales and rotates the image taking into account the aspect ratio:

Matrix4 transformMatrix =
    Matrix4.CreateScale((float)scale) *
    Matrix4.CreateScale(this.Width, this.Height, 1.0f) *
    Matrix4.CreateRotationZ((float)(angle * Math.PI / 180)) *
    Matrix4.CreateScale(1.0f / this.Width, 1.0f / this.Height, 1.0f);

Set the matrix uniform, after the program is installed (after GL.UseProgram):

GL.UniformMatrix4(transformLocation, false, ref transformMatrix);

Upvotes: 1

Related Questions