Erro compilação OpenGL: BITMAPFILEHEADER not declared

Tiago Pimentel
(usa Ubuntu)

Enviado em 03/12/2015 - 14:23h

Ola pessoal, poderiam me ajudar.

Tenho um trabalho da faculdade com OpenGL e C++. Meu código em c++ utilizando opengl compila normalmente do Windows, mas não funciona no linux.
Estou compilando asssim:

g++ fonte.cpp -o saida.out -lGL -lGLU -lglut

E compilador não esta reconhecendo:
BITMAPFILEHEADER
BITMAPINFOHEADER

Esse é o erro que dá!


Segue código(removi algumas partes do código pra não ficar muito grande.):

#include <GL/glut.h>

#include <GL/gl.h>

#include <GL/glu.h>

#include <cstdlib>

#include <ctime>

#include <fstream>

#include <math.h>

#include <iostream>

#include <GL/glext.h>



using namespace std;



const int MAX_PARTICULAS = 100000;

const float TAMANHO_PARTICULA = 0.05f;

const float FADE_RATE = 0.01f;

const float RAIO = 0.5f;

const float PI = 3.14f;

const float GRAVIDADE = -0.0098;

const float MASSA = 2;

const float ENERGIA_CINETICA = 0.0;





int width = 640;

int height = 640;

int dist = 25;

float rotationX = 38.0, rotationY = 22.0;

int proj = 0;



typedef struct particula Particula;

typedef struct imagem Imagem;



struct particula {

	...

};



struct imagem {

	unsigned char* ps;

	GLuint largura;

	GLuint altura;

};



Particula particulas[MAX_PARTICULAS];

GLuint textura[2];



float randomFloat();



void display(void);

void init(void);

void criarParticulas();

void desenharParticulas();

void desenharChao();

void atualizarParticulas();

void reshape(int w, int h);

Imagem *carregarBitmap(const char* nomeArquivo);

GLuint gerarTextura(Imagem *imagem);

void excluirTextura(GLuint textura);



int main(int argc, char** argv) {

	srand((unsigned int)time(0));



	glutInit(&argc, argv);

	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);

	glutInitWindowSize(500, 500);

	glutInitWindowPosition(100, 100);

	glutCreateWindow("Particle System");



	init();



	glutDisplayFunc(display);

	glutIdleFunc(display);

	glutReshapeFunc(reshape);

	glutMainLoop();

	return 0;

}



void desenhaEixos(){

....

}





void display(void) {

....

}



void init(void) {

	glClearColor (0.0, 0.0, 0.0, 0.0);

	glEnable(GL_TEXTURE_2D);

	glEnable(GL_DEPTH_TEST);

	criarParticulas();





	Imagem *particle_mask = carregarBitmap("circlealpha.bmp");

	Imagem *particle = carregarBitmap("circle.bmp");



	if(particle_mask == NULL || particle == NULL) {

		textura[0] = 0;

		textura[1] = 0;

	} else {

		textura[0] = gerarTextura(particle_mask);

		textura[1] = gerarTextura(particle);

	}

}



float randomFloat() {

	return (float)rand() / ((float)RAND_MAX + 1);

}



void criarParticulas() {

....

}



void desenharParticulas() {

....

}



void desenharChao() {

......

}



void atualizarParticulas() {



	.....

}



void reshape (int w, int h) {

....

}



Imagem *carregarBitmap(const char* nome_arquivo) {



	Imagem* imagem = new Imagem;



	/* Codigo adaptado do site http://www.cplusplus.com/articles/GwvU7k9E/ */



	unsigned char* datBuff[2] = {NULL, NULL};

	unsigned char* pixels = NULL;



	BITMAPFILEHEADER* bmpHeader = NULL;

	BITMAPINFOHEADER* bmpInfo   = NULL;



	ifstream file(nome_arquivo, std::ios::binary);

	if(!file) {

		cout << "Arquivo nao encontrado\n";

		return NULL;

	}



	datBuff[0] = (unsigned char*)malloc(sizeof(BITMAPFILEHEADER));

	datBuff[1] = (unsigned char*)malloc(sizeof(BITMAPINFOHEADER));



	file.read((char*)datBuff[0], sizeof(BITMAPFILEHEADER));

	file.read((char*)datBuff[1], sizeof(BITMAPINFOHEADER));



	bmpHeader = (BITMAPFILEHEADER*) datBuff[0];

	bmpInfo   = (BITMAPINFOHEADER*) datBuff[1];



	if(bmpHeader->bfType != 0x4D42)	{

		std::cout << "Arquivo \"" << nome_arquivo << "\" nao eh bitmap\n";

		return NULL;

	}



	pixels = (unsigned char*)malloc(bmpInfo->biSizeImage);

	file.seekg(bmpHeader->bfOffBits);

	file.read((char*)pixels, bmpInfo->biSizeImage);

	unsigned char tmpRGB = 0;

	for (unsigned long i = 0; i < bmpInfo->biSizeImage; i += 3)

	{

		tmpRGB        = pixels[i];

		pixels[i]     = pixels[i + 2];

		pixels[i + 2] = tmpRGB;

	}



	GLuint w = bmpInfo->biWidth;

	GLuint h = bmpInfo->biHeight;



	/* Fim do codigo */



	imagem->altura = h;

	imagem->largura = w;

	imagem->ps = pixels;



	return imagem;

}



GLuint gerarTextura(Imagem* imagem) {



	GLuint textura;

	glGenTextures(1, &textura);

	glBindTexture(GL_TEXTURE_2D, textura);



	GLint mode = GL_RGB;

	glTexImage2D(GL_TEXTURE_2D, 0, mode, imagem->largura, imagem->altura, 0, mode, GL_UNSIGNED_BYTE, imagem->ps);



	delete imagem;



	return textura;

}



void excluirTextura(GLuint textura) {

	glDeleteTextures(1, &textura);

}



 

Espero que possam me ajudar.
Obrigado.

Thihup
(usa Manjaro Linux)

Enviado em 03/12/2015 - 18:49h

Olá amigo, tudo certo?

Bom, tenho que lhe informar que (parte dele) é código do sistema Janelas.

Você está utilizando 2 structs (BITMAPFILEHEADER e BITMAPINFOHEADER) que só existem no Windows.

Vou lhe propor uma solução para você carregar Bitmaps em (quase) qualquer sistema:

Coloque este código bem no começo do seu programa:

#ifndef __WIN32



#include <cstdint>



typedef int LONG;

typedef unsigned char BYTE;

typedef uint32_t DWORD;

typedef unsigned short WORD;



typedef struct tagBITMAPFILEHEADER

{

    WORD    bfType; 

    DWORD   bfSize; 

    WORD    bfReserved1; 

    WORD    bfReserved2; 

    DWORD   bfOffBits;

} __attribute__((packed)) BITMAPFILEHEADER;



typedef struct tagBITMAPINFOHEADER

{

    DWORD    biSize;

    LONG     biWidth;

    LONG     biHeight;

    WORD     biPlanes;

    WORD     biBitCount;

    DWORD    biCompress;

    DWORD    biSizeImage;

    LONG     biXPelsPerMeter;

    LONG     biYPelsPerMeter;

    DWORD    biClrUsed;

    DWORD    biClrImportant;

} __attribute__((packed)) BITMAPINFOHEADER;



#endif



 

Como o código está com a diretiva #ifndef __WIN32, esse código só aparecerá em sistemas diferentes do Windows, agora se for o Windows já está definido essas structs.

Obs: Talvez você precise compilar assim:

g++ arquivo.cpp -o executavel -lGL -lGLU -lglut -std=c++11

Obs²: Você pode trocar de #include <math.h> para #include <cmath>.

Espero ter ajudado

[]'s

T+

--

Att,

Thiago Henrique Hüpner

(Mensagem scaneada pelo antivírus........ops! não precisa, afinal eu uso Linux!)