Me gustaría preguntar cómo llamar a C++.
Archivo de encabezado bitmap.h
/*
Definición de archivo BMP de Windows de OpenGL.
*
*Autor Michael Sweet.
*/
#ifndef _BITMAP_H_
# define _BITMAP_H_
/*
*Incluye encabezados necesarios.
*/
# incluir & ltGL/glut h & gt
# ifdef WIN32
# incluir & ltwindows.h & gt
# include & ltwingdi.h & gt
# endif /* WIN32 */
/*
*Habilitar esto Los archivos de encabezado funcionan con código fuente C y C++...
*/
# ifdef __cplusplus
external "C" {
# endif /* __cplusplus */
/*
*Estructura de datos del archivo de mapa de bits (estos se encuentran en & ltwingdi.h & gt
* Windows... )
*
*Tenga en cuenta que la mayoría de los compiladores de Windows empaquetarán las siguientes estructuras, por lo que
* léalas en MacOS o UNIX, necesitamos leer una sola field
*Para evitar diferencias en la alineación...
*/
# ifndef WIN32
typedef struct /**** Estructura del encabezado del archivo BMP****/
{
BfType corto sin firmar/*número mágico del archivo*/
Unsigned int bfSize/*Tamaño del archivo */
Bfreserved corto sin firmar 1 /*Reserved*/
BfReserved corto sin firmar2/* ...* /
Unsigned int bfOffBits/*Offset de datos de mapa de bits*/
} BITMAPFILEHEADER
# define BF_TYPE 0x4D42 /* "MB" */
typedef struct /**** Estructura de información del archivo BMP* ***/
{
Unsigned int biSize/*El tamaño del encabezado de información*/
int biwidth /*Ancho de la imagen*/
int biHeight/*Altura de la imagen*/
Biplano sin firmar; /*Color Número de planos*/
biBitCount corto sin firmar/*Número de bits por píxel */
Compresión doble de entero sin signo /*Tipo de compresión a utilizar*/
Unsigned int biSizeImage/*Tamaño de los datos de la imagen*/
int biXPelsPerMeter; /*X píxeles por metro*/
int biYPelsPerMeter/*Y píxeles por metro* /
Unsigned int biClrUsed/*Número de colores utilizados*/
Unsigned int biClrImportant/*Número de colores importantes*/
} BITMAPINFOHEADER
/*
*Constante para campos de compresión dual...
*/
# define BI_RGB 0 /*Sin compresión - datos BGR directos*/
# define BI_RLE8 1 /* Compresión de longitud de ejecución de 8 bits*/
# definir BI_RLE4 2 /* Compresión de longitud de ejecución de 4 bits*/
# Definir BI_BITFIELDS 3 con máscara RGB /* Mapa de bits RGB*/
estructura typedef /*** *Estructura de entrada del mapa de colores****/
{
Carácter sin firmar rgbBlue/*valor azul*/
Carácter sin firmar rgbGreen/*valor verde*/
Carácter sin firmar rgbRed/*valor rojo*/
Carácter sin firmar rgbReserved/*reserved*/
} RGBQUAD
typedef struct /****estructura de información de mapa de bits****/
{
BITMAPINFOHEADER bmiHeader/*Título de la imagen*/
Colores RGBQUAD BMI[256] /*Tabla de asignación de colores de la imagen*/
} BITMAPINFO
#endif/*! WIN32 */
/*
*Prototipo...
*/
byte Glu externo * LoadDIBitmap(const char * nombre de archivo , BITMAPINFO * * info);
extern int SaveDIBitmap(const char * nombre de archivo, BITMAPINFO *info,
GLubyte *bit
# ifdef __cplusplus<); /p>
}
# endif /* __cplusplus */
#endif /*! _BITMAP_H_ */
Archivo fuente bitmap.c
/*
*Funciones de archivo BMP de Windows para OpenGL.
*
*Autor Michael Sweet.
*/
#include " bitmap.h "
# include & ltstdio.h & gt
# include & ltstdlib. h & gt
# include & número de error& gt
#ifdef WIN32
/*
* 'LoadDIBitmap()' -Load Archivos DIB/BMP desde el disco.
*
*Si tiene éxito, devuelve un puntero al mapa de bits; de lo contrario, devuelve NULL...
*/
GLubyte * /* O - datos de mapa de bits * /
LoadDIBitmap(const char *nombre de archivo, /* I - archivo a cargar */
BITMAPINFO **info) /* O - información de imagen de bits */
{
ARCHIVO * fp/*puntero de archivo abierto*/
GLubyte *bit /*bit número de píxeles de la imagen*/
int bitsize/*El tamaño del mapa de bits*/
int infosize/*El tamaño de la información del encabezado*/
Encabezado BITMAPFILEHEADER /*Encabezado del archivo*/
/* Intente abrir el archivo; utilice el modo "rb" para leer este archivo *binario*.
*/
if ((fp = fopen(nombre de archivo, "Rb")) = = NULL)
Return (NULL);
/*Leer Obtenga el encabezado del archivo y cualquier información de mapa de bits posterior...*/
if(fread(& header,sizeof(BITMAPFILEHEADER),1,FP)<1)
{
/*No se puede leer el encabezado del archivo: devuelve NULL...*/
fclose(FP);
Devuelve (NULL);
p >}
if (header.bfType!= 'MB') /*Compruebe si BM está invertido...*/
{
/*No es un archivo de mapa de bits: devuelve un valor nulo...*/
fclose(FP);
Devuelve (NULL);
}
infosize = encabezado . bfoff bits-sizeof(bitmapfile header);
if((* info =(BITMAPINFO *)malloc(infosize))= = NULL)
{
/*No se puede asignar memoria para información de mapa de bits: devuelve valor nulo...*/
fclose(FP);
Devuelve (NULL) ;
}
if (fread(*info, 1, infosize, FP)& lt; infosize)
{
/ *No se puede leer el encabezado del mapa de bits: devuelve nulo...*/
free(*info);
fclose(FP);
return (NULL) ;
}
/*Ahora que hemos leído toda la información del encabezado, asigne memoria para el *mapa de bits
* y lea *it *. ..*/
if((bitsize =(* info)-& gt; bmiHeader.biSizeImage) == 0)
bitsize =(* info)-& gt ;bmiHeader .biWidth *
(*info)->bmiHeader.biBitCount + 7) / 8 *
ABS((*info)->Encabezado BMI. Altura BIH);
if((bits = malloc(bitsize))= = NULL)
{
/*No se puede asignar memoria: ¡devuelve NULL! */
Gratis(*info);
fclose(FP);
Devolución (NULL);
}
if (fread(bits, 1, bitsize, FP) & lt; tamaño de bits)
{
/* ¡No se puede leer la memoria libre del mapa de bits y se devuelve NULL! */
Gratis(*info);
Gratis(bit);
fclose(FP);
Retorno (NULL) ;
}
/*Está bien, todo está bien: devuelve el mapa de bits asignado...*/
fclose(FP);
Return (bit);
}
/*
* 'SaveDIBitmap()' - Guarda un archivo DIB/BMP en el disco.
*
*Devuelve 0 en caso de éxito, -1 en caso de error...
*/
int /* O - 0 = éxito, -1 = error */
SaveDIBitmap(const char *nombre de archivo, /* I - archivo a cargar */
BITMAPINFO *info, /* I - bit Información de imagen */
GLubyte *bits) /* I - datos de mapa de bits*/
{
ARCHIVO * fp/*Abrir puntero de archivo*/
int size, /*tamaño de archivo*/
infosize, /*tamaño de la información del mapa de bits*/
bitsize/*tamaño de los píxeles del mapa de bits*/
BITMAPFILEHEADER header; /*Encabezado del archivo*/
/*Intento de abrir el archivo; escriba este archivo *binario* usando el modo "wb".
*/
if ((fp = fopen(nombre de archivo, "WB")) = = NULL)
return(-1);
/* Calcular el tamaño del mapa de bits */
if(info-& gt;bmiHeader.biSizeImage == 0)
bitsize =(info-& gt;bmiHeader.biWidth *
Información->bmiHeader.biBitCount + 7) / 8 *
abs(Información->Encabezado BMI. Altura BIH);
Otro
bitsize = info-& gt;BMI header .imagen bisize;
/*Calcular el tamaño del encabezado*/
infosize = sizeof(BITMAPINFOHEADER);
switch(info->bmiHeader.biCompression)
{
Caso BI_bitfield:
infosize+= 12 /* Agregar 3 máscaras de palabra doble RGB */
if(info->bmiHeader.biClrUsed == 0)
break;
Caso BI_RGB:
if(info-> bmiHeader.biBitCount & gt8 & amp& amp
info->bmiHeader.biClrUsed == 0)
Pausa;
Caso BI_RLE8:
Caso BI_RLE4:
if(info-& gt;bmiHeader.biClrUsed == 0)
infosize+=(1 & lt ;<info->encabezado BMI .bibitcount)* 4;
Otro
infosize+= info->BMI header .biclrsered* 4;
Pausa;
}
size = sizeof(bitmapfile header)+infosize+bitsize;
/*Escribir encabezado de archivo, información de mapa de bits y bits Datos de píxeles de imagen...*/
encabezado. bfType = ' MB/*No portátil...suspiro*/
header.bfSize = tamaño
encabezado . BF reservado 2 = 0;
encabezado. bfoff bits = tamaño de (encabezado del archivo de mapa de bits)+infosize; ;sizeof(BITMAPFILEHEADER))
{
/* No se puede escribir el encabezado del archivo - retorno ..*/
fclose(FP);
return(-1);
}
if (fwrite(info, 1, infosize, FP)<infosize)
{
/*No se puede escribir el encabezado del mapa de bits - return...*/
fclose( FP);
return(-1);
}
if (fwrite(bits, 1, tamaño de bits
, FP)<tamaño de bits)
{
/*No se puede escribir en el mapa de bits - retorno...*/
fclose(FP); /p>
return(-1);
}
/*Está bien, todo está bien - return...*/
fclose( FP);
return(0);
}
#else /*! WIN32 */
/*
*Funciones para leer y escribir enteros little-endian de 16 y 32 bits.
*/
Read_word corto estático sin firmar(FILE * FP);
Estático sin firmar int read_dword(FILE * FP);
static int read_long(FILE * FP);
static int write_word(FILE *fp, unsigned short w);
static int write_dword(FILE *fp, unsigned int dw);
static int write_long(FILE *fp, int l);
/*
* 'LoadDIBitmap()' - Carga archivos DIB/BMP desde el disco.
*
*Si tiene éxito, devuelve un puntero al mapa de bits; de lo contrario, devuelve NULL...
*/
GLubyte * /* O - datos de mapa de bits * /
LoadDIBitmap(const char *nombre de archivo, /* I - archivo a cargar */
BITMAPINFO **info) /* O - información de imagen de bits */
{
ARCHIVO * fp/*puntero de archivo abierto*/
GLubyte *bit /*bit número de píxeles de la imagen*/
GLubyte * ptr/*Puntero al mapa de bits*/
Temperatura GLubyte; /*Variable temporal utilizada para intercambiar rojo y azul*/
int x, y; y posición Y en la imagen*/
int length /*line length*/
int bitsize/*tamaño del mapa de bits*/
int infosize; /*El tamaño de la información del encabezado*/
Encabezado BITMAPFILEHEADER /*Encabezado del archivo*/
/*Intento abrir el archivo usando el modo "rb" Lea esto *binario; * archivo.
*/
if ((fp = fopen(nombre de archivo, "Rb")) = = NULL)
Return (NULL);
/*Leer Obtenga el encabezado del archivo y cualquier información de mapa de bits posterior...*/
header .BF type = read _ word(FP);
header = read _ dword(FP). ;
encabezado . bfreserved 1 = leer _ palabra(FP);
encabezado . bfreserved 2 = leer _ palabra(FP);
encabezado bfoff. = read _ dword(FP);
if (header.bfType!= BF_TYPE) /*Comprueba si BM está invertido...*/
{
/*No es un archivo de mapa de bits: devuelve un valor nulo...*/
fclose(FP);
Devuelve (NULL);
}< / p>
infosize = encabezado . bfoffbits-18;
if((* info =(BITMAPINFO *)malloc(sizeof(BITMAPINFO)))= = NULL)
{
/*No se puede asignar memoria para la información del mapa de bits: devuelve nulo...*/
fclose(FP);
Devuelve (NULL);
}
(*Información)->Encabezado BMI . bisize = read_dword(FP);
(*Información)->Encabezado BMI . = leer _ largo(FP);
(*Información)->Encabezado BMI = leer _ largo(FP); Encabezado BMI . bi planos = leer _ palabra(FP);
(*Información)-& gt;Encabezado BMI .bibitcount = leer _ palabra(FP); )->Encabezado BMI .bi compresión = read_dword(FP);
(*Información)->Encabezado BMI .bisize imagen = read_dword(FP) ;
(*Información )->Encabezado de IMC. bixpelspermeter = leer _ largo(FP);
(*Información)->Encabezado de IMC. biypelspermeter = leer _ largo(FP);
( *Información)->Encabezado de BMI . biclrsered = read_dword(FP);
(*Información)->Encabezado de BMI .biclr importante = read_dword(FP);
if( infosize>40)
if(fread(*info)->bmiColors,infosize-40,1 , FP)<1)
{
/*No se puede leer el encabezado del mapa de bits: devuelve nulo...*/
Free(* info);
fclose(FP);
Return (NULL );
}
/
*Ahora que hemos leído toda la información del encabezado, asigne memoria para * el mapa de bits
* y lea *it*...*/
if((bitsize =( *info)->bmiHeader.biSizeImage) == 0)
bitsize =(*info)->bmiHeader.biWidth *
(*info)->bmiHeader. biBitCount + 7) / 8 *
ABS((* info)-& gt;encabezado BMI . altura BIH);
if((bits = malloc(tamaño de bits) )= = NULL)
{
/*No se puede asignar memoria: ¡devuelve NULL! */
Gratis(*info);
fclose(FP);
Devolución (NULL);
}
if (fread(bits, 1, bitsize, FP) & lt; tamaño de bits)
{
/* ¡No se puede leer la memoria libre del mapa de bits y devuelve NULL! */
Gratis(*info);
Gratis(bit);
fclose(FP);
Retorno (NULL) ;
}
/*Intercambiar rojo y azul*/
longitud =(* info)-& gt;BMI encabezado bi ancho * 3+ 3. )&~3;
for(y = 0;y<(*información)->Encabezado IMC . Altura BIH;y++)
for (ptr = bits + y * longitud, x = (*información) ->BMI encabezado .bi ancho;
x>0;
x -,ptr += 3 )
{
temp = ptr[0];
ptr[0]= ptr[2]
ptr[2 ]= temp;
}
/*Está bien, todo está bien: devuelve el mapa de bits asignado...*/
fclose(FP);
Return (bit);
}
/*
* 'SaveDIBitmap()' - Guarda el archivo DIB/BMP en el disco.
*
*Devuelve 0 en caso de éxito, -1 en caso de error...
*/
int /* O - 0 = éxito, -1 = error */
SaveDIBitmap(const char *nombre de archivo, /* I - archivo a cargar */
BITMAPINFO *info, /* I - bit Información de imagen */
GLubyte *bits) /* I - datos de mapa de bits*/
{
ARCHIVO * fp/*Abrir puntero de archivo*/
int size, /*tamaño de archivo*/
infosize, /*tamaño de la información del mapa de bits*/
bitsize/*tamaño de los píxeles del mapa de bits*/
/* Intenta abrir el archivo; escribe este archivo *binario* en modo "wb".
*/
if ((fp = fopen(nombre de archivo, "WB")) = = NULL)
return(-1);
/* Calcular el tamaño del mapa de bits */
if(info-& gt;bmiHeader.biSizeImage == 0)
bitsize =(info-& gt;bmiHeader.biWidth *
Información->bmiHeader.biBitCount + 7) / 8 *
abs(Información->Encabezado BMI. Altura BIH);
Otro
bitsize = info-& gt;BMI header .imagen bisize;
/*Calcular el tamaño del encabezado*/
infosize = sizeof(BITMAPINFOHEADER);
switch(info->bmiHeader.biCompression)
{
Caso BI_bitfield:
infosize+= 12 /* Agregar 3 máscaras de palabra doble RGB */
if(info->bmiHeader.biClrUsed == 0)
break;
Caso BI_RGB:
if(info-> bmiHeader.biBitCount & gt8 & amp& amp
info->bmiHeader.biClrUsed == 0)
Pausa;
Caso BI_RLE8:
Caso BI_RLE4:
if(info-& gt;bmiHeader.biClrUsed == 0)
infosize+=(1 & lt ;<info->encabezado BMI .bibitcount)* 4;
Otro
infosize+= info->BMI header .biclrsered* 4;
Pausa;
}
size = sizeof(bitmapfile header)+infosize+bitsize;
/*Escribir encabezado de archivo, información de mapa de bits y bits Datos de píxeles de imagen...*/
write_word( fp, BF _ TYPE); /* bfType */
write_dword(fp, tamaño); /* bfSize */
write_word(fp, 0);
write_dword(fp, 0); /* bfReserved2 */
write_dword(fp, 18+infosize); /* bfOffBits */
write_dword(fp); , info-& gt;encabezado BMI . bisize);
write_long(fp, info-& gt;encabezado BMI . bi ancho );
write_long(fp, info-& gt ;encabezado IMC . altura BIH);
write_word(fp, info->encabezado IMC . biplanos);
write_word(fp,info->encabezado IMC . bibitcount) ;
write_dword(fp,info->BM
I encabezado . bi compresión);
write_dword(fp, info-& gt;encabezado BMI . imagen bisize);
write_long(fp, info-& gt;encabezado BMI . bixpelspermeter );
write_long(fp, info-& gt;encabezado BMI. biypelspermeter);
write_dword(fp, info-& gt;encabezado BMI. biclrused);
write_dword(fp,info->encabezado BMI. biclr importante);
if(infosize>40)
if(fwrite(info-> bmiColors, infosize - 40, 1, FP)<1)
{
/* No se puede escribir el encabezado del mapa de bits - devolver...*/
fclose(FP) ;
return(-1);
}
if (fwrite(bits, 1, tamaño de bits, FP)& lt; tamaño de bits)
{
/*No se puede escribir en el mapa de bits - return...*/
fclose(FP);
return(-1) ;
}
/*Vale, todo está bien - return...*/
fclose(FP) ;
return (0);
}
/*
* 'read_word()' - Lee un entero sin signo de 16 bits.
*/
Corto estático sin signo /* O - Entero sin signo de 16 bits */
read_word(FILE *fp) /* I - Archivo para leer de */
{
Carbón sin firmar b0, b 1; /*bytes del archivo*/
B0 = getc (FP);
b 1 = getc(FP);
return((b 1 & lt;& lt8)| B0);
}
/*
* 'read_dword()' - Lee un entero sin signo de 32 bits.
*/
Entero estático sin signo /* O - Entero sin signo de 32 bits */
read_dword(FILE *fp) /* I - Para leer desde Leer archivo */
{
Caracteres sin firmar b0, b1, b2, B3 /* Bytes del archivo */
B0 = getc(FP);
b 1 = getc(FP);
B2 = getc(FP);
B3 = getc(FP);
p>
return((((((B3<<8)|B2)<<8)|b 1)<<8)|B0);
}
/*
* 'read_long()' - Lee un entero de 32 bits con signo.
*/
static int /* O - entero con signo de 32 bits */
read_long(FILE *fp) /* I - para leer desde el archivo */
{
Caracteres sin firmar b0, b1, b2, B3 /*Bytes del archivo*/
B0 = getc( FP);
b 1 = getc(FP);
B2 = getc(FP);
B3 = getc(FP);
retorno( (int)((((B3<<8)|B2)<<8)|b 1)<<8)|B0);
}
/*
* 'write_word()' - Escribe un entero sin signo de 16 bits.
*/
Static int /* O - 0 en caso de éxito, -1 en caso de error */
write_word(FILE *fp, /* I -The archivo a escribir*/
W corto sin signo) /* I -El número entero a escribir*/
{
putc( w, FP);
return(putc(w & gt; & gt8, FP));
}
/*
* 'write_dword( )': escribe un entero sin signo de 32 bits.
*/
Static int /* O - 0 en caso de éxito, -1 en caso de error */
write_dword(FILE *fp, /* I -The archivo a escribir*/
unsigned int dw) /* I -El número entero a escribir*/
{
putc(dw, FP );
putc(dw>>8,FP);
putc(dw>>16,FP);
return(putc (dw>>24, FP)) ;
}
/*
* 'write_long()' - Escribe un entero de 32 bits con signo.
*/
Static int /* O - 0 en caso de éxito, -1 en caso de error */
write_long(FILE *fp, /* I -The archivo a escribir*/
int l) /* I -El número entero a escribir*/
{
putc(l, FP) ;
putc(l>>8,FP);
putc(l>>16,FP);
return(putc( l>& gt24,FP)) ;
}
#endif /*WIN32*/