{
Las texturas pueden ahorrar mucho tiempo de CPU. Jaja, pero esta sección me tomó mucho tiempo: (
Debido a que se usa la biblioteca auxiliar OpenGL, pocas personas usan las funciones de esta biblioteca ahora, pero aún así la encontré. Gracias a zdcnow (Magnetic Effect), me proporcionó la versión Delphi de esta biblioteca auxiliar. Antes de estudiar esta sección, descargue los archivos glaux.dll y Glaux.pas en línea y agréguelos al proyecto.
Bien, sigamos por el camino de OPENGL.
Primero necesitamos agregar la unidad SysUtils, porque usaremos operaciones de archivos en esta sección, y también necesitamos agregar la unidad Glaux.
Luego agregamos varias variables, xrot, yrot y zrot, según la primera lección. Estas variables se utilizan para rotar el cubo alrededor de los ejes X, Y y Z. textura[] asigna espacio de almacenamiento para una textura. Si necesitas más de una textura, deberás cambiar el número 1 por el número que necesites.
}
var
h_RC: HGLRC; // Contexto de representación (tabla de descripción de sombreado).
h_DC: HDC // Contexto del dispositivo (tabla de descripción del dispositivo)
h_Wnd: HWND // identificador de ventana
h_Instance: HINST; // Instancia del programa (instancia).
teclas: Array[0..255] Of Boolean; // Matriz para rutinas de teclado
xrot, // X cantidad de rotación (nuevo)
yrot, // cantidad de rotación Y (nuevo)
zrot: GLfloat; // cantidad de rotación Z (nuevo)
Textura: Array[0..1] Of GLuint // Almacena una textura (nueva)
{Luego cargue los dos procesos en opengl32.dll, necesitamos usarlos}
Procedimiento glGenTextures(n: GLsizei; Var texturas: GLuint external);
opengl32;
Procedimiento glBindTexture(destino: GLenum; textura: GLuint externo);
opengl32;
{A continuación, debemos agregar una nueva función para volver a ingresar la imagen. El tipo de retorno de esta función se define en Glaux.pas de la siguiente manera:
TAUX_RGBImageRec= registro
tamañoX, tamañoY: GLint;
datos: puntero;
fin;
PTAUX_RGBImageRec= ^TAUX_RGBImageRec;
El significado específico se introducirá más adelante}
Función LoadBmp (nombre de archivo: pchar): PTAUX_RGBImageRec;
var
BitmapFile: Thandle // identificador de archivo
Comenzar
//A continuación comprobamos si se ha proporcionado el nombre del archivo
Si Nombre de archivo = '' Entonces // Asegúrese de que se proporcione el nombre de archivo.
resultado := Nil; // Si no se proporciona, devuelve NULL
//Luego verifica si el archivo existe.
BitmapFile := FileOpen(Filename, fmOpenWrite); //Intenta abrir el archivo.
//Si podemos abrir el archivo, obviamente el archivo existe.
Si BitmapFile > 0 Entonces // ¿Existe el archivo?
Comenzar
//Cierra el archivo.
FileClose(BitmapFile); //Cerrar identificador
//auxDIBImageLoad(Filename) lee los datos de la imagen y los devuelve.
resultado := auxDIBImageLoadA(filename); //Carga el mapa de bits y devuelve el puntero
Fin
Demás
//Si no podemos abrir el archivo, devolveremos NiL.
resultado := Nil; // Si la carga falla, devuelve NiL.
Fin;
//A continuación creamos una nueva función para cargar el mapa de textura.
Función LoadTexture: booleana;
//Variable de estado. Usamos esto para rastrear si se puede cargar el mapa de bits y si se puede crear la textura.
// El estado está establecido en FALSO de forma predeterminada (lo que indica que no se carga ni se crea nada).
// Variable TextureImage El tipo PTAUX_RGBImageRec almacena el registro de imagen del mapa de bits.
//Este registro contiene el ancho, alto y datos del mapa de bits.
var
Estado: booleano;
TextureImage: Matriz[0..1] de PTAUX_RGBImageRec;
Comenzar
Estado: = falso;
ZeroMemory(@TextureImage, sizeof(TextureImage) // Establece el puntero en NULL
TextureImage[0] := LoadBMP('Textura.bmp');
Si TextureImage[0] <> Nil entonces
Comenzar
Estado := VERDADERO // Establecer estado en VERDADERO;
//Ahora usa los datos en TextureImage[0] para crear una textura.
//glGenTextures(1, textura[0]) le dice a OpenGL que queremos generar un nombre de textura
//(Si desea cargar varias texturas, aumente el número).
//glBindTexture(GL_TEXTURE_2D, textura[0]) le dice a OpenGL que vincule el nombre de la textura textura[0] al objetivo de la textura.
//Las texturas 2D solo tienen altura (en el eje Y) y ancho (en el eje X).
//La función principal asigna el nombre de la textura a los datos de la textura.
//En este ejemplo le decimos a OpenGL que la memoria en &texture[0] está disponible.
//La textura que creamos se almacenará en el área de memoria señalada por &texture[0].
glGenTextures(1, textura[0]); // Crear textura
glBindTexture(GL_TEXTURE_2D, textura[0]); //Usa una textura típica generada a partir de datos de mapa de bits.
//Abajo creamos la textura real.
//La siguiente línea le dice a OpenGL que esta textura es una textura 2D (GL_TEXTURE_2D).
//El número cero representa el nivel de detalle de la imagen, que normalmente se deja en cero.
//El número tres es el número de componentes de los datos. Porque la imagen se compone de tres componentes: datos rojos, datos verdes y datos azules.
//TextureImage[0].sizeX es el ancho de la textura.
//Si conoce el ancho, puede completarlo aquí, pero la computadora puede calcularlo fácilmente.
// TextureImage[0].sizey es la altura de la textura.
//El número cero es el valor del borde, normalmente cero.
// GL_RGB le dice a OpenGL que los datos de la imagen constan de datos de color rojo, verde y azul.
//GL_UNSIGNED_BYTE significa que los datos que componen la imagen son del tipo byte sin signo.
//Finalmente... TextureImage[0].data le dice a OpenGL la fuente de los datos de textura.
//Este ejemplo apunta a los datos almacenados en el registro TextureImage[0].
// Generar textura
glTexImage2D(GL_TEXTURE_2D, 0, 3, TextureImage[0].sizeX,
TextureImage[0].sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE,
ImagenTextura[0].datos);
//Las dos líneas siguientes le indican a OpenGL cuándo se muestra la imagen,
//Cuando es más grande que la textura original ampliada (GL_TEXTURE_MAG_FILTER)
// O el método de filtrado utilizado por OpenGL cuando la textura se reduce a un tamaño menor que la textura original (GL_TEXTURE_MIN_FILTER).
//Normalmente uso GL_LINEAR en ambos casos. Esto permite que las texturas aparezcan suavemente desde lejos o muy cerca de la pantalla.
//El uso de GL_LINEAR requiere que la CPU y la tarjeta gráfica realicen más operaciones.
//Si tu máquina es lenta, probablemente deberías usar GL_NEAREST.
// Cuando se amplía la textura filtrada, se ve muy mosaico (mosaico).
//También puedes combinar estos dos métodos de filtrado. Utilice GL_LINEAR cuando esté cerca y GL_NEAREST cuando esté lejos.
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
Fin;
//Ahora liberamos la memoria utilizada anteriormente para almacenar datos de mapa de bits.
//Primero comprobamos si los datos del mapa de bits están almacenados en.
//Si es así, verifique si los datos se han almacenado.
//Si se ha almacenado, elimínelo.
// Luego libera la estructura de imagen TextureImage [0] para garantizar que se pueda liberar toda la memoria.
Si está asignado (TextureImage[0]) Entonces // Si la textura existe
Si está asignado (TextureImage[0].data) Entonces // Si la imagen de textura existe
TextureImage[0].data := Nil; // Libera la memoria ocupada por la imagen de textura.
TextureImage[0] := Nil; // Liberar la estructura de la imagen.
//Finalmente devuelve la variable de estado. Si todo está bien, la variable Estado tiene el valor VERDADERO. De lo contrario FALSO
resultado := Estado; // Estado de devolución
Fin;