Render texture to QQuickFramebufferObject using OpenGL

[skore]

I'm following QQuickFramebufferObject example and now I'm editing logorenderer class to render single texture that rotates in 3D and it only renders black square.

EDIT: I simplified code and I found out that if on line 62 i change image's size to 1x1 it works (it's solid blue) but if I change to anything else it stops working. What am I doing wrong?

My code:

logorenderer.cpp
@
#include "logorenderer.h"

void LogoRenderer::initialize()
{
initializeGLFunctions();

QOpenGLShader *vshader1 = new QOpenGLShader(QOpenGLShader::Vertex, &shaderProgram);
const char *vsrc1 =
    "#version 120\n"
    "attribute vec4 vertex;\n"
    "uniform mat4 matrix;\n"
    "attribute vec2 texturePos;\n"
    "varying vec2 texcoord;\n"
    "void main(void)"
    "{"
    "   texcoord = texturePos;"
    "   gl_Position = matrix * vertex;"
    "}";
vshader1->compileSourceCode(vsrc1);

QOpenGLShader *fshader1 = new QOpenGLShader(QOpenGLShader::Fragment, &shaderProgram);
const char *fsrc1 =
        "#version 120\n"
        "uniform sampler2D tex;\n"
        "varying vec2 texcoord;"
        "void main()"
        "{"
        "   gl_FragColor = texture2D(tex, texcoord);"
        "}";;
fshader1->compileSourceCode(fsrc1);

shaderProgram.addShader(vshader1);
shaderProgram.addShader(fshader1);
shaderProgram.link();

vertexAttr = shaderProgram.attributeLocation("vertex");
matrixUniform = shaderProgram.uniformLocation("matrix");

texturePositionAttr = shaderProgram.attributeLocation("texturePos");
textureUniform = shaderProgram.uniformLocation("tex");

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );

m_fAngle = 0;
createGeometry();

glEnable(GL_TEXTURE_2D);
glGenTextures(1, &textureID);
glBindTexture(GL_TEXTURE_2D, textureID);

// create checkerboard array
GLfloat pixels[64*64*3];
for(int i=0;i<64*64;i++){
    if((i/64%2==1)^(i%2==1)){
        pixels[i*3] = 0; pixels[i*3+1] = 1; pixels[i*3+2] = 0;
    }else{
        pixels[i*3] = 0; pixels[i*3+1] = 0; pixels[i*3+2] = 1;
    }
}

glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 64, 64, 0, GL_RGB, GL_FLOAT, &pixels[0]);
glDisable(GL_TEXTURE_2D);

}

void LogoRenderer::render()
{
glDepthMask(true);

glClearColor(1,1,1,1);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

QMatrix4x4 modelview;
modelview.rotate(m_fAngle, 0.0f, 1.0f, 0.0f);
modelview.rotate(10, 1.0f, 0.0f, 0.0f);
modelview.rotate(10, 0.0f, 1.0f, 0.0f);

shaderProgram.bind();
shaderProgram.setUniformValue(matrixUniform, modelview);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, textureID);

shaderProgram.enableAttributeArray(vertexAttr);
shaderProgram.enableAttributeArray(texturePositionAttr);

shaderProgram.setAttributeArray(vertexAttr, vertices.constData());
shaderProgram.setAttributeArray(texturePositionAttr, textureCoords.constData());

glDrawArrays(GL_TRIANGLES, 0, vertices.size());
shaderProgram.disableAttributeArray(vertexAttr);
shaderProgram.disableAttributeArray(texturePositionAttr);
shaderProgram.release();

m_fAngle += 2.0f;

}

void LogoRenderer::createGeometry()
{
vertices << QVector3D(-0.5, -0.5, 0.5) << QVector3D( 0.5, -0.5, 0.5) << QVector3D( 0.5, 0.5, 0.5)
<< QVector3D(-0.5, -0.5, 0.5) << QVector3D( 0.5, 0.5, 0.5) << QVector3D(-0.5, 0.5, 0.5);

textureCoords << QVector2D(0, 0) << QVector2D(1, 0) << QVector2D(1, 1)
<< QVector2D(1, 1) << QVector2D(0, 1) << QVector2D(0, 0);

}
@

logorenderer.h
@
#ifndef LOGORENDERER_H
#define LOGORENDERER_H

#include <QtGui/qvector3d.h>
#include <QtGui/qmatrix4x4.h>
#include <QtGui/qopenglshaderprogram.h>

#include <QVector>
#include <QGLFunctions>

class LogoRenderer: private QGLFunctions {

public:
void render();
void initialize();
void setContext(QGLContext* context);

private:
qreal m_fAngle;

void createGeometry();

QVector<QVector3D> vertices;
QVector<QVector3D> textureCoords;
QOpenGLShaderProgram shaderProgram;

int vertexAttr;
int texturePositionAttr;

int matrixUniform;
int textureUniform;

GLuint textureID;

};
#endif
@