Programação gráfica OPENGL
OPENGL é uma biblioteca de modelos e gráficos tridimensionais. Devido ao seu excelente desempenho em gráficos tridimensionais, muitas linguagens de alto nível atualmente fornecem interfaces com OPENGL, como: VC, DELPHI, C++Builder, etc. O uso do OPENGL pode reduzir bastante a dificuldade dos usuários no desenvolvimento de gráficos e imagens, permitindo aos usuários produzir anúncios comerciais de alto nível, CAD gráfico, animação tridimensional, simulação gráfica e coleção de filmes e televisão.
1. Funções do OPENGL
OPENGL era originalmente uma biblioteca de software gráfico em estações de trabalho. Devido à sua ampla aplicação nos campos comercial, militar, médico, aeroespacial e outros, os gráficos que atendem aos requisitos do usuário agora podem ser desenvolvidos em computadores de baixo custo. OPENGL não só pode desenhar imagens básicas, mas também fornece um grande número de funções e procedimentos para processamento de imagens gráficas.
1. Transformação gráfica
É a base da exibição e produção gráfica. O design e a exibição da animação são inseparáveis da transformação gráfica. A transformação gráfica é matematicamente realizada pela multiplicação de retângulos. De acordo com as propriedades de exibição dos gráficos: transformação de ponto de vista, transformação de modelo, transformação de projeção, transformação de recorte e transformação de janela de visualização, etc.
2. Efeito de iluminação
A cor de um objeto não luminoso é causada pelo objeto que reflete a luz externa, que é a iluminação. Em gráficos tridimensionais, se a iluminação for usada incorretamente, os gráficos tridimensionais perderão seu verdadeiro sentido tridimensional. OPENGL divide a iluminação em: luz radiante, luz ambiente, luz dispersa, luz refletida, etc.
3. Mapeamento de textura
O mapeamento de textura permite adicionar texturas do mundo real a superfícies tridimensionais. Por exemplo: um retângulo não pode representar um objeto no mundo real. Se for preenchido com textura “essencial”, ele se tornará realista.
4. Efeitos especiais gráficos
A função de mesclagem, a função anti-aliasing e a função de neblina podem lidar com a transparência e translucidez dos gráficos tridimensionais, deixar o objeto ser suave, usar segmentos de linha para suavizar e fornecer um efeito de neblina.
5. Efeitos especiais de imagem
Funções básicas para processamento de bitmaps: desenho de imagens, cópia e armazenamento de imagens, mapeamento e transferência, dimensionamento de imagens, etc. A função de operação de bitmap pode ilustrar o processo de formação de caracteres chineses no nível inferior do desenho original.
2. Crie um aplicativo OPENGL
1. Princípios gerais
A. Adicionar unidade de suporte OPENGL nos usos: OpenGL;
B inicializa OPENGL durante o evento OnCreate do formulário;
C inicializa OPENGL durante o evento OnPaing da janela;
D inicializa OPENGL durante o evento OnResize da janela;
E inicializa OPENGL durante o evento OnDestroy da janela;
2. Exemplo simples
A Crie um projeto ARQUIVO->Nova aplicação
B Adicione código no evento OnCreate:
PRocedure TfrmMain.FormCreate(Remetente: TObject);
var
pfd:TPixelFormatDescriptor; //Definir tabela de descrição
PixelFormat:Inteiro;
começar
ControlStyle:=ControlStyle+[csOpaque];
FillChar(pfd,tamanho(pfd),0);
com pfd fazer
começar
nSize:=sizeof(TPixelFormatDescriptor);
nVersão:=1;
dwFlags:=PFD_DRAW_TO_WINDOW ou
PFD_SUPPORT_OPENGL ou PFD_DOUBLEBUFFER;
iPixelType:=PFD_TYPE_RGBA;
cColorBits:=24;
cDepthBits:=32;
iLayerType:=PFD_MAIN_PLANE;
fim;
PixelFormat:=EscolhaPixelFormat(Canvas.Handle,@pfd);
SetPixelFormat(Canvas.Handle,PixelFormat,@pfd);
hrc:=wglCreateContext(Canvas.Handle);
w:=LarguraCliente;
h:=AlturaCliente;
fim;
Código C no evento OnDestroy
procedimento TfrmMain.FormDestroy(Remetente: TObject);
começar
wglDeleteContext(hrc);
fim;
Código D no evento OnPaint
procedimento TfrmMain.FormPaint(Remetente: TObject);
começar
wglMakeCurrent(Canvas.Handle,hrc);
glClearColor(1,1,1,1);
glColor3f(1,0,0);
glClear(GL_COLOR_BUFFER_BIT ou GL_DEPTH_BUFFER_BIT);
MeuDesenhar;
glFlush;
SwapBuffers(Canvas.Handle);
fim;
Código E no evento OnResize
procedimento TfrmMain.FormResize(Remetente: TObject);
começar
glMatrixMode(GL_PROJECTION);
glLoadIdentity;
glFrustum(-1,0,1,0,-1,0,1,0,3,0,7,0);
glViewPort(0,0,ClientWidth,ClientHeight);
MeuDesenhar;
fim;
Código F na função MyDraw (declarado pelo usuário na classe da janela)
procedimento TfrmMain.MyDraw;
começar
glPushMatrix;
Esfera:=gluNewQuadric;
gluQuadricDrawStyle(Esfera,GLU_LINE);
gluSphere(Esfera,0,5,25,25);
glPopMatrix;
SwapBuffers(Canvas.handle);
gluDeleteQuadric(Esfera);
fim;
Em anexo está o código original deste programa:
unidade MainFrm;
interface
usa
Windows, Mensagens, SysUtils, Variantes, Classes, Gráficos, Controles, Formulários,
Diálogos, OpenGL;
tipo
TfrmPrincipal = classe(TForm)
procedimento FormCreate(Remetente: TObject);
procedimento FormDestroy(Remetente: TObject);
procedimento FormPaint(Remetente: TObject);
procedimento FormResize(Remetente: TObject);
privado
{Declarações privadas}
hrc:HGLRC;
w,h:glFloat;
Esfera:GLUquadricObj;
público
{Declarações públicas}
procedimento MyDraw;
fim;
var
frmMain: TfrmMain;
implementação
{$R *.dfm}
procedimento TfrmMain.FormCreate(Remetente: TObject);
var
pfd:TPixelFormatDescriptor;
PixelFormat:Inteiro;
começar
ControlStyle:=ControlStyle+[csOpaque];
FillChar(pfd,tamanho(pfd),0);
com pfd fazer
começar
nSize:=sizeof(TPixelFormatDescriptor);
nVersão:=1;
dwFlags:=PFD_DRAW_TO_WINDOW ou
PFD_SUPPORT_OPENGL ou PFD_DOUBLEBUFFER;
iPixelType:=PFD_TYPE_RGBA;
cColorBits:=24;
cDepthBits:=32;
iLayerType:=PFD_MAIN_PLANE;
fim;
PixelFormat:=EscolhaPixelFormat(Canvas.Handle,@pfd);
SetPixelFormat(Canvas.Handle,PixelFormat,@pfd);
hrc:=wglCreateContext(Canvas.Handle);
w:=LarguraCliente;
h:=AlturaCliente;
fim;
procedimento TfrmMain.FormDestroy(Remetente: TObject);
começar
wglDeleteContext(hrc);
fim;
procedimento TfrmMain.FormPaint(Remetente: TObject);
começar
wglMakeCurrent(Canvas.Handle,hrc);
glClearColor(1,1,1,1);
glColor3f(1,0,0);
glClear(GL_COLOR_BUFFER_BIT ou GL_DEPTH_BUFFER_BIT);
MeuDesenhar;
glFlush;
SwapBuffers(Canvas.Handle);
fim;
procedimento TfrmMain.MyDraw;
começar
glPushMatrix;
Esfera:=gluNewQuadric;
gluQuadricDrawStyle(Esfera,GLU_LINE);
gluSphere(Esfera,0,5,25,25);
glPopMatrix;
SwapBuffers(Canvas.handle);
gluDeleteQuadric(Esfera);
fim;
procedimento TfrmMain.FormResize(Remetente: TObject);
começar
glMatrixMode(GL_PROJECTION);
glLoadIdentidade;
glFrustum(-1,0,1,0,-1,0,1,0,3,0,7,0);
glViewPort(0,0,ClientWidth,ClientHeight);
MeuDesenhar;
fim;
fim.
3. Convenções sobre variáveis e funções OPENGL
1. Convenções da biblioteca OPENGL
Possui três bibliotecas no total: biblioteca básica, biblioteca prática e biblioteca auxiliar. No DELPHI, a biblioteca básica é implementada pela unidade OpenGL. No ambiente Windows, geralmente não são utilizadas bibliotecas auxiliares.
2. Convenção constante OPENGL
As constantes OPENGL usam letras maiúsculas, começando com "GL", e usam sublinhados para separar palavras, como: GL_LINES, o que significa usar a biblioteca básica para desenhar linhas retas.
3. Convenção de nomenclatura de funções OPENGL
A A primeira parte começa com gl ou wgl, como gl em glColor3f.
B A segunda parte é a função expressa em inglês, com a primeira letra da palavra em maiúscula.
A terceira parte de C é um número, representando os parâmetros da função.
A quarta parte de D é uma letra minúscula que indica o tipo de função.
inteiro de b9 bits
inteiro de s16 bits
inteiro de i32 bits
número de ponto flutuante de f32 bits
número de ponto flutuante d64 bits
inteiro não assinado de ub9 bits
Exemplo: glVertex2f(37,40); {dois números de ponto flutuante de 32 bits como parâmetros}
glVertex3d(37,40,5); {Três números de ponto flutuante de 64 bits como parâmetros}
p[1..3]:matriz de glFloat;
glVertes3fv(p); {3f representa três números de ponto flutuante, v representa a chamada de uma matriz como entrada de coordenadas de vértice}
4. Inicialização do OPENGL
1. Estrutura PIXELFORMATDESCRIPTOR
Descreve principalmente as propriedades dos pixels, como o modo de cor dos pixels e a composição das cores vermelho, verde e azul.
tagPIXELFORMATDESCRIPTOR = registro compactado
nTamanho: Palavra;
nVersão: Word;
dwFlags: DWORD;
iPixelType: Byte;
cColorBits: Byte;
cRedBits: Byte;
cRedShift: Byte;
cGreenBits: Byte;
cGreenShift: Byte;
cBlueBits: Byte;
cBlueShift: Byte;
cAlfaBits: Byte;
cAlphaShift: Byte;
cAccumBits: Byte;
cAccumRedBits: Byte;
cAccumGreenBits: Byte;
cAccumBlueBits: Byte;
cAccumAlphaBits: Byte;
cDepthBits: Byte;
cStencilBits: Byte;
cAuxBuffers: Byte;
iLayerType: Byte;
bReservado: Byte;
dwLayerMask: DWORD;
dwVisibleMask: DWORD;
dwDamageMask: DWORD;
fim;
TPixelFormatDescriptor = tagPIXELFORMATDESCRIPTOR;
dwFlags representa os atributos do formato do ponto:
Os gráficos PFD_DRAW_TO_WINDOW são desenhados na tela ou na superfície do dispositivo
PFD_DRAW_TO_BITMAP desenha bitmap na memória
PFD_SUPPORT_GDI suporta desenho GDI
PFD_SUPPORT_OPENGL suporta funções OPENGL
PFD_DOUBLEBUFFER usa buffer duplo
Cache estéreo PFD_STEREO
PFD_NEED_PALLETTE usa paleta RGBA
PFD_GENERIC_FORMAT seleciona o formato de desenho suportado pelo GDI
PFD_NEED_SYSTEM_PALETTE usa paleta de hardware compatível com OPENGL
iPixelType define o modo de cor do pixel: PFD_TYPE_RGBA ou PFD_TYPE_INDEX..
cColorBits define os bits de cor. Se for 9, significa que existem 256 cores para representar a cor do ponto.
cRedBits, cGreenBits, cBlueBits Ao usar RGBA, o número de bits usados nas três cores primárias.
cRedShitfs, cGreenShifts, cBlueShifts Ao usar RGBA, o número de dígitos que podem ser ajustados para as três cores primárias.
cAlphaBits, cAlphaShifts Ao usar RGBA, o número de bits usados pelo Alpha e o número de bits ajustáveis.
cAccumBits define o número total de bits na área do buffer de acumulação.
cAccumRedBits, cAccumGreenBits e cAccumBlueBits definem o número total de três planos de cores primárias na área do buffer de acumulação.
cAccumAlphaBits define o número total de bits Alfa no buffer de acumulação.
cDepthBits define a profundidade do buffer de concentração.
cStencilBits define a profundidade do buffer Stencil.
cAuxBuffers refere-se ao tamanho do buffer auxiliar.
iLayerType especifica o tipo de camada.
bReserved não é usado e deve ser zero.
dwLayerMask especifica a máscara da sobreposição.
dwDamageMask define se o mesmo modo de pixel é compartilhado no mesmo cache de quadros.
2. Etapas de inicialização do OPENGL
A Use Canvas.Handle para obter o identificador da janela.
B Crie uma variável TPixelFormatDescriptor para definir o formato do pixel.
C Use a função ChoosePixelFormat para selecionar o formato de pixel.
D Use a função SetPixelFormat para usar o formato de pixel para entrar em vigor.
E Use a função wglCreateContext para criar uma tabela de descrição de tradução.
F Use a função wglMakeCurrent para usar a tabela de descrição de tradução criada como a tabela de descrição de tradução atual.
3. Liberação de recursos
A Use o procedimento wglDeleteContext para excluir a tabela de contexto de pixel.
B Use o procedimento ReleaseDC para liberar memória da janela.
No evento OnDestroy da janela:
começar
se hrc<>nulo então
wglDeleteCurrent(hrc);
se hdc<>nulo então
ReleaseDC(Alça,hdc);
fim;
5. Desenho de gráficos básicos OPENGL
1. Cor dos gráficos
Preste atenção na configuração da cor de fundo. A configuração da cor geralmente está relacionada à variável de descrição do pixel, ou seja, ao membro iPixelType na definição TPixelFormatDescriptor.
iPixelType:=PFD_TYPE_COLORINDEX;
Então você só pode usar os procedimentos glIndexd, glIndexf, glIndexi, glIndexs, glIndexv, glIndexfv, glIndexiv, glIndexsv para definir a cor dos gráficos.
iPixelType:=PFD_TYPE_RGBA;
Então você só pode usar glColor3b, glColor3f, glColor4b, glColor4f, glColor4fv para definir a cor dos gráficos.
A Cor de fundo dos gráficos: a cor da tela e da janela, ou seja, a cor do buffer de cores. Para alterar a cor de fundo dos gráficos, você deve primeiro usar o procedimento glClearColor para definir a cor de fundo e, em seguida, usar o procedimento glClear para atualizar a janela e a tela com essa cor de fundo.
procedimento glClearColor(vermelho:GLClampf,verde:GLClampf,azul:GLClampf,alfa:GLClampf);
procedimento glClear(máscara:GLBitField);
vermelho, verde, azul e alfa são as cores de fundo a serem definidas e seus valores vão de 0 a 1. A máscara é uma forma de atualizar a cor de fundo.
Exemplo: Defina a janela de coloração para verde
glClearColor(0,1,0,1);
glClear(GL_COLOR_BUFFER_BIT);
O valor e significado da máscara:
GL_COLOR_BUFFER_BIT define o buffer de cores atual
GL_DEPTH_BUFFER_BIT define o buffer de profundidade atual
GL_ACCUM_BUFFER_BIT define o buffer de acumulação atual
GL_STENCIL_BUFFER_BIT define o buffer STENCIL (modelo) atual
A janela de desenho está definida como cinza
glClearColor(0,3,0,3,0,3,1);
glClear(GL_COLOR_BUFFER_BIT);
Cor gráfica B
Use glClear3f e glClear4f para definir a cor de desenho dos gráficos. Se três parâmetros forem usados, significa definir as três cores de luz vermelha, azul e verde, respectivamente. Se forem utilizados quatro parâmetros, o quarto representa o valor RGBA.
Exemplo de configuração da cor do desenho atual para azul:
glColor3f(0,0,1);
Defina a cor do gráfico como branco:
glColor3f(1,1,1);
2. Desenho de gráficos simples
Desenhe gráficos simples, como pontos, linhas, polígonos, etc., entre os procedimentos glBegin e glEnd.
glBegin(mode:GLenum);{Processo de desenho}glEnd;
O valor do modo:
GL_POINTS desenha vários pontos
GL_LINES desenha múltiplas linhas, desenhando uma linha reta a cada dois pontos
GL_LINE_STRIP desenha polilinha
GL_LINE_LOOP desenha polígonos fechados conectados de ponta a ponta
GL_TRIANGLES desenha triângulos
GL_TRIANGLE_STRIP desenha um triângulo, desenhando um triângulo a cada três pontos
GL_TRIANGLE_FAN desenha triângulos
GL_QUADS desenha quadriláteros
GL_QUAD_STRIP desenha faixas quadrilaterais, uma faixa quadrilateral é desenhada para cada quatro pontos
GL_POLYGON desenha polígonos
Exemplo de desenho de três pontos:
começar
glPushMatrix;
glBegin(GL_POINT);
glVertex2f(0.1,0.1);
glVertex2f(0,5,0,5);
glVertex2f(0.1,0.3);
glEnd;
SwapBuffers(Canvas.Handle);
fim;
Se você alterar GL_POINT para GL_LINES, você desenhará uma linha. O terceiro ponto é inválido. Fazer glColor3f(0,0,1) antes de glVertex2f mudará a cor da linha para verde. dois Uma linha reta.
Use o procedimento glPointSize para definir o tamanho do ponto; use o procedimento glLineWidth para definir a largura da linha.
Use o procedimento glLineStipple para definir o modelo de linha ponto-traço e use o procedimento glEnable(GL_LINE_STIPPLE) e os parâmetros correspondentes para permitir o desenho para desenhar linhas ponto-traço. O procedimento glDisable(GL_LINE_STIPPLE) e os parâmetros correspondentes desativam as linhas ponto-traço.
procedimento glLineStipple(fator:GLint,padrão:GLushort);
O parâmetro factor representa o número de repetições do modelo de linha ponto-traço. Padrão. O valor do fator é 1255. Padrão é uma sequência binária.
glLineStipple(1,0,0x11C);{0x11C é representado como 10001110, 0 significa não desenhar pontos, 1 significa desenhar pontos}
Exemplo: começar
glColor3f(1,0,0);
glLineWidth(2);
glLineStipple(1,$11C);
glEnable(GL_LINE_STIPPLE);
glBegin(GL_LINES);
glVertex2f(-0,9,0,3);
glVertex2f(0,9,0,3);
glEnd;
glDisable(GL_LINE_STIPPLE);
glColor3f(1,0,1);
glLineStipple(2,$11C);
glEnable(GL_LINE_STIPPLE);
glBegin(GL_LINES);
glVertex2f(-0,9,0,1);
glVertex2f(0.9,0.1);
glEnd;
glDisable(GL_LINE_STIPPLE);
SwapBuffers(Canvas.Handle);
fim;
O desenho de polígono é semelhante ao desenho de linha de ponto. Você precisa alterar os parâmetros para GL_POLYGON, GL_QUADS, GL_TRANGLES.
Os lados de um polígono se cruzam apenas nos vértices
O polígono B deve ser um polígono convexo. Se for um polígono côncavo, o usuário só pode dobrá-lo em um polígono convexo para acelerar o desenho.
Exemplo: glBegin(GL_POLYGON);
glVertex2f(-0,9,0,3);
glVertex2f(0,9,0,3);
glVertex2f(0,9,-0,6);
glVertex2f(0,5,-0,6);
glVertex2f(-0,9,-0,2);
glEnd;
Os polígonos têm frente e verso, e os processos relacionados a eles são:
glPolygonMode controla os modos de desenho frontal e posterior do polígono
glFrontface especifica a face frontal do polígono
glCullFace exibe polígonos definidos para eliminar faces
glPolygonStripple forma o estilo de um preenchimento de polígono
3. Superfície quadrática simples
Cilindros, anéis e esferas são superfícies quadráticas.
Um cilindro
gluCylinder(qobj:GLUquadricObj,baseRadius:GLdouble,topRadius:GLdouble,height:GLdouble,
fatias:GLint, pilhas:GLint);
qobj especifica uma superfície quadrática, baseRadius é o raio da base do cilindro topRadius é o raio superior da altura do cilindro desenhado é o número de linhas divisórias em torno do eixo Z; linhas divisórias ao longo do eixo Z.
Se baseRadius e topRadius não forem iguais, você poderá desenhar um tronco e um cone.
procedimento TfrmMain.MyDraw;
var
qObj:GLUQuadricObj;
começar
glPushMatrix;
glClear(GL_COLOR_BUFFER_BIT ou GL_DEPTH_BUFFER_BIT);
glColor3f(1,0,0);
qObj:=gluNewQuadric;
gluQuadricDrawStyle(qObj,GLU_LINE);
gluCilindro(qObj,0,5,0,1,0,2,10,10);
fim;
Trazer
gluDisk(qobj:GLUquadricObj,innerRadius:GLdouble,outerRadius:GLdouble,slices:GLint,
loops:GLint);
procedimento TfrmMain.MyDraw;
var
qObj:GLUQuadricObj;
começar
glPushMatrix;
glClear(GL_COLOR_BUFFER_BIT ou GL_DEPTH_BUFFER_BIT);
glColor3f(1,0,0);
qObj:=gluNewQuadric;
gluQuadricDrawStyle(qObj,GLU_LINE);
gluDisk(qObj,0.2,0.5,10,5);
SwapBuffers(Canvas.Handle);
fim;
C semicírculo
gluPartialDisk(qobj:GLUquadricObj,innerRadius:GLdouble,outerRadius:GLdouble,slices:GLint,
loops:GLint,startAngle:GLdouble,sweepAngle:GLdouble);
startAngle, sweepAngle são o ângulo inicial e o ângulo final do semicírculo.
procedimento TfrmMain.MyDraw;
var
qObj:GLUQuadricObj;
começar
glPushMatrix;
glClear(GL_COLOR_BUFFER_BIT ou GL_DEPTH_BUFFER_BIT);
glColor3f(1,0,0);
qObj:=gluNewQuadric;
gluQuadricDrawStyle(qObj,GLU_LINE);
gluPartialDisk(qObj,0.2,0.5,10,5,90,190);
SwapBuffers(Canvas.Handle);
fim;
Esfera D
função gluSphere(qObj:GLUquadricObj,radius:GLdouble,slices:GLint,stacks:GLint);
procedimento TfrmMain.MyDraw;
var
qObj:GLUQuadricObj;
começar
glPushMatrix;
glClear(GL_COLOR_BUFFER_BIT ou GL_DEPTH_BUFFER_BIT);
glColor3f(1,0,0);
qObj:=gluNewQuadric;
gluQuadricDrawStyle(qObj,GLU_LINE);
{silhueta[ silu(:)5et ]n. silhueta, contorno}
gluSphere(qObj,0,5,20,20);
SwapBuffers(Canvas.Handle);
fim;
E Sobre o processo de superfície quadrática
gluNewQuadric cria um novo objeto de superfície quadrática
gluDeleteQuadric exclui um objeto de superfície quadrática
gluQuadricDrawStyle especifica o tipo de superfície quádrica a ser desenhada
gluQuadricNormal define o vetor normal da superfície quadrática
gluQuadricOrientation define se a superfície quadrática é girada internamente ou externamente
gluQuadricTexture define se a superfície quadrática usa textura
F Passos gerais para desenhar superfícies quadráticas
Primeiro defina um objeto GLUquadricObj;
Em segundo lugar, crie um objeto de superfície gluNewQuadric;
Defina as propriedades da superfície quadrática novamente (gluQuadricDrawStyle, gluQuadricTexture)
Desenhar superfícies quadráticas (gluCylinder, gluSphere, gluDisk, gluPartialDisk)
6. Transformação em OPENGL
A transformação é a base do design de animação, incluindo tradução gráfica, rotação, dimensionamento e outras operações, que são implementadas matematicamente por meio de matrizes.
1 processo glLoadIdentity
Capaz de converter a matriz atual em uma matriz identidade.
2 processo glLoadMatrix
Capaz de definir a matriz especificada como a matriz atual.
procedimento glLoadmatrixd(m:GLdouble);
procedimento glLoadmatrixf(m:GLfloat);
m representa uma matriz 4X4, o código a seguir define e torna-a a matriz atual
M:array[1..4,1..4] de GLfloat;
glLoadMatrix(@M);
3 processo glMultMatrix
Capaz de multiplicar o momento atual pela matriz especificada e usar o resultado como o momento atual.
procedimento glMultMatrixd(M:GLdouble);
procedimento glMultMatrixf(M:GLfloat);
4glPushMatrix e glPopmatrix
glPushMatrix pode colocar o momento atual na pilha de matrizes e glPopMatrix pode retirar o momento atual da pilha de matrizes.
glPushMatrix pode lembrar a posição atual da matriz e glPopmatrix pode retornar a posição anterior.
Nota: glPushMatrix e glPopMatrix devem ser colocados fora de glBegin e glEnd.
5 Transformação de projeção
Um glOrtho pode criar uma matriz de projeção ortográfica, multiplicar o momento atual pela matriz de projeção ortográfica e usar o resultado como a matriz atual.
função glOrtho(esquerda:GLdouble,direita:GLdouble,inferior:GLdouble,superior:GLdouble,
perto:GLdouble,far:GLdouble);
procedimento TfrmMain.FormResize(Remetente: TObject);
var
nRange:GLfloat;
começar
nFaixa:=50,0;
w:=larguracliente;
h:=alturadocliente;
se h = 0 então
h:=1;
glViewPort(0,0,w,h);
se w<=h então
glOrtho(-nRange,nRange,-nRange*h/w,nRange*h/w,
-nRange,nRange)
outro
glOrtho(-nRange*h/w,nRange*h/w,-nRange,nRange,
-nRange,nRange);
repintar;
fim;
B glOrtho2D define apenas a frente, trás, esquerda e direita do volume de visualização ortográfica.
procedimento glOrtho(esquerda:GLdouble,direita:GLdouble,inferior:GLdouble,topo:GLdouble);
Procedimento C glMatrixMode
Capacidade de definir o tipo da matriz de operação atual
procedimento glMatrixMode(modo:GLenum);
O valor do modo:
GL_MODELVIEW especifica que as operações de matriz subsequentes são pilhas de matrizes de modelo
GL_PROJECTION especifica que as operações de matriz subsequentes serão pilhas de matrizes de projeção
GL_TEXTURE especifica que as operações de matriz subsequentes são pilhas de matrizes de textura
D gl Processo Frustum
Crie uma matriz de projeção oblíqua em perspectiva e multiplique a matriz atual pela matriz de projeção oblíqua. O resultado é a matriz atual.
procedimento glFrustum (esquerda: GLdouble, direita: GLdouble, inferior: GLdouble, superior: GLdouble,
próximo:GLdouble,far:GLdouble);
Esses parâmetros definem os planos de recorte esquerdo, direito, superior, inferior, frontal e posterior da projeção oblíqua.
E gluProcesso de perspectiva
Capaz de definir um volume de visualização de pirâmide de quatro lados com o eixo Z como linha central.
procedimento gluPerspetive(fovy:GLdouble,aspect:GLdouble,zNear:GLdouble,zFar:GLdouble);
fovy define a perspectiva do plano xoz, aspecto define a proporção nas direções x e y, zNear e zFar definem as distâncias do ponto de vista ao plano de recorte e ao plano de recorte posterior, respectivamente.
procedimento TfrmMain.FormResize(Remetente: TObject);
var
aspecto:GLfloat;
começar
w:=LarguraCliente;
h:=AlturaCliente;
se h = 0 então
h:=1;
glViewPort(0,0,clientWidth,Clientheight);
glMatrixMode(GL_PROJECTION);
glLoadIdentidade;
aspecto:=p/h;
gluPerspectiva(30,0,aspecto,1,0,50,0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentidade;
fim;
6 Matriz de transformação geométrica
A transformação da postura de movimento de um objeto tridimensional refere-se à translação, rotação e dimensionamento do objeto.
Um processo glTranslate pode mover a origem da coordenada para (x, y, z), sua sintaxe de declaração:
procedimento glTranslated(x:GLdouble,y:GLdouble,z:GLdouble);
procedimento glTranslatef(x:GLdouble,y:GLdouble,z:GLdouble);
B glRotate pode girar um objeto em um determinado ângulo. Sua sintaxe de declaração é:
procedimento glRotated(ângulo:GLdouble,x:GLdouble,y:GLdouble,z:GLdouble);
procedimento glRotatef(ângulo:GLdouble,x:GLdouble,y:GLdouble,z:GLdouble);
Entre eles, ângulo é o ângulo de rotação, e o eixo central de rotação é a linha que liga os dois pontos (0,0,0) e (x,y,z).
C glScale pode dimensionar o sistema de coordenadas e sua sintaxe de declaração é:
procedimento glScaled(x:GLdouble,y:GLdoble,z:GLdouble);
procedimento glScalef(x:GLdouble,y:GLdoble,z:GLdouble);
Valores de x, y e z maiores que 1 representam ampliação e valores menores que 1 representam redução.
Exemplo de código original:
unidade MainFrm;
interface
usa
Windows, Mensagens, SysUtils, Variantes, Classes, Gráficos, Controles, Formulários,
Diálogos, OpenGL, ExtCtrls;
tipo
TfrmPrincipal = classe(TForm)
Temporizador1: TTimer;
procedimento FormCreate(Remetente: TObject);
procedimento FormDestroy(Remetente: TObject);
procedimento FormPaint(Remetente: TObject);
procedimento FormKeyDown(Sender: TObject; var Key: Word;
Shift: TShiftState);
procedimento FormResize(Remetente: TObject);
procedimento Timer1Timer(Remetente: TObject);
procedimento FormClose(Sender: TObject; var Action: TCloseAction);
privado
{Declarações privadas}
hrc:HGLRC;
w,h:Inteiro;
latitude, longitude:GLfloat;
raio:GLduplo;
público
{Declarações públicas}
procedimento MyDraw;
procedimento InitializeGL(var largura:GLsizei;altura:GLsizei);
fim;
var
frmMain: TfrmMain;
implementação
{$R *.dfm}
procedimento TfrmMain.FormCreate(Remetente: TObject);
var
pfd:TPixelFormatDescriptor;
PixelFormat:Inteiro;
começar
ControlStyle:=ControlStyle+[csOpaque];
FillChar(pfd,tamanho(pfd),0);
com pfd fazer
começar
nSize:=sizeof(TPixelFormatDescriptor);
nVersão:=1;
dwFlags:=PFD_DRAW_TO_WINDOW ou
PFD_SUPPORT_OPENGL ou PFD_DOUBLEBUFFER;
iPixelType:=PFD_TYPE_RGBA;
cColorBits:=24;
cDepthBits:=32;
iLayerType:=PFD_MAIN_PLANE;
fim;
PixelFormat:=EscolhaPixelFormat(Canvas.Handle,@pfd);
SetPixelFormat(Canvas.Handle,PixelFormat,@pfd);
hrc:=wglCreateContext(Canvas.Handle);
w:=ClienteRect.Right;
h:=ClienteRect.Bottom;
InicializarGL(w,h);
fim;
procedimento TfrmMain.FormDestroy(Remetente: TObject);
começar
wglDeleteContext(hrc);
fim;
procedimento TfrmMain.FormPaint(Remetente: TObject);
começar
wglMakeCurrent(Canvas.Handle,hrc);
glClearColor(1,1,1,1);
glColor3f(1,0,0);
glClear(GL_COLOR_BUFFER_BIT ou GL_DEPTH_BUFFER_BIT);
MeuDesenhar;
glFlush;
fim;
procedimento TfrmMain.MyDraw;
var
qObj:GLUQuadricObj;
começar
glPushMatrix;
glClear(GL_COLOR_BUFFER_BIT ou GL_DEPTH_BUFFER_BIT);
glColor3f(1,0,0);
glRotated(0,5,0,0,1,0,0,0);
glRotated(-latitude,1.0,0.0,0.0);
glorotated(longitude,0.0,0.0,1.0);
qObj:=gluNewQuadric;
gluQuadricDrawStyle(qObj,GLU_LINE);
gluSphere(qObj,0,5,20,20);
SwapBuffers(Canvas.Handle);
fim;
{procedimento TfrmMain.FormResize(Remetente: TObject);
var
nRange:GLfloat;
começar
nFaixa:=50,0;
w:=larguracliente;
h:=alturadocliente;
se h = 0 então
h:=1;
glViewPort(0,0,w,h);
glMatrixMode(GL_PROJECTION);
glLoadIdentidade;
se w<=h então
glOrtho(-nRange,nRange,-nRange*h/w,nRange*h/w,
-nRange,nRange)
outro
glOrtho(-nRange*h/w,nRange*h/w,-nRange,nRange,
-nRange,nRange);
glMatrixMode(GL_MODELVIEW);
glLoadidentidade;
repintar;
fim;
}
procedimento TfrmMain.FormKeyDown(Sender: TObject; var Key: Word;
Shift: TShiftState);
começar
se Chave=VK_ESCAPE então
Fechar;
se Chave=VK_UP então
glRotatef(-5,1.0,0.0,0.0);
se Chave=VK_DOWN então
glRotatef(5,1.0,0.0,0.0);
se Chave=VK_LEFT então
glRotatef(-5,0,0,1,0,0,0);
se Chave=VK_RIGHT então
glRotatef(5.0,0.0,1.0,0.0);
repintar;
fim;
procedimento TfrmMain.FormResize(Remetente: TObject);
começar
glMatrixMode(GL_PROJECTION);
glLoadIdentity;
glFrustum(-1,0,1,0,-1,0,1,0,3,0,7,0);
glViewPort(0,0,clientWidth,clientHeight);
repintar;
invalidar;
fim;
procedimento TfrmMain.InitializeGL(var largura: GLsizei; altura: GLsizei);
var
maxObjectSize,aspecto:GLfloat;
perto_plano:GLdouble;
começar
glClearindex(0);
glClearDepth(1.0);
glEnable(GL_DEPTH_TEST);
glMatrixMode(GL_PROJECTION);
aspecto:=1,0;
gluPerspectiva(45,0,aspecto,3,0,7,0);
gmatrixMode(GL_MODELVIEW);
perto_plano:=0,3;
maxObjectSize:=0,3;
raio:=near_plane+maxObjectSize/2.0;
latitude:=0,3;
longitude:=0,6;
fim;
procedimento TfrmMain.Timer1Timer(Remetente: TObject);
começar
timer1.Enabled:=falso;
MeuDesenhar;
Colheita;
Timer1.Enabled:=true;
fim;
procedimento TfrmMain.FormClose(Sender: TObject; var Action: TCloseAction);
começar
timer1.Enabled:=falso;
se hrc<>nulo então
wglDeleteContext(hrc);
fim;
fim.
7. Iluminação e textura do OPENGL
Todos eles são meios para aprimorar o efeito tridimensional e o efeito de cor. A iluminação pode aumentar o brilho e o efeito tridimensional dos gráficos, e a textura pode tornar os gráficos mais realistas. Através do uso da iluminação, a aparência de um objeto pode ser expressa de maneira forte, e as texturas podem fazer com que o objeto mostre uma variedade de aparências.
1 Processos e aplicações de iluminação e fontes de luz
Um procedimento glIndex transforma uma cor na tabela de índice de cores na cor atual.
procedimento glIndexd(c:GLdouble);
procedimento glIndexf(c:GLdouble);
procedimento glIndexi(c:GLdouble);
procedimento glIndexs(c:GLdouble);
O parâmetro C é o valor do índice Se o procedimento glIndex for usado, o membro iPixelType na estrutura TPiexlFormatDescriptor será definido como PFD_TYPE_COLORINDEX.
Procedimento B glShadeModel
O processo glShadeModel define o modo de preenchimento, valor: GL_SMOOTH.
procedimento glShadeModel(modo:GLenum);
Nota: Os dois processos acima só podem ser usados fora de glBegin....glEnd.
O procedimento C glLight define a fonte de luz
procedimento glLightf(light:GLenum,pname:GLenum,param:GLfloat);
procedimento glLighti(light:GLenum,pname:GLenum,param:GLfloat);
O parâmetro light define a fonte de luz, seu valor pode ser: GL_LIGHT0....GL_LIGHTN, o valor N é menor que GL_MAX_LIGHT.
O parâmetro pname especifica os parâmetros da fonte de luz:
Intensidade do componente GL_AMBIENT da luz ambiente
Intensidade do componente GL_DIFFUSE da luz espalhada
Intensidade do componente GL_SPECULAR da luz refletida
Posição da fonte de luz GL_POSITION
GL_SPOT_DIRECTION A direção do foco da fonte de luz
Índice de fonte de luz GL_SPOT_EXPONENT
Direção da fonte de luz GL_SPOT_CUTOFF
GL_CONSTANT_ATTENUATION fator de decaimento constante de luz
GL_LINEAR_ATTENUATION fator de atenuação secundária de luz
Habilite e desligue fontes de luz usando os procedimentos glEnable() e glDisable()
glEnable(GL_LIGHTING); //Habilita fonte de luz
glDisable(GL_LIGHTING); //Desliga a fonte de luz
glEnable(GL_LIGHT0); //Habilita a 0ª fonte de luz
glDisable(GL_LIGHT0); //Desliga a 0ª fonte de luz
Exemplo de configuração da fonte de luz:
var
direção:Array[1..4] do GLfloat:={0.0,1.0,0.0,0.0};
glLightfv(GL_LIGHT0,GL_SPOT_CUTOFF,60);
glLightfv(GL_LIGHT0,GL_SPOT_DIRECTION,sdireção);
2 Material e modelo de iluminação
Um procedimento glMaterial define parâmetros de material
procedimento glMaterialf(face:GLenum,pname:GLenum,param:GLfloat);
procedimento glMateriali(face:GLenum,pname:GLenum,param:GLfloat);
procedimento glMaterialfv(face:GLenum,pname:GLenum,param:GLfloat);
procedimento glMaterialiv(face:GLenum,pname:GLenum,param:GLfloat);
O parâmetro face especifica a superfície do objeto, e seus valores são: GL_FRONT, GL_BACK, GL_FRONT_BACK.
pname,param não são introduzidos neste material.
Processo B glLightModel
procedimento glLightModelf(pname:GLenum,param:GLfloat);
O parâmetro pname é o parâmetro do modelo da fonte de luz, que pode assumir o valor GL_LIGHT_MODEL_AMBIENT,
GL_LIGHT_MODEL_LOCAL_VIEWER,GL_LIGHT_MODEL_TWO_SIDE.
Código de exemplo:
procedimento TfrmMain.SetLighting;
var
MaterialAmbient:array[1..4] do GLfloat;
MaterialDiffuse:Array[1..4] do GLfloat;
MaterialSpecular:Array[1..4] do GLfloat;
AmbientLightPosition:Array[1..4] do GLfloat;
LightAmbient:Array[1..4] do GLfloat;
MaterialBrilho:GLfloat;
começar
MaterialAmbiente[1]:=0,5;
MaterialAmbiente[2]:=0,8;
MaterialAmbiente[1]:=0,2;
MaterialAmbiente[1]:=1,0;
MaterialDifuso[1]:=0,4;
MaterialDifuso[2]:=0,8;
MaterialDifuso[3]:=0,1;
MaterialDifuso[4]:=1,0;
MaterialSpecular[1]:=1,0;
MaterialSpecular[2]:=0,5;
MaterialSpecular[3]:=0,1;
MaterialSpecular[4]:=1,0;
brilho do material:=50,0;
PosiçãoLuzAmbiente[1]:=0,5;
PosiçãoLuzAmbiente[2]:=1.0;
PosiçãoLuzAmbiente[3]:=1.0;
PosiçãoLuzAmbiente[4]:=0,0;
Ambiente Claro[1]:=0,5;
Ambiente Claro[2]:=0,2;
Ambiente Claro[3]:=0,8;
Ambiente Claro[4]:=1,0;
glMaterialfv(GL_FRONT,GL_AMBIENT,@MaterialAmbient);
glMaterialfv(GL_FRONT,GL_DIFFUSE,@MaterialDiffuse);
glMaterialfv(GL_FRONT,GL_SPECULAR,@MaterialSpecular);
glMaterialfv(GL_FRONT,GL_SHININESS,@MaterialBrilho);
glLightfv(GL_LIGHT0,GL_POSITION,@AmbientLightPosition);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT,@LightAmbient);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
GLShadeModel(GL_SMOOTH);
fim;
3 Aplicação de textura
Um glTexImage1D define um mapa de textura unidimensional.
procedimento glTexImage1D(destino:GLenum,nível:GLint,componentes:GLint,largura:GLsizei,
borda:GLint,formato:GLenum,tipo:GLenum,pixels:GLvoid);
O valor alvo do parâmetro é GL_TEXTURE_1D, que é definido como mapeamento de textura, nível é o nível da imagem de textura com resolução multinível, largura é a largura da textura, o valor é 2n, o valor n é 32, 64, 129, etc. border é o limite da textura e seu valor é 0 ou 1, Pixel é a localização da textura na memória. O componente especifica a mixagem e ajuste de RGBA:
1Selecione o ingrediente B
2Selecione os ingredientes B e A
3Selecione os ingredientes R, G, B
4Selecione os ingredientes R, G, B, A
B glTexImage2D define mapeamento de textura bidimensional
procedimento glTexImage2D(destino:GLenum,nível:GLint,componentes:GLint,largura:GLsizei,
borda:GLint,formato:GLenum,tipo:GLenum,pixels:GLvoid);
Se o parâmetro target for GL_TEXTURE_2D, o significado é mapeamento de textura bidimensional, altura é a altura da textura e outros parâmetros na função são iguais a glTexImage1D. O valor do parâmetro do componente é o mesmo acima.
Código de exemplo:
procedimento TfrmMain.SetTextures;
var
bits:Array[1..64,1..64,1..64] de GLubyte;
bmp:TBitmap;
i,j:Inteiro;
começar
bmp:=TBitmap.Create;
bmp.LoadFromFile('d:/dsoft/1119/01/logon.bmp');
para i:=1 a 64 faça
para j:=1 a 64 faça
começar
bits[i,j,1]:=GLbyte(GetRValue(bmp.Canvas.Pixels[i,j]));
bits[i,j,2]:=GLbyte(GetRValue(bmp.Canvas.Pixels[i,j]));
bits[i,j,3]:=GLbyte(GetRValue(bmp.Canvas.Pixels[i,j]));
bits[i,j,4]:=255;
fim;
{0 representa um único nível de sombreamento de cor, GL_RGBA representa um valor misto
64X64 representa a altura e largura da textura, 0 representa nenhuma borda,
GL_RGBA representa o tipo de textura, GL_UNSIGNED_TYPE representa o tipo de dados, @Geneation Object Endereço}
GLTIXAGE2D (GL_TEXTURE_2D, 0, GL_RGBA, 64,64,0, GL_RGBA,
GL_UNSIGNED_BYTE,@bits);
glenable (gl_texture_2d);
fim;
C GltexParameter Procedure Define parâmetros de textura
Procedimento GLTEXPARAMETERF (Target: Glenum, Pname: Glenum, Param: Glfloat);
Procedimento GLTEXPARAMETERI (Target: Glenum, Pname: Glenum, Param: Glfloat);
O destino do parâmetro representa GL_TEXTURE_1D ou GL_TEXTURE_2D, e o param é o valor da textura.
D GLTEXENV Função define os parâmetros do ambiente da textura
function gltexenvf (alvo: glenum, pname: glenum, param: Glfloat);
function gltexenvi (alvo: glenum, pname: glenum, param: glfloat);
O destino do parâmetro é gl_texture_env,
O parâmetro PNAME é o valor do parâmetro textura e o valor é gl_texture_env_mode
O parâmetro param é o valor do ambiente e seus valores são gl_modulados, gl_decal e gl_blend.
Código de exemplo para este programa:
unidade mainfrm;
interface
usa
Windows, Mensagens, SysUtils, Variantes, Classes, Gráficos, Controles, Formulários,
Diálogos, OpenGL, extctrls;
tipo
TfrmPrincipal = classe(TForm)
Temporizador1: TTimer;
procedimento FormCreate(Remetente: TObject);
procedimento FormDestroy(Remetente: TObject);
Procedimento FormPaint (remetente: Tobject);
Procedimento FormKeyDown (remetente: TOBJECT; VAR Tecla: Word;
Shift: TShiftState);
procedimento formResize (remetente: tabjas);
procedimento Timer1Timer(Remetente: TObject);
procedimento FormClose(Sender: TObject; var Action: TCloseAction);
privado
{Declarações privadas}
HRC: HGLRC;
W, H: Inteiro;
Latitude, longitude: Glfloat;
raio: gldouble;
público
{Declarações públicas}
Procedimento Liftinging;
Procedimento setTextures;
procedimento mydraw;
Procedimento InitializeGL (Var Largura: GlsizeI; Altura: Glsizei);
fim;
var
FRMMAIN: TfrMMain;
implementação
{$R *.dfm}
procedimento tfrmMain.formCreate (remetente: tabjas);
var
PFD: tpixelformatDescriptor;
Pixelformat: Inteiro;
começar
ControlStyle: = ControlStyle+[csopaque];
Preenchchar (pfd, sizeof (pfd), 0);
com pfd fazer
começar
nsize: = sizeof (tpixelformatDescriptor);
nversion: = 1;
dwflags: = pfd_draw_to_window ou
Pfd_support_opengl ou pfd_doublebuffer;
ipixeltype: = pfd_type_rgba;
ccolorbits: = 24;
CDEPTHBITS: = 32;
ilayerType: = pfd_main_plane;
fim;
Pixelformat: = escolhapixelformat (canvas.handle,@pfd);
SetPixelformat (Canvas.Handle, Pixelformat,@pfd);
hrc: = wglcreateContext (canvas.handle);
W: = clientrect.right;
h: = clientRect.bottom;
InitializeGL (W, H);
fim;
procedimento tfrmmAin.formDestroy (remetente: tabjas);
começar
wglDeleteContext (HRC);
fim;
procedimento tfrmmAin.formPaint (remetente: tabjas);
começar
wglMakecurrent (Canvas.Handle, HRC);
GLCLEARCOLOR (1,1,1,1);
glcolor3f (1,0,0);
GLCLEAR (GL_COLOR_BUFFER_BIT ou GL_DEPTH_BUFFER_BIT);
SetTextures;
Mydraw;
SetLetinging;
Glflush;
fim;
procedimento tfrmmAin.myDraw;
var
QOBJ: GluquadRicobj;
começar
glpushmatrix;
GLCLEAR (GL_COLOR_BUFFER_BIT ou GL_DEPTH_BUFFER_BIT);
glcolor3f (1,0,0);
glrotado (0,5,0,0,1,0,0.0);
glrotated (-latitude, 1,0,0.0,0.0);
glrotado (longitude, 0,0,0,0,1,0);
qobj: = glunewquadric;
gluquadricDrawStyle (qobj, glu_line);
glusphere (QOBJ, 0,5,20,20);
SwapBuffers (Canvas.Handle);
SetLetinging;
SetTextures;
fim;
{procedure tfrmmAin.formResize (remetente: tabjas);
var
nRange: Glfloat;
começar
nRange: = 50,0;
W: = ClientWidth;
h: = clientHeight;
Se h = 0 então
h: = 1;
GlViewport (0,0, W, H);
GlMatrixMode (GL_PROJECIÇÃO);
GlloadIdentity;
Se w <= h então
GLORTHO (-NRANGE, NRANGE, -NRANGE*H/W, NRANGE*H/W,
-NRange, nRange)
outro
GLORTHO (-NRANGE*H/W, NRANGE*H/W, -NRANGE, NRANGE,
-NRange, nRange);
GlMatrixMode (GL_MODelView);
GlloadIdentity;
repintar;
fim;
}
procedimento tfrmmAin.formKeydown (remetente: tabjas; var tecla: word;
Shift: TShiftState);
começar
Se key = vk_escape então
Fechar;
se key = vk_up então
glrotatef (-5,1,0,0,0,0.0);
se key = vk_down então
glrotatef (5,1,0,0,0,0.0);
se key = vk_left então
glrotatef (-5,0,0,1,0,0.0);
Se key = vk_right então
glrotatef (5,0,0.0,1.0,0.0);
repintar;
fim;
procedimento tfrmMain.formResize (remetente: tabjas);
começar
GlMatrixMode (GL_PROJECIÇÃO);
GlloadIdentity;
glfrustum (-1,0,1.0, -1,0,1,0,3.0,7.0);
GlViewPort (0,0, ClientWidth, ClientHeight);
repintar;
invalidar;
fim;
procedimento tfrmmAin.initializeGL (var largura: glsizei; altura: glsizei);
var
maxObjectSize, aspecto: Glfloat;
próximo_plane: gldouble;
começar
glclearIndex (0);
GLCLEARDEDEPTH (1.0);
glenable (gl_depth_test);
GlMatrixMode (GL_PROJECIÇÃO);
aspecto: = 1.0;
Gluperspective (45.0, aspecto, 3.0,7.0);
GlMatrixMode (GL_MODelView);
near_plane: = 0,3;
maxObjectSize: = 0,3;
raio: = near_plane+maxobjectSize/2.0;
Latitude: = 0,3;
longitude: = 0,6;
fim;
procedimento tfrmMain.timer1timer (remetente: tabjas);
começar
timer1.enabled: = false;
Mydraw;
Colheita;
Timer1.enabled: = true;
fim;
procedimento tfrmmAin.formClose (remetente: tabjas; var ação: tcloSeation);
começar
timer1.enabled: = false;
Se hrc <> nulo, então
wglDeleteContext (HRC);
fim;
procedimento tfrmmAin.SetLighting;
var
MaterialAnCient: matriz [1..4] de Glfloat;
Materialdiffuse: matriz [1..4] de Glfloat;
Material Especular: Array [1..4] de Glfloat;
AmbientLightPosition: Array [1..4] de Glfloat;
Lightambient: Array [1..4] de Glfloat;
MaterialshiniP: Glfloat;
começar
MaterialABIENT [1]: = 0,5;
MaterialAmbient [2]: = 0,8;
MaterialABIENT [1]: = 0,2;
MaterialABIENT [1]: = 1,0;
Materialdiffuse [1]: = 0,4;
Materialdiffuse [2]: = 0,8;
Materialdiffuse [3]: = 0,1;
Materialdiffuse [4]: = 1.0;
Materialspecular [1]: = 1,0;
Materialspecular [2]: = 0,5;
Materialspecular [3]: = 0,1;
Materialspecular [4]: = 1,0;
MATERIALHIMINION: = 50,0;
AmbientLightPosition [1]: = 0,5;
AmbientLightPosition [2]: = 1.0;
AmbientLightPosition [3]: = 1.0;
AmbientLightPosition [4]: = 0,0;
Lightambient [1]: = 0,5;
Lightambient [2]: = 0,2;
Lightambient [3]: = 0,8;
Lightambient [4]: = 1,0;
GlMaterialfv (Gl_front, Gl_ambient,@materialAmbient);
GlMaterialfv (gl_front, gl_diffuse,@materialdiffuse);
GlMaterialfv (gl_front, gl_specular,@materialspecular);
GlMaterialfv (gl_front, gl_shininess,@materialshinines);
Gllightfv (gl_light0, gl_Position,@AmbienteLightPosition);
Gllightmodelfv (gl_light_model_ambient,@lightambient);
Glenable (gl_lighting);
Glenable (gl_light0);
Glshademodel (gl_smooth);
fim;
Procedimento tfrmmAin.SettexTures;
var
Bits: Array [1..64, 1..64, 1..64] de glibyte;
BMP: TBBITMAP;
I, J: Inteiro;
começar
BMP: = tbitmap.create;
Bmp.loadfromfile ('d: /DSoft/1119/02/logon.bmp');
para i: = 1 a 64 fazer
para j: = 1 a 64 fazer
começar
bits [i, j, 1]: = glbyte (getrValue (bmp.canvas.pixels [i, j]));
bits [i, j, 2]: = glbyte (getrValue (bmp.canvas.pixels [i, j]));
bits [i, j, 3]: = glbyte (getrValue (bmp.canvas.pixels [i, j]));
bits [i, j, 4]: = 255;
fim;
glpixelstorei (gl_unpack_alignment, 4);
GLTEXPARAMETERI (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
GLTEXPARAMETERI (GL_TEXTURE_2D, GL_TEXTUR
GLTEXPAMETERI (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
{0 significa nível de cor monocromática, GL_RGBA representa um valor misto
64x64 representa a altura e a largura da textura, 0 significa nenhum limite,
GL_RGBA representa o tipo de textura, GL_UNSIGNED_TYPE representa o tipo de dados,@g endereço de objeto}
GLTIXAGE2D (GL_TEXTURE_2D, 0, GL_RGBA, 64,64,0, GL_RGBA,
GL_UNSIGNED_BYTE,@bits);
Glenable (gl_texture_2d);
GLTEXENVF (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
fim;
fim.