Problema com texturas no OpenGL/C++

1. Problema com texturas no OpenGL/C++

Adriano Andrei Goede
adrianogoede

(usa Debian)

Enviado em 07/12/2021 - 21:26h

Boa noite meus consagrados,

Estou na jornada de aprender um pouco sobre o OpenGL e a bola da vez é texturas, porém estou brigando com um problema bastante chato: Ao invés de a imagem ser aplicada como se esperaria o meu objeto (uma meia pirâmide nesse caso) simplesmente é renderizado com uma cor sólida, semelhante à cor predominante da imagem, vou deixar uma imagem em anexo.

Estou usando a biblioteca STB_image para carregar a imagem, porém em outra oportunidade quando tentei utilizar a SOIL me deparei com o mesmo problema. Segue abaixo o código da classe e dos Shaders que estou usando:

Classe Texture:

#include <GL/glew.h>
#include "stb_image.h"

class Texture
{
private:

GLuint _textureID = 0;
int _width = 0, _heigth = 0, _bitDepth = 0;

void GenerateTexture()
{
glGenTextures(1, &_textureID);
glBindTexture(GL_TEXTURE_2D, _textureID);
}

void SetParameters()
{
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
}

void Config(unsigned char* textureBytes)
{
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, _width, _heigth, 0, GL_RGB, GL_UNSIGNED_BYTE, textureBytes);
glGenerateMipmap(GL_TEXTURE_2D);
}

void Cleanup(unsigned char* textureBytes)
{
glBindTexture(GL_TEXTURE_2D, 0);
stbi_image_free(textureBytes);
}

void LoadFromFile(const char* filePath)
{
unsigned char* textureBytes = stbi_load(filePath, &_width, &_heigth, &_bitDepth, 0);
if (!textureBytes) {
std::cout << "\nFile " << filePath << " doesn't exist or is corrupted\n!";
return;
}

GenerateTexture();
SetParameters();
Config(textureBytes);
Cleanup(textureBytes);

}

public:

Texture(const char* filePath) { LoadFromFile(filePath); }
~Texture() { glDeleteTextures(1, &_textureID); }

void Use(int textureUnit = 0)
{
glActiveTexture(GL_TEXTURE0 + textureUnit);
glBindTexture(GL_TEXTURE_2D, _textureID);
}
};


Criação do objeto (parcial):

private:
static GLuint InitializeVAO()
{
GLuint vao;
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
return vao;
}

static void InitializeVBO(GLfloat* vertices, unsigned int numVertices)
{
GLuint vbo;
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, numVertices, vertices, GL_STATIC_DRAW);
}

static void InitializeIBO(GLuint* indices, unsigned int numIndices)
{
GLuint ibo;
glGenBuffers(1, &ibo);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, numIndices, indices, GL_STATIC_DRAW);
}

static void Finish(GLfloat* vertices)
{
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, (sizeof(vertices[0]) * 5), 0);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, (sizeof(vertices[0]) * 5), ((void*)(sizeof(vertices[0]) * 3)));
glEnableVertexAttribArray(0);
}

static void Cleanup()
{
glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
}

static GLuint CreateBuffers(GLfloat* vertices, unsigned int numVertices, GLuint* indices, unsigned int numIndices)
{
GLuint vao{InitializeVAO()};

InitializeVBO(vertices, numVertices);
if (numIndices > 0)
InitializeIBO(indices, numIndices);

Finish(vertices);
Cleanup();

return vao;
}
public
static GLuint DrawHalfPyramid()
{
GLfloat vertices[] = {
-1.0f, -1.0f, 0.0f, 0.0f, 0.0f,
0.0f, -1.0f, 1.0f, 0.5f, 0.0f,
1.0f, -1.0f, 0.0f, 1.0f, 0.0f,
0.0f, 1.0, 0.0f, 0.5f, 1.0f
};

GLuint indices[] = {
0, 3, 1,
1, 3, 2,
2, 3, 0,
0, 1, 2
};

return CreateBuffers(vertices, sizeof(vertices), indices, sizeof(indices));
}


Vertex Shader:

#version 460

layout (location = 0) in vec3 pos;
layout (location = 1) in vec2 texCoord;
uniform mat4 projectionMatrix, viewMatrix, translationMatrix;
out vec2 texCoordVec;

void main()
{
gl_Position = (projectionMatrix * viewMatrix * translationMatrix * vec4(pos, 1.0));
texCoordVec = texCoord;
}


Fragment Shader:

#version 460
in vec2 texCoordVec;
out vec4 color;
uniform sampler2D texSampler;

void main()
{
color = texture(texSampler, texCoordVec);
}


Alguém poderia me ajudar?

Muito Obrigado!!!


  






Patrocínio

Site hospedado pelo provedor RedeHost.
Linux banner
Linux banner

Destaques

Artigos

Dicas

Tópicos

Top 10 do mês

Scripts