HomeHome  CalendarCalendar  FAQFAQ  SearchSearch  MemberlistMemberlist  UsergroupsUsergroups  RegisterRegister  Log inLog in  

Share | 
 

 IRRSystem

View previous topic View next topic Go down 
AuthorMessage
Escen



Messages : 9
Date d'inscription : 2009-12-01

PostSubject: IRRSystem    Sun Apr 24, 2011 4:05 am

I want to use IRRSystem to manual setVisible the particlesystem.
In Code::Blocks with GNU GCC compiler this works fine, but when I use Microsoft Visual C++ 2005/2008 as compiler it crashes on the setVisible function.

For a simple test I just modified the IRRFiredemo.cpp with the following:

Code:
IRRSystem* particleSystem = NULL;

added:
Code:
particleSystem->setVisible(false);


linked all my libraries to the vc2008 path and coppied the dynamic dll's in my executable path.

any idea what I'm missing here?
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: IRRSystem    Mon Apr 25, 2011 4:52 am

Hello,

Could you please show the whole code, including the IRRSystem initialization ?

Whatever you use, manual update/rendering or Irrlicht system, visibility is set manually.
More about it here: http://spark.forum0.net/t114-disable-enable-hide-particle-system
Back to top Go down
View user profile
Escen



Messages : 9
Date d'inscription : 2009-12-01

PostSubject: Re: IRRSystem    Mon Apr 25, 2011 9:03 am

Hello,

It didn't work in my main app, so I made a small test with the standard IRRFiredemo.cpp but I have the same result.
GNU GCC compiler works fine, but when I use Microsoft Visual C++ 2005/2008 as compiler it crashed.

When commenting setVisible and setAutoUpdateEnabled it's running 'normally'.

here is the complete code I'm using:

Code:
//////////////////////////////////////////////////////////////////////////////////
// SPARK Irrlicht Rendering library                                    //
// Copyright (C) 2009                                             //
// Thibault Lescoat -  info-tibo <at> orange <dot> fr                     //
// Julien Fryer - julienfryer@gmail.com                                 //
//                                                            //
// 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>

// SPARK lib
#include <SPK.h>
#include <SPK_IRR.h>

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

using namespace std;
using namespace irr;
using namespace SPK;
using namespace SPK::IRR;

float angleY = 10.0f;
float angleX = -45.0f;
float camPosZ = 5.0f;

int deltaTime = 0;

const float PI = 3.14159265358979323846f;

const string STR_NB_PARTICLES = "NB PARTICLES : ";
const string STR_FPS = "FPS : ";

string strNbParticles = STR_NB_PARTICLES;
string strFps = STR_FPS;

Group* fireGroup = NULL;
Group* smokeGroup = NULL;
Emitter* smokeEmitter = NULL;
IRRSystem* particleSystem = NULL;

IrrlichtDevice* device = NULL;
scene::ICameraSceneNode* cam = NULL;

bool smokeEnabled = true;

// Input Receiver
class MyEventReceiver : public IEventReceiver
{
    public:
      MyEventReceiver() :
        IEventReceiver(),
        init(false)
        {}

        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();
            }
                if(event.KeyInput.Key == KEY_SPACE && event.KeyInput.PressedDown==false)
                {
                    smokeEnabled=!smokeEnabled;
                    smokeGroup->getEmitter(0)->setActive(smokeEnabled);
                    return true;
                }
                if(event.KeyInput.Key == KEY_DELETE && event.KeyInput.PressedDown==false)
                {
                    particleSystem->empty();
                    return true;
                }
            if(event.KeyInput.Key == KEY_KEY_V && event.KeyInput.PressedDown==false)
            {
               IRRBuffer::activateVBOHint(!IRRBuffer::isVBOHintActivated());
               return true;
            }
            }
            else if(event.EventType == EET_MOUSE_INPUT_EVENT)
            {
            if (init)
            {
               angleX += (oldMouseX - event.MouseInput.X)*0.1f;
               angleY += (oldMouseY - event.MouseInput.Y)*0.1f;

               if(angleY < 1.0f) angleY=1.0f;
               if(angleY > 70.0f) angleY=70.0f;
               camPosZ -= event.MouseInput.Wheel;
               if(camPosZ < 3.0f) camPosZ=3.0f;
               if(camPosZ > 18.0f) camPosZ=18.0f;

               cam->setPosition(core::vector3df(camPosZ*sinf(angleX*core::DEGTORAD)*sinf((90.0f-angleY)*core::DEGTORAD),
                  camPosZ*cosf((90.0f-angleY)*core::DEGTORAD),camPosZ*cosf(angleX*core::DEGTORAD)*sinf((90.0f-angleY)*core::DEGTORAD)));
               cam->setTarget(core::vector3df());
            }

            init = true;
            oldMouseX=event.MouseInput.X;
            oldMouseY=event.MouseInput.Y;

                return true;
            }
            return false;
        }

        int oldMouseX,oldMouseY;

   private :

      bool init;
};

// 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 ?","SPARK Fire Demo using Irrlicht",MB_YESNO) == 6)
        //chosenDriver = video::EDT_DIRECT3D9;
#endif

    //!IRRLICHT
   MyEventReceiver* evtrcv = new MyEventReceiver;
   device = createDevice(chosenDriver,
      core::dimension2d<u32>(640,480),
      32,
      false,
      false,
      false,
      evtrcv);

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

    device->setWindowCaption(L"SPARK Fire Demo using Irrlicht");
   device->getCursorControl()->setVisible(false);
    cam = smgr->addCameraSceneNode(0,core::vector3df(camPosZ*sinf(angleX*core::DEGTORAD)*sinf((90.0f-angleY)*core::DEGTORAD),
        camPosZ*cosf((90.0f-angleY)*core::DEGTORAD),camPosZ*cosf(angleX*core::DEGTORAD)*sinf((90.0f-angleY)*core::DEGTORAD)),
        core::vector3df());
    cam->setNearValue(0.05f);

   scene::IMesh* sceneryMesh = smgr->getMesh("res/SceneFireCamp.obj");
   scene::ISceneNode* sceneryNode = smgr->addMeshSceneNode(sceneryMesh);
   sceneryNode->setPosition(core::vector3df(0.0f,-1.5f,0.0f));
   sceneryNode->setScale(core::vector3df(0.01f,0.01f,0.01f));

   smgr->setAmbientLight(video::SColorf(0.15f,0.15f,0.25f));

   scene::ILightSceneNode* lightNode = smgr->addLightSceneNode();
   lightNode->setLightType(video::ELT_SPOT);
   video::SLight& lightData = lightNode->getLightData();
   lightData.AmbientColor = video::SColorf(0.0f,0.0f,0.0f);
   lightData.DiffuseColor = video::SColorf(1.0f,0.75f,0.25f);
   lightData.InnerCone = 180.0f;
   lightData.OuterCone = 180.0f;
   lightData.Attenuation.X = 0.0f;
   lightData.Attenuation.Y = 0.0f;

   // random seed
   randomSeed = device->getTimer()->getRealTime();
   // Sets the update step
   System::setClampStep(true,0.1f);         // clamp the step to 100 ms
   System::useAdaptiveStep(0.001f,0.01f);      // use an adaptive step from 1ms to 10ms (1000fps to 100fps)

   // Inits Particle Engine

   // Renderers
   IRRQuadRenderer* fireRenderer = IRRQuadRenderer::create(device);
   fireRenderer->setScale(0.3f,0.3f);
   fireRenderer->setTexture(driver->getTexture("res/fire2.bmp"));
   fireRenderer->setTexturingMode(TEXTURE_2D);
   fireRenderer->setBlending(BLENDING_ADD);
   fireRenderer->enableRenderingHint(DEPTH_WRITE,false);
   fireRenderer->setAtlasDimensions(2,2);

   IRRQuadRenderer* smokeRenderer = IRRQuadRenderer::create(device);
   smokeRenderer->setScale(0.3f,0.3f);
   smokeRenderer->setTexture(driver->getTexture("res/explosion.png"));
   smokeRenderer->setTexturingMode(TEXTURE_2D);
   smokeRenderer->setBlending(BLENDING_ALPHA);
   smokeRenderer->enableRenderingHint(DEPTH_WRITE,false);
   smokeRenderer->setAtlasDimensions(2,2);

   // Models
   Model* fireModel = Model::create(FLAG_RED | FLAG_GREEN | FLAG_BLUE | FLAG_ALPHA | FLAG_SIZE | FLAG_ANGLE | FLAG_TEXTURE_INDEX,
      FLAG_RED | FLAG_GREEN | FLAG_ALPHA | FLAG_ANGLE,
      FLAG_RED | FLAG_GREEN | FLAG_TEXTURE_INDEX | FLAG_ANGLE,
      FLAG_SIZE);
   fireModel->setParam(PARAM_RED,0.8f,0.9f,0.8f,0.9f);
   fireModel->setParam(PARAM_GREEN,0.5f,0.6f,0.5f,0.6f);
   fireModel->setParam(PARAM_BLUE,0.3f);
   fireModel->setParam(PARAM_ALPHA,0.4f,0.0f);
   fireModel->setParam(PARAM_ANGLE,0.0f,2.0f * PI,0.0f,2.0f * PI);
   fireModel->setParam(PARAM_TEXTURE_INDEX,0.0f,4.0f);
   fireModel->setLifeTime(1.0f,1.5f);

   Interpolator* interpolator = fireModel->getInterpolator(PARAM_SIZE);
   interpolator->addEntry(0.5f,2.0f,5.0f);
   interpolator->addEntry(1.0f,0.0f);

   Model* smokeModel = Model::create(FLAG_RED | FLAG_GREEN | FLAG_BLUE | FLAG_ALPHA | FLAG_SIZE | FLAG_ANGLE | FLAG_TEXTURE_INDEX,
      FLAG_RED | FLAG_GREEN | FLAG_SIZE | FLAG_ANGLE,
      FLAG_TEXTURE_INDEX | FLAG_ANGLE,
      FLAG_ALPHA);
   smokeModel->setParam(PARAM_RED,0.3f,0.2f);
   smokeModel->setParam(PARAM_GREEN,0.25f,0.2f);
   smokeModel->setParam(PARAM_BLUE,0.2f);
   smokeModel->setParam(PARAM_ALPHA,0.2f,0.0f);
   smokeModel->setParam(PARAM_SIZE,5.0,10.0f);
   smokeModel->setParam(PARAM_TEXTURE_INDEX,0.0f,4.0f);
   smokeModel->setParam(PARAM_ANGLE,0.0f,2.0f * PI,0.0f,2.0f * PI);
   smokeModel->setLifeTime(5.0f,5.0f);

   interpolator = smokeModel->getInterpolator(PARAM_ALPHA);
   interpolator->addEntry(0.0f,0.0f);
   interpolator->addEntry(0.2f,0.2f);
   interpolator->addEntry(1.0f,0.0f);

   // Emitters
   // The emitters are arranged so that the fire looks realistic
   StraightEmitter* fireEmitter1 = StraightEmitter::create(Vector3D(0.0f,1.0f,0.0f));
   fireEmitter1->setZone(Sphere::create(Vector3D(0.0f,-1.0f,0.0f),0.5f));
   fireEmitter1->setFlow(40);
   fireEmitter1->setForce(1.0f,2.5f);

   StraightEmitter* fireEmitter2 = StraightEmitter::create(Vector3D(1.0f,0.6f,0.0f));
   fireEmitter2->setZone(Sphere::create(Vector3D(0.15f,-1.2f,0.075f),0.1f));
   fireEmitter2->setFlow(15);
   fireEmitter2->setForce(0.5f,1.5f);

   StraightEmitter* fireEmitter3 = StraightEmitter::create(Vector3D(-0.6f,0.8f,-0.8f));
   fireEmitter3->setZone(Sphere::create(Vector3D(-0.375f,-1.15f,-0.375f),0.3f));
   fireEmitter3->setFlow(15);
   fireEmitter3->setForce(0.5f,1.5f);

   StraightEmitter* fireEmitter4 = StraightEmitter::create(Vector3D(-0.8f,0.5f,0.2f));
   fireEmitter4->setZone(Sphere::create(Vector3D(-0.255f,-1.2f,0.225f),0.2f));
   fireEmitter4->setFlow(10);
   fireEmitter4->setForce(0.5f,1.5f);

   StraightEmitter* fireEmitter5 = StraightEmitter::create(Vector3D(0.1f,0.8f,-1.0f));
   fireEmitter5->setZone(Sphere::create(Vector3D(-0.075f,-1.2f,-0.3f),0.2f));
   fireEmitter5->setFlow(10);
   fireEmitter5->setForce(0.5f,1.5f);

   smokeEmitter = SphericEmitter::create(Vector3D(0.0f,1.0f,0.0f),0.0f,0.5f * PI);
   smokeEmitter->setZone(Sphere::create(Vector3D(),1.2f));
   smokeEmitter->setFlow(25);
   smokeEmitter->setForce(0.5f,1.0f);

   // Groups
   fireGroup = Group::create(fireModel,135);
   fireGroup->addEmitter(fireEmitter1);
   fireGroup->addEmitter(fireEmitter2);
   fireGroup->addEmitter(fireEmitter3);
   fireGroup->addEmitter(fireEmitter4);
   fireGroup->addEmitter(fireEmitter5);
   fireGroup->setRenderer(fireRenderer);
   fireGroup->setGravity(Vector3D(0.0f,3.0f,0.0f));
   fireGroup->enableAABBComputing(true);

   smokeGroup = Group::create(smokeModel,135);
   smokeGroup->addEmitter(smokeEmitter);
   smokeGroup->setRenderer(smokeRenderer);
   smokeGroup->setGravity(Vector3D(0.0f,0.4f,0.0f));
   smokeGroup->enableAABBComputing(true);

   // System
   particleSystem = IRRSystem::create(smgr->getRootSceneNode(),smgr);
   particleSystem->addGroup(smokeGroup);
   particleSystem->addGroup(fireGroup);
   particleSystem->enableAABBComputing(true);


   //Added this
   particleSystem->setVisible(false);
    particleSystem->setAutoUpdateEnabled(false,false);
   
   // setup some useful variables
   float time=(f32)device->getTimer()->getTime() / 1000.0f,oldtime,deltaTime;
   float step = 0.0f;

   cout << "\nSPARK FACTORY AFTER INIT :" << endl;
   SPKFactory::getInstance().traceAll();

   float lightTime = 0.05f;

   while(device->run())
   {
      oldtime = time;
        time = (f32)device->getTimer()->getTime() / 1000.0f;
        deltaTime = time - oldtime;

      lightTime += deltaTime;
      if (lightTime >= 0.05f)
      {
         float lightIntensity = 1.0f - (random(0.0f,0.05f) * 5.0f);
         lightTime -= lightTime;
         lightNode->setPosition(core::vector3df(random(-0.5f,0.5f),0.5f + random(-0.5f,0.5f),random(-0.5f,0.5f)));
         lightNode->getLightData().Attenuation.Z = 15.0f / lightIntensity;
      }

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

      // Renders scene
      smgr->drawAll();

      core::stringw infos; infos+="FPS: "; infos+=driver->getFPS(); infos+=" - Nb Particles: "; infos+=particleSystem->getNbParticles();
      infos+=" - VBO: "; infos+=(IRRBuffer::isVBOHintActivated() ? "true" : "false");
        guienv->getBuiltInFont()->draw(infos.c_str(),core::rect<s32>(0,0,170,20),video::SColor(255,255,255,255));

      driver->endScene();

      // clip mouse
        if(device->getCursorControl()->getPosition().X < 20)
        {
            device->getCursorControl()->setPosition(620,device->getCursorControl()->getPosition().Y);
            evtrcv->oldMouseX = 620;
        }
        if(device->getCursorControl()->getPosition().X > 620)
        {
            device->getCursorControl()->setPosition(20,device->getCursorControl()->getPosition().Y);
            evtrcv->oldMouseX = 20;
        }
        if(device->getCursorControl()->getPosition().Y < 20)
        {
            device->getCursorControl()->setPosition(device->getCursorControl()->getPosition().X,460);
            evtrcv->oldMouseY = 460;
        }
        if(device->getCursorControl()->getPosition().Y > 460)
        {
            device->getCursorControl()->setPosition(device->getCursorControl()->getPosition().X,20);
            evtrcv->oldMouseY = 20;
        }
   }

   cout << "\nSPARK FACTORY BEFORE DESTRUCTION :" << endl;
   SPKFactory::getInstance().traceAll();
   SPKFactory::getInstance().destroyAll();
   cout << "\nSPARK FACTORY AFTER DESTRUCTION :" << endl;
   SPKFactory::getInstance().traceAll();
   device->drop();

   cout << endl;
   system("pause"); // Waits for the user to close the console

   return 0;
}
Back to top Go down
View user profile
Juff
Developer


Messages : 539
Date d'inscription : 2009-07-14
Age : 34

PostSubject: Re: IRRSystem    Tue Apr 26, 2011 3:53 am

Hi, seems like a linking problem to me.

When compiling spark with visual, you need to link to an irrlicht compiled with visual and when compiling with gcc, you need to link with an Irrlicht compiled with gcc. Is that what you did ?
Back to top Go down
View user profile http://spark.developpez.com
Escen



Messages : 9
Date d'inscription : 2009-12-01

PostSubject: Re: IRRSystem    Tue Apr 26, 2011 2:52 pm

Hi Juff,

Quote :
When compiling spark with visual, you need to link to an irrlicht compiled with visual and when compiling with gcc, you need to link with an Irrlicht compiled with gcc. Is that what you did ?

Yes, I linked all to the visual versions.
Also the compiler settings in Code::Blocks are pointing to the correct installation directory (using VC2008).

But replaced all Spark-dll's with the VC2005 versions all works fine!!

Correct me if I'm wrong, I guess I have to compile Irrlicht with VC2008.



Back to top Go down
View user profile
Juff
Developer


Messages : 539
Date d'inscription : 2009-07-14
Age : 34

PostSubject: Re: IRRSystem    Tue Apr 26, 2011 3:14 pm

This is strange, i am using myself VS2008 with no problem. However I dont know if i checked the setVisible or not.

Either recompile SPARK with the correct version of Irrlicht or recompile Irrlicht with the version SPARK uses. All in all, both SPARK and your app must be compile under the same version of Irrlicht. In other words, the .lib used to compile SPARK must be the one going with the .dll your using at runtime.

I ll have a try a home and let you know.
Back to top Go down
View user profile http://spark.developpez.com
Sponsored content




PostSubject: Re: IRRSystem    Today at 3:38 am

Back to top Go down
 
IRRSystem
View previous topic View next topic Back to top 
Page 1 of 1

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