main.cpp

Go to the documentation of this file.

#include <iostream>
#include <vector>

#ifdef __APPLE__
#include <GraphicsLib/GraphicsLib.h>
        #include <GraphicsLib/ThreadTimer.h>
#else
#include "GraphicsLib.h"
#include "ThreadTimer.h"
#endif

#include <math.h>
#include "ParticleSystems.h"
#include "Debugger.h"

using namespace std;
using namespace GraphicsLib;
using namespace ParticleSystems;

Emitter *emit;
DataStructure *dataParticle;
ParticleSystem *particleSys;

ParticleSystemManager *manager;

int WIDTH = 1024;
int HEIGHT = 800;

int FRAMESPERSEC = 25;

// The global camera
Camera Cam;
// the values to spin the main window by in x y and z
int spinxface = 0 ;
int spinyface = 0 ;
int spinzface = 0 ;
int  origx,origy,origz,RotateXY,RotateXZ=0;
int Rotate;

void MakeFloor()
{
const static GLfloat FSIZE=10.0;
glPushMatrix();
        glDisable(GL_LIGHTING);
        glColor3f(0.2,0.2,0.2); 
        glBegin(GL_QUADS);
                glVertex3d(-FSIZE,0,-FSIZE); 
                glVertex3d(FSIZE,0,-FSIZE);
                glVertex3d(FSIZE,0,FSIZE); 
                glVertex3d(-FSIZE,0,FSIZE);
        glEnd();
        glColor3f(0.6,0.6,0.6);

        for(int x=-10; x<10; x++)
        {
        glBegin(GL_LINES);
                glVertex3d(x,0,FSIZE); 
                glVertex3d(x,0,-FSIZE);
        glEnd();
        glBegin(GL_LINES);
                glVertex3d(FSIZE,0,x); 
                glVertex3d(-FSIZE,0,x);
        glEnd();
        }
glPopMatrix();
glEnable(GL_LIGHTING);
}

void display()
{
        //start the timer
        int start = GetThreadTimeMS();
        #ifdef __TIMER__
        std::cout << "VectorDS: time start " << start  << std::endl;
        #endif
        // clear the current buffer
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        // save the current transformation matrix
        // turn on the lights
        glPushMatrix();
                //rotate the global scene based on the mouse rotations
                glRotated       ( (GLdouble) spinxface, 1.0, 0.0, 0.0 ) ;
                glRotated       ( (GLdouble) spinyface, 0.0, 1.0, 0.0 ) ;
                glRotated       ( (GLdouble) spinzface, 0.0, 0.0, 1.0 ) ;
                
                //draw the x, y, z axis
                DrawAxis(5);
                //MakeFloor();
                #ifdef __PERFORMANCE__
                        cout << "main: render" << endl;
                #endif
                //draw all the ParticleSystems
                manager->render();
                #ifdef __PERFORMANCE__
                        cout << "main: update" << endl;
                #endif
                
                //update all the ParticleSystems
                manager->update();
                #ifdef __PERFORMANCE__
                        cout << "main: update finished" << endl;
                #endif
        //glRecti(-10,-10,10,10);

        glPopMatrix();
        // render the scene
        glutSwapBuffers();
        //take the time how long it took
        int end_time = GetThreadTimeMS();
        
        //check if we need to wait
        while(end_time < start+FRAMESPERSEC) {
                end_time = GetThreadTimeMS();
        }
        #ifdef __TIMER__
        std::cout << "VectorDS: time end " << end_time << std::endl;
        #endif
}




void update()
{
    glutPostRedisplay();
}

void initPSManager()
{
    manager = new ParticleSystemManager();
}



void multiCollision() {
        //constrain for the RandomForce
        Vector *constrain = new Vector(0.0,0.0,0.0);

        //First ParticleSystem inital Velocity
        Vector *initVelocity2 = new Vector(0,0.05,0.1);
        
        //Second ParticleSystem inital Velocity
        Vector *initVelocity3 = new Vector(0.1,0.05,0.0);
        
        //The inital Colour
        Colour *colour = new Colour(0.0,0.0,1.0,1.0);
        colour->set(0.0,0.0,1.0,1.0);
        
        //No flare colour
        Colour *flare = new Colour(0.0,0.0,0.0,0.00);
        flare->set(0.0,0.0,0.0,0.00);
        
        //The Vector for the Gravity
    Vector *gravCon = new Vector(0,-0.005,0);
        
        //The Emitter position for the first ParticleSystem
        Point3 emitPoint = new Point3(0,1,0);
        
        //The Emitter position for the second ParticleSystem
        Point3 emitPoint2 = new Point3(-5,1,7);

        //A random force
        RandomForce *rf = new RandomForce(constrain, 0.01);
        
        //The Gravity force
        GravityForce *f = new GravityForce(gravCon, 1, 0.9);
        
        //The Solver with both forces added
        StraightSolver *solver = new StraightSolver();
        solver->addForce(rf);
    solver->addForce(f);

        //The first emitter
    Emitter *emit2 = new PointEmitter(manager->getNextID(), solver, Emitter::STRIKE, (*initVelocity2),(*colour),0.1,"/Users/hannes/Documents/Uni/Bournemouth/Term2/ProgrammingGFX/ParticleSystem/smoke2.tga", emitPoint,0.05);
        emit2->flareColor = (*flare);
        emit2->particleLife = 100;
        
        //The second emitter
        Emitter *emit3 = new PointEmitter(manager->getNextID(), solver, Emitter::STRIKE, (*initVelocity3),(*colour),0.1,"/Users/hannes/Documents/Uni/Bournemouth/Term2/ProgrammingGFX/ParticleSystem/smoke2.tga", emitPoint2,0.05);
        emit3->flareColor = (*flare);
        emit3->particleLife = 100;

    //The dataStructures for both ParticleSystems
    DataStructure *data2 = new VectorDS();
        DataStructure *data3 = new VectorDS();
        
        //The position of the CollisionSphere
        Point3 *sPoint = new Point3(0,-4,8);
        //The radius
        Real radius = 2.0;
        CollisionSphere *sphere = new CollisionSphere(sPoint, radius);
        
        //add it to both
    data2->addCollisionObject(sphere);
        data3->addCollisionObject(sphere);
    //data2->addCollisionObject(collide);
        //turn on collision
    data2->collision = true;
        data3->collision = true;

    ParticleSystem *particleSys2 = new ParticleSystem(manager->getNextID(), emit2, data2, solver, 1000,1000);
        
    manager->addSystem(particleSys2);
        
        ParticleSystem *particleSys3 = new ParticleSystem(manager->getNextID(), emit3, data3, solver, 1000,1000);
        
        manager->addSystem(particleSys3);

}

void fire() {
        
    Vector *constrain = new Vector(0.1,0.1,0.1);

        Vector *initVelocity = new Vector(0,0.5,0);

        Colour *colour = new Colour(0.5,0.5,0.5,1.0);
        colour->set(0.75,0.5,0.25,1.0);

        Colour *flare = new Colour(0.05,0.05,0.05,0.00);
        flare->set(0.05,0.05,0.05,0.00);

    Vector *gravCon = new Vector(0,-0.1,0);
        Vector *x = new Vector(20,0,0);
        Vector *z = new Vector(0,0,20);

        Point3 midPoint = new Point3(0,0,0);
        RandomForce *rf = new RandomForce(constrain, 1);
        GravityForce *f = new GravityForce(gravCon, 1, 0.5);

        StraightSolver *solver = new StraightSolver();
        solver->addForce(rf);
    //solver->addForce(f);

        /******** SYSID ******/
    emit = new PlanarEmitter(1, solver, Emitter::IMAGE,(*initVelocity),(*colour),0.5,"/Users/hannes/Documents/Uni/Bournemouth/Term2/ProgrammingGFX/ParticleSystem/Particle.tga",(*x), (*z));
    emit->flareColor = (*flare);
        emit->particleSizeFlare = 0.03;
        emit->particleLife = 30;

    dataParticle = new VectorDS();

    particleSys = new ParticleSystem(manager->getNextID(), emit, dataParticle, solver, 1000,5000);

    manager->addSystem(particleSys);
}

void smoke() {
    Vector *constrain = new Vector(0.1,0.1,0.1);

        Vector *initVelocity = new Vector(0,0.5,0);

        Colour *colour = new Colour(0.5,0.5,0.5,1.0);
        colour->set(0.5,0.5,0.5,0.3);

        Colour *flare = new Colour(0.05,0.05,0.05,0.00);
        flare->set(0.0,0.0,0.0,0.00);

    Vector *gravCon = new Vector(0,-0.1,0);
        Vector *x = new Vector(20,0,0);
        Vector *z = new Vector(0,0,20);

        Point3 midPoint = new Point3(0,0,0);
        //UniformForce *f = new UniformForce(constrain, 1);
        RandomForce *rf = new RandomForce(constrain, 1);
        GravityForce *f = new GravityForce(gravCon, 1, 0.5);

        StraightSolver *solver = new StraightSolver();
        solver->addForce(rf);
    //solver->addForce(f);

        /******** SYSID ******/
    emit = new PlanarEmitter(1, solver, Emitter::IMAGE,(*initVelocity),(*colour),0.5,"/Users/hannes/Documents/Uni/Bournemouth/Term2/ProgrammingGFX/ParticleSystem/smoke2.tga",(*x), (*z));
    emit->flareColor = (*flare);
        emit->particleSizeFlare = 0.01;
        emit->particleLife = 20;

    dataParticle = new VectorDS();

    //manager = new ParticleSystemManager(dataParticle);

    particleSys = new ParticleSystem(manager->getNextID(), emit, dataParticle, solver, 1000,2000);


    manager->addSystem(particleSys);
}

void init() {
        initPSManager();
}

void InitGL()
{
glClearColor(0.5f, 0.5f, 0.5f, 1.0f);                   
// render things smoothly
glShadeModel(GL_SMOOTH);
// enable the default light
glEnable(GL_LIGHT0);
// set the ambient colour to dark grey

GLfloat AmbColour[]={0.2,0.2,0.2};
glLightModelfv(GL_LIGHT_MODEL_AMBIENT,AmbColour);
// setup the Camera
Point3 Eye(15.0f,15.0f,15.0f);
Point3 Look(0.0f,0.0f,0.0f);
Vector Up(0.0f,1.0f,0.0f); //Y == UP

Cam.set(Eye,Look,Up);
Cam.setShape(45,640.0/480.0,0.5,150);
glEnable(GL_LIGHTING);
glEnable(GL_COLOR_MATERIAL);
glColorMaterial(GL_FRONT,GL_AMBIENT_AND_DIFFUSE);
glHint(GL_PERSPECTIVE_CORRECTION_HINT,GL_NICEST);
glHint(GL_POINT_SMOOTH_HINT,GL_NICEST);
glEnable(GL_NORMALIZE);

}


void resetPMManager()
{
        manager->reset();
        manager->restart();
}


void KeyPressed(unsigned char ch, int x, int y)
{
  switch (ch)
  {
  // ESC key to exit program
                  case 27 : exit(0); break;
                  case 'p' : manager->pause(); break;
                  case 'r' : resetPMManager(); break;
                  case 's' : initPSManager(); smoke(); break;
                  case 'f' : initPSManager(); fire(); break;
                  case 'm' : initPSManager(); multiCollision(); break; 
                  case 't' : initPSManager(); smoke(); fire(); break;
                  //case 'c' : ChangeParticleType(); break;
  }
  // tell the system we need to redisplay
 glutPostRedisplay();
}



void SpecialKeyPressed(int key, int x, int y)
{
    switch (key)
    {
    // slide the camera left right up and down
    case GLUT_KEY_LEFT  :
                Cam.slide(0.5,0.0,0.0);
        break;
    case GLUT_KEY_UP    :
        Cam.slide(0.0,-0.5,0.0);
        break;
        case GLUT_KEY_RIGHT     :
                Cam.slide(-0.5,0.0,0.0);
    break;
        case GLUT_KEY_DOWN      :
        Cam.slide(0.0,0.5,0.0);
        break;
    //slide the camera along the z axis
        case GLUT_KEY_PAGE_UP   :
        Cam.slide(0.0,0.0,0.5);
                break;
        case GLUT_KEY_PAGE_DOWN :
        Cam.slide(0.0,0.0,-0.5);
                break;

        //turn the mouse rotate on and off

    }
 //redisplay the scene
glutPostRedisplay();
}


void motion ( int x, int y )
{
 if (Rotate) {
         spinyface = ( spinyface + (x - origx) ) % 360 ;
         spinxface = ( spinxface + (y - origy) ) % 360 ;
         origx = x;
         origy = y;
         glutPostRedisplay();
  }
}

static void Button(int button, int down, int x, int y)
{
Rotate = 0;
  switch(button)
  {
  case GLUT_LEFT_BUTTON:
         if (down == GLUT_DOWN)
        {
                origx = x;
                origy = y;
                Rotate = 1;
        }
     else Rotate = 0;
   break;
   }
}

void intro() {
        std::cout << "Welcome to Hannes Ricklefs ParticleSystem" << std::endl;
        std::cout << "There are 4 different demo scenes" << std::endl;
        std::cout << "1) Smoke can be viewed by pressing s" << std::endl;
        std::cout << "2) Fire can be viewed by pressing f" << std::endl;
        std::cout << "3) Fire and smoke together can be viewed by pressing t" << std::endl;
        std::cout << "4) Two ParticleSystems colliding with a CollisionSphere can be viewed by pressing m" << std::endl;
        std::cout << "To restart any of the demos press r" << std::endl;
        std::cout << "To pause any of the demos press p" << std::endl;
        std::cout << "To quit press esc" << std::endl;
        std::cout << "You can fly arround the scene by using your mouse or " << std::endl;
        std::cout << "by using the arrow keys";
        std::cout << "To zoom in and out use the page up and down keys" << std::endl;
}


int main(int argc, char **argv)
{
    init();
        // set the rng seed
        srand(time(NULL));
        // get how many particles to create
        //initPSManager(200);
        glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DEPTH | GLUT_RGBA | GLUT_DOUBLE |GLUT_ALPHA |GLUT_ACCUM);
        glutInitWindowSize(WIDTH, HEIGHT);
    glutCreateWindow("ParticleSystem :: Hannes Ricklefs");
        //set the time to the current time
    //load the glut callbacks
    glutDisplayFunc(display);
    //glutIdleFunc(idle);

        glutMouseFunc(Button);
    glutMotionFunc(motion);
    glutKeyboardFunc(KeyPressed);
    glutSpecialFunc(SpecialKeyPressed);
        glutIdleFunc(update);
        intro();
        //initialise opengl
    InitGL();
        glutMainLoop();
        //this never gets called due to glutmainloop not exiting properly
    return 1;
}


//end of file

---