Programación de gráficos OPENGL
OPENGL es una biblioteca de modelos y gráficos tridimensionales. Debido a su excelente rendimiento en gráficos tridimensionales, muchos lenguajes de alto nivel actualmente proporcionan interfaces con OPENGL, como: VC, DELPHI, C ++ Builder, etc. El uso de OPENGL puede reducir en gran medida la dificultad para los usuarios a la hora de desarrollar gráficos e imágenes, permitiéndoles producir anuncios comerciales de alto nivel, CAD gráfico, animación tridimensional, simulación gráfica y colecciones de cine y televisión.
1. Funciones de OPENGL
OPENGL era originalmente una biblioteca de software de gráficos para estaciones de trabajo. Debido a su amplia aplicación en los campos comercial, militar, médico, aeroespacial y otros, ahora se pueden desarrollar gráficos que cumplan con los requisitos del usuario en computadoras de gama baja. OPENGL no solo puede dibujar imágenes básicas, sino que también proporciona una gran cantidad de funciones y procedimientos para procesar imágenes gráficas.
1. Transformación gráfica
Es la base de la visualización y producción gráfica. El diseño de animación y la visualización de animación son inseparables de la transformación gráfica. La transformación gráfica se realiza matemáticamente mediante la multiplicación de rectángulos. Según las propiedades de visualización de los gráficos: transformación de punto de vista, transformación de modelo, transformación de proyección, transformación de recorte y transformación de ventana gráfica, etc.
2. Efecto de iluminación
El color de un objeto no luminoso es causado por el objeto que refleja la luz externa, que es la iluminación. En los gráficos tridimensionales, si la iluminación se utiliza incorrectamente, los gráficos tridimensionales perderán su verdadero sentido tridimensional. OPENGL divide la iluminación en: luz radiante, luz ambiental, luz dispersa, luz reflejada, etc.
3. Mapeo de texturas
El mapeo de texturas le permite agregar texturas del mundo real a superficies tridimensionales. Por ejemplo: un rectángulo no puede representar un objeto en el mundo real. Si se rellena con una textura "esencial", se volverá realista.
4. Efectos especiales gráficos
La función de fusión, la función de suavizado y la función de niebla pueden manejar la transparencia y la translucidez de gráficos tridimensionales, dejar que el objeto sea suave, usar segmentos de línea para suavizar y proporcionar un efecto de niebla.
5. Efectos especiales de imagen
Funciones básicas para procesar mapas de bits: dibujo de imágenes, copia y almacenamiento de imágenes, mapeo y transferencia, escalado de imágenes, etc. La función de operación de mapa de bits puede explicar el proceso de formación de caracteres chinos en el nivel inferior del dibujo original.
2. Cree la aplicación OPEGL
1. Principios generales
A. Agregar unidad de soporte OPENGL en usos: OpenGL;
B inicializa OPENGL durante el evento OnCreate del formulario;
C inicializa OPENGL durante el evento OnPaing de la ventana;
D inicializa OPENGL durante el evento OnResize de la ventana;
E inicializa OPENGL durante el evento OnDestroy de la ventana;
2. Ejemplo sencillo
A Crear un proyecto ARCHIVO->Nueva aplicación
B Agregar código en el evento OnCreate:
Procedimiento TfrmMain.FormCreate(Remitente: TObject);
var
pfd:TPixelFormatDescriptor; //Establecer tabla de descripción
Formato de píxel: entero;
comenzar
ControlStyle:=ControlStyle+[csOpaque];
FillChar(dfp,tamañode(dfp),0);
con dfp hacer
comenzar
nTamaño:=tamañode(TPixelFormatDescriptor);
nVersión:=1;
dwFlags:=PFD_DRAW_TO_WINDOW o
PFD_SUPPORT_OPENGL o PFD_DOUBLEBUFFER;
iPixelType:=PFD_TYPE_RGBA;
cColorBits:=24;
cBits de profundidad:=32;
iLayerType:=PFD_MAIN_PLANE;
fin;
PixelFormat:=ElijaPixelFormat(Canvas.Handle,@pfd);
SetPixelFormat(Canvas.Handle,PixelFormat,@pfd);
hrc:=wglCreateContext(Canvas.Handle);
w:=AnchoDeCliente;
h:=AlturaCliente;
fin;
Código C en el evento OnDestroy
procedimiento TfrmMain.FormDestroy(Remitente: TObject);
comenzar
wglDeleteContext(hrc);
fin;
Código D en el evento OnPaint
procedimiento TfrmMain.FormPaint(Remitente: TObject);
comenzar
wglMakeCurrent(Canvas.Handle,hrc);
glClearColor(1,1,1,1);
glColor3f(1,0,0);
glClear(GL_COLOR_BUFFER_BIT o GL_DEPTH_BUFFER_BIT);
Mi sorteo;
glFlush;
SwapBuffers(Canvas.Handle);
fin;
Código E en el evento OnResize
procedimiento TfrmMain.FormResize(Remitente: TObject);
comenzar
glMatrixMode(GL_PROJECTION);
glLoadIdentidad;
glFrustum(-1.0,1.0,-1.0,1.0,3.0,7.0);
glViewPort(0,0,AnchoCliente,AlturaCliente);
Mi sorteo;
fin;
Código F en la función MyDraw (declarado por el usuario en la clase de ventana)
procedimiento TfrmMain.MyDraw;
comenzar
glPushMatrix;
Esfera:=gluNewQuadric;
gluQuadricDrawStyle(Esfera,GLU_LINE);
gluEsfera(Esfera,0.5,25,25);
glPopMatrix;
SwapBuffers(Canvas.handle);
gluDeleteQuadric(Esfera);
fin;
Adjunto el código original de este programa:
unidad MainFrm;
interfaz
usos
Windows, Mensajes, SysUtils, Variantes, Clases, Gráficos, Controles, Formularios,
Diálogos, OpenGL;
tipo
TfrmMain = clase(TForm)
procedimiento FormCreate(Remitente: TObject);
procedimiento FormDestroy(Remitente: TObject);
procedimiento FormPaint(Remitente: TObject);
procedimiento FormResize(Remitente: TObject);
privado
{Declaraciones privadas}
hrc:HGLRC;
w,h:glFlotar;
Esfera:GLUquadricObj;
público
{Declaraciones públicas}
procedimiento MyDraw;
fin;
var
frmPrincipal: TfrmPrincipal;
implementación
{$R*.dfm}
procedimiento TfrmMain.FormCreate(Remitente: TObject);
var
pfd:TPixelFormatDescriptor;
Formato de píxel: entero;
comenzar
ControlStyle:=ControlStyle+[csOpaque];
FillChar(dfp,tamañode(dfp),0);
con dfp hacer
comenzar
nTamaño:=tamañode(TPixelFormatDescriptor);
nVersión:=1;
dwFlags:=PFD_DRAW_TO_WINDOW o
PFD_SUPPORT_OPENGL o PFD_DOUBLEBUFFER;
iPixelType:=PFD_TYPE_RGBA;
cColorBits:=24;
cBits de profundidad:=32;
iLayerType:=PFD_MAIN_PLANE;
fin;
PixelFormat:=ElijaPixelFormat(Canvas.Handle,@pfd);
SetPixelFormat(Canvas.Handle,PixelFormat,@pfd);
hrc:=wglCreateContext(Canvas.Handle);
w:=AnchoDeCliente;
h:=AlturaCliente;
fin;
procedimiento TfrmMain.FormDestroy(Remitente: TObject);
comenzar
wglDeleteContext(hrc);
fin;
procedimiento TfrmMain.FormPaint(Remitente: TObject);
comenzar
wglMakeCurrent(Canvas.Handle,hrc);
glClearColor(1,1,1,1);
glColor3f(1,0,0);
glClear(GL_COLOR_BUFFER_BIT o GL_DEPTH_BUFFER_BIT);
Mi sorteo;
glFlush;
SwapBuffers(Canvas.Handle);
fin;
procedimiento TfrmMain.MyDraw;
comenzar
glPushMatrix;
Esfera:=gluNewQuadric;
gluQuadricDrawStyle(Esfera,GLU_LINE);
gluEsfera(Esfera,0.5,25,25);
glPopMatrix;
SwapBuffers(Canvas.handle);
gluDeleteQuadric(Esfera);
fin;
procedimiento TfrmMain.FormResize(Remitente: TObject);
comenzar
glMatrixMode(GL_PROJECTION);
glLoadIdentidad;
glFrustum(-1.0,1.0,-1.0,1.0,3.0,7.0);
glViewPort(0,0,AnchoCliente,AlturaCliente);
Mi sorteo;
fin;
fin.
3. Convenciones sobre variables y funciones OPENGL
1. Convenciones de la biblioteca OPENGL
Dispone de tres bibliotecas en total: biblioteca básica, biblioteca práctica y biblioteca auxiliar. En DELPHI, la biblioteca básica la implementa la unidad OpenGL. En el entorno Windows, generalmente no se utilizan bibliotecas auxiliares.
2. Convención constante OPENGL
Las constantes OPENGL usan letras mayúsculas, comenzando con "GL" y usan guiones bajos para separar palabras, como: GL_LINES, lo que significa usar la biblioteca básica para dibujar líneas rectas.
3. Convención de nomenclatura de funciones OPENGL
R La primera parte comienza con gl o wgl, como gl en glColor3f.
B La segunda parte es la función expresada en inglés, con la primera letra de la palabra en mayúscula.
La tercera parte de C es un número que representa los parámetros de la función.
La cuarta parte de D es una letra minúscula que indica el tipo de función.
bentero de 9 bits
entero de 16 bits
iEntero de 32 bits
fNúmero de punto flotante de 32 bits
dNúmero de coma flotante de 64 bits
ubEntero sin signo de 9 bits
Ejemplo: glVertex2f(37,40); {dos números de punto flotante de 32 bits como parámetros}
glVertex3d(37,40,5); {Tres números de punto flotante de 64 bits como parámetros}
p[1..3]:matriz de glFloat;
glVertes3fv(p); {3f representa tres números de punto flotante, v representa llamar a una matriz como entrada de coordenadas de vértice}
4. Inicialización de OPENGL
1. Estructura PIXELFORMATDESCRIPTOR
Describe principalmente las propiedades de los píxeles, como el modo de color de los píxeles y la composición de los colores rojo, verde y azul.
tagPIXELFORMATDESCRIPTOR = registro empaquetado
nTamaño: Palabra;
nVersión: Palabra;
dwFlags: DWORD;
Tipo de iPixel: Byte;
cColorBits: Byte;
cRedBits: byte;
cRedShift: Byte;
cGreenBits: Byte;
cGreenShift: Byte;
cBlueBits: Byte;
cBlueShift: Byte;
cAlphaBits: Byte;
cAlphaShift: Byte;
cAccumBits: byte;
cAccumRedBits: Byte;
cAccumGreenBits: Byte;
cAccumBlueBits: Byte;
cAccumAlphaBits: Byte;
cProfundidadBits: Byte;
cStencilBits: Byte;
cAuxBuffers: Byte;
iLayerType: Byte;
bReservado: Byte;
dwLayerMask: DWORD;
dwVisibleMask: DWORD;
dwDañoMask: DWORD;
fin;
TPixelFormatDescriptor = etiquetaPIXELFORMATDESCRIPTOR;
dwFlags representa los atributos del formato de puntos:
Los gráficos PFD_DRAW_TO_WINDOW se dibujan en la pantalla o en la superficie del dispositivo
PFD_DRAW_TO_BITMAP dibuja un mapa de bits en la memoria
PFD_SUPPORT_GDI admite dibujo GDI
PFD_SUPPORT_OPENGL admite funciones OPENGL
PFD_DOUBLEBUFFER utiliza doble buffer
Caché estéreo PFD_STEREO
PFD_NEED_PALLETTE usa la paleta RGBA
PFD_GENERIC_FORMAT selecciona el formato de dibujo soportado por GDI
PFD_NEED_SYSTEM_PALETTE utiliza la paleta de hardware compatible con OPENGL
iPixelType establece el modo de color de píxel: PFD_TYPE_RGBA o PFD_TYPE_INDEX.
cColorBits establece los bits de color. Si es 9, significa que hay 256 colores para representar el color del punto.
cRedBits, cGreenBits, cBlueBits Cuando se utiliza RGBA, el número de bits utilizados para los tres colores primarios.
cRedShitfs, cGreenShifts, cBlueShifts Cuando se utiliza RGBA, el número de dígitos que se pueden ajustar para los tres colores primarios.
cAlphaBits, cAlphaShifts Cuando se usa RGBA, la cantidad de bits utilizados por Alpha y la cantidad de bits ajustables.
cAccumBits establece el número total de bits en el área del búfer de acumulación.
cAccumRedBits, cAccumGreenBits y cAccumBlueBits establecen el número total de tres planos de color primario en el área del búfer de acumulación.
cAccumAlphaBits establece el número total de bits Alpha en el búfer de acumulación.
cDepthBits establece la profundidad del búfer de concentración.
cStencilBits establece la profundidad del caché de plantilla.
cAuxBuffers se refiere al tamaño del búfer auxiliar.
iLayerType especifica el tipo de capa.
bReserved no se utiliza y debe ser cero.
dwLayerMask especifica la máscara de la superposición.
dwDamageMask establece si se comparte el mismo modo de píxel en la misma caché de fotogramas.
2. Pasos de inicialización de OPENGL
A Utilice Canvas.Handle para obtener el identificador de la ventana.
B Cree una variable TPixelFormatDescriptor para definir el formato de píxel.
C Utilice la función ChoosePixelFormat para seleccionar el formato de píxel.
D Utilice la función SetPixelFormat para utilizar el formato de píxel y que surta efecto.
E Utilice la función wglCreateContext para crear una tabla de descripción de traducción.
F Utilice la función wglMakeCurrent para utilizar la tabla de descripción de traducción creada como la tabla de descripción de traducción actual.
3. Liberación de recursos
A Utilice el procedimiento wglDeleteContext para eliminar la tabla de contexto de píxeles.
B Utilice el procedimiento ReleaseDC para liberar la memoria de la ventana.
En el evento OnDestroy de la ventana:
comenzar
si hrc<>nulo entonces
wglDeleteCurrent(hrc);
si hdc<>nulo entonces
ReleaseDC(Mango,hdc);
fin;
5. Dibujo de gráficos básicos de OPENGL.
1. Color de los gráficos
Preste atención a la configuración del color de fondo. La configuración del color generalmente está relacionada con la variable de descripción del píxel, es decir, con el miembro iPixelType en la definición de TPixelFormatDescriptor.
iPixelType:=PFD_TYPE_COLORINDEX;
Entonces solo podrá utilizar los procedimientos glIndexd, glIndexf, glIndexi, glIndexs, glIndexv, glIndexfv, glIndexiv, glIndexsv para configurar el color de los gráficos.
iPixelType:=PFD_TYPE_RGBA;
Entonces solo puedes usar glColor3b, glColor3f, glColor4b, glColor4f, glColor4fv para configurar el color de los gráficos.
A Color de fondo de los gráficos: el color de la pantalla y la ventana, es decir, el color del búfer de color. Para cambiar el color de fondo de los gráficos, primero debe usar el procedimiento glClearColor para establecer el color de fondo y luego usar el procedimiento glClear para actualizar la ventana y la pantalla con este color de fondo.
procedimiento glClearColor(rojo:GLClampf,verde:GLClampf,azul:GLClampf,alfa:GLClampf);
procedimiento glClear(máscara:GLBitField);
rojo, verde, azul y alfa son los colores de fondo que se configurarán y sus valores son de 0 a 1. La máscara es una forma de actualizar el color de fondo.
Ejemplo: establecer la ventana para colorear en verde
glClearColor(0,1,0,1);
glClear(GL_COLOR_BUFFER_BIT);
El valor y significado de la máscara:
GL_COLOR_BUFFER_BIT establece el búfer de color actual
GL_DEPTH_BUFFER_BIT establece el búfer de profundidad actual
GL_ACCUM_BUFFER_BIT establece el búfer de acumulación actual
GL_STENCIL_BUFFER_BIT establece el búfer STENCIL (plantilla) actual
La ventana de dibujo está configurada en gris.
glClearColor(0.3,0.3,0.3,1);
glClear(GL_COLOR_BUFFER_BIT);
color gráfico B
Utilice glClear3f y glClear4f para establecer el color de dibujo de los gráficos. Si se utilizan tres parámetros, significa configurar los tres colores de luz roja, azul y verde respectivamente. Si se utilizan cuatro parámetros, el cuarto representa el valor RGBA.
Ejemplo de configuración del color de dibujo actual en azul:
glColor3f(0,0,1);
Establezca el color del trazado en blanco:
glColor3f(1,1,1);
2. Dibujo de gráficos simples.
Dibuje gráficos simples, como puntos, líneas, polígonos, etc., entre los procedimientos glBegin y glEnd.
glBegin(modo:GLenum);{Proceso de dibujo}glEnd;
El valor de la moda:
GL_POINTS dibuja múltiples puntos
GL_LINES dibuja múltiples líneas, dibujando una línea recta cada dos puntos
GL_LINE_STRIP dibuja polilínea
GL_LINE_LOOP dibuja polígonos cerrados conectados de un extremo a otro
GL_TRIANGLES dibuja triángulos
GL_TRIANGLE_STRIP dibuja un triángulo, dibujando un triángulo cada tres puntos
GL_TRIANGLE_FAN dibuja triángulos
GL_QUADS dibuja cuadriláteros
GL_QUAD_STRIP dibuja franjas de cuadriláteros, se dibuja una franja de cuadrilátero por cada cuatro puntos
GL_POLYGON dibuja polígonos
Ejemplo de dibujo de tres puntos:
comenzar
glPushMatrix;
glBegin(GL_POINT);
glVertex2f(0.1,0.1);
glVertex2f(0.5,0.5);
glVertex2f(0.1,0.3);
glEnd;
SwapBuffers(Canvas.Handle);
fin;
Si cambia GL_POINT a GL_LINES, dibujará una línea. El tercer punto no es válido. Hacer glColor3f(0,0,1) antes de glVertex2f cambiará el color de la línea a verde. Si cambia GL_LINES a GL_LINE_STRIP, podrá dibujar. dos Una línea recta.
Utilice el procedimiento glPointSize para establecer el tamaño del punto; utilice el procedimiento glLineWidth para establecer el ancho de la línea.
Utilice el procedimiento glLineStipple para configurar la plantilla para líneas de puntos y utilice el procedimiento glEnable(GL_LINE_STIPPLE) y los parámetros correspondientes para habilitar el dibujo para dibujar líneas de puntos. El procedimiento glDisable(GL_LINE_STIPPLE) y los parámetros correspondientes desactivan las líneas de puntos.
procedimiento glLineStipple(factor:GLint,patrón:GLushort);
El parámetro factor representa el número de repeticiones del patrón de línea de puntos y rayas. El valor del factor es 1255. El patrón es una secuencia binaria.
glLineStipple(1,0,0x11C);{0x11C se representa como 10001110, 0 significa no dibujar puntos, 1 significa dibujar puntos}
Ejemplo: comenzar
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);
fin;
El dibujo de polígonos es similar al dibujo de líneas de puntos. Debe cambiar los parámetros a GL_POLYGON, GL_QUADS, GL_TRANGLES.
Los lados de un polígono se cortan sólo en los vértices.
El polígono B debe ser un polígono convexo. Si es un polígono cóncavo, el usuario sólo puede doblarlo en un polígono convexo para acelerar el dibujo.
Ejemplo: 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;
Los polígonos tienen lados frontal y posterior, y los procesos relacionados con ellos son:
glPolygonMode controla los modos de dibujo frontal y posterior del polígono
glFrontface especifica la cara frontal del polígono
glCullFace muestra polígonos configurados para eliminar caras
glPolygonStripple forma el estilo de un relleno de polígono
3. Superficie cuadrática simple
Los cilindros, anillos y esferas son todos superficies cuadráticas.
un cilindro
gluCylinder(qobj:GLUquadricObj,baseRadius:GLdouble,topRadius:GLdouble,height:GLdouble,
rebanadas:GLint,pilas:GLint);
qobj especifica una superficie cuadrática, baseRadius es el radio base del cilindro; topRadius es el radio superior del cilindro dibujado; la altura es la altura de los cortes del cilindro es el número de líneas divisorias alrededor del eje Z; líneas divisorias a lo largo del eje Z.
Si baseRadius y topRadius no son iguales, puedes dibujar un tronco y un cono.
procedimiento TfrmMain.MyDraw;
var
qObj:GLUQuadricObj;
comenzar
glPushMatrix;
glClear(GL_COLOR_BUFFER_BIT o GL_DEPTH_BUFFER_BIT);
glColor3f(1,0,0);
qObj:=gluNewQuadric;
gluQuadricDrawStyle(qObj,GLU_LINE);
gluCilindro(qObj,0.5,0.1,0.2,10,10);
fin;
Traer
gluDisk(qobj:GLUquadricObj,innerRadius:GLdouble,outerRadius:GLdouble,slices:GLint,
bucles:GLint);
procedimiento TfrmMain.MyDraw;
var
qObj:GLUQuadricObj;
comenzar
glPushMatrix;
glClear(GL_COLOR_BUFFER_BIT o 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);
fin;
C semicírculo
gluPartialDisk(qobj:GLUquadricObj,innerRadius:GLdouble,outerRadius:GLdouble,slices:GLint,
bucles:GLint,startAngle:GLdouble,sweepAngle:GLdouble);
startAngle,weepAngle son el ángulo inicial y el ángulo final del semicírculo.
procedimiento TfrmMain.MyDraw;
var
qObj:GLUQuadricObj;
comenzar
glPushMatrix;
glClear(GL_COLOR_BUFFER_BIT o 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);
fin;
esfera D
función gluSphere(qObj:GLUquadricObj,radio:GLdouble,slices:GLint,stacks:GLint);
procedimiento TfrmMain.MyDraw;
var
qObj:GLUQuadricObj;
comenzar
glPushMatrix;
glClear(GL_COLOR_BUFFER_BIT o GL_DEPTH_BUFFER_BIT);
glColor3f(1,0,0);
qObj:=gluNewQuadric;
gluQuadricDrawStyle(qObj,GLU_LINE);
{ silueta[ silu(:)5et ]n. silueta, contorno}
gluEsfera(qObj,0.5,20,20);
SwapBuffers(Canvas.Handle);
fin;
E Sobre el proceso de superficie cuadrática.
gluNewQuadric crea un nuevo objeto de superficie cuadrática
gluDeleteQuadric elimina un objeto de superficie cuadrática
gluQuadricDrawStyle especifica el tipo de superficie cuádrica a dibujar
gluQuadricNormal establece el vector normal de la superficie cuadrática
gluQuadricOrientation establece si la superficie cuadrática se gira internamente o externamente
gluQuadricTexture establece si la superficie cuadrática usa textura
F Pasos generales para dibujar superficies cuadráticas
Primero defina un objeto GLUquadricObj;
En segundo lugar, cree un objeto de superficie gluNewQuadric;
Establezca nuevamente las propiedades de la superficie cuadrática (gluQuadricDrawStyle, gluQuadricTexture)
Dibujar superficies cuadráticas (gluCylinder, gluSphere, gluDisk, gluPartialDisk)
6. Transformación en OPENGL
La transformación es la base del diseño de animación, incluida la traducción gráfica, la rotación, el escalado y otras operaciones, que se implementan matemáticamente a través de matrices.
1 proceso glLoadIdentity
Capaz de convertir la matriz actual en una matriz de identidad.
2 proceso glLoadMatrix
Capaz de establecer la matriz especificada como la matriz actual.
procedimiento glLoadmatrixd(m:GLdouble);
procedimiento glLoadmatrixf(m:GLfloat);
m representa una matriz 4X4, el siguiente código la define y la convierte en la matriz actual
M:matriz[1..4,1..4] de GLfloat;
glLoadMatrix(@M);
3 proceso glMultMatrix
Capaz de multiplicar el momento actual por la matriz especificada y utilizar el resultado como el momento actual.
procedimiento glMultMatrixd(M:GLdouble);
procedimiento glMultMatrixf(M:GLfloat);
4 glPushMatrix y glPopmatrix
glPushMatrix puede insertar el momento actual en la pila de matrices, y glPopMatrix puede sacar el momento actual de la pila de matrices.
glPushMatrix puede recordar la posición actual de la matriz y glPopmatrix puede devolver la posición anterior.
Nota: glPushMatrix y glPopMatrix deben colocarse fuera de glBegin y glEnd.
5 Transformación de proyección
Un glOrtho puede crear una matriz de proyección ortográfica, multiplicar el momento actual por la matriz de proyección ortográfica y utilizar el resultado como matriz actual.
función glOrtho(izquierda:GLdoble,derecha:GLdoble,abajo:GLdoble,arriba:GLdoble,
cerca:GLdoble,lejos:GLdoble);
procedimiento TfrmMain.FormResize(Remitente: TObject);
var
nRango:GLfloat;
comenzar
nRango:=50,0;
w:=ancho del cliente;
h:=alturadelcliente;
si h=0 entonces
h:=1;
glViewPort(0,0,w,h);
si w<=h entonces
glOrtho(-nRango,nRango,-nRango*h/w,nRango*h/w,
-nRango,nRango)
demás
glOrtho(-nRango*h/w,nRango*h/w,-nRango,nRango,
-nRango,nRango);
repintar;
fin;
B glOrtho2D solo define el frente, la parte posterior, la izquierda y la derecha del volumen de visualización ortográfica.
procedimiento glOrtho(izquierda:GLdoble,derecha:GLdoble,abajo:GLdoble,arriba:GLdoble);
Procedimiento C glMatrixMode
Capacidad para establecer el tipo de matriz de operación actual.
procedimiento glMatrixMode(modo:GLenum);
El valor de la moda:
GL_MODELVIEW especifica que las operaciones matriciales posteriores son pilas de matrices modelo
GL_PROJECTION especifica que las operaciones matriciales posteriores sean pilas de matrices de proyección
GL_TEXTURE especifica que las operaciones matriciales posteriores son pilas de matrices de textura
Proceso D glFrustum
Cree una matriz de proyección oblicua en perspectiva y multiplique la matriz actual por la matriz de proyección oblicua. El resultado es la matriz actual.
procedimiento glFrustum(izquierda:GLdoble,derecha:GLdoble,abajo:GLdoble,arriba:GLdoble,
siguiente:GLdoble,lejos:GLdoble);
Estos parámetros definen los planos de recorte izquierdo, derecho, superior, inferior, frontal y posterior de la proyección oblicua.
E gluProceso de perspectiva
Capaz de definir un volumen de visualización piramidal de cuatro lados con el eje Z como línea central.
procedimiento gluPerspetive(fovy:GLdouble,aspecto:GLdouble,zNear:GLdouble,zFar:GLdouble);
fovy define la perspectiva del plano xoz, el aspecto define la relación en las direcciones x e y, zNear y zFar definen las distancias desde el punto de vista hasta el plano de recorte y el plano de recorte posterior, respectivamente.
procedimiento TfrmMain.FormResize(Remitente: TObject);
var
aspecto:GLflotador;
comenzar
w:=AnchoDeCliente;
h:=AlturaCliente;
si h=0 entonces
h:=1;
glViewPort(0,0,ancho del cliente,altura del cliente);
glMatrixMode(GL_PROJECTION);
glLoadIdentidad;
aspecto:=an/al;
gluPerspectiva(30.0,aspecto,1.0,50.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentidad;
fin;
6 Matriz de transformación geométrica
La transformación de la postura del movimiento de un objeto tridimensional se refiere a la traslación, rotación y escala del objeto.
Un proceso glTranslate puede mover el origen de las coordenadas a (x, y, z), su sintaxis de declaración:
procedimiento glTranslated(x:GLdouble,y:GLdouble,z:GLdouble);
procedimiento glTranslatef(x:GLdouble,y:GLdouble,z:GLdouble);
B glRotate puede rotar un objeto hasta un ángulo determinado. Su sintaxis de declaración es:
procedimiento glRotated(ángulo:GLdouble,x:GLdouble,y:GLdouble,z:GLdouble);
procedimiento glRotatef(ángulo:GLdouble,x:GLdouble,y:GLdouble,z:GLdouble);
Entre ellos, el ángulo es el ángulo de rotación y el eje central de rotación es la línea que conecta los dos puntos (0,0,0) y (x,y,z).
C glScale puede escalar el sistema de coordenadas y su sintaxis de declaración es:
procedimiento glScaled(x:GLdouble,y:GLdoble,z:GLdouble);
procedimiento glScalef(x:GLdouble,y:GLdoble,z:GLdouble);
Los valores de x, y y z mayores que 1 representan ampliación y los valores menores que 1 representan reducción.
Ejemplo de código original:
unidad MainFrm;
interfaz
usos
Windows, Mensajes, SysUtils, Variantes, Clases, Gráficos, Controles, Formularios,
Diálogos, OpenGL, ExtCtrls;
tipo
TfrmMain = clase(TForm)
Temporizador1: Temporizador T;
procedimiento FormCreate(Remitente: TObject);
procedimiento FormDestroy(Remitente: TObject);
procedimiento FormPaint(Remitente: TObject);
procedimiento FormKeyDown(Remitente: TObject; var Clave: Palabra;
Cambio: TShiftState);
procedimiento FormResize(Remitente: TObject);
procedimiento Timer1Timer(Remitente: TObject);
procedimiento FormClose(Remitente: TObject; var Acción: TCloseAction);
privado
{Declaraciones privadas}
hrc:HGLRC;
w,h:Entero;
latitud, longitud: GLfloat;
radio:GLdoble;
público
{Declaraciones públicas}
procedimiento MyDraw;
procedimiento InicializarGL(var ancho:GLsizei;alto:GLsizei);
fin;
var
frmPrincipal: TfrmPrincipal;
implementación
{$R*.dfm}
procedimiento TfrmMain.FormCreate(Remitente: TObject);
var
pfd:TPixelFormatDescriptor;
Formato de píxel: entero;
comenzar
ControlStyle:=ControlStyle+[csOpaque];
FillChar(dfp,tamañode(dfp),0);
con dfp hacer
comenzar
nTamaño:=tamañode(TPixelFormatDescriptor);
nVersión:=1;
dwFlags:=PFD_DRAW_TO_WINDOW o
PFD_SUPPORT_OPENGL o PFD_DOUBLEBUFFER;
iPixelType:=PFD_TYPE_RGBA;
cColorBits:=24;
cBits de profundidad:=32;
iLayerType:=PFD_MAIN_PLANE;
fin;
PixelFormat:=ElijaPixelFormat(Canvas.Handle,@pfd);
SetPixelFormat(Canvas.Handle,PixelFormat,@pfd);
hrc:=wglCreateContext(Canvas.Handle);
w:=ClientRect.Derecha;
h:=ClientRect.Bottom;
InicializarGL(w,h);
fin;
procedimiento TfrmMain.FormDestroy(Remitente: TObject);
comenzar
wglDeleteContext(hrc);
fin;
procedimiento TfrmMain.FormPaint(Remitente: TObject);
comenzar
wglMakeCurrent(Canvas.Handle,hrc);
glClearColor(1,1,1,1);
glColor3f(1,0,0);
glClear(GL_COLOR_BUFFER_BIT o GL_DEPTH_BUFFER_BIT);
Mi sorteo;
glFlush;
fin;
procedimiento TfrmMain.MyDraw;
var
qObj:GLUQuadricObj;
comenzar
glPushMatrix;
glClear(GL_COLOR_BUFFER_BIT o 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);
glorado(longitud,0.0,0.0,1.0);
qObj:=gluNewQuadric;
gluQuadricDrawStyle(qObj,GLU_LINE);
gluEsfera(qObj,0.5,20,20);
SwapBuffers(Canvas.Handle);
fin;
{procedimiento TfrmMain.FormResize(Remitente: TObject);
var
nRango:GLfloat;
comenzar
nRango:=50,0;
w:=ancho del cliente;
h:=alturadelcliente;
si h=0 entonces
h:=1;
glViewPort(0,0,w,h);
glMatrixMode(GL_PROJECTION);
glLoadIdentidad;
si w<=h entonces
glOrtho(-nRango,nRango,-nRango*h/w,nRango*h/w,
-nRango,nRango)
demás
glOrtho(-nRango*h/w,nRango*h/w,-nRango,nRango,
-nRango,nRango);
glMatrixMode(GL_MODELVIEW);
glLoadidentidad;
repintar;
fin;
}
procedimiento TfrmMain.FormKeyDown(Remitente: TObject; var Clave: Palabra;
Cambio: TShiftState);
comenzar
si clave = VK_ESCAPE entonces
Cerca;
si clave = VK_UP entonces
glRotatef(-5,1.0,0.0,0.0);
si clave = VK_DOWN entonces
glRotatef(5,1.0,0.0,0.0);
si clave = VK_LEFT entonces
glRotatef(-5,0.0,1.0,0.0);
si clave = VK_RIGHT entonces
glRotatef(5.0,0.0,1.0,0.0);
repintar;
fin;
procedimiento TfrmMain.FormResize(Remitente: TObject);
comenzar
glMatrixMode(GL_PROJECTION);
glLoadIdentidad;
glFrustum(-1.0,1.0,-1.0,1.0,3.0,7.0);
glViewPort (0,0, ancho de cliente, altura de cliente);
repintar;
invalidar;
fin;
procedimiento TfrmMain.InitializeGL(var ancho: GLsizei; alto: GLsizei);
var
maxObjectSize,aspecto:GLfloat;
near_plane:GLdoble;
comenzar
glClearindex(0);
glClearDepth(1.0);
glEnable(GL_DEPTH_TEST);
glMatrixMode(GL_PROJECTION);
aspecto:=1,0;
gluPerspective(45.0,aspecto,3.0,7.0);
glmatrixMode(GL_MODELVIEW);
plano_cercano:=0,3;
maxObjectSize:=0.3;
radio:=avión_cercano+maxObjectSize/2.0;
latitud:=0,3;
longitud:=0,6;
fin;
procedimiento TfrmMain.Timer1Timer(Remitente: TObject);
comenzar
temporizador1.Enabled:=falso;
Mi sorteo;
Producir;
Temporizador1.Enabled:=verdadero;
fin;
procedimiento TfrmMain.FormClose(Remitente: TObject; var Acción: TCloseAction);
comenzar
temporizador1.Enabled:=falso;
si hrc<>nulo entonces
wglDeleteContext(hrc);
fin;
fin.
7. Iluminación y textura de OPENGL
Todos ellos son medios para mejorar el efecto tridimensional y el efecto de color. La iluminación puede aumentar el brillo y el efecto tridimensional de los gráficos, y la textura puede hacer que los gráficos sean más realistas. Mediante el uso de la iluminación, la apariencia de un objeto se puede expresar de manera fuerte y las texturas pueden hacer que el objeto muestre una variedad de apariencias.
1 Procesos y aplicaciones de iluminación y fuentes de luz.
Un procedimiento glIndex convierte un color en la tabla de índice de colores en el color actual.
procedimiento glIndexd(c:GLdouble);
procedimiento glIndexf(c:GLdouble);
procedimiento glIndexi(c:GLdouble);
procedimiento glIndexs(c:GLdouble);
El parámetro C es el valor del índice. Si se utiliza el procedimiento glIndex, el miembro iPixelType en la estructura TPiexlFormatDescriptor se establece en PFD_TYPE_COLORINDEX.
Procedimiento B glShadeModel
El proceso glShadeModel establece el modo de relleno, valor: GL_SMOOTH.
procedimiento glShadeModel(modo:GLenum);
Nota: Los dos procesos anteriores solo se pueden utilizar fuera de glBegin....glEnd.
El procedimiento C glLight define la fuente de luz
procedimiento glLightf(luz:GLenum,pname:GLenum,param:GLfloat);
procedimiento glLighti(luz:GLenum,pname:GLenum,param:GLfloat);
El parámetro luz define la fuente de luz, su valor puede ser: GL_LIGHT0....GL_LIGHTN, el valor N es menor que GL_MAX_LIGHT.
El parámetro pname especifica los parámetros de la fuente de luz:
Componente GL_AMBIENT intensidad de la luz ambiental
Componente GL_DIFFUSE intensidad de la luz dispersa
GL_SPECULAR componente intensidad de la luz reflejada
Posición de la fuente de luz GL_POSITION
GL_SPOT_DIRECTION La dirección de enfoque de la fuente de luz.
GL_SPOT_EXPONENT índice de fuente de luz
GL_SPOT_CUTOFF dirección de la fuente de luz
GL_CONSTANT_ATTENUATION factor de caída constante de la luz
GL_LINEAR_ATTENUATION factor de atenuación secundaria de luz
Habilite y apague las fuentes de luz usando los procedimientos glEnable() y glDisable()
glEnable(GL_LIGHTING); //Habilitar fuente de luz
glDisable(GL_LIGHTING); //Apaga la fuente de luz
glEnable(GL_LIGHT0); //Habilita la 0ª fuente de luz
glDisable(GL_LIGHT0); //Apaga la 0ª fuente de luz
Ejemplo de configuración de la fuente de luz:
var
sdirection:Array[1..4] de GLfloat:={0.0,1.0,0.0,0.0};
glLightfv(GL_LIGHT0,GL_SPOT_CUTOFF,60);
glLightfv(GL_LIGHT0,GL_SPOT_DIRECTION,dirección);
2 Modelo de material e iluminación.
Un procedimiento glMaterial establece parámetros de material.
procedimiento glMaterialf(cara:GLenum,pname:GLenum,param:GLfloat);
procedimiento glMateriali(cara:GLenum,pname:GLenum,param:GLfloat);
procedimiento glMaterialfv(cara:GLenum,pname:GLenum,param:GLfloat);
procedimiento glMaterialiv(cara:GLenum,pname:GLenum,param:GLfloat);
El parámetro cara especifica la superficie del objeto y sus valores son: GL_FRONT, GL_BACK, GL_FRONT_BACK.
pname,param no se presentan en este material.
B proceso glLightModel
procedimiento glLightModelf(pname:GLenum,param:GLfloat);
El parámetro pname es el parámetro del modelo de fuente de luz, que puede tomar el valor GL_LIGHT_MODEL_AMBIENT,
GL_LIGHT_MODEL_LOCAL_VIEWER,GL_LIGHT_MODEL_TWO_SIDE.
Código de ejemplo:
procedimiento TfrmMain.SetLighting;
var
MaterialAmbient:matriz[1..4] de GLfloat;
MaterialDiffuse:Matriz[1..4] de GLfloat;
MaterialSpecular:Matriz[1..4] de GLfloat;
AmbientLightPosition:Matriz[1..4] de GLfloat;
LightAmbient:Matriz[1..4] de GLfloat;
MaterialBrillo:GLfloat;
comenzar
AmbienteMaterial[1]:=0.5;
AmbienteMaterial[2]:=0.8;
AmbienteMaterial[1]:=0.2;
AmbienteMaterial[1]:=1.0;
Materialdifuso[1]:=0,4;
Materialdifuso[2]:=0,8;
Materialdifuso[3]:=0,1;
Materialdifuso[4]:=1,0;
MaterialEspecular[1]:=1.0;
MaterialEspecular[2]:=0.5;
MaterialEspecular[3]:=0.1;
MaterialEspecular[4]:=1.0;
materialBrillo:=50.0;
PosiciónLuzAmbient[1]:=0.5;
PosiciónLuzAmbient[2]:=1.0;
PosiciónLuzAmbient[3]:=1.0;
PosiciónLuzAmbient[4]:=0.0;
Luz ambiental[1]:=0,5;
Luz Ambiental[2]:=0.2;
Luz Ambiental[3]:=0,8;
Luz Ambiental[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_SHININES,@MaterialShininess);
glLightfv(GL_LIGHT0,GL_POSITION,@AmbientLightPosition);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT,@LightAmbient);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
GLShadeModel(GL_SMOOTH);
fin;
3 Aplicación de textura
Un glTexImage1D define un mapa de textura unidimensional.
procedimiento glTexImage1D(objetivo:GLenum,nivel:GLint,componentes:GLint,ancho:GLsizei,
borde:GLint,formato:GLenum,tipo:GLenum,píxeles:GLvoid);
El valor del objetivo del parámetro es GL_TEXTURE_1D, que se define como mapeo de textura, el nivel es el nivel de la imagen de textura con resolución multinivel, el ancho es el ancho de la textura, el valor es 2n y el valor de n es 32, 64, 129. , etc. El borde es el límite de la textura y su valor es 0 o 1. Píxel es la ubicación de la textura en la memoria. El componente especifica la mezcla y el ajuste de RGBA:
1Seleccione el ingrediente B
2Selecciona los ingredientes B y A
3Seleccione los ingredientes R, G, B
4Seleccione los ingredientes R,G,B,A
B glTexImage2D define el mapeo de textura bidimensional
procedimiento glTexImage2D(objetivo:GLenum,nivel:GLint,componentes:GLint,ancho:GLsizei,
borde:GLint,formato:GLenum,tipo:GLenum,píxeles:GLvoid);
Si el objetivo del parámetro es GL_TEXTURE_2D, el significado es mapeo de textura bidimensional, la altura es la altura de la textura y otros parámetros en la función son los mismos que glTexImage1D. El valor del parámetro del componente es el mismo que el anterior.
Código de ejemplo:
procedimiento TfrmMain.SetTextures;
var
bits: Matriz [1..64,1..64,1..64] de GLubyte;
bmp:TBitmap;
i,j:Entero;
comenzar
bmp:=TBitmap.Create;
bmp.LoadFromFile('d:/dsoft/1119/01/logon.bmp');
para i:=1 a 64 hacer
para j:=1 a 64 hacer
comenzar
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;
fin;
{0 representa un nivel de sombreado de un solo color, GL_RGBA representa un valor mixto
64x64 representa la altura y el ancho de la textura, 0 no representa el borde,
GL_RGBA representa el tipo de textura, GL_UNSIGNED_TYPE Representa el tipo de datos, la dirección del objeto @Generation}
GLTEXIMAGE2D (GL_TEXTURE_2D, 0, GL_RGBA, 64,64,0, GL_RGBA,
Gl_unsigned_byte,@bits);
Glenable (GL_Texture_2d);
fin;
C GltexParameter Procedimiento Establece parámetros de textura
Procedimiento GltexParameterf (objetivo: Glenum, Pname: Glenum, Param: Glfloat);
Procedimiento GltexParameteri (objetivo: Glenum, Pname: Glenum, Param: Glfloat);
El objetivo del parámetro representa GL_Texture_1D o GL_Texture_2D, y Param es el valor de textura.
D La función GLTEXENV establece los parámetros de entorno de la textura
función GLTEXENVF (Target: Glenum, Pname: Glenum, Param: Glfloat);
function GltexenVi (Target: Glenum, Pname: Glenum, Param: Glfloat);
El objetivo del parámetro es GL_Texture_env,
El parámetro pname es el valor del parámetro de textura, y el valor es GL_Texture_env_Mode
El parámetro de parámetro es el valor del entorno, y sus valores son GL_MODULE, GL_DECAL y GL_BLEND.
Código de muestra para este programa:
Unidad mainfrm;
interfaz
usos
Windows, Mensajes, SysUtils, Variantes, Clases, Gráficos, Controles, Formularios,
Cuadros de diálogo, OpenGL, extctrls;
tipo
TFRMMAIN = CLASE (TFORM)
Temporizador1: Temporizador T;
procedimiento FormCreate(Remitente: TObject);
procedimiento FormDestrOY (remitente: tobject);
procedimiento FormPaint (remitente: tobject);
procedimiento FormKeyDown (remitente: tobject; var key: word;
Cambio: TShiftState);
procedimiento FormResize (remitente: tobject);
procedimiento Timer1Timer(Remitente: TObject);
procedimiento FormClose(Remitente: TObject; var Acción: TCloseAction);
privado
{Declaraciones privadas}
HRC: HGLRC;
W, H: entero;
Latitud, longitud: glfloat;
Radius: GlDouble;
público
{Declaraciones públicas}
procedimiento de luz de la luz;
procedimiento setTextures;
procedimiento mydraw;
procedimiento inicializeGL (ancho de var: glsizei; altura: glsizei);
fin;
var
FrMMain: TFRMMain;
implementación
{$R*.dfm}
procedimiento tfrMMain.FormCreate (remitente: tobject);
var
PFD: TPIXELFORMATDESCRIPTOR;
PixeflaMat: Integer;
comenzar
ControlStyle: = ControlStyle+[CSOPAQUE];
Fillchar (PFD, sizeOf (PFD), 0);
con pfd hacer
comenzar
nsize: = sizeof (tpixeflaMatDescriptor);
Nversion: = 1;
DWFLAGS: = PFD_DRAW_TO_WINDOW o
Pfd_support_opengl o pfd_doubleBuffer;
ipixelType: = pfd_type_rgba;
ccolorbits: = 24;
CDEPTHBITS: = 32;
ilayertype: = pfd_main_plane;
fin;
PixeflaMat: = ChoosePixeformat (Canvas.handle,@pfd);
SetPixeflaMat (Canvas.handle, PixEftormat,@pfd);
hrc: = wglcreateContext (canvas.handle);
w: = clientRect.right;
h: = clientRect.bottom;
InitializeGL (W, H);
fin;
procedimiento tfrMMain.FormDestroy (remitente: tobject);
comenzar
wglDeletecontext (HRC);
fin;
procedimiento tFRMMain.FormPaint (remitente: tobject);
comenzar
wglmakecurrent (canvas.handle, hrc);
GlcLearcolor (1,1,1,1);
Glcolor3f (1,0,0);
GLCLEAR (GL_COLOR_BUFFER_BIT o GL_DEPTH_BUFFER_BIT);
SetTextures;
Mydraw;
Setlighting;
Glflush;
fin;
procedimiento TFRMMain.mydraw;
var
QOBJ: Gluquadricobj;
comenzar
Glpushmatrix;
GLCLEAR (GL_COLOR_BUFFER_BIT o GL_DEPTH_BUFFER_BIT);
Glcolor3f (1,0,0);
glrotado (0.5,0.0,1.0,0.0);
glrotated (-latitud, 1.0,0.0,0.0);
glrotado (longitud, 0.0,0.0,1.0);
QOBJ: = Glunewquadric;
GluquadricDrawStyle (QOBJ, Glu_Line);
Glusfera (QOBJ, 0.5,20,20);
Swapbuffers (Canvas.handle);
Setlighting;
SetTextures;
fin;
{procedimiento tFRMMain.FormResize (remitente: tobject);
var
nrange: glfloat;
comenzar
nrange: = 50.0;
W: = ClientWidth;
H: = ClientHeight;
Si h = 0 entonces
H: = 1;
glviewport (0,0, w, h);
GLMATRIXMODE (GL_PROJECTION);
GlLoadIdentity;
Si w <= h entonces
Glortho (-nrange, nrange, -nrange*h/w, nrange*h/w,
-nrange, nrange)
demás
Glortho (-nrange*h/w, nrange*h/w, -nrange, nrange,
-nrange, nrange);
GLMATRIXMODE (GL_MODELVIEW);
GlLoadIdentity;
repintado;
fin;
}
Procedimiento TFRMMain.FormKeyDown (remitente: tobject; var key: word;
Cambio: TShiftState);
comenzar
if key = vk_escape entonces
Cerca;
if key = vk_up entonces
glrotatef (-5,1.0,0.0,0.0);
if key = vk_down entonces
GlrotateF (5,1.0,0.0,0.0);
if key = vk_left entonces
glrotatef (-5,0.0,1.0,0.0);
if key = vk_right entonces
GlrotateF (5.0,0.0,1.0,0.0);
repintado;
fin;
procedimiento tFRMMain.FormResize (remitente: tobject);
comenzar
GLMATRIXMODE (GL_PROJECTION);
GlLoadIdentity;
glfrustum (-1.0,1.0, -1.0,1.0,3.0,7.0);
Glviewport (0,0, ClientWidth, ClientHeight);
repintado;
invalidar;
fin;
procedimiento tFRMMain.initializeGL (ancho de var: glsizei; altura: glsizei);
var
maxObjectSize, aspecto: glfloat;
Near_Plane: GlDouble;
comenzar
GlcLearIndex (0);
GlcLearDepth (1.0);
Glenable (GL_DEPTH_TEST);
GLMATRIXMODE (GL_PROJECTION);
aspecto: = 1.0;
GluperSpective (45.0, aspecto, 3.0,7.0);
GLMATRIXMODE (GL_MODELVIEW);
cerca de_plane: = 0.3;
maxObjectSize: = 0.3;
radio: = cerca_plane+maxObjectSize/2.0;
latitud: = 0.3;
Longitud: = 0.6;
fin;
procedimiento TFRMMain.Timer1Timer (remitente: tobject);
comenzar
temporizador1.Enabled:=falso;
Mydraw;
Producir;
Timer1.enabled: = true;
fin;
procedimiento tFRMMain.FormClose (remitente: tobject; VAR Action: TCLoseAction);
comenzar
temporizador1.Enabled:=falso;
Si hrc <> nulo entonces
wglDeletecontext (HRC);
fin;
Procedimiento TFRMMain.setlighting;
var
Materialambient: matriz [1..4] de glfloat;
MaterialDiffuse: Array [1..4] de Glfloat;
Materialpecular: matriz [1..4] de glfloat;
AmbientlightPosition: Array [1..4] de Glfloat;
Lightambient: matriz [1..4] de glfloat;
Materialidad: glfloat;
comenzar
Materialambiente [1]: = 0.5;
Materialambiente [2]: = 0.8;
Materialambiente [1]: = 0.2;
Materialambiente [1]: = 1.0;
Materialdiffuse [1]: = 0.4;
Materialdiffuse [2]: = 0.8;
Materialdiffuse [3]: = 0.1;
MaterialDiffuse [4]: = 1.0;
Materialpecular [1]: = 1.0;
Materialpecular [2]: = 0.5;
Material especular [3]: = 0.1;
Materialpecular [4]: = 1.0;
material de material: = 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_SHINING,@materialshininess);
GLLIGHFV (GL_LIGHT0, GL_POSICIÓN,@AmbientlightPosition);
GllightModEffv (GL_LIGHT_MODEL_AMBIENT,@Lightambient);
Glenable (GL_LIGHTING);
Glenable (GL_LIGHT0);
GLSHADEDEL (GL_SMOOTH);
fin;
Procedimiento TFRMMain.setTextures;
var
bits: matriz [1..64,1..64,1..64] de glubyte;
BMP: TBITMAP;
I, J: entero;
comenzar
bmp: = tbitmap.create;
bmp.loadFromFile ('d: /dsoft/1119/02/logon.bmp');
para i: = 1 a 64 hacer
para j: = 1 a 64 hacer
comenzar
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;
fin;
GLPIXELSTOREI (GL_UNPACK_ALINGMENT, 4);
GLTEXPARAMETERI (GL_Texture_2d, GL_Texture_Wrap_S, GL_CLAMP);
GLTEXPARAMETERI (GL_Texture_2d, GL_Texture_Mag_Filter, GL_Nearest);
GLTEXPARAMETERI (GL_Texture_2d, GL_Texture_min_Filter, GL_Nearest);
{0 representa un solo nivel de sombreado de color, GL_RGBA representa un valor mixto
64x64 representa la altura y el ancho de la textura, 0 no representa el borde,
GL_RGBA representa el tipo de textura, GL_UNSIGNED_TYPE Representa el tipo de datos, la dirección del objeto @Generation}
GLTEXIMAGE2D (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);
fin;
fin.