Unwanted pixelisation

Hello,

I’m encountering a problem with a basic processing chain and need some help as I’m stuck and don’t understand what happens.

I would like to write texcoords on the target of a fbo within my first shader, then use this texture to read and display an image with my second shader. The goal is to make some king of pixel drifting by manipulating texcoords.
But using a texture to read texcoords give me an unwanted pixelisation effect.

//========================================================================
int main( ){

    ofGLFWWindowSettings gl_settings;
    gl_settings.setGLVersion( 3, 2 );
    gl_settings.width = 1920;
    gl_settings.height = 1080;
    gl_settings.visible = true;
    gl_settings.decorated = false;
    gl_settings.numSamples = 2;

    shared_ptr<ofAppBaseWindow> of_main_window = ofCreateWindow(gl_settings);
    shared_ptr<ofApp> of_main_app(new ofApp());

    ofDisableArbTex();

    ofRunApp( of_main_window, of_main_app );
    ofRunMainLoop();
}

//--------------------------------------------------------------
void ofApp::setup()
{
    this->m_tex_width = 1920;
    this->m_tex_height = 1080;

    // FBO
    ofFbo::Settings fbo_settings;
    fbo_settings.width = this->m_tex_width;
    fbo_settings.height = this->m_tex_height;
    fbo_settings.colorFormats = std::vector<GLint>({GL_RGBA});
    fbo_settings.useDepth = true;
    fbo_settings.useStencil = false;
    fbo_settings.depthStencilAsTexture = false;
    fbo_settings.textureTarget = GL_TEXTURE_2D;
    fbo_settings.internalformat = GL_RGBA;
    fbo_settings.wrapModeHorizontal = GL_CLAMP_TO_EDGE;
    fbo_settings.wrapModeVertical = GL_CLAMP_TO_EDGE;
    fbo_settings.minFilter = GL_LINEAR;
    fbo_settings.maxFilter = GL_LINEAR;
    fbo_settings.numSamples = 0;

    this->m_fbo.allocate(fbo_settings);

    // SHADERS
    this->m_init_shader.load( "shaders/init.vert", "shaders/init.frag" );
    this->m_shader.load( "shaders/update.vert", "shaders/update.frag" );

    // PRIMITIVES
    this->m_quad.set( 2, 2, 2, 2 );

    // MISC
    this->m_init = true;

    this->m_image.load("forest.png");
}
//--------------------------------------------------------------
void ofApp::draw()
{

    if ( this->m_init ) {
        
        this->m_fbo.begin();

        this->m_init_shader.begin();

        this->m_quad.draw();

        this->m_init_shader.end();

        this->m_fbo.end();

        this->m_init = false;
    }

    this->m_shader.begin();

    this->m_shader.setUniformTexture( "u_pos_texture", this->m_fbo.getTexture(), this->m_shader.getUniformLocation("u_pos_texture") );
    this->m_shader.setUniformTexture( "u_texture", this->m_image.getTexture(), this->m_shader.getUniformLocation("u_texture") );

    this->m_quad.draw();

    this->m_shader.end();
}

// init.frag

#version 150

in vec2 vs_texcoord;
out vec4 frag_color;

void main()
{
	frag_color = vec4( vs_texcoord, 0.f, 1.f );
}

//update.frag

#version 150

in vec2 vs_texcoord;
uniform sampler2D u_pos_texture;
uniform sampler2D u_texture;
out vec4 frag_color;

void main()
{
	frag_color = texture( u_texture, texture( u_pos_texture, vs_texcoord ).xy );
}

This is a screenshot of what I got

Any hints, by chance ? Thank you

I founded it.
I was using GL_RGBA for which oF defines GL_UNSIGNED_BYTE as internal data type when allocating the texture, GL_FLOAT is needed so switching to GL_RGBA16F resolves it.