Updated OpenGL

#include <stdafx.h>
#include<stdlib.h>
#include<Windows.h>
#include <time.h>
#include <GL\glut.h>
#include<GL\GLU.h>

#define MAX_PARTICLES 100
#define MAX_BOUNCE_COUNT 10
#define MAX_PARTICLE_AGE 20

//Colours
float R = 0.8f;
float G = 0.2f;
float B = 0.0f;
float cR = 0.001f;
float cG = 0.002f;
float cB = 0.003f;
float Size = 0.01f; //size for points
GLuint txParticle;

struct PARTICLE {
    float X,Y,Z; // Current position
    float sX,sY,sZ; // Current Speed/Movement
    float tX,tY,tZ; // Target Speed/Movement
    float R,B,G; // Particle Colour
    bool Active; // Is particle Active
    int Age; // Age of the particle
    int MaxAge; // Maximum Age before particle dies
    int BounceCount;
} Particles[MAX_PARTICLES];

void Init_Particles();
void Activate_Particles();
void Adjust_Particles();
void Render_Particles();
bool LoadBitmapTexture(char * FileName, GLuint &texid);
void idle();
void DrawGLscene();
void Reshape(GLsizei w, GLsizei h);


int main(int argc, char** argv){
    glutInit(&argc,argv);
    glutCreateWindow("Particle fountain");
    Init_Particles();
    glutDisplayFunc(DrawGLscene);
    glutIdleFunc(idle);
    glutReshapeFunc(Reshape);
    glutMainLoop();
}

void DrawGLscene(){

    glTranslatef(0.0f, -0.05f, 0.0f);
    Render_Particles();
    glFlush();
}

void Reshape(GLsizei w,GLsizei h){
    // resize viewport to new canvas size
    glViewport(0, 0, w, h);
    // change clipping region to have same w:h ratio as canvas
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();

    if (w <= h)
        gluOrtho2D(-1.0, 1.0, -1.0 * h/w, 1.0 * h/w);
    else
        gluOrtho2D(-1.0 * w/h, 1.0 * w/h, -1.0, 1.0);
}

void idle(){
    Activate_Particles();
    Adjust_Particles();
    glutPostRedisplay();
}

void Init_Particles(){
    int p;
    LoadBitmapTexture("./Particle.bmp", txParticle);
    srand((int)time(NULL));
    for(p=0; p<MAX_PARTICLES; p++){
        Particles[p].Active = false;
        Particles[p].tX = 0.0f;
        Particles[p].tY = -0.1f;
        Particles[p].tZ = 0.0f;
    }
}

void Activate_Particles(){
    int p;
    for(p=0; p<MAX_PARTICLES; p++){
        if(!Particles[p].Active){
            // Start the particle at 0,0,0 origin
            Particles[p].X = 0.0f;
            Particles[p].Y = 0.0f;
            Particles[p].Z = 0.0f;
            // The following lines set a random speed value
            Particles[p].sX = (((float)((rand() % 100) + 1)) /
                1000.0f) - 0.05f;
            Particles[p].sY = (((float)((rand() % 100) + 50)) /
                500.0f);
            Particles[p].sZ = (((float)((rand() % 100) + 1)) /
                1000.0f) - 0.05f;
            // We also activate the particle
            Particles[p].Active = true;
            // Set it's Age to zero
            Particles[p].Age = 0;
            // We also assign a max age to the particles
            Particles[p].MaxAge = MAX_PARTICLE_AGE;
            // We Also reset the bouncecount to zero
            Particles[p].BounceCount = 0;

            Particles[p].R = R;
            Particles[p].G = G;
            Particles[p].B = B;
            R+=cR;
            G+=cG;
            B+=cB;
            if(R>1.0f){R=1.0f; cR=-cR;}
            if(R<0.0f){R=0.0f; cR=-cR;}
            if(G>1.0f){G=1.0f; cG=-cG;}
            if(G<0.0f){G=0.0f; cG=-cG;}
            if(B>1.0f){B=1.0f; cB=-cB;}
            if(B<0.0f){B=0.0f; cB=-cB;}
            return;
        }
    }
}

void Adjust_Particles(){
    int p;
    for(p=0; p<MAX_PARTICLES; p++){
        // We move the speed towards the target speed by 1/20 (5%)
        Particles[p].sX+= (Particles[p].tX - Particles[p].sX) / 20.0f;
        Particles[p].sY+= (Particles[p].tY - Particles[p].sY) / 20.0f;
        Particles[p].sZ+= (Particles[p].tZ - Particles[p].sZ) / 20.0f;
        // Then we adjust the position of
        // the particle by the new speed
        Particles[p].X+= Particles[p].sX;
        Particles[p].Y+= Particles[p].sY;
        Particles[p].Z+= Particles[p].sZ;
        // Now for the bounce code.
        if(Particles[p].Y < 0.0f){
            Particles[p].Y = 0.0f;
            Particles[p].sY = -Particles[p].sY;
            Particles[p].BounceCount++;
            if(Particles[p].BounceCount > MAX_BOUNCE_COUNT){
                Particles[p].Active = false;
            }
        }
        // And finally the age check
        Particles[p].Age++;
        if(Particles[p].Age > Particles[p].MaxAge){
            Particles[p].Active = false;
        }
}
}

void Render_Particles(){
    int p;
    // Enable textures and bind our particle texture
    glEnable(GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, txParticle);
    // Disable Depth testing.
    glDisable(GL_DEPTH_TEST);
    // Enable blending
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_COLOR,GL_ONE);
    for(p=0; p<MAX_PARTICLES; p++){
        if(Particles[p].Active){
            glColor4f(Particles[p].R,
                Particles[p].G,
                Particles[p].B, 1.0f);
            glPushMatrix();
            glTranslatef(Particles[p].X,
                Particles[p].Y,
                Particles[p].Z);
            glBegin(GL_QUADS);
            glNormal3f(0.0f, 0.0f, 1.0f);
            glTexCoord2f(0.0f, 0.0f);
            glVertex3f(-Size, -Size, 0.0f);
            glTexCoord2f(1.0f, 0.0f);
            glVertex3f(Size, -Size, 0.0f);
            glTexCoord2f(1.0f, 1.0f);
            glVertex3f(Size, Size, 0.0f);
            glTexCoord2f(0.0f, 1.0f);
            glVertex3f(-Size, Size, 0.0f);
            glEnd();
            glPopMatrix();

        }
    }
}

bool LoadBitmapTexture(char * FileName, GLuint &texid){
    HBITMAP hBMP; // Handle Of The Bitmap
    BITMAP BMP; // Bitmap Structure
    glGenTextures(1, &texid); // Create The Texture
    hBMP=(HBITMAP)LoadImage(GetModuleHandle(NULL),
        FileName,
        IMAGE_BITMAP, 0, 0,
        LR_CREATEDIBSECTION | LR_LOADFROMFILE
        );
    if (!hBMP) // Does The Bitmap Exist?
        return FALSE; // If Not Return False
    GetObject(hBMP, sizeof(BMP), &BMP); // Get The Object
    // hBMP: Handle To Graphics Object
    // sizeof(BMP): Size Of Buffer For Object Information
    // &BMP: Buffer For Object Information
    glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
    // Pixel Storage Mode (Word Alignment / 4 Bytes)
    // Typical Texture Generation Using Data From The Bitmap
    glBindTexture(GL_TEXTURE_2D, texid);// Bind To The Texture ID
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
        GL_LINEAR); // Linear Min Filter
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
        GL_LINEAR); // Linear Mag Filter
    glTexImage2D(GL_TEXTURE_2D, 0, 3, BMP.bmWidth, BMP.bmHeight,
        0, GL_BGR_EXT, GL_UNSIGNED_BYTE, BMP.bmBits);
    DeleteObject(hBMP); // Delete The Object
    return TRUE; // Loading Was Successful
}