class CParticle
{
public:
        CParticle() {};
        virtual ~CParticle() {};

};

class CParticleSystem
{
public:
        CParticleSystem() {}
        ~CParticleSystem() {}

        virtual HRESULT ResetSystem() = 0;
virtual void UpdateSystem(DWORD TimePassed) = 0;
virtual HRESULT RenderSystem() = 0;
        virtual HRESULT PSSendMessage(DWORD param1, DWORD param2) { return TRUE; }
};

class CFountainParticle : public CParticle
{
public:
        CFountainParticle() {}
        VECTOR Position;
        VECTOR OldPos;
        VECTOR Velocity;
        VECTOR Acceleration;
        int Age;
        float Size;
};

class CFountain : public CParticleSystem
{
public:
        int m_iTimeRandFactor;
        int m_iMinTime;
        DWORD m_iMaxParts;
        VECTOR m_Velocity;
        VECTOR m_Acceleration;
        VECTOR m_RandomFactor;
        VECTOR m_SystemOrigin;
        int m_iKillDown;
        float m_fPartSize;
        int m_iKillValue;

        CFountainParticle *Particles;

CFountain :: CFountain()
{
        m_Velocity     = VECTOR(0, 0, 0.07f);
        m_Acceleration = VECTOR(0, 0, -0.001f);
        m_SystemOrigin = VECTOR(0, 0, 0);
        m_RandomFactor = VECTOR(0.03f, 0.03f, 0.05f);

        m_iMinTime   = 2000;
        m_iTimeRandFactor = 500;
        m_iMaxParts  = 200;
        m_fPartSize  = 1;
        m_iKillValue = 0;
        m_iKillDown  = AXE_Z;

        Particles = new CFountainParticle[m_iMaxParts];
}

CFountain :: ~CFountain()
{
        delete Particles;
}

HRESULT CFountain :: ResetSystem()
{
        for(DWORD i=0;i < m_iMaxParts;i++) SetParticleDefaults(i);
        return S_OK;
}

void CFountain :: SetParticleDefaults(int i)
{
        Particles[i].Position = m_SystemOrigin;
        Particles[i].Velocity = VECTOR( m_Velocity.x + m_RandomFactor.x * RandFloatZ,
                                        m_Velocity.y + m_RandomFactor.y * RandFloatZ,
                                                m_Velocity.z + m_RandomFactor.z * RandFloatZ);
        Particles[i].Acceleration = m_Acceleration;
        Particles[i].Age = m_iMinTime + (int)(RandFloat * (float)m_iTimeRandFactor);
}

void CFountain :: UpdateSystem(DWORD TimePassed)
{
        for (DWORD i=0; i < m_iMaxParts; i++)
        {
                Particles[i].Position = Particles[i].Position + (Particles[i].Velocity * (float)TimePassed);
                Particles[i].Velocity = Particles[i].Velocity + Particles[i].Acceleration;
                if (CheckForDown(i)) SetParticleDefaults(i);
                Particles[i].Age -= TimePassed;
                if (Particles[i].Age < 0) SetParticleDefaults(i);
        }
}

#define AXE_X 1
#define AXE_Y 2
#define AXE_Z 3

int CFountain :: CheckForDown(int i)
{
        switch(m_iKillDown)
        {
        case 0:
                return FALSE;
                break;
        case AXE_X:
                if(Particles[i].Position.x < m_iKillValue) return TRUE;
                break;
        case AXE_Y:
                if(Particles[i].Position.y < m_iKillValue) return TRUE;
                break;
        case AXE_Z:
                if(Particles[i].Position.z < m_iKillValue) return TRUE;
                break;
        default: break;
        }
        return FALSE;
}

HRESULT CFountain :: RenderSystem()
{
        glEnable(GL_POINT_SMOOTH);
        glPointSize(3);
        glBegin(GL_POINTS);
        for( DWORD i=0; i < m_iMaxParts; i++ )
        {
                glVertex3f(
                        Particles[i].Position.x,
                        Particles[i].Position.y,
                        Particles[i].Position.z);
        }
        glEnd();

        return S_OK;
}

#define RandFloat  ((float)(rand()%1000)/1000.0f)
#define RandFloatZ ((float)((rand()%1000)-500)/1000.0f)
#define RandFloatHalf ((float)(rand()%500)/500.0f+0.5f)

class VECTOR
{
public:
        float x, y, z;  // координаты вектора

        VECTOR(float nx, float ny, float nz) // конструктор с заданием параметров
        {
                x = nx;
                y = ny;
                z = nz;
        }
        VECTOR(){} // конструктор без задания параметров

        inline VECTOR operator+(const VECTOR &src) // сложение векторов
        {
                VECTOR nv;
                nv.x = x + src.x;
                nv.y = y + src.y;
                nv.z = z + src.z;

                return nv;
        }

        inline VECTOR operator*(const float f) // умножение вектора на число
        {
                VECTOR nv;
                nv.x = x * f;
                nv.y = y * f;
                nv.z = z * f;

                return nv;
        }
};

// константы
#define MAX_PS 100
#define MIN_TIME_LIVE 10

// описание ПС'ы
typedef struct
{
        CParticleSystem *ps; // указатель на ПС (вот зачем нужны базовые классы)
        BYTE blive;  // определяет время жизни ПС
        DWORD TimeLive;
}DescriptPS;

//Описание класса
class CParticleManager
{
private:
        // описания ПС
        DescriptPS m_PS[MAX_PS];
        // количество созданных ПС
        int m_numPS;
public:
        CParticleManager();
        virtual ~CParticleManager();

// Non comments
        HRESULT Move(DWORD);
        void DeletePS(int numPS);
        HRESULT Render();
        virtual HRESULT PSSendMessage(int nPS, DWORD param1, DWORD param2)
                { return m_PS[nPS].ps->PSSendMessage(param1,param2); }

// А так создаем нашу, пока единственную, ПС.
        void AddPSFountain()
        {
                m_PS[m_numPS].ps = new CFountain();
                m_PS[m_numPS].blive = FALSE;
                m_PS[m_numPS].AutoDraw = TRUE;
                m_numPS++;
        }
};

// Описание функций
CParticleManager::CParticleManager()
{
        m_numPS = 0;
}

CParticleManager::~CParticleManager()
{
        for(int i=0;i < m_numPS;i++)
        {
                delete m_PS[i].ps;
        }
}

HRESULT CParticleManager::Render()
{
        glEnable(GL_BLEND);
        glDepthMask(0);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE);

        for(int i=0;i < m_numPS;i++)
        {
                m_PS[i].ps->RenderSystem();
        }

        glDepthMask(1);
        glDisable(GL_BLEND);

        return S_OK;
}
// Удаляем ПС
void CParticleManager::DeletePS(int numPS)
{
        m_numPS--;
        m_PS[numPS].ps = m_PS[m_numPS].ps;
        m_PS[numPS].blive = m_PS[m_numPS].blive;
        m_PS[numPS].TimeLive = m_PS[m_numPS].TimeLive;

        delete m_PS[numPS].ps;
        m_PS[numPS].ps       = NULL;
        m_PS[numPS].blive    = FALSE;
        m_PS[numPS].TimeLive = 0;
}

HRESULT CParticleManager::Move(DWORD tic)
{
        for(int i=0;i < m_numPS;i++)
        {
        // учитывается возможность временного существования ПС
                if(m_PS[i].blive == TRUE)
                {
                        m_PS[i].TimeLive -= tic;
                        if(m_PS[i].TimeLive < 0)
                        {
                                DeletePS(i);
                                i--;
                                continue;
                        }
                }
                m_PS[i].ps->UpdateSystem(tic);
        }
        return S_OK;
}

while (GetMessage(&msg, NULL, 0, 0) == TRUE) {
                TranslateMessage(&msg);
                DispatchMessage(&msg);
}

на:

BOOL bGotMsg;
PeekMessage( &msg, NULL, 0U, 0U, PM_NOREMOVE );
m_bActive = TRUE;

while( WM_QUIT != msg.message  )
{
        if( m_bActive )
                bGotMsg = PeekMessage( &msg, NULL, 0U, 0U, PM_REMOVE );
        else
                bGotMsg = GetMessage( &msg, NULL, 0U, 0U );

        if( bGotMsg )
        {
                if( 0 == TranslateAccelerator( hWnd, NULL, &msg ) )
                {
                        TranslateMessage( &msg );
                        DispatchMessage( &msg );
                }
        }
        else
        {
                if( m_bActive && m_bReady )
                {
                        redraw();
                }
        }
}

case WM_CREATE:
                hDC = GetDC(hWnd);
                setupPixelFormat(hDC);
                hGLRC = wglCreateContext(hDC);
                wglMakeCurrent(hDC, hGLRC);
                Init();
                m_bReady = TRUE;
                break;

void setupPixelFormat(HDC hDC)
{
    PIXELFORMATDESCRIPTOR pfd = {
        sizeof(PIXELFORMATDESCRIPTOR),  /* size */
        1,                              /* version */
        PFD_SUPPORT_OPENGL |
        PFD_DRAW_TO_WINDOW |
        PFD_DOUBLEBUFFER,               /* support double-buffering */
        PFD_TYPE_RGBA,                  /* color type */
        16,                             /* prefered color depth */
        0, 0, 0, 0, 0, 0,               /* color bits (ignored) */
        0,                              /* no alpha buffer */
        0,                              /* alpha bits (ignored) */
        0,                              /* no accumulation buffer */
        0, 0, 0, 0,                     /* accum bits (ignored) */
        16,                             /* depth buffer */
        0,                              /* no stencil buffer */
        0,                              /* no auxiliary buffers */
        PFD_MAIN_PLANE,                 /* main layer */
        0,                              /* reserved */
        0, 0, 0,                        /* no layer, visible, damage masks */
    };
    int pixelFormat;

    pixelFormat = ChoosePixelFormat(hDC, &pfd);
    if (pixelFormat == 0) {
        MessageBox(WindowFromDC(hDC), "ChoosePixelFormat failed.", "Error",
                MB_ICONERROR | MB_OK);
        exit(1);
    }

    if (SetPixelFormat(hDC, pixelFormat, &pfd) != TRUE) {
        MessageBox(WindowFromDC(hDC), "SetPixelFormat failed.", "Error",
                MB_ICONERROR | MB_OK);
        exit(1);
    }
}

void Init()
{
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        glOrtho(-64,64, -48,48, -700,700);
        gluLookAt(0,0,5, 0,0,0, 0,1,0);
        glMatrixMode(GL_MODELVIEW);
        glEnable(GL_DEPTH_TEST);
        PM.AddPSFountain();
}

case WM_DESTROY:
        m_bReady = FALSE;
        if (hGLRC)
        {
                wglMakeCurrent(NULL, NULL);
                wglDeleteContext(hGLRC);
        }
        ReleaseDC(hWnd, hDC);
        PostQuitMessage(0);
        break;

case WM_KEYDOWN:
        if(wParam == 'P') g_bPause = !g_bPause;
        break;

void redraw()
{
        static dwLastTime = timeGetTime();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        DWORD time = timeGetTime() - dwLastTime;
        dwLastTime += time;
        if(!g_bPause) PM.Move(time);
        PM.Render();

SwapBuffers(hDC);
}

pVertices[0].vec = TransPos+VECTOR(-PartSize,  PartSize,0);
pVertices[1].vec = TransPos+VECTOR( PartSize,  PartSize,0);
pVertices[2].vec = TransPos+VECTOR(-PartSize, -PartSize,0);
pVertices[3].vec = TransPos+VECTOR( PartSize, -PartSize,0);

// простой пример класса, хранящий строку и функцию вывода этой строки
class MyClass
{
MyClass() {}
~MyClass() {}
        char str[255];
        void Print()
{
        cout << str << '\n';
}
}

// определяем тип MyVector - как вектор с типом данных (MyClass*)
typedef std::vector< MyClass* > MyVector;

// Определяем переменную
MyVector vec;

// пихаем пару объектов в вектор
MyClass *p = new MyClass;
lstrcpy(p1->str, "str1");
vec.push_back(p);

p = new MyClass;
lstrcpy(p->str, "str2");
vec.push_back(p);

p = new MyClass;
lstrcpy(p->str, "str3");
vec.push_back(p);

┘

// выводим эти строки на экран
for(MyClass **it = vec.begin(); it!=vec.end; it++)
{
        (*it)->Print();
}