Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » C/Visual C » Dibujo de Opengl en Visual C++

C/Visual C - Dibujo de Opengl en Visual C++

Volver
Nuevo Tema
<<>>
 
Vista:

Dibujo de Opengl en Visual C++

Publicado por J.A (1 intervención) el 28/09/2001 18:55:10
Me gustaria saber si es posible mostrar 2 opengl distintos en un mismo cuadro de dialogo simultaneamente.
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Alejandro

Mostrar dos contextos OpenGL en un mismo cuadro de diálogo

Publicado por Alejandro (913 intervenciones) el 16/10/2024 00:04:09
Sí, J.A., es posible mostrar dos contextos OpenGL diferentes en un mismo cuadro de diálogo simultáneamente, pero hay algunas consideraciones y técnicas que debes tener en cuenta. Aquí te explico cómo hacerlo:

1. Crear dos controles de OpenGL



Para mostrar dos contextos OpenGL, necesitarás crear dos controles (por ejemplo, dos `CWnd` o `CView`) en tu cuadro de diálogo. Cada uno de estos controles tendrá su propio contexto OpenGL.

2. Inicializar OpenGL para cada control



Cada control debe tener su propio contexto OpenGL. Esto implica que deberás crear un contexto para cada uno y hacer el manejo de inicialización y renderizado por separado.

3. Ejemplo de implementación



Aquí tienes un ejemplo básico de cómo podrías implementar esto en un cuadro de diálogo de MFC:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
#include <windows.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <afxwin.h>
 
class CMyOpenGLView : public CWnd {
public:
    HGLRC m_hRC; // OpenGL Rendering Context
    HDC m_hDC;   // Device Context
 
    CMyOpenGLView() {
        // Constructor
    }
 
    BOOL CreateOpenGLContext() {
        // Crear el contexto OpenGL
        m_hDC = GetDC(m_hWnd);
        PIXELFORMATDESCRIPTOR pfd = { sizeof(PIXELFORMATDESCRIPTOR), 1, PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL,
                                      PFD_TYPE_RGBA, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
        int pixelFormat = ChoosePixelFormat(m_hDC, &pfd);
        SetPixelFormat(m_hDC, pixelFormat, &pfd);
        m_hRC = wglCreateContext(m_hDC);
        wglMakeCurrent(m_hDC, m_hRC);
        return TRUE;
    }
 
    void Render() {
        // Renderizar OpenGL
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        // Aquí va tu código de renderizado
        SwapBuffers(m_hDC);
    }
 
    void Cleanup() {
        // Limpiar el contexto OpenGL
        wglMakeCurrent(m_hDC, NULL);
        wglDeleteContext(m_hRC);
        ReleaseDC(m_hWnd, m_hDC);
    }
 
protected:
    afx_msg void OnPaint() {
        Render();
    }
 
    DECLARE_MESSAGE_MAP()
};
 
BEGIN_MESSAGE_MAP(CMyOpenGLView, CWnd)
    ON_WM_PAINT()
END_MESSAGE_MAP()
 
class CMyDialog : public CDialog {
public:
    CMyOpenGLView m_view1;
    CMyOpenGLView m_view2;
 
    CMyDialog() : CDialog(IDD_MY_DIALOG) {}
 
    BOOL OnInitDialog() {
        CDialog::OnInitDialog();
 
        // Crear los controles OpenGL
        m_view1.Create(NULL, CRect(10, 10, 300, 300), _T("OpenGL View 1"), WS_CHILD | WS_VISIBLE, this->m_hWnd);
        m_view1.CreateOpenGLContext();
 
        m_view2.Create(NULL, CRect(310, 10, 600, 300), _T("OpenGL View 2"), WS_CHILD | WS_VISIBLE, this->m_hWnd);
        m_view2.CreateOpenGLContext();
 
        return TRUE;
    }
 
    void OnDestroy() {
        m_view1.Cleanup();
        m_view2.Cleanup();
        CDialog::OnDestroy();
    }
 
    DECLARE_MESSAGE_MAP()
};
 
BEGIN_MESSAGE_MAP(CMyDialog, CDialog)
    ON_WM_DESTROY()
END_MESSAGE_MAP()
 
class CMyApp : public CWinApp {
public:
    BOOL InitInstance() {
        CMyDialog dlg;
        m_pMainWnd = &dlg;
        dlg.DoModal();
        return FALSE;
    }
};
 
CMyApp theApp;

Consideraciones



1. Renderizado independiente: Cada control OpenGL debe manejar su propio ciclo de renderizado. Asegúrate de que cada uno tenga su propio contexto y que se llame a `SwapBuffers` para cada uno.

2. Sincronización: Si ambos contextos están actualizando la pantalla al mismo tiempo, asegúrate de que no haya conflictos en el uso de recursos.

3. Rendimiento: Renderizar dos contextos OpenGL puede afectar el rendimiento, así que asegúrate de optimizar tu código de renderizado.

4. Manejo de eventos: Cada control puede manejar sus propios eventos de entrada (teclado, ratón, etc.) de manera independiente.

Conclusión



Es totalmente factible mostrar dos contextos OpenGL en un mismo cuadro de diálogo, pero requiere una gestión cuidadosa de los contextos y el renderizado.

¡Saludos!
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar