Código fuente del evento del mouse OpenGL
#pragma comment(lib, "openGL32.lib")
#pragma comment(lib, "glu32.lib")< / p>
#pragma comentario (lib, "glaux.lib")
# incluye ltiostream.h gt//CIN cout
# incluye ltmath.h gt// abs
# define GLUT _ DISABLE _ ate xit _ HACK
# incluye ltglut.h gt
int x0, y01, xEnd, yEnd//variables globales ( y0 tiene el mismo nombre que la variable en math.h, así que reemplácelo con y01).
int width=400, height = 400
Voidsetpixel (glint x, glint y)//Función de dibujo OpenGL
{
GL start(GL _ POINTS); //Comienza a dibujar puntos
glVertex2i(x, y); //Dibuja un punto basado en 2 valores enteros.
glEnd(); //Finalizar punto de dibujo
}
void lineBresenham()
{// Algoritmo de dibujo de líneas de Bresenham. Entre ellas, x0, y01, xend y yend son variables globales.
int dx=xEnd-x0, dy = yEnd-y 01; //δx, δy
int x, y, p;
int dosDy, twoDyMinusDx, twoDyAddDx//2δy, 2(δy-δx)
GL clear(GL _ COLOR _ BUFFER _ BIT //Borra la ventana de visualización original y deja que aparezca la nueva ventana de visualización (caché de color)
Si (dy==0) // m=0, la línea horizontal y la coordenada X aumentan en 1 cada vez, y Y permanece sin cambios.
{
Si (x0 gtXEnd) // (x0, y01) es el punto final correcto.
{//Intercambia las coordenadas de ambos extremos para que (x, y01) represente el punto final izquierdo.
x = xEnd
xEnd = x0
x0 = x;
}
Si no // ( x0, y01) es el punto final izquierdo.
x = x0//El orden (x, y01) representa el punto final izquierdo.
mientras(x lt;=xEnd)
{
setPixel(x, y 01);
x;
}
}
De lo contrario, si (dx==0) // m=∞, la línea vertical y la coordenada y aumentan en 1 cada vez, y x permanece sin cambios .
{
if(y 01 gt; YEnd) // (x0, y01) es el punto final inferior.
{//Intercambia las coordenadas de ambos extremos para que (x0, y) represente el punto final superior.
y = yEnd
yEnd = y 01
y 01 = y
}
De lo contrario; // (x0, y01) es el punto final superior.
y = y 01; //El orden (x0, y) representa el punto final superior.
mientras(y lt;=yen)
{
setPixel(x0, y);
y;
}
}
De lo contrario, if(dx==dy) // 45 grados (apóstrofe), m=1, las coordenadas x, y aumentan en 1 cada vez.
{
Si (x0 gtXEnd) // (x0, y01) es el punto final correcto.
{//Intercambia las coordenadas de ambos extremos para que (x, y) represente el punto final izquierdo.
x = xEnd
y = yEnd
xEnd = x0
yEnd = y 01;
x0 = x;
y 01 = y;
}
Else // (x0, y01) es el punto final izquierdo.
{//El orden (x, y) representa el punto final izquierdo.
x = x0
y = y 01
}
mientras(x lt; =xEnd)
{
setPixel(x, y
x;
y
}
}
De lo contrario, si (dx = =-dy)/-45 grados (si), m=-1, la coordenada x aumenta en 1 y la coordenada y disminuye en 1.
{
Si (x0 gtXEnd) // (x0, y01) es el punto final correcto.
{//Intercambia las coordenadas de ambos extremos para que (x, y) represente el punto final izquierdo.
x = xEnd
y = yEnd
xEnd = x0
yEnd = y 01;
x0 = x;
y 01 = y;
}
Else // (x0, y01) es el punto final izquierdo.
{//El orden (x, y) representa el punto final izquierdo.
x = x0
y = y 01
}
mientras(x lt; =xEnd)
{
setPixel(x, y);
x
y-;
}
else if(abs(dx)>ABS(dy))//0 lt | m | lt1.0, la coordenada x aumenta en 1 cada vez.
{
Si (x0 gtXEnd) // (x0, y01) es el punto final correcto.
{//Intercambia las coordenadas de ambos extremos para que (x, y) represente el punto final izquierdo.
x = xEnd
y = yEnd
xEnd = x0
yEnd = y 01;
x0 = x;
y 01 = y;
dx =-dx; //δx
dy =-dy; //δy
}
Else // (x0, y01) es el punto final izquierdo.
{//El orden (x, y) representa el punto final izquierdo.
x = x0
y = y 01;
}
dosDy = 2 * dy//2δy
dosDyMinusDx = 2 *(dy-dx); //2(δy-δx)
dosDyAddDx = 2 *(dy dx); //2(δy δx)
if(dy gt;0)//0 lt;m lt1.0
{
p = 2 * dy-dx; //P0 = 2δy-δx
mientras(x lt; =xEnd)
{
setPixel(x, y);
x;
si (p lt0)
p = dosDy;
Otro
{
y;
p = dosDyMinusDx ;
}
}
}
else//-1 lt;m lt0
{
p = 2 * dy dx; //P0 = 2δy δx
mientras(x lt; =xEnd)
{
setPixel (x, y);
x;
si (p lt0)
{
y-;
p = twoDyAddDx;
}
Otro
p = twoDy;
}
}
}
de lo contrario if(ABS(dx) lt; ABS(dy))//1.0 lt | m | lt∞, la coordenada y aumenta en 1 cada vez.
{
if(y 01 gt; YEnd) // (x0, y01) es el punto final inferior.
{//Intercambia las coordenadas de ambos extremos para que (x, y) represente el punto final superior.
x = xEnd
y = yEnd
xEnd = x0
yEnd = y 01;
x0 = x;
y 01 = y;
dx =-dx; //δx
dy =-dy; //δy
}
Else // (x0, y01) es el punto final superior.
{//El comando (x, y) representa el punto final superior.
x = x0
y = y 01;
}
dosDy = 2 * dx//2δx
dosDyMinusDx = 2 *(dx-dy); //2(δx-δy)
dosDyAddDx = 2 *(dx dy); //2(δx δy)
if(dx gt; 0) // 1.0 lt; m lt∞
{
p = 2 * dx-dy //P0 = 2δx-δy
<; p>mientras(y lt;=yen){
setPixel(x, y);
y;
if ( p lt0)
p = twoDy;
Otro
{
x;
p = twoDyMinusDx ;
}
}
}
else//-1 lt;m lt0
{< / p>
p = 2 * dx dy; //P0 = 2δx δy
mientras(y lt;=yen)
{
setPixel( x, y);
y;
si (p lt0)
{
x-;
p = twoDyAddDx;
}
Otro
p = twoDy;
}
}
}
GL flush(); //Procesa el dibujo lo más rápido posible.
}
Void main(int argc, char** argv) //No se requieren parámetros de entrada.
{
cout lt lt"Ingrese x 0 y0 xx end:"
CIN gtx0 gt gty01 > gtxEnd gt gtyEnd
Gelatin(ampargc, argv); //Inicializar GLUT
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); //Establecer el caché y el modelo de color de la ventana.
glutInitWindowPosition(0, 0); //Establece las coordenadas de la esquina superior izquierda de la ventana (en la esquina superior izquierda de la pantalla)
glutInitWindowSize(ancho, alto) ; //Establece el tamaño de la ventana
GlutCreateWindow("Algoritmo de dibujo lineal 1"); //Crea una ventana y muestra una cadena en la barra de título.
glClearColor(1.0, 1.0, 1.0, 0.0); //Establece un fondo blanco (R, G, B, transparente), el valor predeterminado es negro.
glColor3f(1.0, 0.0, 0.0); //Utiliza 3 números de punto flotante para representar el color de primer plano (rojo), el valor predeterminado es blanco.
glMatrixMode(GL _ PROJECTION); //Proyección ortográfica de gráficos tridimensionales
glload identidad(); //Inicializar matriz de transformación del modelo
glutortho 2d (0.0, ancho, 0.0, alto); // Sistema de coordenadas cartesiano bidimensional, coordenadas iniciales y finales de X e y.
glutDisplayFunc(lineBresenham); //Muestra la función de dibujo lineal lineBresenham()
glutMainLoop(); //La última función del programa activa la ventana y los gráficos. Pone el programa en un bucle que comprueba el ratón y el teclado.
}