{
As texturas podem economizar muito tempo de CPU. Haha, mas essa seção me levou muito tempo :(
Como a biblioteca auxiliar OpenGL é usada, poucas pessoas usam as funções desta biblioteca agora, mas ainda a encontrei. Graças ao zdcnow (Magnetic Effect), ele me forneceu a versão Delphi desta biblioteca auxiliar. Antes de estudar esta seção, baixe os arquivos glaux.dll e Glaux.pas online e adicione-os ao projeto.
Ok, vamos continuar no caminho para OPENGL.
Primeiro precisamos adicionar a unidade SysUtils, porque usaremos operações de arquivo nesta seção e também precisaremos adicionar a unidade Glaux.
Depois adicionamos diversas variáveis, xrot, yrot e zrot com base na primeira lição. Essas variáveis são usadas para girar o cubo em torno dos eixos X, Y e Z. textura[] aloca espaço de armazenamento para uma textura. Se precisar de mais de uma textura, você deve alterar o número 1 para o número necessário.
}
VAR
h_RC: HGLRC; // Contexto de renderização (tabela de descrição de sombreamento).
h_DC: HDC; // Contexto do dispositivo (tabela de descrição do dispositivo)
h_Wnd: HWND; // identificador da janela
h_Instance: HINST; // Instância do programa (instância).
teclas: Array[0..255] Of Boolean; // Array para rotinas de teclado
xrot, // Quantidade de rotação X (novo)
yrot, // Quantidade de rotação Y (novo)
zrot : GLfloat; // Quantidade de rotação Z (novo)
Textura: Array[0..1] Of GLuint; // Armazena uma textura (nova)
{Em seguida, carregue os dois processos em opengl32.dll, precisamos usá-los}
Procedimento glGenTextures(n: GLsizei; Var texturas: GLuint externo stdcall);
opengl32;
Procedimento glBindTexture(destino: GLenum; textura: GLuint externo);
opengl32;
{Em seguida, precisamos adicionar uma nova função para inserir novamente a imagem. O tipo de retorno desta função é definido em Glaux.pas da seguinte forma:
TAUX_RGBImageRec= registro
tamanhoX, tamanhoY: Glint;
dados: ponteiro;
fim;
PTAUX_RGBImageRec=^TAUX_RGBImageRec;
O significado específico será introduzido mais tarde}
Função LoadBmp (nome do arquivo: pchar): PTAUX_RGBImageRec;
Var
BitmapFile : Thandle; // identificador de arquivo
Começar
//Próxima verificação se o nome do arquivo foi fornecido
If Filename = '' Then // Certifique-se de que o nome do arquivo seja fornecido.
resultado := Nil; // Se não for fornecido, retorne NULL;
//Então verifique se o arquivo existe.
BitmapFile := FileOpen(Filename, fmOpenWrite); //Tenta abrir o arquivo
//Se pudermos abrir o arquivo, obviamente o arquivo existe.
Se BitmapFile > 0 Então // O arquivo existe?
Começar
//Fecha o arquivo.
FileClose(BitmapFile); //Fecha o identificador
//auxDIBImageLoad(Filename) lê os dados da imagem e os retorna.
result := auxDIBImageLoadA(filename); //Carrega o bitmap e retorna o ponteiro
Fim
Outro
//Se não conseguirmos abrir o arquivo, retornaremos NiL.
resultado := Nil; // Se o carregamento falhar, retorne NiL.
Fim;
//Em seguida, crie uma nova função para carregar o mapa de textura
Função LoadTexture: booleano;
//Variável de status. Usamos isso para rastrear se o bitmap pode ser carregado e se a textura pode ser criada.
// O status é definido como FALSE por padrão (indicando que nada foi carregado ou criado).
//A variável TextureImage do tipo PTAUX_RGBImageRec armazena o registro da imagem do bitmap.
//Este registro contém a largura, altura e dados do bitmap.
Var
Status: booleano;
TextureImage: Array[0..1] de PTAUX_RGBImageRec;
Começar
Estado := falso;
ZeroMemory(@TextureImage, sizeof(TextureImage)); // Define o ponteiro para NULL
TextureImage[0] := LoadBMP('Texture.bmp');
Se TextureImage[0] <> Nulo Então
Começar
Status := VERDADEIRO; // Define o status como VERDADEIRO;
//Agora use os dados em TextureImage[0] para criar uma textura.
//glGenTextures(1, textura[0]) informa ao OpenGL que queremos gerar um nome de textura
//(Se quiser carregar múltiplas texturas, aumente o número).
//glBindTexture(GL_TEXTURE_2D, textura[0]) diz ao OpenGL para vincular o nome da textura textura[0] ao destino da textura.
//As texturas 2D só possuem altura (no eixo Y) e largura (no eixo X).
//A função principal atribui o nome da textura aos dados da textura.
//Neste exemplo informamos ao OpenGL que a memória em &texture[0] está disponível.
//A textura que criamos será armazenada na área de memória apontada por &texture[0].
glGenTextures(1, textura[0]); // Cria textura
glBindTexture(GL_TEXTURE_2D, textura[0]); //Use uma textura típica gerada a partir de dados bitmap
//Abaixo criamos a textura real.
//A linha a seguir informa ao OpenGL que esta textura é uma textura 2D (GL_TEXTURE_2D).
//O número zero representa o nível de detalhe da imagem, que normalmente é deixado em zero.
//O número três é o número de componentes dos dados. Porque a imagem é composta por três componentes: dados vermelhos, dados verdes e dados azuis.
//TextureImage[0].sizeX é a largura da textura.
//Se você souber a largura, poderá preenchê-la aqui, mas o computador poderá descobrir isso facilmente para você.
// TextureImage[0].sizey é a altura da textura.
//O número zero é o valor da borda, geralmente zero.
// GL_RGB informa ao OpenGL que os dados da imagem consistem em dados de cores vermelho, verde e azul.
//GL_UNSIGNED_BYTE significa que os dados que compõem a imagem são do tipo byte não assinado.
//Finalmente... TextureImage[0].data informa ao OpenGL a fonte dos dados de textura.
//Este exemplo aponta para os dados armazenados no registro TextureImage[0].
//Gera textura
glTexImage2D(GL_TEXTURE_2D, 0, 3, TextureImage[0].tamanhoX,
TexturaImagem[0].tamanhoY, 0, GL_RGB, GL_UNSIGNED_BYTE,
TexturaImage[0].data);
//As duas linhas a seguir informam ao OpenGL ao exibir a imagem,
//Quando for maior que a textura original ampliada (GL_TEXTURE_MAG_FILTER)
//Ou o método de filtragem usado pelo OpenGL quando a textura é reduzida para um tamanho menor que a textura original (GL_TEXTURE_MIN_FILTER).
//Normalmente eu uso GL_LINEAR em ambos os casos. Isso permite que as texturas apareçam suavemente de longe ou muito perto da tela.
//Usar GL_LINEAR requer que a CPU e a placa gráfica realizem mais operações.
//Se sua máquina estiver lenta, você provavelmente deveria usar GL_NEAREST.
//Quando a textura filtrada é ampliada, fica muito mosaico (mosaico).
//Você também pode combinar esses dois métodos de filtragem. Use GL_LINEAR quando estiver próximo e GL_NEAREST quando estiver longe.
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
Fim;
//Agora liberamos a memória anteriormente usada para armazenar dados bitmap.
//Primeiro verificamos se os dados bitmap estão armazenados em.
//Se sim, verifique se os dados foram armazenados.
//Se estiver armazenado, exclua-o.
//Em seguida, libere a estrutura da imagem TextureImage[0] para garantir que toda a memória possa ser liberada.
Se atribuído(TextureImage[0]) Then // Se a textura existe
Se atribuído(TextureImage[0].data) Then // Se a imagem de textura existe
TextureImage[0].data := Nil; // Libera a memória ocupada pela imagem de textura
TextureImage[0] := Nil; // Libera a estrutura da imagem
//Finalmente retorna a variável de status. Se tudo estiver OK, a variável Status terá o valor TRUE. Caso contrário FALSO
resultado := Status; // Status de retorno
Fim;