C++ ParticleEmitter::update方法代码示例

void ParticleSystem::updateEmitters( float milliseconds )
{
	for(EmitterSet::const_iterator i=emitters.begin(); i!=emitters.end(); ++i)
	{
		ParticleEmitter *emitter = *i;
		emitter->update(milliseconds);
	}
}

void ParticleSystem::update(float delta) {
    if (sprite == NULL) {
        std::cout << "sprite was null" << std::endl;
        return;
        return;
    }
    removeMe.clear();

    //std::cout << "1" << std::endl;


    for(unsigned int i = 0; i < emitters.size(); i++) {
        ParticleEmitter* emitter = emitters.at(i);
        if (emitter->isEnabled()) {
            //std::cout << "en" << std::endl;
            emitter->update(this, delta);
            //std::cout << "en2" << std::endl;
            if (removeCompletedEmitters) {
                if (emitter->isComplete()) {
                    removeMe.push_back(emitter);
                    particlesByEmitter.erase(emitter);
                }
            }
        }
    }

    //std::cout << "2" << std::endl;

    // remove items in removeMe from emitters.
    vector<ParticleEmitter*>::iterator ito = emitters.begin();
    while (ito != emitters.end()) {
        ParticleEmitter* e = (*ito);

        vector<ParticleEmitter*>::iterator ito2 = removeMe.begin();
        while (ito2 != removeMe.end()) {
            ParticleEmitter* e2 = (*ito2);

            if (e == e2) {
                ito = emitters.erase(ito);
                continue;
            }

            ito2++;
        }

        ito++;
    }

    //std::cout << "3" << std::endl;

    pCount = 0;

    if (!particlesByEmitter.empty()) {
        //std::cout << "4: " << particlesByEmitter.size() << std::endl;
        map<ParticleEmitter*, ParticlePool*>::iterator it = particlesByEmitter.begin();
        while (it != particlesByEmitter.end()) {
            ParticleEmitter* emitter = it->first;
            if (emitter->isEnabled()) {
                ParticlePool* pool = it->second;
                //std::cout << "5" << std::endl;
                for (unsigned int i = 0; i < pool->particlesActive.size(); i++) {
                    if (pool->particlesActive.at(i)->getLife() > 0) {
                        pool->particlesActive.at(i)->update(delta);
                        pCount++;
                    }
                }
            }
            it++;
            //std::cout << "6" << std::endl;
        }
    }
}

// main program
int main (int argc, char * const argv[])
{
	argc;
	argv;
	bool success = false;
	srand(1);

	// initialize timers:------------------------------
		// Initialize timer
		timer::initTimer();

		// Create a global Timer
		globalTimer::create();

		// Create a timer objects
		timer updateTimer;
		timer drawTimer;

	// create a window:---------------------------------
		success = OpenGLDevice::InitWindow();
		assert(success);
	
	// create an emitter:-------------------------------
		ParticleEmitter emitter;

	// Get the inverse Camera Matrix:-------------------

		// initialize the camera matrix
		Matrix cameraMatrix;
		cameraMatrix.setIdentMatrix();

		// setup the translation matrix
		Matrix transMatrix;
		Vect4D trans(0.0f,3.0f,10.0f);
		transMatrix.setTransMatrix( trans );

		// multiply them together
		Matrix tmp;
		tmp = cameraMatrix * transMatrix;

		// get the inverse matrix
		Matrix inverseCameraMatrix;
		tmp.Inverse(inverseCameraMatrix);

	// counter for printing
	int i = 0;

	// main update loop... do this forever or until some breaks 
	while(OpenGLDevice::IsRunning())
	{
		// start update timer ---------------------------------------
		updateTimer.tic();

			// start draw... end draw (the draw updates)
			OpenGLDevice::StartDraw();
		
			// set matrix to Model View
			// push the inverseCameraMarix to stack
			glMatrixMode(GL_MODELVIEW);
			glLoadMatrixf(reinterpret_cast<float*>(&inverseCameraMatrix));
			glPushMatrix(); // push the camera matrix

			// update the emitter
			emitter.update();

		// stop update timer: -----------------------------------------
		updateTimer.toc();

		// start draw timer: ----------------------------------------
		drawTimer.tic();

			// draw particles
			emitter.draw();
		
			// pop matrix - needs to correspond to previous push
			glPopMatrix();

		// stop draw timer: -----------------------------------------
		drawTimer.toc();

		// finish draw update
		OpenGLDevice::EndDraw();

		// Love for Windows - allows the windows to behave to external events
		EventHandler::ProcessEvents();

		// update ouput every 50 times
		i++;
		if( i > 50 ) 
		{
			i = 0;
			float updateTime = updateTimer.timeInSeconds();
			float drawTime = drawTimer.timeInSeconds();
			printf("LoopTime: update:%f ms  draw:%f ms  tot:%f\n",updateTime * 1000.0f, drawTime * 1000.0f, (updateTime + drawTime) *1000.0f);
		}
	}
	
    return 0;
}