OpenGL load textures from QImage



  • Hi! I try to make a transition animation between 2 pages in OpenGL. I have 2 QImages objects, tex1 - the current page, tex2 - the next page. The mask is the image drawed in OpenGL.

    
    	if (!m_program) {
    
    		initializeOpenGLFunctions ();
    
    		m_program = new QOpenGLShaderProgram ();
    		qDebug () << m_program->addShaderFromSourceCode (QOpenGLShader::Vertex,
    					"attribute highp vec4 posAttr;\n"
    					"attribute lowp vec4 colAttr;\n"
    					"uniform highp mat4 matrix;\n"
    
    					"varying highp vec2 coord;\n"
    					"varying lowp vec4 col;\n"
    
    					 "void main() {\n"
    					 "		col = colAttr;\n"
    					 "		coord = vec2(gl_MultiTexCoord0.xy);\n"
    					 "		gl_Position = matrix * posAttr;\n"
    					 "}"
    					);
    
    		qDebug () << m_program->addShaderFromSourceCode (QOpenGLShader::Fragment,
    					 "varying highp vec2 coord;\n"
    					"varying lowp vec4 col;\n"
    
    					 "uniform sampler2D texx1;\n"
    					 "uniform sampler2D texx2;\n"
    
    					"void main() {\n"
    					 "		mediump vec4 texture1Color = vec4(texture2D(texx1, coord).xyz, 1.0);\n"
    					 "		mediump vec4 texture2Color = vec4(texture2D(texx2, coord).xyz, 1.0);\n"
    					 "		gl_FragColor = mix(texture1Color, texture2Color, col);\n"
    //					 "		gl_FragColor = col;"
    					 "}"
    					);
    		qDebug () << m_program->link ();
    
    
    	}
    	qDebug () << m_program->bind ();
    
    	int vert = m_program->attributeLocation ("posAttr");
    	int cols = m_program->attributeLocation ("colAttr");
    	int matx = m_program->uniformLocation ("matrix");
    
    	m_program->enableAttributeArray (0);
    	m_program->enableAttributeArray (1);
    
    
    	GLfloat vertex [40] = {
    		center_x,			current_rgb_top,
    		center_x,			current_mono_top,
    		current_mono_left,	center_y,
    		current_rgb_left,	center_y,
    
    		current_rgb_left,	center_y,
    		current_mono_left,	center_y,
    		center_x,			current_mono_bottom,
    		center_x,			current_rgb_bottom,
    
    		center_x,			current_rgb_bottom,
    		center_x,			current_mono_bottom,
    		current_mono_right, center_y,
    		current_rgb_right,	center_y,
    
    		current_rgb_right,	center_y,
    		current_mono_right, center_y,
    		center_x,			current_mono_top,
    		center_x,			current_rgb_top,
    
    		center_x,			current_mono_top,
    		current_mono_right, center_y,
    		center_x,			current_mono_bottom,
    		current_mono_left,	center_y,
    	};
    
    	QMatrix4x4 matrix;
    	matrix.ortho (0., viewportSize.width (), viewportSize.height (), 0., -1, 1);
    
    	glEnable (GL_TEXTURE_2D);
    
    	GLuint m_tex1, m_tex2;
    	glGenTextures (1, &m_tex1);
    	glBindTexture (GL_TEXTURE_2D, m_tex1);
    //	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    //	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, tex1.width(), tex1.height(), 0, GL_RGB, GL_UNSIGNED_BYTE, tex1.bits());
    	glBindTexture (GL_TEXTURE_2D, 0);
    
    	qDebug() << "tex1 sizes" << tex1.width() << tex1.height();
    
    	glGenTextures (1, &m_tex2);
    	glBindTexture (GL_TEXTURE_2D, m_tex2);
    //	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    //	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, tex2.width(), tex2.height(), 0, GL_RGB, GL_UNSIGNED_BYTE, tex2.bits());
    	glBindTexture (GL_TEXTURE_2D, 0);
    
    	qDebug() << "tex2 sizes" << tex2.width() << tex2.height();
    
    //	glGenerateMipmap (GL_TEXTURE_2D);
    
    
    	m_program->setUniformValue (matx, matrix);
    
    	glVertexAttribPointer (vert, 2, GL_FLOAT, GL_FALSE, 0, vertex);
    	glVertexAttribPointer (cols, 3, GL_FLOAT, GL_FALSE, 0, colors);
    
    	glViewport (0, 0, viewportSize.width (), viewportSize.height () );
    
    	glDisable (GL_DEPTH_TEST);
    	glClearColor (0.5, 0.5, 0.5, 1);
    
    	glClear (GL_COLOR_BUFFER_BIT);
    
    	glActiveTexture (GL_TEXTURE0);
    	glBindTexture (GL_TEXTURE_2D, m_tex1);
    
    
    	glActiveTexture (GL_TEXTURE1);
    	glBindTexture (GL_TEXTURE_2D, m_tex2);
    
    	GLint m_tex1_loc, m_tex2_loc;
    
    	m_tex1_loc = m_program->uniformLocation ("texx1");
    	m_tex2_loc = m_program->uniformLocation ("texx2");
    
    	m_program->setUniformValue (m_tex1_loc, m_tex1);
    	m_program->setUniformValue (m_tex2_loc, m_tex2);
    
    	glDrawArrays (GL_QUADS, 0, 20);
    
    	m_program->disableAttributeArray (0);
    	m_program->disableAttributeArray (1);
    
    	m_program->release ();
    
    	glBegin (GL_TRIANGLES);
    
    	glVertex3f (0., 1, 0);
    	glVertex3f (1., 0, 0);
    	glVertex3f (1., 1, 0);
    
    	glEnd ();
    
    	glDisable (GL_TEXTURE_2D);
    
    	qDebug () << m_program->log ();
    

    The texture colors are always black, tex1 and and tex 2 are valid images. The code print in console:

    tex1 sizes 390 520
    tex2 sizes 390 520
    

    Which is the problem?



  • There could be quite a few thing wrong. Could you try using power-of-two textures to see if the images start showing (resize the images to a 512x512 or 256x256) and ensure the image is completely defined?
    https://www.opengl.org/wiki/Common_Mistakes#Creating_a_complete_texture

    It would help if you provided code for the entire application.


Log in to reply
 

Looks like your connection to Qt Forum was lost, please wait while we try to reconnect.