Jump to content

  • Log In with Google      Sign In   
  • Create Account

We're offering banner ads on our site from just $5!

1. Details HERE. 2. GDNet+ Subscriptions HERE. 3. Ad upload HERE.


Texture loading with devIL


Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.

  • You cannot reply to this topic
5 replies to this topic

#1 shocobenn   Members   -  Reputation: 273

Like
0Likes
Like

Posted 19 July 2013 - 09:45 AM

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 sad.png (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 !


Edited by shocobenn, 19 July 2013 - 10:07 AM.


Sponsor:

#2 sethhope   Members   -  Reputation: 462

Like
1Likes
Like

Posted 19 July 2013 - 11:40 AM

I ran into several problems much like yours while using DevIL. After that, I decided to switch to SOIL. It is very easy to use (alot more so than devIL). http://www.lonesock.net/soil.html


I develop to expand the universe.
"Live long and code strong!" - Delta_Echo (dream.in.code)

#3 dpadam450   Members   -  Reputation: 944

Like
0Likes
Like

Posted 19 July 2013 - 01:37 PM

I would agree. I have had DevIL for basic image loading, but its not documented well anymore and for things like DDS textures etc it starts to blow up. It does work though.

SOIL may be better.



#4 shocobenn   Members   -  Reputation: 273

Like
0Likes
Like

Posted 22 July 2013 - 07:58 AM

Thank you guys, used SOIL and resolved the problem :)



#5 eastcowboy   Members   -  Reputation: 170

Like
0Likes
Like

Posted 23 July 2013 - 07:47 PM

Ah, if you still want to use the DevIL library, just use the ilutGLLoadImage function, to replace your loadImage function.

This works very well for me.



#6 EarthBanana   Members   -  Reputation: 989

Like
0Likes
Like

Posted 24 July 2013 - 12:30 AM

devIL does some things nicely and SOIL does others.. I use them both






Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.



PARTNERS