Пример #1
0
// Creates the base system and returns its ID
SPK::SPK_ID createParticleSystemBase(GLuint textureIndex)
{
    // Creates the model
    SPK::Model* model = SPK::Model::create(SPK::FLAG_RED | SPK::FLAG_GREEN | SPK::FLAG_BLUE | SPK::FLAG_ALPHA,
                                           SPK::FLAG_ALPHA,
                                           SPK::FLAG_RED | SPK::FLAG_GREEN | SPK::FLAG_BLUE);
    model->setParam(SPK::PARAM_ALPHA,1.0f,0.0f); // This makes the particles fade out over time
    model->setLifeTime(1.0f,2.0f);

    // Create the renderer
    SPK::GL::GLRenderer* renderer = NULL;
    // If the point sprite extension and the point parameter extensions are supported by the hardware, we use point sprites
    if ((SPK::GL::GLPointRenderer::loadGLExtPointSprite())&&(SPK::GL::GLPointRenderer::loadGLExtPointParameter()))
    {
        SPK::GL::GLPointRenderer* pointRenderer = SPK::GL::GLPointRenderer::create();
        pointRenderer->setType(SPK::POINT_SPRITE);
        pointRenderer->enableWorldSize(true);
        SPK::GL::GLPointRenderer::setPixelPerUnit(45.0f * 3.14159f / 180.f,screenHeight);
        pointRenderer->setSize(0.1f);
        pointRenderer->setTexture(textureIndex);
        renderer = pointRenderer;
    }
    else // else we use quads
    {
        SPK::GL::GLQuadRenderer* quadRenderer = SPK::GL::GLQuadRenderer::create();
        quadRenderer->setTexturingMode(SPK::TEXTURE_2D);
        quadRenderer->setScale(0.1f,0.1f);
        quadRenderer->setTexture(textureIndex);
        renderer = quadRenderer;
    }

    renderer->enableBlending(true);
    renderer->setBlendingFunctions(GL_SRC_ALPHA,GL_ONE); // additive blending
    renderer->setTextureBlending(GL_MODULATE); // the texture is modulated with the particle's color
    renderer->enableRenderingHint(SPK::DEPTH_TEST,false); // the depth test is disabled

    // Creates the zone
    SPK::Point* source = SPK::Point::create();

    // Creates the emitter
    SPK::RandomEmitter* emitter = SPK::RandomEmitter::create();
    emitter->setForce(2.8f,3.2f);
    emitter->setZone(source);
    emitter->setTank(500);
    emitter->setFlow(-1); // Creates all the particles in the tank at the first frame

    // Creates the Group
    SPK::Group* group = SPK::Group::create(model,500); // 500 particles is the maximum capacity of the group
    group->addEmitter(emitter);
    group->setGravity(SPK::Vector3D(0.0f,-1.0f,0.0f));
    group->setFriction(2.0f);
    group->setRenderer(renderer);

    // Creates the System
    SPK::System* system = SPK::System::create();
    system->addGroup(group);

    // Defines which objects will be shared by all systems
    model->setShared(true);
    renderer->setShared(true);

    // Creates the base and gets a pointer to the base
    return system->getSPKID();
}
Пример #2
0
SPK::SPK_ID createRain( const SparkDrawable::TextureIDMap& textureIDMap, int screenWidth, int screenHeight )
{
    SparkDrawable::TextureIDMap::const_iterator itr;
    GET_TEXTURE_ID( "waterdrops", textureSplash );
    
    // Inits Particle Engine
    SPK::Vector3D gravity = SPK::Vector3D(0.0f,0.0f,-2.0f);

    // Renderers
    // the size ratio is used with renderers whose size are defined in pixels. This is to adapt to any resolution
    float sizeRatio = static_cast<float>(screenWidth) / 1440;

    // point renderer
    SPK::GL::GLPointRenderer* dropRenderer = SPK::GL::GLPointRenderer::create();
    dropRenderer->setType(SPK::POINT_CIRCLE);
    dropRenderer->setSize(2.0f * sizeRatio);
    dropRenderer->enableBlending(true);
    
    // line renderer
    SPK::GL::GLLineRenderer* rainRenderer = SPK::GL::GLLineRenderer::create();
    rainRenderer->setLength(-0.1f);
    rainRenderer->enableBlending(true);

    // quad renderer
    SPK::GL::GLQuadRenderer* splashRenderer = SPK::GL::GLQuadRenderer::create();
    splashRenderer->setScale(0.05f,0.05f);
    splashRenderer->setTexturingMode(SPK::TEXTURE_2D);
    splashRenderer->setTexture(textureSplash);
    splashRenderer->enableBlending(true);
    splashRenderer->enableRenderingHint(SPK::DEPTH_WRITE,false);
    
    // Models
    // rain model
    SPK::Model* rainModel = SPK::Model::create(
        SPK::FLAG_GREEN | SPK::FLAG_RED | SPK::FLAG_BLUE | SPK::FLAG_ALPHA | SPK::FLAG_MASS,
        0, SPK::FLAG_MASS);
    rainModel->setParam(SPK::PARAM_ALPHA,0.2f);
    rainModel->setImmortal(true);

    // drop model
    SPK::Model* dropModel = SPK::Model::create(
        SPK::FLAG_GREEN | SPK::FLAG_RED | SPK::FLAG_BLUE | SPK::FLAG_ALPHA | SPK::FLAG_MASS,
        0, SPK::FLAG_MASS);
    dropModel->setParam(SPK::PARAM_ALPHA,0.6f);

    // splash model
    SPK::Model* splashModel = SPK::Model::create(
        SPK::FLAG_GREEN | SPK::FLAG_RED | SPK::FLAG_BLUE |
        SPK::FLAG_ALPHA | SPK::FLAG_SIZE | SPK::FLAG_ANGLE,
        SPK::FLAG_SIZE | SPK::FLAG_ALPHA,
        SPK::FLAG_SIZE | SPK::FLAG_ANGLE);
    splashModel->setParam(SPK::PARAM_ANGLE,0.0f,2.0f * osg::PI);
    splashModel->setParam(SPK::PARAM_ALPHA,1.0f,0.0f);

    // rain emitter
    SPK::Ring* rainZone = SPK::Ring::create(SPK::Vector3D(0.0f,0.0f,5.0f), SPK::Vector3D(0.0f,0.0f,1.0f));
    SPK::SphericEmitter* rainEmitter = SPK::SphericEmitter::create(SPK::Vector3D(0.0f,0.0f,-1.0f),0.0f,0.03f * osg::PI);
    rainEmitter->setZone(rainZone);

    // drop emitter
    SPK::SphericEmitter* dropEmitter = SPK::SphericEmitter::create(SPK::Vector3D(0.0f,0.0f,1.0f),0.0f,0.2f * osg::PI);
    
    // Groups
    // rain group
    SPK::Group* rainGroup = SPK::Group::create(rainModel,8000);
    rainGroup->setCustomUpdate(&killRain);
    rainGroup->setRenderer(rainRenderer);
    rainGroup->addEmitter(rainEmitter);
    rainGroup->setFriction(0.7f);
    rainGroup->setGravity(gravity);

    // drop group
    SPK::Group* dropGroup = SPK::Group::create(dropModel,16000);
    dropGroup->setRenderer(dropRenderer);
    //dropGroup->addEmitter(dropEmitter);
    dropGroup->setFriction(0.7f);
    dropGroup->setGravity(gravity);

    // splash group
    SPK::Group* splashGroup = SPK::Group::create(splashModel,2400);
    splashGroup->setRenderer(splashRenderer);

    // System
    SPK::System* particleSystem = SPK::System::create();
    particleSystem->addGroup(splashGroup);
    particleSystem->addGroup(dropGroup);
    particleSystem->addGroup(rainGroup);
    
    // Compute rain RAIN_PARAMeters
    rainModel->setParam(SPK::PARAM_RED,RAIN_PARAM(1.0f,0.40f));
    rainModel->setParam(SPK::PARAM_GREEN,RAIN_PARAM(1.0f,0.40f));
    rainModel->setParam(SPK::PARAM_BLUE,RAIN_PARAM(1.0f,0.42f));
    rainModel->setParam(SPK::PARAM_MASS,RAIN_PARAM(0.4f,0.8f),RAIN_PARAM(0.8f,1.6f));

    dropModel->setParam(SPK::PARAM_RED,RAIN_PARAM(1.0f,0.40f));
    dropModel->setParam(SPK::PARAM_GREEN,RAIN_PARAM(1.0f,0.40f));
    dropModel->setParam(SPK::PARAM_BLUE,RAIN_PARAM(1.0f,0.42f));
    dropModel->setParam(SPK::PARAM_MASS,RAIN_PARAM(0.4f,0.8f),RAIN_PARAM(3.0f,4.0f));
    dropModel->setLifeTime(RAIN_PARAM(0.05f,0.3f),RAIN_PARAM(0.1f,0.5f));

    splashModel->setParam(SPK::PARAM_RED,RAIN_PARAM(1.0f,0.40f));
    splashModel->setParam(SPK::PARAM_GREEN,RAIN_PARAM(1.0f,0.40f));
    splashModel->setParam(SPK::PARAM_BLUE,RAIN_PARAM(1.0f,0.42f));
    splashModel->setParam(SPK::PARAM_SIZE,0.0f,0.0f,RAIN_PARAM(0.375f,2.25f),RAIN_PARAM(0.75f,3.78f));
    splashModel->setLifeTime(RAIN_PARAM(0.2f,0.3f),RAIN_PARAM(0.4f,0.5f));

    rainEmitter->setFlow(RAIN_PARAM(0.0f,4800.0f));
    rainEmitter->setForce(RAIN_PARAM(3.0f,5.0f),RAIN_PARAM(6.0f,10.0f));
    rainZone->setRadius(0.0f,RAIN_PARAM(20.0f,5.0f));

    dropEmitter->setForce(RAIN_PARAM(0.1f,1.0f),RAIN_PARAM(0.2f,2.0f));
    dropRenderer->setSize(RAIN_PARAM(1.0f,3.0f) * sizeRatio);
    rainRenderer->setWidth(RAIN_PARAM(1.0f,4.0f) * sizeRatio);
    
    g_splashGroup = splashGroup;
    g_dropGroup = dropGroup;
    g_dropEmitter = dropEmitter;
    return particleSystem->getSPKID();
}
Пример #3
0
SPK::SPK_ID createExplosion( const SparkDrawable::TextureIDMap& textureIDMap, int screenWidth, int screenHeight )
{
    SparkDrawable::TextureIDMap::const_iterator itr;
    GET_TEXTURE_ID( "explosion", textureExplosion );
    GET_TEXTURE_ID( "flash", textureFlash );
    GET_TEXTURE_ID( "spark1", textureSpark1 );
    GET_TEXTURE_ID( "spark2", textureSpark2 );
    GET_TEXTURE_ID( "wave", textureWave );
    
    //
    // Renderers
    //
    
    // smoke renderer
    SPK::GL::GLQuadRenderer* smokeRenderer = SPK::GL::GLQuadRenderer::create();
    smokeRenderer->setTexturingMode(SPK::TEXTURE_2D);
    smokeRenderer->setTexture(textureExplosion);
    smokeRenderer->setTextureBlending(GL_MODULATE);
    smokeRenderer->setAtlasDimensions(2,2); // uses 4 different patterns in the texture
    smokeRenderer->setBlending(SPK::BLENDING_ALPHA);
    smokeRenderer->enableRenderingHint(SPK::DEPTH_WRITE,false);
    smokeRenderer->setShared(true);

    // flame renderer
    SPK::GL::GLQuadRenderer* flameRenderer = SPK::GL::GLQuadRenderer::create();
    flameRenderer->setTexturingMode(SPK::TEXTURE_2D);
    flameRenderer->setTexture(textureExplosion);
    flameRenderer->setTextureBlending(GL_MODULATE);
    flameRenderer->setAtlasDimensions(2,2);
    flameRenderer->setBlending(SPK::BLENDING_ADD);
    flameRenderer->enableRenderingHint(SPK::DEPTH_WRITE,false);
    flameRenderer->setShared(true);

    // flash renderer
    SPK::GL::GLQuadRenderer* flashRenderer = SPK::GL::GLQuadRenderer::create();
    flashRenderer->setTexturingMode(SPK::TEXTURE_2D);
    flashRenderer->setTexture(textureFlash);
    flashRenderer->setTextureBlending(GL_REPLACE);
    flashRenderer->setBlending(SPK::BLENDING_ADD);
    flashRenderer->enableRenderingHint(SPK::DEPTH_WRITE,false);
    flashRenderer->setShared(true);

    // spark 1 renderer
    SPK::GL::GLQuadRenderer* spark1Renderer = SPK::GL::GLQuadRenderer::create();
    spark1Renderer->setTexturingMode(SPK::TEXTURE_2D);
    spark1Renderer->setTexture(textureSpark1);
    spark1Renderer->setTextureBlending(GL_REPLACE);
    spark1Renderer->setBlending(SPK::BLENDING_ADD);
    spark1Renderer->enableRenderingHint(SPK::DEPTH_WRITE,false);
    spark1Renderer->setOrientation(SPK::DIRECTION_ALIGNED); // sparks are oriented function o their velocity
    spark1Renderer->setScale(0.05f,1.0f); // thin rectangles
    spark1Renderer->setShared(true);

    // spark 2 renderer
    SPK::GL::GLRenderer* spark2Renderer = NULL;
    if ( SPK::GL::GLPointRenderer::loadGLExtPointSprite() &&
         SPK::GL::GLPointRenderer::loadGLExtPointParameter()) // uses point sprite if possible
    {
        SPK::GL::GLPointRenderer::setPixelPerUnit(45.0f * osg::PI / 180.0f, screenHeight);
        SPK::GL::GLPointRenderer* pointRenderer = SPK::GL::GLPointRenderer::create();
        pointRenderer->setType(SPK::POINT_SPRITE);
        pointRenderer->setTexture(textureSpark2);
        pointRenderer->setTextureBlending(GL_MODULATE);
        pointRenderer->enableWorldSize(true);
        pointRenderer->setSize(0.02f);
        spark2Renderer = pointRenderer;
    }
    else
    {
        SPK::GL::GLQuadRenderer* quadRenderer = SPK::GL::GLQuadRenderer::create();
        quadRenderer->setTexturingMode(SPK::TEXTURE_2D);
        quadRenderer->setTexture(textureSpark2);
        quadRenderer->setTextureBlending(GL_MODULATE);
        quadRenderer->setScale(0.02f,0.02f);
        spark2Renderer = quadRenderer;
    }
    spark2Renderer->setBlending(SPK::BLENDING_ADD);
    spark2Renderer->enableRenderingHint(SPK::DEPTH_WRITE,false);
    spark2Renderer->setShared(true);

    // wave renderer
    SPK::GL::GLQuadRenderer* waveRenderer = SPK::GL::GLQuadRenderer::create();
    waveRenderer->setTexturingMode(SPK::TEXTURE_2D);
    waveRenderer->setTexture(textureWave);
    waveRenderer->setTextureBlending(GL_MODULATE);
    waveRenderer->setBlending(SPK::BLENDING_ALPHA);
    waveRenderer->enableRenderingHint(SPK::DEPTH_WRITE,false);
    waveRenderer->enableRenderingHint(SPK::ALPHA_TEST,true); // uses the alpha test
    waveRenderer->setAlphaTestThreshold(0.0f);
    waveRenderer->setOrientation(SPK::FIXED_ORIENTATION); // the orientatin is fixed
    waveRenderer->lookVector.set(0.0f,1.0f,0.0f);
    waveRenderer->upVector.set(1.0f,0.0f,0.0f); // we dont really care about the up axis
    waveRenderer->setShared(true);
    
    //
    // Models
    //
    SPK::Interpolator* interpolator = NULL; // pointer to an interpolator that is used to retrieve interpolators    

    // smoke model
    SPK::Model* smokeModel = SPK::Model::create(
        SPK::FLAG_RED | SPK::FLAG_GREEN | SPK::FLAG_BLUE | SPK::FLAG_ALPHA |
        SPK::FLAG_SIZE | SPK::FLAG_ANGLE | SPK::FLAG_TEXTURE_INDEX,
        SPK::FLAG_SIZE | SPK::FLAG_ANGLE,
        SPK::FLAG_SIZE | SPK::FLAG_ANGLE | SPK::FLAG_TEXTURE_INDEX,
        SPK::FLAG_ALPHA);
    smokeModel->setParam(SPK::PARAM_RED,0.2f);
    smokeModel->setParam(SPK::PARAM_GREEN,0.2f);
    smokeModel->setParam(SPK::PARAM_BLUE,0.2f);
    smokeModel->setParam(SPK::PARAM_SIZE,0.6f,0.8f,1.0f,1.4f);
    smokeModel->setParam(SPK::PARAM_TEXTURE_INDEX,0.0f,4.0f);
    smokeModel->setParam(SPK::PARAM_ANGLE,0.0f,osg::PI * 0.5f,0.0f,osg::PI * 0.5f);
    smokeModel->setLifeTime(2.5f,3.0f);
    smokeModel->setShared(true);

    interpolator = smokeModel->getInterpolator(SPK::PARAM_ALPHA);
    interpolator->addEntry(0.0f,0.0f);
    interpolator->addEntry(0.4f,0.4f,0.6f);
    interpolator->addEntry(0.6f,0.4f,0.6f);
    interpolator->addEntry(1.0f,0.0f);

    // flame model
    SPK::Model* flameModel = SPK::Model::create(
        SPK::FLAG_RED | SPK::FLAG_GREEN | SPK::FLAG_BLUE | SPK::FLAG_ALPHA |
        SPK::FLAG_SIZE | SPK::FLAG_ANGLE | SPK::FLAG_TEXTURE_INDEX,
        SPK::FLAG_ANGLE | SPK::FLAG_RED | SPK::FLAG_GREEN | SPK::FLAG_BLUE,
        SPK::FLAG_ANGLE | SPK::FLAG_TEXTURE_INDEX,
        SPK::FLAG_SIZE | SPK::FLAG_ALPHA);
    flameModel->setParam(SPK::PARAM_RED,1.0f,0.2f);
    flameModel->setParam(SPK::PARAM_GREEN,0.5f,0.2f);
    flameModel->setParam(SPK::PARAM_BLUE,0.2f,0.2f);
    flameModel->setParam(SPK::PARAM_TEXTURE_INDEX,0.0f,4.0f);
    flameModel->setParam(SPK::PARAM_ANGLE,0.0f,osg::PI * 0.5f,0.0f,osg::PI * 0.5f);
    flameModel->setLifeTime(1.5f,2.0f);
    flameModel->setShared(true);

    interpolator = flameModel->getInterpolator(SPK::PARAM_SIZE);
    interpolator->addEntry(0.0f,0.25f);
    interpolator->addEntry(0.02f,0.6f,0.8f);
    interpolator->addEntry(1.0f,1.0f,1.4f);

    interpolator = flameModel->getInterpolator(SPK::PARAM_ALPHA);
    interpolator->addEntry(0.5f,1.0f);
    interpolator->addEntry(1.0f,0.0f);

    // flash model
    SPK::Model* flashModel = SPK::Model::create(
        SPK::FLAG_ALPHA | SPK::FLAG_SIZE | SPK::FLAG_ANGLE,
        SPK::FLAG_NONE,
        SPK::FLAG_ANGLE,
        SPK::FLAG_ALPHA | SPK::FLAG_SIZE);
    flashModel->setParam(SPK::PARAM_ANGLE,0.0f,2.0f * osg::PI);
    flashModel->setLifeTime(0.5f,0.5f);
    flashModel->setShared(true);

    interpolator = flashModel->getInterpolator(SPK::PARAM_SIZE);
    interpolator->addEntry(0.0f,0.25f);
    interpolator->addEntry(0.1f,1.0f,2.0f);

    interpolator = flashModel->getInterpolator(SPK::PARAM_ALPHA);
    interpolator->addEntry(0.0f,1.0f);
    interpolator->addEntry(0.4f,0.0f);

    // spark 1 model
    SPK::Model* spark1Model = SPK::Model::create(
        SPK::FLAG_SIZE | SPK::FLAG_ALPHA,
        SPK::FLAG_ALPHA,
        SPK::FLAG_SIZE);
    spark1Model->setParam(SPK::PARAM_ALPHA,1.0f,0.0f);
    spark1Model->setParam(SPK::PARAM_SIZE,0.2f,0.4f);
    spark1Model->setLifeTime(0.2f,1.0f);
    spark1Model->setShared(true);

    // spark 2 model
    SPK::Model* spark2Model = SPK::Model::create(
        SPK::FLAG_RED | SPK::FLAG_GREEN | SPK::FLAG_BLUE | SPK::FLAG_ALPHA,
        SPK::FLAG_GREEN | SPK::FLAG_BLUE | SPK::FLAG_ALPHA,
        SPK::FLAG_GREEN);
    spark2Model->setParam(SPK::PARAM_ALPHA,1.0f,0.0f);
    spark2Model->setParam(SPK::PARAM_RED,1.0f);
    spark2Model->setParam(SPK::PARAM_GREEN,1.0f,1.0f,0.3f,1.0f);
    spark2Model->setParam(SPK::PARAM_BLUE,0.7f,0.3f);
    spark2Model->setLifeTime(1.0f,3.0f);
    spark2Model->setShared(true);

    // wave model
    SPK::Model* waveModel = SPK::Model::create(
        SPK::FLAG_ALPHA | SPK::FLAG_SIZE,
        SPK::FLAG_SIZE | SPK::FLAG_ALPHA);
    waveModel->setParam(SPK::PARAM_SIZE,0.0f,4.0f);
    waveModel->setParam(SPK::PARAM_ALPHA,0.2f,0.0f);
    waveModel->setLifeTime(0.8f,0.8f);
    waveModel->setShared(true);
    
    //
    // Emitters
    //
    SPK::Sphere* explosionSphere = SPK::Sphere::create(SPK::Vector3D(0.0f,0.0f,0.0f),0.4f);

    // smoke emitter
    SPK::RandomEmitter* smokeEmitter = SPK::RandomEmitter::create();
    smokeEmitter->setZone(SPK::Sphere::create(SPK::Vector3D(0.0f,0.0f,0.0f),0.6f),false);
    smokeEmitter->setFlow(-1);
    smokeEmitter->setTank(15);
    smokeEmitter->setForce(0.02f,0.04f);

    // flame emitter
    SPK::NormalEmitter* flameEmitter = SPK::NormalEmitter::create();
    flameEmitter->setZone(explosionSphere);
    flameEmitter->setFlow(-1);
    flameEmitter->setTank(15);
    flameEmitter->setForce(0.06f,0.1f);

    // flash emitter
    SPK::StaticEmitter* flashEmitter = SPK::StaticEmitter::create();
    flashEmitter->setZone(SPK::Sphere::create(SPK::Vector3D(0.0f,0.0f,0.0f),0.1f));
    flashEmitter->setFlow(-1);
    flashEmitter->setTank(3);

    // spark 1 emitter
    SPK::NormalEmitter* spark1Emitter = SPK::NormalEmitter::create();
    spark1Emitter->setZone(explosionSphere);
    spark1Emitter->setFlow(-1);
    spark1Emitter->setTank(20);
    spark1Emitter->setForce(2.0f,3.0f);

    // spark 2 emitter
    SPK::NormalEmitter* spark2Emitter = SPK::NormalEmitter::create();
    spark2Emitter->setZone(explosionSphere);
    spark2Emitter->setFlow(-1);
    spark2Emitter->setTank(400);
    spark2Emitter->setForce(0.4f,0.8f);

    // wave emitter
    SPK::StaticEmitter* waveEmitter = SPK::StaticEmitter::create();
    waveEmitter->setZone(SPK::Point::create());
    waveEmitter->setFlow(-1);
    waveEmitter->setTank(1);
    
    //
    // Groups
    //
    
    // smoke group
    SPK::Group* smokeGroup = SPK::Group::create(smokeModel,15);
    smokeGroup->addEmitter(smokeEmitter);
    smokeGroup->setRenderer(smokeRenderer);
    smokeGroup->setGravity(SPK::Vector3D(0.0f,0.0f,0.05f));

    // flame group
    SPK::Group* flameGroup = SPK::Group::create(flameModel,15);
    flameGroup->addEmitter(flameEmitter);
    flameGroup->setRenderer(flameRenderer);

    // flash group
    SPK::Group* flashGroup = SPK::Group::create(flashModel,3);
    flashGroup->addEmitter(flashEmitter);
    flashGroup->setRenderer(flashRenderer);

    // spark 1 group
    SPK::Group* spark1Group = SPK::Group::create(spark1Model,20);
    spark1Group->addEmitter(spark1Emitter);
    spark1Group->setRenderer(spark1Renderer);
    spark1Group->setGravity(SPK::Vector3D(0.0f,0.0f,-1.5f));

    // spark 2 group
    SPK::Group* spark2Group = SPK::Group::create(spark2Model,400);
    spark2Group->addEmitter(spark2Emitter);
    spark2Group->setRenderer(spark2Renderer);
    spark2Group->setGravity(SPK::Vector3D(0.0f,0.0f,-0.3f));
    spark2Group->setFriction(0.4f);

    // wave group
    SPK::Group* waveGroup = SPK::Group::create(waveModel,1);
    waveGroup->addEmitter(waveEmitter);
    waveGroup->setRenderer(waveRenderer);
    
    //
    // System
    //
    SPK::System* system = SPK::System::create();
    system->addGroup(waveGroup);
    system->addGroup(smokeGroup);
    system->addGroup(flameGroup);
    system->addGroup(flashGroup);
    system->addGroup(spark1Group);
    system->addGroup(spark2Group);
    return system->getSPKID();
}
Пример #4
0
void ParticleEmitterBase::CreateParticleSystem() {
  if (particleSystem) delete particleSystem;
  particleSystem = new ParticleSystemWrapper;

  int enabledFlag = 0;
  int mutableFlag = 0;
  int randomFlag = 0;

  if (redParam == Enabled)
    enabledFlag |= SPK::FLAG_RED;
  else if (redParam == Mutable) {
    enabledFlag |= SPK::FLAG_RED;
    mutableFlag |= SPK::FLAG_RED;
  } else if (redParam == Random) {
    enabledFlag |= SPK::FLAG_RED;
    randomFlag |= SPK::FLAG_RED;
  }

  if (greenParam == Enabled)
    enabledFlag |= SPK::FLAG_RED;
  else if (greenParam == Mutable) {
    enabledFlag |= SPK::FLAG_GREEN;
    mutableFlag |= SPK::FLAG_GREEN;
  } else if (greenParam == Random) {
    enabledFlag |= SPK::FLAG_GREEN;
    randomFlag |= SPK::FLAG_GREEN;
  }

  if (blueParam == Enabled)
    enabledFlag |= SPK::FLAG_BLUE;
  else if (blueParam == Mutable) {
    enabledFlag |= SPK::FLAG_BLUE;
    mutableFlag |= SPK::FLAG_BLUE;
  } else if (blueParam == Random) {
    enabledFlag |= SPK::FLAG_BLUE;
    randomFlag |= SPK::FLAG_BLUE;
  }

  if (alphaParam == Enabled)
    enabledFlag |= SPK::FLAG_ALPHA;
  else if (alphaParam == Mutable) {
    enabledFlag |= SPK::FLAG_ALPHA;
    randomFlag |= SPK::FLAG_ALPHA;
    mutableFlag |= SPK::FLAG_ALPHA;
  } else if (alphaParam == Random) {
    enabledFlag |= SPK::FLAG_ALPHA;
    randomFlag |= SPK::FLAG_ALPHA;
  }

  if (sizeParam == Mutable) {
    enabledFlag |= SPK::FLAG_SIZE;
    randomFlag |= SPK::FLAG_SIZE;
    mutableFlag |= SPK::FLAG_SIZE;
  } else if (sizeParam == Random) {
    enabledFlag |= SPK::FLAG_SIZE;
    randomFlag |= SPK::FLAG_SIZE;
  }

  if (angleParam == Mutable) {
    enabledFlag |= SPK::FLAG_ANGLE;
    randomFlag |= SPK::FLAG_ANGLE;
    mutableFlag |= SPK::FLAG_ANGLE;
  } else if (angleParam == Random) {
    enabledFlag |= SPK::FLAG_ANGLE;
    randomFlag |= SPK::FLAG_ANGLE;
  }

  if (rendererType == Quad) enabledFlag |= SPK::PARAM_TEXTURE_INDEX;

  // Create the model
  particleSystem->particleModel =
      SPK::Model::create(enabledFlag, mutableFlag, randomFlag);
  UpdateRedParameters();
  UpdateGreenParameters();
  UpdateBlueParameters();
  UpdateAlphaParameters();
  UpdateSizeParameters();
  UpdateAngleParameters();
  UpdateLifeTime();

  // Create the renderer
  if (rendererType == Line)
    particleSystem->renderer =
        SPK::GL::GLLineRenderer::create(rendererParam1, rendererParam2);
  else if (rendererType == Quad) {
    SPK::GL::GLQuadRenderer* quadRenderer =
        new SPK::GL::GLQuadRenderer(rendererParam1, rendererParam2);

    if (particleSystem->textureParticle) {
      quadRenderer->setTexturingMode(SPK::TEXTURE_2D);
      quadRenderer->setTexture(
          particleSystem->textureParticle->texture.getNativeHandle());
    }

    particleSystem->renderer = quadRenderer;
  } else {
    SPK::GL::GLPointRenderer* pointRenderer =
        SPK::GL::GLPointRenderer::create();
    pointRenderer->setType(SPK::POINT_CIRCLE);
    pointRenderer->setSize(rendererParam1);

    particleSystem->renderer = pointRenderer;
  }

  particleSystem->renderer->enableBlending(true);
  if (additive)
    particleSystem->renderer->setBlendingFunctions(GL_SRC_ALPHA, GL_ONE);
  else
    particleSystem->renderer->setBlendingFunctions(GL_SRC_ALPHA,
                                                   GL_ONE_MINUS_SRC_ALPHA);
  particleSystem->renderer->setTextureBlending(
      GL_MODULATE);  // Texture color modulated with particle color
  particleSystem->renderer->enableRenderingHint(
      SPK::DEPTH_TEST, false);  // No depth test for performance

  // Create the zone
  particleSystem->zone = SPK::Sphere::create(SPK::Vector3D(0, 0), zoneRadius);

  // Create the emitter
  particleSystem->emitter = SPK::SphericEmitter::create(
      SPK::Vector3D(emitterXDirection, -emitterYDirection, emitterZDirection),
      emitterAngleA / 180.0f * 3.14159f,
      emitterAngleB / 180.0f * 3.14159f);
  particleSystem->emitter->setForce(emitterForceMin, emitterForceMax);
  particleSystem->emitter->setZone(particleSystem->zone);
  particleSystem->emitter->setTank(tank);
  particleSystem->emitter->setFlow(flow);

  // Create the Group
  particleSystem->group =
      SPK::Group::create(particleSystem->particleModel, maxParticleNb);
  particleSystem->group->addEmitter(particleSystem->emitter);
  particleSystem->group->setGravity(
      SPK::Vector3D(particleGravityX, -particleGravityY, particleGravityZ));
  particleSystem->group->setFriction(friction);
  particleSystem->group->setRenderer(particleSystem->renderer);

  // Create the System
  particleSystem->particleSystem = SPK::System::create();
  particleSystem->particleSystem->addGroup(particleSystem->group);
}