OpenGL: Как рисовать на уже существующей форме?

#include <Form1.h>

BOOL GetClientRect
( 
    HWND hWnd,      // указатель на окно
    LPRECT lpRect           // указатель на структуру с координатами
);

#pragma once
 
#include <windows.h>
#include <GL/gl.h>    
 
using namespace System::Windows::Forms;
 
namespace OpenGLForm
{
    public ref class COpenGL: 
        public System::Windows::Forms::NativeWindow
            {
public:
    COpenGL(System::Windows::Forms::Form ^ parentForm, 
            GLsizei iWidth, GLsizei iHeight)
    {
        CreateParams^ cp = gcnew CreateParams;
 
        // Set the position on the form
        cp->X = 100;
        cp->Y = 100;
        cp->Height = iWidth;
        cp->Width = iHeight;
 
        // Specify the form as the parent.
        cp->Parent = parentForm->Handle;
 
        // Create as a child of the specified parent
        // and make OpenGL compliant (no clipping)
        cp->Style = WS_CHILD | WS_VISIBLE | 
                    WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
 
        // Create the actual window
        this->CreateHandle(cp);
 
        m_hDC = GetDC((HWND)this->Handle.ToPointer());
 
        if(m_hDC)
            MySetPixelFormat(m_hDC);
    }
 
virtual System::Void Render(System::Void)
{
    // Clear the color and depth buffers.
    glClearColor(0.0f, 0.0f, 0.0f, 0.0f) ;
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
 
System::Void SwapOpenGLBuffers(System::Void)
{
    SwapBuffers(m_hDC) ;
}
private:
    HDC m_hDC;
    HGLRC m_hglrc;
 
protected:
    ~COpenGL(System::Void)
    {
        this->DestroyHandle();
    }
 
    GLint MySetPixelFormat(HDC hdc)
    {
        PIXELFORMATDESCRIPTOR pfd = { 
            sizeof(PIXELFORMATDESCRIPTOR),    // size of this pfd 
            1,                                // version number 
            PFD_DRAW_TO_WINDOW |              // support window 
            PFD_SUPPORT_OPENGL |              // support OpenGL 
            PFD_DOUBLEBUFFER,                 // double buffered 
            PFD_TYPE_RGBA,                    // RGBA type 
            24,                               // 24-bit color depth 
            0, 0, 0, 0, 0, 0,                 // color bits ignored 
            0,                                // no alpha buffer 
            0,                                // shift bit ignored 
            0,                                // no accumulation buffer 
            0, 0, 0, 0,                       // accum bits ignored 
            32,                               // 32-bit z-buffer     
            0,                                // no stencil buffer 
            0,                                // no auxiliary buffer 
            PFD_MAIN_PLANE,                   // main layer 
            0,                                // reserved 
            0, 0, 0                           // layer masks ignored 
        }; 
    
        GLint  iPixelFormat; 
     
        // get the device context's best, available pixel format match 
        if((iPixelFormat = ChoosePixelFormat(hdc, &pfd)) == 0)
        {
            MessageBox::Show("ChoosePixelFormat Failed");
            return 0;
        }
         
        // make that match the device context's current pixel format 
        if(SetPixelFormat(hdc, iPixelFormat, &pfd) == FALSE)
        {
            MessageBox::Show("SetPixelFormat Failed");
            return 0;
        }
    
        if((m_hglrc = wglCreateContext(m_hDC)) == NULL)
        {
            MessageBox::Show("wglCreateContext Failed");
            return 0;
        }
        
        if((wglMakeCurrent(m_hDC, m_hglrc)) == NULL)
        {
            MessageBox::Show("wglMakeCurrent Failed");
            return 0;
        }
    
        return 1;
    }
};

#pragma comment(lib, "opengl32.lib") 
#pragma comment(lib, "gdi32.lib")
#pragma comment(lib, "user32.lib")

#pragma once
 
#include <windows.h>
#include <GL/gl.h>    
#include <GL/glu.h> 
#pragma comment(lib, "opengl32.lib")
#pragma comment(lib, "gdi32.lib")
#pragma comment(lib, "user32.lib")
 
using namespace System::Windows::Forms;
 
namespace OpenGLForm
{
    public ref class COpenGL: 
      public System::Windows::Forms::NativeWindow
          {
public:
    COpenGL(System::Windows::Forms::Form ^ parentForm, 
            GLsizei iWidth, GLsizei iHeight)
    {
        CreateParams^ cp = gcnew CreateParams;
 
        cp->X = 100;
        cp->Y = 100;
        cp->Height = iWidth;
        cp->Width = iHeight;
 
        cp->Parent = parentForm->Handle;
 
        cp->Style = WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
 
        this->CreateHandle(cp);
 
        m_hDC = GetDC((HWND)this->Handle.ToPointer());
 
        if(m_hDC)
            MySetPixelFormat(m_hDC);
    }
 
    virtual System::Void Render(System::Void)
{
    glClearColor(0.0f, 0.0f, 0.0f, 0.0f) ;
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
 
    System::Void SwapOpenGLBuffers(System::Void)
{
    SwapBuffers(m_hDC) ;
}
 
    private:
    HDC m_hDC;
    HGLRC m_hglrc;
 
    protected:
    ~COpenGL(System::Void)
    {
        this->DestroyHandle();
    }
    GLint MySetPixelFormat(HDC hdc)
    {
        PIXELFORMATDESCRIPTOR pfd = { 
            sizeof(PIXELFORMATDESCRIPTOR),
            1,                                
            PFD_DRAW_TO_WINDOW |
            PFD_SUPPORT_OPENGL |
            PFD_DOUBLEBUFFER,
            PFD_TYPE_RGBA,
            24,                   
            0, 0, 0, 0, 0, 0,   
            0,                     
            0,                     
            0,                     
            0, 0, 0, 0,          
            32,                   
            0,                     
            0,                     
            PFD_MAIN_PLANE,
            0,                      
            0, 0, 0                
        }; 
    
        GLint  iPixelFormat; 
     
 
        if((iPixelFormat = ChoosePixelFormat(hdc, &pfd)) == 0)
        {
            MessageBox::Show("ChoosePixelFormat Failed");
            return 0;
        }
 
        if(SetPixelFormat(hdc, iPixelFormat, &pfd) == FALSE)
        {
            MessageBox::Show("SetPixelFormat Failed");
            return 0;
        }
    
        if((m_hglrc = wglCreateContext(m_hDC)) == NULL)
        {
            MessageBox::Show("wglCreateContext Failed");
            return 0;
        }
        
        if((wglMakeCurrent(m_hDC, m_hglrc)) == NULL)
        {
            MessageBox::Show("wglMakeCurrent Failed");
            return 0;
        }
    
        return 1;
    }
};
}

#pragma once
#include "OpenGL.h"
 
namespace OpenGLWinForm {
 
    using namespace System;
    using namespace System::ComponentModel;
    using namespace System::Collections;
    using namespace System::Windows::Forms;
    using namespace System::Data;
    using namespace System::Drawing;
    using namespace OpenGLForm;
 
    /// <summary>
    /// Сводка для Form1
    ///
    /// Внимание! При изменении имени этого класса необходимо также изменить
    ///          свойство имени файла ресурсов ("Resource File Name") для средства компиляции управляемого ресурса,
    ///          связанного со всеми файлами с расширением .resx, от которых зависит данный класс. В противном случае,
    ///          конструкторы не смогут правильно работать с локализованными
    ///          ресурсами, сопоставленными данной форме.
    /// </summary>
    public ref class Form1 : public System::Windows::Forms::Form
    {
    public:
        Form1(void)
        {
            InitializeComponent();
            //
            //TODO: добавьте код конструктора
            //
            OpenGL = gcnew COpenGL(this, 640, 480);
        }
 
    protected:
        /// <summary>
        /// Освободить все используемые ресурсы.
        /// </summary>
        ~Form1()
        {
            if (components)
            {
                delete components;
            }
        }
 
    private: System::ComponentModel::IContainer^  components;
     protected:
    private: System::Windows::Forms::Timer^  timer1;
 
    private:
        /// <summary>
        /// Required designer variable.
        /// </summary>
   
        OpenGLWinForm::COpenGL ^ OpenGL;
 
#pragma region Windows Form Designer generated code
        /// <summary>
        /// Обязательный метод для поддержки конструктора - не изменяйте
        /// содержимое данного метода при помощи редактора кода.
        /// </summary>
        void InitializeComponent(void)
        {
            this->components = (gcnew System::ComponentModel::Container());
            this->timer1 = (gcnew System::Windows::Forms::Timer(this->components));
            this->SuspendLayout();
            // 
            // timer1
            // 
            this->timer1->Enabled = true;
            this->timer1->Interval = 10;
            this->timer1->Tick += gcnew System::EventHandler(this, &Form1::timer1_Tick);
            // 
            // Form1
            // 
            this->AutoScaleDimensions = System::Drawing::SizeF(6, 13);
            this->AutoScaleMode = System::Windows::Forms::AutoScaleMode::Font;
            this->ClientSize = System::Drawing::Size(795, 489);
            this->Name = L"Form1";
            this->Text = L"OpenGL on a Windows Form using Managed C++";
            this->ResumeLayout(false);
 
        }
        
#pragma endregion
    private: System::Void timer1_Tick(System::Object^  sender, System::EventArgs^  e)
             {
                 UNREFERENCED_PARAMETER(sender);
                 UNREFERENCED_PARAMETER(e);
                 OpenGL->Render();
                 OpenGL->SwapOpenGLBuffers();
             }
    private: System::Void timer1_Tick_1(System::Object^  sender, System::EventArgs^  e) {
                 UNREFERENCED_PARAMETER(sender);
                 UNREFERENCED_PARAMETER(e);
                 OpenGL->Render();
                 OpenGL->SwapOpenGLBuffers();
             }
    };
   }

OpenGL->Render();

#pragma once
 
namespace TaoFrameworkCLI {
 
    using namespace System;
    using namespace System::ComponentModel;
    using namespace System::Collections;
    using namespace System::Windows::Forms;
    using namespace System::Data;
    using namespace System::Drawing;
    using namespace Tao::OpenGl;
    using namespace Tao::FreeGlut;
    using namespace Tao::Platform::Windows;
 
    /// <summary>
    /// Сводка для Form1
    /// </summary>
    public ref class Form1 : public System::Windows::Forms::Form
    {
    public:
        Form1(void)
        {
            InitializeComponent();
            //
            //TODO: добавьте код конструктора
            //          
            MyInitializeComponent();
        }
 
    protected:
        /// <summary>
        /// Освободить все используемые ресурсы.
        /// </summary>
        ~Form1()
        {
            if (components)
            {
                delete components;
            }
        }
    private: System::Windows::Forms::Button^  button1;
    private: System::Windows::Forms::Button^  button2;
    private: Tao::Platform::Windows::SimpleOpenGlControl^ glControl;
 
    private: System::ComponentModel::IContainer^  components;
    protected: 
 
    private:
        /// <summary>
        /// Требуется переменная конструктора.
        /// </summary>
 
        #pragma region Windows Form Designer generated code
        /// <summary>
        /// Обязательный метод для поддержки конструктора - не изменяйте
        /// содержимое данного метода при помощи редактора кода.
        /// </summary>
        void InitializeComponent(void)
        {
            this->SuspendLayout();
            // 
            // Form1
            // 
            this->AutoScaleDimensions = System::Drawing::SizeF(6, 13);
            this->AutoScaleMode = System::Windows::Forms::AutoScaleMode::Font;
            this->ClientSize = System::Drawing::Size(284, 262);
            this->Name = L"Form1";
            this->Text = L"Form1";
            this->ResumeLayout(false);
 
        }
#pragma endregion
 
#pragma region 
    
        void MyInitializeComponent(void)
        {
            this->glControl = gcnew Tao::Platform::Windows::SimpleOpenGlControl();
            this->glControl->InitializeContexts();
            this->glControl->Location = Point(0, 0);
            this->glControl->Dock = DockStyle::Fill;
            this->glControl->Visible = true;
            // 
            // SimpleOpenGlControl
            //
            this->button1 = (gcnew System::Windows::Forms::Button());
            // 
            // button1
            // 
            this->button1->Location = System::Drawing::Point(210, 195);
            this->button1->Text = L"Show";
            this->button1->Click += gcnew System::EventHandler(this, &Form1::button1_Click);
            // 
            // Form1
            // 
            this->ClientSize = System::Drawing::Size(304, 262);
            this->Controls->Add(this->button1);
            this->Controls->Add(this->glControl);
 
            this->Load += gcnew System::EventHandler(this, &Form1::Form1_Load);
 
        }
#pragma endregion
    private: System::Void button1_Click(System::Object^  sender, System::EventArgs^  e) {
                Gl::glClear(Gl::GL_COLOR_BUFFER_BIT | Gl::GL_DEPTH_BUFFER_BIT);
                Gl::glLoadIdentity();
                Gl::glColor3f( 0.1f, 0.7f, 1.0f);
 
                Gl::glPushMatrix();
                Gl::glTranslated(0,0,-6);
                Gl::glRotated(45, 1, 1, 0);
 
                Glut::glutWireSphere(2, 32, 32);
 
                Gl::glPopMatrix();
                Gl::glFlush();
                this->glControl->Invalidate();
             }
    
    private: System::Void Form1_Load(System::Object^  sender, System::EventArgs^  e) {
            
        Glut::glutInit();
        Glut::glutInitDisplayMode(Glut::GLUT_RGB | Glut::GLUT_DOUBLE | Glut::GLUT_DEPTH);
 
        Gl::glViewport(0, 0, glControl->Width, glControl->Height);
 
        Gl::glMatrixMode(Gl::GL_PROJECTION);
        Gl::glLoadIdentity();
        Glu::gluPerspective(45, (float)glControl->Width / (float)glControl->Height, 0.1, 200);
        Gl::glMatrixMode(Gl::GL_MODELVIEW);
        Gl::glLoadIdentity();
        Gl::glEnable(Gl::GL_DEPTH_TEST);
             }
};
}

using namespace Tao::FreeGlut;