Skip to content
  • Categories
  • Recent
  • Tags
  • Popular
  • Users
  • Groups
  • Search
  • Get Qt Extensions
  • Unsolved
Collapse
Brand Logo
  1. Home
  2. Qt Development
  3. General and Desktop
  4. QOpenGLTexture being loaded or linked to a shader as monochromatic image
Forum Updated to NodeBB v4.3 + New Features

QOpenGLTexture being loaded or linked to a shader as monochromatic image

Scheduled Pinned Locked Moved Unsolved General and Desktop
1 Posts 1 Posters 213 Views
  • Oldest to Newest
  • Newest to Oldest
  • Most Votes
Reply
  • Reply as topic
Log in to reply
This topic has been deleted. Only users with topic management privileges can see it.
  • J Offline
    J Offline
    JesusM
    wrote on last edited by
    #1

    I am doing an OpenGL application in Qt and I am having problems with the textures. My objects are painted with a monochromatic texture but my images are colorful images in a .png format. I had the application donde in Visual Studio with C++ programming and there it works well.

    I tried to disable illuminance but it doesn't provide any change. I also tried to force the shader to paint all the objects as red and it works, so the surface allows me to paint with colors. Also, I have a mode where I don't use textures, i just paint with materials and it works fine. I saw an example that is provided by Qt and it doesn't have so much differences with mine. The way the texture is created is like mine and, in the example, a cube is painted with the colorful texture.

    This is the texture class:

    texture::texture()
    {
        initializeOpenGLFunctions();
    }
    
    texture::texture(QVector<QString> rutas, QVector<TexturesTypes> tipo)
    {
        initializeOpenGLFunctions();
        for (int i = 0; i < rutas.size(); i++)
        {
    
    
            QString filename = rutas[i];
            TexturesTypes tipoTextura = tipo[i];
            QImage imagen = QImage(filename);
    
            if(imagen.isNull())
            {
                std::cout<<"IS NULL"<<std::endl;
            }
    
            QOpenGLTexture *texture = new QOpenGLTexture(QImage(filename).mirrored());
    
            if (texture == nullptr)
            {
                std::cout << filename.toStdString() << " cannot be loaded" << std::endl;
                return;
            }
            std::cout<<"Textura cargada correctamente"<<std::endl;
    
            //Construimos la textura con las imágenes que queremos y la función de cada imagen
            switch (tipoTextura)
            {
                case COLOR:
                {
                    color = texture;
                    color->setMinificationFilter(QOpenGLTexture::LinearMipMapLinear);
                    color->setMagnificationFilter(QOpenGLTexture::Linear);
                    color->setWrapMode(QOpenGLTexture::DirectionS,QOpenGLTexture::ClampToEdge );
                    color->setWrapMode(QOpenGLTexture::DirectionT,QOpenGLTexture::ClampToEdge );
                    color->generateMipMaps();
    
                    break;
                }
                case BRILLO:
                {
                    brillo = texture;
                    brillo->setMinificationFilter(QOpenGLTexture::LinearMipMapLinear);
                    brillo->setMagnificationFilter(QOpenGLTexture::Linear);
                    brillo->setWrapMode(QOpenGLTexture::DirectionS,QOpenGLTexture::ClampToEdge );
                    brillo->setWrapMode(QOpenGLTexture::DirectionT,QOpenGLTexture::ClampToEdge );
                    brillo->generateMipMaps();
                    break;
                }
                case BUMPMAPPING:
                {
                    bumpMapping = texture;
                    bumpMapping->setMinificationFilter(QOpenGLTexture::LinearMipMapLinear);
                    bumpMapping->setMagnificationFilter(QOpenGLTexture::Linear);
                    bumpMapping->setWrapMode(QOpenGLTexture::DirectionS,QOpenGLTexture::ClampToEdge );
                    bumpMapping->setWrapMode(QOpenGLTexture::DirectionT,QOpenGLTexture::ClampToEdge );
                    bumpMapping->generateMipMaps();
                    break;
                }
    
                case DISPLACEMENTMAPPING:
                {
                    displacementMapping = texture;
                    displacementMapping->setMinificationFilter(QOpenGLTexture::LinearMipMapLinear);
                    displacementMapping->setMagnificationFilter(QOpenGLTexture::Linear);
                    displacementMapping->setWrapMode(QOpenGLTexture::DirectionS,QOpenGLTexture::ClampToEdge );
                    displacementMapping->setWrapMode(QOpenGLTexture::DirectionT,QOpenGLTexture::ClampToEdge );
                    displacementMapping->generateMipMaps();
                    break;
                }
    
            }
    
        }
    
    }
    
    
    /**
     * @brief Obtener una de las imágenes que forman la textura
     * @param tipo Tipode imagen que se quiere obtener
     * @return imagen Puntero a la imagen que se ha obtenido
     */
    
    QOpenGLTexture* texture::getTextura(TexturesTypes tipo)
    {
        switch (tipo)
        {
            case COLOR:
            {
                return this->color;
            }
            case BRILLO:
            {
                return this->brillo;
            }
    
            case BUMPMAPPING:
            {
                return this->bumpMapping;
            }
            case DISPLACEMENTMAPPING:
            {
                return this->displacementMapping;
            }
        }
    }
    
    /**
     * @brief Aplicar la textura al shader
     * @param shader Shader al que se le va a aplicar la textura
     */
    
    void texture::aplicar(shaderProgram* shader)
    {
        shader->use();
        if (color != nullptr)
        {
            shader->setUniform("TexSamplerColor", 0);
            color->bind(GL_TEXTURE0);
        }
        if (brillo != nullptr)
        {
            shader->setUniform("TexSamplerBrillo", 1);
            brillo->bind(GL_TEXTURE1);
        }
    }
    
    
    texture::~texture()
    {
        color->destroy();
        brillo->destroy();
        bumpMapping->destroy();
        displacementMapping->destroy();
        delete color;
        delete brillo;
        delete bumpMapping;
        delete displacementMapping;
    }
    

    This is the fragment shader:

    #version 400
    
    in vec3 position;
    in vec3 normal;
    in vec2 texCoord;
    
    uniform vec3 lightPosition;
    uniform vec3 Ia;
    uniform vec3 Id;
    uniform vec3 Is;
    
    uniform sampler2D TexSamplerColor;
    uniform sampler2D TexSamplerBrillo;
    
    layout (location = 0) out vec4 FragColor;
    
    vec3 ads(vec4 texColor, vec4 texBrillo)
    {
        vec3 Kad = texColor.rgb;
        vec3 Ks = texBrillo.rgb;
        float Shininess = texBrillo.a;
        Shininess = Shininess*200;
    
        vec3 n;
        if (gl_FrontFacing) {
            n = normalize(normal);
        } else {
            n = normalize(-normal);
        }
        vec3 l = normalize( lightPosition-position );
        vec3 v = normalize( -position );
        vec3 r = reflect( -l, n );
        return (Ia * Kad) + (Id * Kad * max( dot(l, n), 0.0)) + (Is * Ks * pow( max( dot(r,v), 0.0), Shininess ));
    }
    
    void main() {
        vec4 texColor = texture(TexSamplerColor, texCoord);
        vec4 texBrillo = texture(TexSamplerBrillo, texCoord);
            FragColor = vec4(ads(texColor,texBrillo), 1.0);
    }
    

    I expected to have the textures well applied to my objects but what I have is all the objects with a monochromatic texture.

    0_1557237592258_textura.png

    1 Reply Last reply
    0

    • Login

    • Login or register to search.
    • First post
      Last post
    0
    • Categories
    • Recent
    • Tags
    • Popular
    • Users
    • Groups
    • Search
    • Get Qt Extensions
    • Unsolved