Erro compilação OpenGL: BITMAPFILEHEADER not declared

1. Erro compilação OpenGL: BITMAPFILEHEADER not declared

Tiago da Silva Pimentel
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á!
.cpp: Na função ‘Imagem* carregarBitmap(const char*)’:
.cpp:289:2: erro: ‘BITMAPFILEHEADER’ was not declared in this scope
.cpp:289:20: erro: ‘bmpHeader’ was not declared in this scope
.cpp:290:2: erro: ‘BITMAPINFOHEADER’ was not declared in this scope
.cpp:290:20: erro: ‘bmpInfo’ was not declared in this scope
.cpp:304:32: erro: expected primary-expression before ‘)’ token
.cpp:304:34: erro: expected ‘;’ before ‘datBuff’
.cpp:305:32: erro: expected primary-expression before ‘)’ token
.cpp:305:34: erro: expected ‘;’ before ‘datBuff’


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.


  


2. Re: Erro compilação OpenGL: BITMAPFILEHEADER not declared

Thiago Henrique Hüpner
Thihup

(usa Linux Mint)

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!)






Patrocínio

Site hospedado pelo provedor RedeHost.
Linux banner
Linux banner
Linux banner

Destaques

Artigos

Dicas

Tópicos

Top 10 do mês

Scripts