HomeHome  CalendarCalendar  FAQFAQ  SearchSearch  MemberlistMemberlist  UsergroupsUsergroups  RegisterRegister  Log inLog in  

Share | 
 

 SPARK2 explosion demo

View previous topic View next topic Go down 
AuthorMessage
thecno



Messages : 7
Date d'inscription : 2012-03-25

PostSubject: SPARK2 explosion demo   Sat Mar 31, 2012 12:36 pm

Hello,

Is there anyone who succesfully ported the explosion demo to SPARK2?

Greetz
Back to top Go down
View user profile
qidaozhilong2



Messages : 11
Date d'inscription : 2012-03-31

PostSubject: If i not reply u, i found no one will. So......   Thu Apr 26, 2012 12:18 am

thecno,

Good news:I've ported all demos to SPARK1.5.5 using IRRLICHT
Bad news: but not SPARK2.

The problem i found is alpha channel, some TRANSPARENT expected but occur BLACK color.
You know, BLACK color of png picture should be treated as TRANSPARENT.
So, when run 'explosion demo', not explosion, just pictures with BLACK background color.

btw, this forum is not an active one. Maybe only some active users, the numbers of active users i think less than 5.
If @thecno and @Darkit not reply you, no one will give some advice or help.

Sad
Back to top Go down
View user profile
Darktib
Committer


Messages : 389
Date d'inscription : 2009-07-20
Localisation : A coté de Paris

PostSubject: Re: SPARK2 explosion demo   Thu Apr 26, 2012 8:09 am

I never really played with OpenGL, but I think OpenGL demos can be easily ported from SPARK 1.5.5 to SPARK2. The only code that will slightly change is the SPARK logic code.
So, first, which rendering system would you like to see in action ?

The black parts of a png texture are invisible only if you use additive blending. But there are bugs with that, I know at least one in Irrlicht that affect DirectX. It seems that there is one with OpenGL, but I don't know where it is...

_________________
Back to top Go down
View user profile
thecno



Messages : 7
Date d'inscription : 2012-03-25

PostSubject: Re: SPARK2 explosion demo   Fri Apr 27, 2012 3:29 am

Darktib wrote:
I never really played with OpenGL, but I think OpenGL demos can be easily ported from SPARK 1.5.5 to SPARK2. The only code that will slightly change is the SPARK logic code.
So, first, which rendering system would you like to see in action ?

Would like to see it for the Irrlicht rendering system.
Back to top Go down
View user profile
Darktib
Committer


Messages : 389
Date d'inscription : 2009-07-20
Localisation : A coté de Paris

PostSubject: Re: SPARK2 explosion demo   Sat Apr 28, 2012 2:22 pm

OK, here is the code for the explosion demo. Note that for the moment I will not port other demos (I am still working on the controller system, see Showcase forum)
Code:
//////////////////////////////////////////////////////////////////////////////////
// SPARK Irrlicht Rendering library                                    //
// Copyright (C) 2008-2011                                          //
// Julien Fryer - julienfryer@gmail.com                                 //
// Thibault Lescoat -  info-tibo <at> orange <dot> fr                     //
//                                                            //
//                                                            //
// This software is provided 'as-is', without any express or implied         //
// warranty.  In no event will the authors be held liable for any damages      //
// arising from the use of this software.                              //
//                                                            //
// Permission is granted to anyone to use this software for any purpose,      //
// including commercial applications, and to alter it and redistribute it      //
// freely, subject to the following restrictions:                        //
//                                                            //
// 1. The origin of this software must not be misrepresented; you must not      //
//    claim that you wrote the original software. If you use this software      //
//    in a product, an acknowledgment in the product documentation would be      //
//    appreciated but is not required.                                 //
// 2. Altered source versions must be plainly marked as such, and must not be   //
//    misrepresented as being the original software.                     //
// 3. This notice may not be removed or altered from any source distribution.   //
//////////////////////////////////////////////////////////////////////////////////

// external libs
#include <irrlicht.h>
#include <time.h>

// SPARK lib
#include <SPARK.h>
#include <SPARK_IRR.h>

// windows only
#ifdef _WIN32
#include <windows.h>
#endif

float angleX = 0.0f;
float angleY = 0.0f;
const float CAM_POS_Z = 3.0f;
unsigned int randomSeed = time(NULL);
template<typename T>
T random(T min,T max)
{
   // optimized standard minimal
   long tmp0 = 16807L * (randomSeed & 0xFFFFL);
   long tmp1 = 16807L * (randomSeed >> 16);
   long tmp2 = (tmp0 >> 16) + tmp1;
   tmp0 = ((tmp0 & 0xFFFF)|((tmp2 & 0x7FFF) << 16)) + (tmp2 >> 15);

   // correction of the error
   if ((tmp0 & 0x80000000L) != 0)
      tmp0 = (tmp0 + 1) & 0x7FFFFFFFL;

   randomSeed = tmp0;

   // find a random number in the interval
   return static_cast<T>(min + ((randomSeed - 1) / 2147483646.0) * (max - min));
}

using namespace irr;
IrrlichtDevice* device = NULL;
irr::video::ITexture* explosionTexture;
irr::video::ITexture* flashTexture;
irr::video::ITexture* spark1Texture;
irr::video::ITexture* spark2Texture;
irr::video::ITexture* waveTexture;

// Creates the base system and returns its ID
SPK::Ref<SPK::System> createParticleSystem(const SPK::Vector3D& position)
{
   ///////////////
   // Renderers //
   ///////////////

   // smoke renderer
   SPK::Ref<SPK::IRR::IRRQuadRenderer> smokeRenderer = SPK::IRR::IRRQuadRenderer::create(device);
   smokeRenderer->setBlendMode(SPK::BLEND_MODE_ALPHA);
   smokeRenderer->enableRenderingOption(SPK::RENDERING_OPTION_DEPTH_WRITE,false);
   smokeRenderer->setTexture(explosionTexture);
   smokeRenderer->setTexturingMode(SPK::TEXTURE_MODE_2D);
   smokeRenderer->setAtlasDimensions(2,2);

   // flame renderer
   SPK::Ref<SPK::IRR::IRRQuadRenderer> flameRenderer = SPK::IRR::IRRQuadRenderer::create(device);
   flameRenderer->setBlendMode(SPK::BLEND_MODE_ADD);
   flameRenderer->enableRenderingOption(SPK::RENDERING_OPTION_DEPTH_WRITE,false);
   flameRenderer->setTexture(explosionTexture);
   flameRenderer->setTexturingMode(SPK::TEXTURE_MODE_2D);
   flameRenderer->setAtlasDimensions(2,2);

   // flash renderer
   SPK::Ref<SPK::IRR::IRRQuadRenderer> flashRenderer = SPK::IRR::IRRQuadRenderer::create(device);
   flashRenderer->setBlendMode(SPK::BLEND_MODE_ADD);
   flashRenderer->enableRenderingOption(SPK::RENDERING_OPTION_DEPTH_WRITE,false);
   flashRenderer->setTexture(flashTexture);
   flashRenderer->setTexturingMode(SPK::TEXTURE_MODE_2D);

   // spark 1 renderer
   SPK::Ref<SPK::IRR::IRRQuadRenderer> spark1Renderer = SPK::IRR::IRRQuadRenderer::create(device);
   spark1Renderer->setBlendMode(SPK::BLEND_MODE_ADD);
   spark1Renderer->enableRenderingOption(SPK::RENDERING_OPTION_DEPTH_WRITE,false);
   spark1Renderer->setTexture(spark1Texture);
   spark1Renderer->setTexturingMode(SPK::TEXTURE_MODE_2D);
   spark1Renderer->setOrientation(SPK::DIRECTION_ALIGNED); // sparks are oriented function o their velocity
   spark1Renderer->setScale(0.05f,1.0f); // thin rectangles
   
   // spark 2 renderer
   SPK::Ref<SPK::IRR::IRRQuadRenderer> spark2Renderer = SPK::IRR::IRRQuadRenderer::create(device);
   spark2Renderer->setBlendMode(SPK::BLEND_MODE_ADD);
   spark2Renderer->enableRenderingOption(SPK::RENDERING_OPTION_DEPTH_WRITE,false);
   spark2Renderer->setTexture(spark2Texture);
   spark2Renderer->setTexturingMode(SPK::TEXTURE_MODE_2D);
   spark2Renderer->setScale(0.02f,0.02f);
   
   // wave renderer
   SPK::Ref<SPK::IRR::IRRQuadRenderer> waveRenderer = SPK::IRR::IRRQuadRenderer::create(device);
   waveRenderer->setBlendMode(SPK::BLEND_MODE_ALPHA);
   waveRenderer->enableRenderingOption(SPK::RENDERING_OPTION_DEPTH_WRITE,false);
   waveRenderer->enableRenderingOption(SPK::RENDERING_OPTION_ALPHA_TEST,true); // uses the alpha test
   waveRenderer->setAlphaTestThreshold(0.0f);
   waveRenderer->setTexture(waveTexture);
   waveRenderer->setTexturingMode(SPK::TEXTURE_MODE_2D);
   waveRenderer->setOrientation(SPK::FIXED_ORIENTATION); // the orientation 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

   //////////////
   // Emitters //
   //////////////

   // This zone will be used by several emitters
   SPK::Ref<SPK::Sphere> explosionSphere = SPK::Sphere::create(SPK::Vector3D(0.0f,0.0f,0.0f),0.4f);

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

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

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

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

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

   // wave emitter
   SPK::Ref<SPK::StaticEmitter> waveEmitter = SPK::StaticEmitter::create();
   waveEmitter->setZone(SPK::Point::create());
   waveEmitter->setTank(1);
   waveEmitter->setFlow(-1);

   ////////////
   // System //
   ////////////

   SPK::Ref<SPK::System> system = SPK::System::create(false);

   ////////////
   // Groups //
   ////////////

   // smoke group
   SPK::Ref<SPK::Group> smokeGroup = system->createGroup(15);
   smokeGroup->addEmitter(smokeEmitter);
   smokeGroup->addModifier(SPK::Gravity::create(SPK::Vector3D(0.0f,0.05f,0.0f)));
   smokeGroup->setRenderer(smokeRenderer);
   smokeGroup->setLifeTime(2.5f,3.0f);
   smokeGroup->setParamInterpolator(SPK::PARAM_SCALE,SPK::FloatRandomInterpolator::create(0.6f,0.8f,1.0f,1.4f));
   smokeGroup->setParamInterpolator(SPK::PARAM_ANGLE,SPK::FloatRandomInterpolator::create(0.0f,irr::core::PI * 0.5f,0.0f,irr::core::PI * 0.5f));
   smokeGroup->setParamInterpolator(SPK::PARAM_TEXTURE_INDEX,SPK::FloatRandomInitializer::create(0.0f,4.0f));

   SPK::Ref<SPK::ColorGraphInterpolator> smokeColorInterpolator = SPK::ColorGraphInterpolator::create();
   smokeColorInterpolator->addEntry(0.0f,SPK::Color(51,51,51,0));
   smokeColorInterpolator->addEntry(0.4f,SPK::Color(51,51,51,102),SPK::Color(51,51,51,153));
   smokeColorInterpolator->addEntry(0.6f,SPK::Color(51,51,51,102),SPK::Color(51,51,51,153));
   smokeColorInterpolator->addEntry(1.0f,SPK::Color(51,51,51,0));
   smokeGroup->setColorInterpolator(smokeColorInterpolator);
   
   // flame group
   SPK::Ref<SPK::Group> flameGroup = system->createGroup(15);
   flameGroup->addEmitter(flameEmitter);
   flameGroup->setRenderer(flameRenderer);
   flameGroup->setLifeTime(1.5f,2.0f);
   flameGroup->setParamInterpolator(SPK::PARAM_ANGLE,SPK::FloatRandomInterpolator::create(0.0f,irr::core::PI * 0.5f,0.0f, irr::core::PI * 0.5f));
   flameGroup->setParamInterpolator(SPK::PARAM_TEXTURE_INDEX,SPK::FloatRandomInitializer::create(0.0f,4.0f));

   SPK::Ref<SPK::FloatGraphInterpolator> flameSizeInterpolator = SPK::FloatGraphInterpolator::create();
   flameSizeInterpolator->addEntry(0.0f,0.25f);
   flameSizeInterpolator->addEntry(0.02f,0.6f,0.8f);
   flameSizeInterpolator->addEntry(1.0f,1.0f,1.4f);
   flameGroup->setParamInterpolator(SPK::PARAM_SCALE,flameSizeInterpolator);

   SPK::Ref<SPK::ColorGraphInterpolator> flameColorInterpolator = SPK::ColorGraphInterpolator::create();
   flameColorInterpolator->addEntry(0.0f,SPK::Color(255,128,51,255));
   flameColorInterpolator->addEntry(0.5f,SPK::Color(153,89,51,255));
   flameColorInterpolator->addEntry(1.0f,SPK::Color(51,51,51,0));
   flameGroup->setColorInterpolator(flameColorInterpolator);

   // flash group
   SPK::Ref<SPK::Group> flashGroup = system->createGroup(3);
   flashGroup->addEmitter(flashEmitter);
   flashGroup->setRenderer(flashRenderer);
   flashGroup->setLifeTime(0.5f,0.5f);
   flashGroup->setParamInterpolator(SPK::PARAM_ANGLE,SPK::FloatRandomInitializer::create(0.0f,2.0f * irr::core::PI));

   SPK::Ref<SPK::ColorGraphInterpolator> flashColorInterpolator = SPK::ColorGraphInterpolator::create();
   flashColorInterpolator->addEntry(0.0f,SPK::Color(255,255,255,255));
   flashColorInterpolator->addEntry(0.4f,SPK::Color(255,255,255,0));
   flashGroup->setColorInterpolator(flashColorInterpolator);

   SPK::Ref<SPK::FloatGraphInterpolator> flashSizeInterpolator = SPK::FloatGraphInterpolator::create();
   flashSizeInterpolator->addEntry(0.0f,0.25f);
   flashSizeInterpolator->addEntry(0.1f,1.0f,2.0f);
   flashGroup->setParamInterpolator(SPK::PARAM_SCALE,flashSizeInterpolator);

   // spark 1 group
   SPK::Ref<SPK::Group> spark1Group = system->createGroup(20);
   spark1Group->addEmitter(spark1Emitter);
   spark1Group->addModifier(SPK::Gravity::create(SPK::Vector3D(0.0f,-1.5f,0.0f)));
   spark1Group->setRenderer(spark1Renderer);
   spark1Group->setLifeTime(0.2f,1.0f);
   spark1Group->setParamInterpolator(SPK::PARAM_SCALE,SPK::FloatRandomInitializer::create(0.2f,0.4f));
   spark1Group->setColorInterpolator(SPK::ColorSimpleInterpolator::create(SPK::Color(255,255,255,255),SPK::Color(255,255,255,0)));

   // spark 2 group
   SPK::Ref<SPK::Group> spark2Group = system->createGroup(400);
   spark2Group->addEmitter(spark2Emitter);
   spark2Group->addModifier(SPK::Gravity::create(SPK::Vector3D(0.0f,-0.3f,0.0f)));
   spark2Group->addModifier(SPK::Friction::create(0.4f));
   spark2Group->setRenderer(spark2Renderer);
   spark2Group->setLifeTime(1.0f,3.0f);
   spark2Group->setColorInterpolator(SPK::ColorRandomInterpolator::create(SPK::Color(255,255,179,255),SPK::Color(255,255,179,255),SPK::Color(255,77,77,0),SPK::Color(255,255,77,0)));

   // wave group
   SPK::Ref<SPK::Group> waveGroup = system->createGroup(1);
   waveGroup->addEmitter(waveEmitter);
   waveGroup->setRenderer(waveRenderer);
   waveGroup->setLifeTime(0.8f,0.8f);
   waveGroup->setColorInterpolator(SPK::ColorSimpleInterpolator::create(SPK::Color(255,255,255,51),SPK::Color(255,255,255,0)));
   waveGroup->setParamInterpolator(SPK::PARAM_SCALE,SPK::FloatSimpleInterpolator::create(0.0f,4.0f));

   // Finalize
   system->initialize();
   return system;
}

// Input Receiver
class MyEventReceiver : public IEventReceiver
{
   public:
      virtual bool OnEvent(const SEvent& event)
      {
         if(event.EventType==EET_KEY_INPUT_EVENT)
         {
            if(event.KeyInput.Key == KEY_ESCAPE && event.KeyInput.PressedDown==false)
            {
               device->closeDevice();
            }
            else if(event.KeyInput.Key == KEY_SPACE && event.KeyInput.PressedDown==false)
            {
               //*
               SPK::Vector3D position(random(-2.0f,2.0f),random(-2.0f,2.0f),random(-2.0f,2.0f));
               SPK::Ref<SPK::System> sys = createParticleSystem(position);
               irr::scene::CSPKParticleSystemNode* system = new irr::scene::CSPKParticleSystemNode(sys, device->getSceneManager()->getRootSceneNode(), device->getSceneManager(),false);
               system->setPosition(SPK::IRR::spk2irr(position));
               system->setID(42);
               system->drop(); // We let the scene manager take care of the system life time
               //*/
               /*
               irr::scene::CSPKParticleSystemNode* system = new irr::scene::CSPKParticleSystemNode(device->getSceneManager()->getRootSceneNode(),device->getSceneManager());
               system->drop(); // We let the scene manager take care of the system life time
               SPK::Ref<SPK::IRR::IRRQuadRenderer> quadRenderer = SPK::IRR::IRRQuadRenderer::create(device);
               quadRenderer->setBlendMode(SPK::BLEND_MODE_ADD);
               quadRenderer->enableRenderingOption(SPK::RENDERING_OPTION_DEPTH_WRITE,false);
               quadRenderer->setTexture(0);
               quadRenderer->setTexturingMode(SPK::TEXTURE_MODE_2D);

               SPK::Ref<SPK::RandomEmitter> emitter = SPK::RandomEmitter::create(SPK::Point::create());
               emitter->setForce(0.4f,0.6f);
               emitter->setFlow(200);

               SPK::Ref<SPK::ColorGraphInterpolator> graphInterpolator = SPK::ColorGraphInterpolator::create();
               graphInterpolator->addEntry(0.0f,0xFF000088);
               graphInterpolator->addEntry(0.5f,0x00FF0088);
               graphInterpolator->addEntry(1.0f,0x0000FF88);

               SPK::Ref<SPK::Group> group = system->createSPKGroup(400);
               group->setRadius(0.15f);
               group->setLifeTime(1.0f,2.0f);
               group->setColorInterpolator(graphInterpolator);
               group->setParamInterpolator(SPK::PARAM_SCALE,SPK::FloatRandomInterpolator::create(0.8f,1.2f,0.0f,0.0f));
               group->setParamInterpolator(SPK::PARAM_ANGLE,SPK::FloatRandomInitializer::create(0.0f,2 * 3.14159f));
               group->addEmitter(emitter);
               group->addModifier(SPK::Gravity::create(SPK::Vector3D(0.0f,-0.5f,0.0f)));
               group->addModifier(SPK::Friction::create(0.2f));
               group->setRenderer(quadRenderer);
               //*/
            }
         }
         return false;
      }

      int oldMouseX,oldMouseY;
};

// Main function
int main(int argc, char *argv[])
{
   //!IRRLICHT
   video::E_DRIVER_TYPE chosenDriver = video::EDT_OPENGL;
#ifdef _WIN32
   if(MessageBoxA(0,"Do you want to use DirectX 9 ? (else OpenGL)","SPARK Irrlicht test",MB_YESNO | MB_ICONQUESTION) == IDYES)
      chosenDriver = video::EDT_DIRECT3D9;
#endif

   //!IRRLICHT
   device = createDevice(chosenDriver,
      core::dimension2d<u32>(800,600),
      32,
      false,
      false,
      false,
      new MyEventReceiver);

   video::IVideoDriver* driver = device->getVideoDriver();
   scene::ISceneManager* smgr = device->getSceneManager();
   gui::IGUIEnvironment* guienv = device->getGUIEnvironment();

   device->setWindowCaption(L"SPARK Irrlicht test");
   device->getCursorControl()->setVisible(false);
   irr::scene::ICameraSceneNode* cam = smgr->addCameraSceneNodeFPS(smgr->getRootSceneNode(),100.0f,0.0005f);
   cam->setPosition(irr::core::vector3df(2,2,2));
   cam->setTarget(irr::core::vector3df(0.0f,0.0f,0.0f));
   cam->setNearValue(0.05f);
   cam->setFarValue(200.0f);

   // Inits Particle Engine
   // Sets the update step
   SPK::System::setClampStep(true,0.1f);         // clamp the step to 100 ms
   SPK::System::useAdaptiveStep(0.001f,0.01f);      // use an adaptive step from 1ms to 10ms (1000fps to 100fps)

   explosionTexture = driver->getTexture("res\\explosion.bmp");
   flashTexture = driver->getTexture("res\\flash.bmp");
   spark1Texture = driver->getTexture("res\\spark1.bmp");
   spark2Texture = driver->getTexture("res\\point.bmp");
   waveTexture = driver->getTexture("res\\wave.bmp");

   int frame = 0, particleCount = 0;
   irr::core::aabbox3df bbox;
   while(device->run())
   {
      frame++;

      driver->beginScene(true, true, irr::video::SColor(0,0,0,0));

      // Renders scene
      smgr->drawAll();

      irr::core::stringw infos; infos+="FPS: "; infos+=driver->getFPS(); infos += " - Polys: "; infos += driver->getPrimitiveCountDrawn(0); infos += " - Nb particles: "; infos += particleCount;
      guienv->getBuiltInFont()->draw(infos.c_str(),irr::core::rect<irr::s32>(0,0,170,20),irr::video::SColor(255,255,255,255));

      driver->endScene();

      // Delete sleeping systems every 10 frames
      if(frame % 10 == 0)
      {
         irr::core::list<irr::scene::ISceneNode*> nodes = smgr->getRootSceneNode()->getChildren();
         for(irr::core::list<irr::scene::ISceneNode*>::Iterator it = nodes.begin(); it != nodes.end(); ++it)
            if((*it)->getID() == 42)
            {
               irr::scene::CSPKParticleSystemNode* node = (irr::scene::CSPKParticleSystemNode*)(*it);
               if(!node->isAlive())
                  node->remove();
            }
      }
      else // Else update particle count
      {
         particleCount = 0;
         irr::core::list<irr::scene::ISceneNode*> nodes = smgr->getRootSceneNode()->getChildren();
         for(irr::core::list<irr::scene::ISceneNode*>::Iterator it = nodes.begin(); it != nodes.end(); ++it)
            if((*it)->getID() == 42)
               particleCount += ((irr::scene::CSPKParticleSystemNode*)(*it))->getNbParticles();
      }
   }

   device->drop();
   SPK_DUMP_MEMORY

   return 0;
}
IMPORTANT: You must add
Code:
group->setRadius(1.0f)
where 'group' is the name of a group (smokeGroup, etc...) for ALL groups.
There is still a bug with the blending of smoke, will investigate when the controller system is finished.
Note that this demo can be slow in debug mode as every object creation is logged to the console (and printf is a slow function).

_________________
Back to top Go down
View user profile
Sponsored content




PostSubject: Re: SPARK2 explosion demo   Today at 3:42 am

Back to top Go down
 
SPARK2 explosion demo
View previous topic View next topic Back to top 
Page 1 of 1
 Similar topics
-
» Should Nintendo Release A Splatoon Demo And Advertise The Heck Out of It?
» how to put this slider into my annoucement
» Moto Heroz (NL Racers)
» FE7 Batta Mode DEMO
» Super Smash Bros. for 3DS demo first impressions

Permissions in this forum:You cannot reply to topics in this forum
 :: English Forum :: Questions (en)-
Jump to: