Hello !
I tried to use devIL to import textures into OpenGL, my soft pass all the tests durring the loading of the devIL image and I get a "texture successfully loaded" BUT the result after building is that the texture is empty in the fragment shader 
(so I get a black rectangle)
So, to be sure that the problem is totally about the devIL loading, i tried with a DDS loader, and that worked.
My texture is 128 x 128 and 24 depth
Here is my code :
Vertex Shader :
#version 400
uniform mat4 model_matrix;
uniform mat4 projection_matrix;
layout (location = 0) in vec4 position;
layout (location = 1) in vec2 instance_uv;
out vec2 UV;
void main(void)
{
UV = instance_uv;
gl_Position = position;
}
Fragment Shader :
#version 400 core
// Interpolated values from the vertex shaders
in vec2 UV;
// Ouput data
out vec4 color;
// Values that stay constant for the whole mesh.
uniform sampler2D myTextureSampler;
void main(){
// Output color = color of the texture at the specified UV
color = texture( myTextureSampler, UV.xy ).rgba;
}
main.cpp
#include <stdlib.h>
#include <stdio.h>
#include <iostream>
#include <GL\glew.h>
#include <GL\freeglut.h>
#include <vgl.h>
#include <LoadShaders.h>
#include <IL\il.h>
#include <IL\ilut.h>
#include <IL\ilu.h>
#include "texture.hpp"
#define INSTANCE_COUNT 200
float aspect;
GLuint render_prog;
GLuint vao[1];
GLuint vbo[1];
GLuint ebo[1];
GLint render_model_matrix_loc;
GLint render_projection_matrix_loc;
ILuint images[2];
GLuint texture;
GLuint TextureLoc;
GLuint loadImage(const char* theFileName)// devIL loader
{
ILuint imageID; // Create an image ID as a ULuint
GLuint textureID; // Create a texture ID as a GLuint
ILboolean success; // Create a flag to keep track of success/failure
ILenum error; // Create a flag to keep track of the IL error state
ilGenImages(1, &imageID); // Generate the image ID
ilBindImage(imageID); // Bind the image
success = ilLoadImage(theFileName); // Load the image file
// If we managed to load the image, then we can start to do things with it...
if (success)
{
// If the image is flipped (i.e. upside-down and mirrored, flip it the right way up!)
ILinfo ImageInfo;
iluGetImageInfo(&ImageInfo);
if (ImageInfo.Origin == IL_ORIGIN_UPPER_LEFT)
{
iluFlipImage();
}
// Convert the image into a suitable format to work with
// NOTE: If your image contains alpha channel you can replace IL_RGB with IL_RGBA
success = ilConvertImage(IL_RGB, IL_UNSIGNED_BYTE);
// Quit out if we failed the conversion
if (!success)
{
error = ilGetError();
std::cout << "Image conversion failed - IL reports error: " << error << " - " << iluErrorString(error) << std::endl;
exit(-1);
}
// Generate a new texture
glGenTextures(1, &textureID);
// Bind the texture to a name
glBindTexture(GL_TEXTURE_2D, textureID);
// Set texture clamping method
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
// Set texture interpolation method to use linear interpolation (no MIPMAPS)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
// Specify the texture specification
glTexImage2D(GL_TEXTURE_2D, // Type of texture
0, // Pyramid level (for mip-mapping) - 0 is the top level
ilGetInteger(IL_IMAGE_BPP), // Image colour depth
ilGetInteger(IL_IMAGE_WIDTH), // Image width
ilGetInteger(IL_IMAGE_HEIGHT), // Image height
0, // Border width in pixels (can either be 1 or 0)
ilGetInteger(IL_IMAGE_FORMAT), // Image format (i.e. RGB, RGBA, BGR etc.)
GL_UNSIGNED_BYTE, // Image data type
ilGetData()); // The actual image data itself
}
else // If we failed to open the image file in the first place...
{
error = ilGetError();
std::cout << "Image load failed - IL reports error: " << error << " - " << iluErrorString(error) << std::endl;
exit(-1);
}
ilDeleteImages(1, &imageID); // Because we have already copied image data into texture data we can release memory used by image.
std::cout << "Texture creation successful." << std::endl;
return textureID; // Return the GLuint to the texture so you can use it!
}
void init()
{
glEnable(GL_TEXTURE_2D);
ShaderInfo shader_info[] =
{
{ GL_VERTEX_SHADER, "instance.vert" },
{ GL_FRAGMENT_SHADER, "instance.frag" },
{ GL_NONE, NULL }
};
render_prog = LoadShaders(shader_info);
render_model_matrix_loc = glGetUniformLocation(render_prog, "model_matrix");
render_projection_matrix_loc = glGetUniformLocation(render_prog, "projection_matrix");
// A single triangle
static const GLfloat vertex_positions[] =
{
-0.5f, -0.5f, 0.0f, 1.0f,
0.5f, -0.5f, 0.0f, 1.0f,
0.5f, 0.5f, 0.0f, 1.0f,
-0.5f, 0.5f, 0.0f, 1.0f
};
static const GLfloat vertex_uv[] =
{
0.0, 1.0,
1.0, 1.0,
1.0, 0.0,
0.0, 0.0
};
// Indices for the triangle strips
static const GLushort vertex_indices[] =
{
0, 1, 2, 3
};
glGenVertexArrays(1, vao);
glBindVertexArray(vao[0]);
glGenBuffers(1, vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo[0]);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertex_positions) + sizeof(vertex_uv) , NULL, GL_STATIC_DRAW);
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertex_positions), vertex_positions);
glBufferSubData(GL_ARRAY_BUFFER, sizeof(vertex_positions), sizeof(vertex_uv), vertex_uv);
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, (const GLvoid*) 0);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, (const GLvoid*) sizeof(vertex_positions));
//texture = loadDDS("uvtemplate.DDS"); works
texture = loadImage("test.jpg"); // doesn't work
TextureLoc = glGetUniformLocation(render_prog, "myTextureSampler");
glClearColor(1.0f, 0.0f, 0.0f, 1.0f);
}
void display()
{
// Setup
glPointSize(21.0);
glDisable(GL_DEPTH_TEST);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glUseProgram(render_prog);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, texture);
// Set our "myTextureSampler" sampler to user Texture Unit 0
glUniform1i(TextureLoc, 0);
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
glDisableVertexAttribArray(0);
glDisableVertexAttribArray(1);
glutSwapBuffers();
}
void Reshape(int width, int height)
{
glViewport(0, 0 , width, height);
aspect = float(height) / float(width);
}
int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitContextFlags(GLUT_DEBUG);
glutInitWindowSize(1024, 768);
glutInitContextVersion(4, 0);
glutInitWindowPosition (140, 140);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
glutInitContextProfile(GLUT_CORE_PROFILE);
glutCreateWindow("hello");
if (glewInit())
{
std::cout << "Une erreur est survenue lors de l'init de glew" << std::endl;
exit(EXIT_FAILURE);
}
ilInit();
iluInit();
ilutInit();
ilutRenderer(ILUT_OPENGL);
init();
glutDisplayFunc(display);
glutReshapeFunc(Reshape);
glutMainLoop();
glDeleteVertexArrays(1, vao);
glDeleteBuffers(1, vbo);
glDeleteTextures(1, &texture);
return 0;
}
Thank you for your help !
