¿Quién puede darme algún código fuente para programas de nivel básico openGL?
Primero, genere el marco del programa Test.dsw
Nuevo proyecto | Asistente de aplicación MFC (EXE) | "Prueba" OK
*Nota*: " El signo más" se refiere a una cadena escrita manualmente.
En segundo lugar, importe el archivo de curva Bezier
Utilice el siguiente método para generar dos archivos: beziercurve.hbeiziercove.cpp:
Vista de clase de espacio de trabajo | | ltHaga clic derecho para abrir > Nueva clase | Clase genérica (no use la clase MFC) | "CBezierCurve" OK
En tercer lugar, edite la definición y la implementación de la clase de curva de Bezier.
Escriba los dos documentos siguientes:
BezierCurve.h BezierCurve.cpp
Cuarto, configure el entorno de compilación:
1. En BezierCurve.h y TestView.h, agregue el siguiente contenido:
# include ltGL/GL h gt
# include ltGL/Glu h gt .
# include ltGL/glaux.h gt;
2. En el entorno integrado
Proyecto|Configuración|Enlace|Objeto/Módulo Biblioteca|" OpenGL 32.lib Glu 32 lib glaux . lib " | OK
Verbo (abreviatura de verbo) establece el entorno de trabajo OpenGL: (Las siguientes operaciones son para TestView.cpp)
1. Procesar PreCreateWindow(). : Configurar el dibujo OpenGL El estilo de la ventana.
CS .style | = WS _ hermanos del clip | WS _ hijos del clip | CS _ propio DC
2.
El mecanismo del dibujo OpenGL es: primero use el contexto de dibujo de OpenGL (denominado RC) para dibujar y luego pase el resultado del dibujo al contexto de dibujo de la ventana (denominado DC) a través de SwapBuffer(). función. Cabe señalar que puede haber varios DC durante la ejecución del programa, pero solo un RC. Entonces, cuando el DC termina de dibujar, el RC debe liberarse inmediatamente para que otros DC puedan usarlo también. En el código siguiente, habrá comentarios detallados.
int ctest view::OnCreate(LPCREATESTRUCT LPCREATESTRUCT)
{
if(CView::OnCreate(lpCreateStruct)= =-1)
return-1;
myInitOpenGL();
return 0;
}
void CTestView::myInitOpenGL()
{
m _ pDC = new CClientDC(this); //Crear DC
Aserción (m_pDC!= NULL);
if(!MySetupixElFormat())//Establece el formato de mapa de bits del dibujo. Estas características se enumeran a continuación.
Regresar;
m _ hRC = wglCreateContext(m _ pDC- gt; m _ hDC- //Crear RC
wglMakeCurrent(m _ pDC-); gt; m_hDC, m_hRC); //RC está asociado con el DC actual
}//cclient * m_pDC;
BOOL ctest view::mySetupPixelFormat()
{// No nos importa el contenido específico del formato por el momento, y cambiaremos el formato cuando están familiarizados con él.
Descriptor de formato de píxel estático pfd =
{
sizeof(PIXELFORMATDESCRIPTOR), //El tamaño de este pfd
1,/ /Número de versión
PFD_DRAW_TO_WINDOW | //Ventana de soporte
PFD_SUPPORT_OPENGL | //Soporte OPENGL
PFD_DOUBLEBUFFER, //Doble buffer
PFD_TYPE_RGBA , // Tipo RGBA
24, // Profundidad de color de 24 bits
0, 0, 0, 0, 0, 0, // Los bits de color se ignoran
0, //Sin búfer alfa
0, //Ignora el bit de desplazamiento
0, //Sin búfer de acumulación
0,0, 0, 0, // Los bits de acumulación se ignoran
32, // Búfer z de 32 bits
0, // No hay búfer de matriz
0, / /Sin buffer auxiliar
PFD_MAIN_PLANE, //Capa principal
0, //Reservado
0, 0, 0 //Máscara de capa ignorada
};
int pixelformat
if((formato de píxel = elegir formato de píxel(m_pDC- gt; m_hDC amp; pfd)) == 0)
{
MessageBox("Error al elegirPixelFormat");
Devolver FALSO
}
if(SetPixelFormat(m_pDC- gt; m_hDC , formato de píxel. pfd) == false)
{
MessageBox("SetPixelFormat falló");
Devuelve FALSE
}
Devuelve VERDADERO
}
3. Procesar OnDestroy()
void CTestView::OnDestroy()
{
wglMakeCurrent(m_pDC- gt; m_hDC, NULL); // Libera el RC correspondiente a m_hDC.
wglDeleteContext(m_hRC); //Eliminar RC
IF (m_pDC)
Eliminar m_pDC//Eliminar el DC propiedad de la vista actual.
CView::on destroy();
}
4. Procesar OnEraseBkgnd()
BOOL ctest view::OnEraseBkgnd( CDC * pDC)
{
// TODO: Agregue su código de controlador de mensajes aquí y/o llame al valor predeterminado
// Regrese a CView:: OnEraseBkgnd( pDC);
//Comente esta oración; de lo contrario, la ventana
//se actualizará con una vista norte blanca, lo que provocará que la pantalla parpadee.
Devuelve VERDADERO//Solo devuelve vacío.
}
5. Procesando OnDraw()
void CTestView::OnDraw(CDC* pDC)
{
wglMakeCurrent(m_pDC-gt; m_hDC, m_hRC); //Asociar RC con el DC actual.
mydrawsscene(); //Función de dibujo específica, dibujada con RC.
swap buffers(m_pDC-gt; m_hDC); //Transfiere el dibujo en RC al DC actual, para
//Mostrar en pantalla
wglMakeCurrent(m_pDC-gt; m_hDC, NULL); //Libera RC para que otros DC dibujen.
}
void CTestView::myDrawScene()
{
glClearColor(0.0f, 0.0f, 0.0f, 1.0f ); //Establece el color de fondo en negro.
GL clear(GL _ COLOR _ BUFFER _ BIT | GL _ DEPTH _ BUFFER _ BIT
glPushMatrix()
glTranslated(0.0f, 0.0f, -3.0f); //Traduce el objeto en la dirección (0, 0, -1)
//Para que sea visible durante la proyección. Debido a que el punto de vista predeterminado es (0, 0, 0), aléjese.
//El objeto se puede ver.
//Este ejemplo demuestra una curva Bézier plana y solo realiza una rotación.
//Transforma, podrás ver su efecto 3D con mayor claridad.
//Dibuja una curva de Bézier a continuación.
bezier_curve.mypolygon();//Dibuja el polígono de control de la curva de Bezier
bezier_curve.mydraw();//CBezierCurveBezier curve_curve
//It es una variable miembro de CTestView.
//Consulte el apéndice para funciones específicas.
glPopMatrix();
GL flush(); //Finalizar dibujo RC
Regresar;
}
6. Manejar OnSize()
vista ctest vacía::en tamaño(UINT nType, int cx, int cy)
{
CView:: OnSize(nType, cx, cy);
Verificar (wglMakeCurrent(m_pDC-gt; m_hDC, m_hRC)); // Confirmar que RC está asociado con el DC actual.
w = cx
h = cy
VERIFY(wglMakeCurrent(NULL, NULL)); //Confirma que DC lanza RC.
}
7 Procesamiento de OnLButtonDown()
vista ctest vacía::OnLButtonDown(UINT nFlags, CPoint)
{
CView::OnLButtonDown(nFlags, punto);
if(bezier_curve.m_Ngt;MAX-1)
{
MessageBox("El el número de vértices excede el valor máximo MAX = 50 ");
Retorno;
}
//La siguiente es la preparación para la conversión de coordenadas.
GetClientRect( amp; m _ client rect); // Obtener el tamaño del área de la ventana gráfica
w = m _ client rect . Ancho w
h = m _ client rect . bottom-m _ client rect . //Altura de la ventana gráfica h
//w, h es una variable miembro de CTestView.
centex =(m _ client rect . left m _ client rect . right)/2 //Posición central,
centery =(m _ client rect . top m _ client rect . bottom)/2; //Úselo como origen
//centerx, centery son variables miembro de CTestView.
GLdouble tmpx, tmpy
tmpx = scrx 2g LX(point . x); //Convierte las coordenadas del punto en la pantalla a las coordenadas estándar del dibujo OpenGL.
tmpy = scry 2 Gly(punto . y);
Curva de Bézier m vértice [Curva de Bézier m N]. x = tmpx//Agregar un vértice
Curva de Bézier m vértice [curva de Bézier m N]. y = tmpy
Curva de Bezier. m_n; //Agrega 1 al número de vértices
invalidatory(NULL, TRUE); //Envía mensajes de actualización y redibujo. p>}
vista ctest doble::scrx 2 glx(int scrx)
{
return(double)(scrx-centex)/double (h);
}
vista doble ctest:: scry 2 Gly(int scry)
{
}
Apéndice:
Declaración de 1. CBezierCurve: (BezierCurve.h)
Clase CBezierCurve
{
Público:
mi punto 2d m _ Vertex[MAX]; //Control de vértices, almacenados en una matriz.
//myPOINT2D es una estructura con puntos bidimensionales.
//Los miembros son gldouble x, y.
int m_N; //Controla el número de vértices
Público:
CBezierCurve();
Virtual ~ CBezierCurve() ;
void bezier _ generación(mi punto 2d P[MAX], nivel int);
//La implementación específica del algoritmo
void myDraw() ; //Función de dibujo de curva
void my polygon(); //Dibujo de polígono de control
};
2. )
CBezierCurve::CBezierCurve()
{
m _ N = 4
m_Vertex[0]. x =-0.5f;
m_Vertex[0]. y =-0.5f;
m_Vertex[1]. x =-0.5f;
m_Vertex[1]. y = 0.5f
m_Vertex[2]. x = 0.5f
m_Vertex[2]. y = 0.5f
m_Vertex[3]. x = 0.5f
m_Vertex[3]. y =-0.5f;
}
CBezierCurve::~CBezierCurve()
{
}
void CBezierCurve::myDraw()
{
bezier_generate(m_vertex, nivel);
}
void CBezierCurve::bezier_generación (mi punto es 2d P[MAX], nivel int)
{//Para obtener una descripción detallada del algoritmo, consulte los libros relevantes.
int i, j;
nivel-;
Si (nivel lt0) devuelve
Si (nivel == 0)
{
glColor3f(1.0f, 1.0f, 1.0f);
GL comenzar(GL _ LINES); //Dibujar un segmento de línea
glColor3f(1.0f, 1.0f, 1.0f); p >
glVertex2d(P[0]). x,P[0]. y);
glVertex2d(P[m_N-1].x,P[m_N-1].y);
glEnd(); //Fin del dibujo de línea
Regresar; //Recurrir hasta el final, saltar de la recursión
}
myPOINT2D Q[MAX], R[MAX];
for(I = 0; i {
q . x = p . x;
q . y = p . y;
}
para (I = 1;iltm_N;i)
{
R[m_N-i]. . p>R[m_N-i]. y=Q[m_N-1];
for(j = m_N-1; j gt= I; j -)
{
x=(Q[j-1].x Q[j].x)/doble(2);
Q[j] .y=(Q[ j-1].y Q[j].
y)/doble(2);
}
}
R[0]. x=Q[m_N-1]. x;
R[0]. y=Q[m_N-1]. y;
Bessel_generación(Q, nivel);
Bessel_generación(R, nivel);
}
void CBezierCurve::myPolygon ()
{
GL comenzar(GL _ LINE _ STRIP); //Dibujar segmentos de línea de conexión
glColor3f(0.2 f, 0.4f, 0.4f );
for(int I = 0;iltm_N;i)
{
glVertex2d(m_Vertex.x , m _ vertex . y
}
glEnd(); //Finalizar el segmento de conexión del dibujo
}