Виснет WM_PAINT

PAINTSTRUCT myPS;  //В myPaintStruct будут все парамтры перерисовки
RECT myRect;  //Прямоугольную облать, требующая перерисовки
BITMAPINFO* bm_info = new BITMAPINFO;
byte* wrk = new byte[4*400*500];
LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)        
{
    switch (uMsg) 
    {
    case WM_CREATE:
        {
        bm_info->bmiHeader.biSize = 40;
        bm_info->bmiHeader.biSizeImage = 0;
        bm_info->bmiHeader.biWidth = 500;
        bm_info->bmiHeader.biHeight = -400;
        bm_info->bmiHeader.biPlanes = 1;
        bm_info->bmiHeader.biBitCount = 32;
        bm_info->bmiHeader.biCompression = BI_RGB;
        for (int i = 0; i < 400*500; i++){
                wrk[i*4] = 0;
                wrk[i*4+1] = 0;
                wrk[i*4+2] = 0xFF;
            }
        return 0;
        }
case WM_PAINT:
    {
        BeginPaint(hWnd, &myPS);
        myRect = myPS.rcPaint; 
        SetDIBitsToDevice(hDC, 0, 0, myRect.right - myRect.left, myRect.bottom - myRect.top, 0, 0, 0, myRect.bottom - myRect.top, (void*)wrk, bm_info, DIB_RGB_COLORS);
        EndPaint(hWnd, &myPS);
        return 0;
    }

LRESULT CALLBACK WndProc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam )
{
    switch( message )
    {
    case WM_SIZE:
        GLResize( LOWORD(lParam), HIWORD(lParam) );
        break;
    case WM_CREATE:
        GLinit( hWnd );
        SetTimer( hWnd, 1, 7000, NULL );// ставишь нужный тебе таймер
        
        break;
    case WM_DESTROY:
        GLFree;
        KillTimer( hWnd, 1 );
        PostQuitMessage( 0 );
        break;
    case WM_TIMER:
        // здесь что-то происходит по таймеру
        break;
    case WM_KEYDOWN: 
    case WM_LBUTTONDOWN:
    case WM_MBUTTONDOWN:
    case WM_RBUTTONDOWN:
        // здесь обрабатываешь нажатия
        // и если необходимо выход
        PostMessage( g_hMainWnd, WM_CLOSE, 0,0 );
        break;
    case WM_MOUSEMOVE:
        // здесь изменеия положения камеры например
        break;
    default:
        return ( DefWindowProc( hWnd, message, wParam, lParam ) );
    };
    return 0L;
}
// собственно сама точка входа
int WINAPI _tWinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nShowCmd )
{
    hInst = GetModuleHandle( NULL );
    DWORD dwWSflag = WS_VISIBLE | WS_CLIPCHILDREN 
                | WS_CLIPSIBLINGS | WS_OVERLAPPEDWINDOW;
    UINT style =  CS_VREDRAW | CS_HREDRAW |CS_OWNDC;
 
    
    WNDCLASSEX wc;
    MSG msg;
    ZeroMemory( &wc, sizeof( wc ) );
    ZeroMemory( &msg, sizeof( msg ));
    wc.cbSize = sizeof( wc );
    wc.style = style;
    wc.lpszClassName = szClassName;
    wc.hInstance = hInst;
    wc.lpfnWndProc = (WNDPROC)WndProc;
    wc.hCursor = LoadCursor( NULL, IDC_ARROW );
 
    if( ! RegisterClassEx( &wc ) )
        return FALSE;
    timeBeginPeriod( 1 );
    DWORD dwLastTick = timeGetTime();
 
    g_hMainWnd = CreateWindowEx( /*WS_EX_TOPMOST*/NULL, szClassName, szWindowName, dwWSflag, //WS_OVERLAPPEDWINDOW,
        0, 0, 640 ,480,
        hParent, NULL, hInst, NULL );
 
    if( ! g_hMainWnd )  
        return FALSE;
 
    ShowWindow( g_hMainWnd, SW_SHOW );
    UpdateWindow( g_hMainWnd );
 
 
    while ( msg.message != WM_QUIT )
    {
        if( PeekMessage( &msg, NULL, 0U, 0U, PM_REMOVE ) )
        {
            TranslateMessage( &msg );
            DispatchMessage( &msg );
        }else
        {
            // здесь идёт постоянные обновления и прорисовка пока нет никаких сообщений
// а также вычисляется дельта анимации.
            DWORD dwCurrentTick = timeGetTime();
            GLUpdateAndRender( (float)(dwCurrentTick - dwLastTick) );
            dwLastTick = dwCurrentTick;
        }
    };
    timeEndPeriod( 1 );
    UnregisterClass( szClassName, hInst );
    return msg.wParam;
}

int mainGL::InitGL( HWND hWnd )
{
    m_hDC = GetDC( hWnd );
    if( m_hDC == NULL )
        return 0x01;
    SetDCPixelFormat();
    m_hRC = wglCreateContext( m_hDC );
    if( m_hRC == NULL )
        return 0x02;
    wglMakeCurrent( m_hDC, m_hRC );
    glClearColor( pfClearColor[0], pfClearColor[1], pfClearColor[2], pfClearColor[3] );
    glEnable( GL_COLOR_MATERIAL );
    glDepthFunc( GL_ALWAYS );
    glEnable( GL_DEPTH_TEST );
    glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
    glEnable( GL_BLEND );
    glFogi ( GL_FOG_MODE, GL_EXP2 );
    glFogfv( GL_FOG_COLOR, pfClearColor);
    glFogf ( GL_FOG_DENSITY, 0.02f );
    glEnable( GL_FOG );
    glEnableClientState( GL_TEXTURE_COORD_ARRAY );
    glEnableClientState( GL_COLOR_ARRAY );
    glEnableClientState( GL_VERTEX_ARRAY );
    LoadTexture();
    return 0x00;
}
// он же GLResize
void mainGL::Resize( int x, int y )
{   
    glViewport( 0, 0, x, y );
    if( y <= 0 )
        y = 1;
    float aspect = (float)x/(float)y;
    glMatrixMode( GL_PROJECTION );
    glLoadIdentity();
    gluPerspective( 45.0f, aspect, 1.0f, 101.0f );
    
    glMatrixMode( GL_MODELVIEW );
    glLoadIdentity();
    if( !g_flCameraRot )
    {
        glTranslatef( 0.0f, 0.0f, -(float)nAbsRangeZ-35.0f );
        CalcFrustum();
    }
    fLoadNotReady = false;
}
// он же GLUpdateAndRender
void mainGL::UpdateAndRender( float delta )
{
    if( fLoadNotReady )
        return;
    // тут у меня идёт оптимизация - что именно нужно рисовать(что попало в обзор камеры)
    glPushMatrix();
 
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
 
    CGLChain::Render();
    glPopMatrix();
    SwapBuffers( m_hDC );
}

mainGL::~mainGL(void)
{
    //CGLChain::Free();
    glDeleteTextures( 1, &g_uiTextureName );
    if( m_hDC )
    {
        wglMakeCurrent( m_hDC, NULL );
        if( m_hRC )
            wglDeleteContext( m_hRC );
        ReleaseDC( g_hMainWnd, m_hDC );
    };
}

glBegin( GL_QUADS );
glColor3f( cr1, cg1, cb1 );
glNormal3f( nx1, ny1, nz1 );
glVertex3f( x1, y1, z1 );
glVertex3f( x2, y2, z2 );
glVertex3f( x3, y3, z3 );
glVertex3f( x4, y4, z4 );
glEnd();

int DrawGLScene( GLvoid ){          
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); // Очистить экран и буфер глубины
    glLoadIdentity();                               // Сброс просмотра
    glTranslatef(-1.5f,0.0f,-6.0f);
    glBegin(GL_TRIANGLES);
    glVertex3f( 0.0f, 1.0f, 0.0f);  // Вверх
    glVertex3f(-1.0f,-1.0f, 0.0f);  // Слева снизу
    glVertex3f( 1.0f,-1.0f, 0.0f);  // Справа снизу
    glEnd();
    return true;        // Прорисовка прошла успешно
}

#include <windows.h>        // Заголовочные файлы для Windows
#include "glee.h"
#include "glut.h"
#include <stdlib.h>
#include <gl\gl.h>          // Заголовочные файлы для библиотеки OpenGL32
 
#define FBO_WIDTH  640
#define FBO_HEIGHT 480
 
GLuint frameBuffer;
GLuint fbTexture;
GLuint fbDepth;
 
GLsizei window_w, window_h;
HWND hWnd;
 
void initGL()
{
    //glEnable(GL_DEPTH_TEST);
    glEnable(GL_CULL_FACE);
    glCullFace(GL_BACK);
    glFrontFace(GL_CCW);
    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
}
 
void createFBO()
{
    glGenFramebuffersEXT(1, &frameBuffer); // создаем FBO
    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, frameBuffer); // делаем его текущим
 
    glGenTextures(1, &fbTexture);  // создаем текстуру
    glBindTexture(GL_TEXTURE_2D, fbTexture);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, FBO_WIDTH, FBO_HEIGHT, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 
    glGenRenderbuffersEXT(1, &fbDepth);   // создаем буфер глубины для FBO
    glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, fbDepth);
    glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, FBO_WIDTH, FBO_HEIGHT);
 
    // присобачиваем к FBO текстуру
    glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, fbTexture, 0);
    
    // присобачиваем к FBO буфер глубины
    glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, fbDepth);
 
    if(glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT) != GL_FRAMEBUFFER_COMPLETE_EXT)
    {
        MessageBox(NULL, "Cannot create FrameBuffer object", "Error", MB_OK | MB_ICONERROR);
        exit(1);
    }
    glClearColor(0.0, 0.0, 0.0, 0.0);
}
 
void renderToFBO()
{
    // включаем рисование в наш FBO
    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, frameBuffer);
    glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);
    glReadBuffer(GL_COLOR_ATTACHMENT0_EXT);
 
    glViewport(0, 0, FBO_WIDTH, FBO_HEIGHT);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
    // Устанавливаем матрицы
    glMatrixMode (GL_MODELVIEW);
    glLoadIdentity ();
    glMatrixMode (GL_PROJECTION);
    glLoadIdentity ();
 
    // рисуем...
    glColor3f(1.0f, 1.0f, 1.0f);
 
    glBegin(GL_TRIANGLES);
        glVertex3f(-0.5, -0.5, 0.0);
        glVertex3f(0.5, -0.5, 0.0);
        glVertex3f(0.0, 0.5, 0.0);
    glEnd();
 
    // переключаем рисование обратно в буфер кадра
    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); 
    glDrawBuffer(GL_BACK);
    glReadBuffer(GL_BACK);
}
 
void render()
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
    // рисуем в FBO
    renderToFBO();
 
    glViewport(0, 0, window_w, window_h);
 
    // включаем FBO-текстуру
    glBindTexture(GL_TEXTURE_2D, fbTexture);
    glEnable(GL_TEXTURE_2D);
 
    // Устанавливаем единичные матрицы для того, чтобы было
    // удобно рисовать квадратик на весь экран
    glMatrixMode (GL_MODELVIEW);
    glLoadIdentity ();
    glMatrixMode (GL_PROJECTION);
    glLoadIdentity ();
 
    // рисуем квадратик на весь экран
    glColor3f(1.0, 1.0, 1.0);
    glBegin(GL_QUADS);
        glTexCoord2f(0.0, 0.0);
        glVertex3f(-1.0, -1.0, 0.0);
 
        glTexCoord2f(1.0, 0.0);
        glVertex3f(1.0, -1.0, 0.0);
 
        glTexCoord2f(1.0, 1.0);
        glVertex3f(1.0, 1.0, 0.0);
 
        glTexCoord2f(0.0, 1.0);
        glVertex3f(-1.0, 1.0, 0.0);
    glEnd();
    
    // выключаем текстурирование (или выбираем другие текстуры и т.д.)
    glDisable(GL_TEXTURE_2D);
    
    // устанавливаем матрицы для рисования нашего объекта
    // (в данном случае единичные)
    glMatrixMode (GL_MODELVIEW);
    glLoadIdentity ();
    glMatrixMode (GL_PROJECTION);
    glLoadIdentity ();
 
    // рисуем объект
    glColor3f(1.0f, 0.0f, 0.0f);
    glBegin(GL_TRIANGLES);
        glVertex3f(-0.3, -0.3, 0.0);
        glVertex3f( 0.3, -0.3, 0.0);
        glVertex3f( 0.0,  0.3, 0.0);
    glEnd();
    glutSwapBuffers();
}
 
void onSize(GLsizei w, GLsizei h)
{
    window_w = w;
    window_h = h;
    render();
}
 
int main(int argc, char *argv[])
{
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
    hWnd = (HWND)glutCreateWindow("FBO");
    glutDisplayFunc(render);
    glutReshapeFunc(onSize);
    initGL();
    createFBO();
    glutMainLoop();
    return 0;
}