Module Irrlicht en développement

inline float f_cos(float v)
{
    static float inv90 = 1.0f/90.0f;
    static float inv180 = 1.0f/180.0f;

    int numClass = (v + f_sign(v) * 90.0f) * inv180;
    float x = (v * inv90 - (float)numClass * 2);
    if(numClass & 1)
        return x * x - 1;
    else
        return 1 - x * x;
}

int numClass = (v + (abs(v)/v) * 90.0f) * inv180;

int numClass = (v + (v > 0 ? 90.0f : -90.0f)) * inv180;

fast cos is 50% faster than std cos
lut cos is 108% faster than std cos
lut2 cos is 76% faster than std cos

fast cos : avg error=0.0104858 - max error=0.0560169
lut cos : avg error=0.00292838 - max error=0.0174548
lut2 cos : avg error=3.61282e-005 - max error=0.000186011

#include <irrlicht.h>
#include <SPK.h>

#include <ctime>
#include "SPARK\final\SPK_IRR_Renderer.h"

#include "SPARK\final\imp_QuadFinder.h"

using namespace irr;

// Calls back function to have particle bounce on the floor
bool bounceOnFloor(SPK::Particle& particle,float deltaTime)
{
   if (particle.position().y < 0.015f)
   {
      particle.position().y = 0.015f;
      particle.velocity().y = -particle.velocity().y * 0.6f;
   }
   return false;
}

bool paused = false;
SPK::IRR::IrrRenderer* renderer = 0;

class MyEventReceiver : public irr::IEventReceiver
{
    public:
        virtual bool OnEvent(const irr::SEvent& event)
        {
            if(event.EventType == irr::EET_KEY_INPUT_EVENT)
            {
                if(event.KeyInput.Key == irr::KEY_SPACE && event.KeyInput.PressedDown == false)
                {
                    paused = !paused;
                    return true;
                }
                if(event.KeyInput.Key == irr::KEY_F4 && event.KeyInput.PressedDown == false)
                {
                    static int last=1;
                    last++; if(last>3) last=0;
                    if(renderer)
                        renderer->setRenderMode((SPK::IRR::E_IRRSPK_RENDERMODE)last);
                    return true;
                }
            }
            return false;
        }
};

int main(int argc, char** argv)
{
    //!IRRLICHT
    IrrlichtDevice *device = createDevice(video::EDT_DIRECT3D9, core::dimension2d<u32>(640, 480), 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 using Irrlicht");
    irr::scene::ICameraSceneNode* cam = smgr->addCameraSceneNodeFPS(smgr->getRootSceneNode(),100.0f,0.0005f);
    cam->setPosition(irr::core::vector3df(1.5f,1.5f,1.5f));
    cam->setTarget(irr::core::vector3df(0.0f,0.015f,0.0f));
    cam->setNearValue(0.05f);

    //!SPARK
    SPK::randomSeed = static_cast<unsigned int>(time(NULL));

    // importé depuis BasicDemo.cpp
    // Inits Particle Engine
   SPK::Vector3D gravity(0.0f,-0.8f,0.0f);

   // Renderer
   renderer = new SPK::IRR::IrrRenderer(device);
   renderer->setTexture(driver->getTexture("media\\point.bmp"));

   // System
   SPK::System particleSystem;

   // Model
   SPK::Model particleModel(SPK::FLAG_RED | SPK::FLAG_GREEN | SPK::FLAG_BLUE | SPK::FLAG_ALPHA);
   particleModel.setParam(SPK::PARAM_ALPHA,0.8f); // constant alpha
   particleModel.setLifeTime(8.0f,8.0f);

   // Emitter
   SPK::Point point(SPK::Vector3D(0.0f,0.015f,0.0f));
   SPK::SphericEmitter particleEmitter(SPK::Vector3D(0.0f,1.0f,0.0f),0.1f * irr::core::PI,0.1f * irr::core::PI);
   particleEmitter.setZone(&point);
   particleEmitter.setFlow(250);
   particleEmitter.setForce(1.5f,1.5f);

   // Group
   SPK::Group particleGroup(&particleModel,2100);
   particleGroup.addEmitter(&particleEmitter);
   particleGroup.setRenderer(renderer);
   particleGroup.setCustomUpdate(&bounceOnFloor);
   particleGroup.setGravity(gravity);
/*
// Emitter 2
SPK::Point point2(SPK::Vector3D(0.0f,2.0f,0.0f));
SPK::SphericEmitter particleEmitter2(SPK::Vector3D(1.0f,1.0f,1.0f),0.1f * irr::core::PI,0.1f * irr::core::PI);
particleEmitter2.setZone(&point2);
particleEmitter2.setFlow(250);
particleEmitter2.setForce(1.5f,1.5f);

// Group 2
SPK::Group particleGroup2(&particleModel,2100);
particleGroup2.addEmitter(&particleEmitter2);
particleGroup2.setRenderer(renderer);
particleGroup2.setCustomUpdate(&bounceOnFloor);
particleGroup2.setGravity(gravity);*/

   particleSystem.addGroup(&particleGroup);

http://particleSystem.addGroup(&particleGroup2);


    //!BOUCLE
    float time=(irr::f32)device->getTimer()->getTime() / 1000.0f,oldtime,deltaT;
    float step=0.0f;
    while(device->run())
    {
        oldtime = time;
        time = (irr::f32)device->getTimer()->getTime() / 1000.0f;
        deltaT = time - oldtime;

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

        // Changes the color of the model over time
        step += deltaT;
        http://particleModel.setParam(SPK::PARAM_RED,0.6f + 0.4f * sin(step));
        http://particleModel.setParam(SPK::PARAM_GREEN,0.6f + 0.4f * sin(step + irr::core::PI * 2.0f / 3.0f));
        http://particleModel.setParam(SPK::PARAM_BLUE,0.6f + 0.4f * sin(step + irr::core::PI * 4.0f / 3.0f));

        // Updates particle system
        if(!paused) particleSystem.update(deltaT);   // 1 defined as a second

        // render particles
        smgr->drawAll();
        particleSystem.render();

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

        driver->endScene();
    }

    particleGroup.setRenderer(0);
    delete renderer;
    device->drop();

    return 0;
}

#ifndef _SPARK_IRRLICHT_RENDERER_
#define _SPARK_IRRLICHT_RENDERER_

#include <irrlicht.h>
#include <SPK.h>
#include "SPK_IRR_Defs.h"

namespace SPK
{
namespace IRR
{
    class ImpIrrRenderer;

    //! A renderer using Irrlicht
    /** This renderer allow you to use several renderers easily with Irrlicht. You can switch
        between render mode simply by calling setRenderMode(). Each rendermode will be described
        here:
        * First, there is a point renderer. Each particle is rendered as a point, and you can
          change the size for a point. Don't forget that the default size is about 1 px, therefore some people
          might see this points hardly... This is a simple renderer, mainly designed for debugging purposes.
          However this renderer has been optimized for speed and is the fastest render mode of this
          renderer. Be aware that changing point size affect the fps heavily if the fill rate of
          your graphic card is average.
        * You can also use a line renderer.
    **/
    class IrrRenderer : public Renderer
    {
        SPK_IMPLEMENT_REGISTERABLE(IrrRenderer)

        public:
            //! Constructor
            IrrRenderer(irr::IrrlichtDevice* d);

            //! Destructor
            ~IrrRenderer();

        // QUADS
            //! Set the texture to apply on quads or to use as atlas //CONVENIENCE FUNCTION
            virtual void setTexture(irr::video::ITexture* tex);

            //! Get the texture applied on quads (or used as atlas) //CONVENIENCE FUNCTION
            virtual irr::video::ITexture* getTexture() const;

            //! Set atlas dimensions
            virtual void setAtlasDimension(unsigned int dimX, unsigned int dimY);
            virtual void setAtlasDimension(irr::core::dimension2d<irr::u32> dim);

            //! Get atlas dimensions
            virtual irr::core::dimension2d<irr::u32> getAtlasDimension() const;

        // QUAD AND OBJECT
            //! Set quads or objects orientation
            virtual void setOrientation(E_IRRSPK_ORIENTATION o);

            //! Get quads or objects orientation
            virtual E_IRRSPK_ORIENTATION getOrientation() const;

        // QUAD, OBJECTS, POINTS AND LINES
            //! Set scale (for non 3D : thickness)
            virtual void setScale(float s);

            //! Get scale (for non 3D : thickness)
            virtual float getScale() const;

            //! Get the material
            virtual irr::video::SMaterial& getMaterial();

            //! Update material (must call this after a modification to the material)
            virtual void updateMaterial();

        // LINES
            //! Set line length
            virtual void setLength(float l);

            //! Get line length
            virtual float getLength() const;

        // MISC
            //! Render the group
            virtual void  render(const Group &group);

            //! Create mesh buffers
            virtual inline void createBuffers(const Group& group) {}

            //! Delete mesh buffers
            virtual inline void destroyBuffers(const Group& group) {}

            //! Get the Irrlicht Device
            virtual irr::IrrlichtDevice* getDevice() const { return device; }

            //! Set the VBO hint
            virtual void setHardwareMappingHint(irr::scene::E_HARDWARE_MAPPING m);

            //! Get the VBO hint
            virtual irr::scene::E_HARDWARE_MAPPING getHardwareMappingHint() const;

            //! Set the render mode
            virtual void setRenderMode(E_IRRSPK_RENDERMODE rm);

            //! Get the render mode
            virtual E_IRRSPK_RENDERMODE getRenderMode();

            //! Set the index mode
            virtual void setIndexMode(E_IRRSPK_INDEXMODE im) {}

            //! Get the index mode
            virtual E_IRRSPK_INDEXMODE getIndexMode() {}
        private:
            irr::IrrlichtDevice* device;
            ImpIrrRenderer* rendererArray[EIRM_COUNT];
            int currentRenderer;
    };
}
}

#endif // _SPARK_IRRLICHT_RENDERER_

#ifndef _SPARK_IRRLICHT_RENDERER_DEFINES_
#define _SPARK_IRRLICHT_RENDERER_DEFINES_

#include <irrlicht.h>
#include <SPK.H>
#include <string>

namespace SPK
{
namespace IRR
{
    //! Lists all possible render modes
    enum E_IRRSPK_RENDERMODE
    {
        //! Do not render anything
        EIRM_NONE = 0,

        //! Only render particles as points
        EIRM_POINT = 1,

        //! Particles are rendered as lines
        EIRM_LINE = 2,

        //! This rendermode is useful if you want textured particles
        EIRM_QUAD = 3,

        //! Each particle is rendered as an instanced object
        EIRM_OBJECT = 4,

        //! Useful only for counting possible render modes
        EIRM_COUNT = 5
    };

    //! Names for E_IRRSPK_RENDERMODE values
    const std::string EIR_NAMES[EIRM_COUNT] = {
        "None",
        "Point",
        "Line",
        "Quad",
        "Object"
    };

    //! Lists all possible orientations for a quad
    enum E_IRRSPK_ORIENTATION
    {
        //! Quad faces active camera
        EIO_CAMERA,

        //! Quad is aligned on x axis
        EIO_XAXIS,

        //! Quad is aligned on y axis
        EIO_YAXIS,

        //! Quad is aligned on z axis
        EIO_ZAXIS
    };

    //! Lists indices modes
    enum E_IRRSPK_INDEXMODE
    {
        //! Choose the best index mode according to the group size
        EII_AUTO=0,

        //! Always use 16bits indices. Any attempt to create a buffer with more particles will fail (and the renderer won't render anything)
        EII_16BITS,

        //! Try to always use 32bits indices. Not available on all graphic cards.
        EII_32BITS,

        //! Always use 16 bits indices, but if a buffer is created with too much particles, it's dispatched in several 16 bits buffers. Available on all graphics cards.
        EII_DISPATCHED16BITS
    };

    //! Conversion function

    //! Vectors
    inline irr::core::vector3df spk2irr(Vector3D v)
    {
        return irr::core::vector3df(v.x,v.y,v.z);
    }

    //! Colors
    inline irr::video::SColor spk2irr(float a, float r, float g, float b)
    {
        return irr::video::SColorf(r,g,b,a).toSColor();
    }
}
}

#endif // _SPARK_IRRLICHT_RENDERER_DEFINES_

#ifndef _SPARK_IRRLICHT_RENDERER_IRRBUFFERS_
#define _SPARK_IRRLICHT_RENDERER_IRRBUFFERS_

#include <irrlicht.h>
#include <SPK.h>

namespace SPK
{
namespace IRR
{
    //! A buffer designed to use with Irrlicht
    /** A ECRIRE ! **/
    class IrrBuffer : public Buffer, public irr::scene::CMeshBuffer<irr::video::S3DVertex>
    {
        public:
            //! Constructor
            IrrBuffer() : Purpose(0) { /*setHardwareMappingHint(irr::scene::EHM_STATIC,irr::scene::EBT_INDEX);*/ }

            //! Construct indices of this buffer in order to use it with a point renderer
            virtual inline void constructIndicesForPointRendering()
            {
                Purpose=0;

                Indices.set_used(Vertices.size());
                for(unsigned int t=0; t<Indices.size(); t++)
                    Indices[t] = t;

                setDirty(irr::scene::EBT_INDEX);
            }

            //! Construct indices of this buffer in order to use it with a line renderer
            virtual void constructIndicesForLineRendering()
            {
                Purpose=1;

                Indices.set_used(Vertices.size());
                for(unsigned int t=0; t<Indices.size(); t++)
                    Indices[t] = t;

                setDirty(irr::scene::EBT_INDEX);
            }

            //! Construct indices of this buffer in order to use it with a quad renderer
            virtual void constructIndicesForQuadRendering(unsigned int nbP)
            {
                Purpose=2;

                Indices.set_used(nbP*6);
                for(unsigned int t=0; t<nbP; t++)
                {
                    Indices[6*t+0] = 4*t+0;
                    Indices[6*t+1] = 4*t+2;
                    Indices[6*t+2] = 4*t+1;
                    Indices[6*t+3] = 4*t+2;
                    Indices[6*t+4] = 4*t+3;
                    Indices[6*t+5] = 4*t+1;
                }

                setDirty(irr::scene::EBT_INDEX);
            }

            //! Set the number of particles, and the purpose
            /** \param nbParticles : The number of particles the buffer can handle
              * \param purpose : The purpose of this buffer (e.g. 0 for point rendering) **/
            virtual void set(unsigned int nbParticles, int purpose)
            {
                if(purpose>=0 && purpose<3)
                {
                    Purpose=purpose;
                    switch(Purpose)
                    {
                        case 0:
                        {
                            Vertices.set_used(nbParticles);
                            for(unsigned int t = 0; t < Vertices.size(); t++)
                                Vertices[t] = irr::video::S3DVertex();
                            constructIndicesForPointRendering();
                            break;
                        }
                        case 1:
                        {
                            Vertices.set_used(nbParticles*2);
                            for(unsigned int t = 0; t < Vertices.size(); t++)
                                Vertices[t] = irr::video::S3DVertex();
                            constructIndicesForLineRendering();
                            break;
                        }
                        case 2:
                        {
                            Vertices.set_used(nbParticles*4);
                            for(unsigned int t=0; t<nbParticles; t++)
                            {
                                Vertices[4*t+0] = Vertices[4*t+1] = Vertices[4*t+2] = Vertices[4*t+3] = irr::video::S3DVertex();
                                Vertices[4*t+0].TCoords = irr::core::vector2df(1,0);
                                Vertices[4*t+1].TCoords = irr::core::vector2df(0,0);
                                Vertices[4*t+2].TCoords = irr::core::vector2df(1,1);
                                Vertices[4*t+3].TCoords = irr::core::vector2df(0,1);
                            }
                            constructIndicesForQuadRendering(nbParticles);
                            break;
                        }
                    }
                }
            }

            //! Returns the number of primitives
            /** \return The number of primitives according to the purpose of this buffer **/
            virtual inline unsigned int getPrimCount()
            {
                switch(Purpose)
                {
                    case 0: return Vertices.size();
                    case 1: return Vertices.size()/2;
                    case 2: return Vertices.size()/2;
                    default: return 0;
                }
            }

            //! Get the purpose of this buffer
            /** \return An int representing the aim of this buffer. **/
            virtual inline int getPurpose() { return Purpose; }

            //! Get primitive type
            /** \return the primitive type for this buffer (depends on purpose) */
            virtual irr::scene::E_PRIMITIVE_TYPE getPrimType() const
            {
                switch(Purpose)
                {
                    case 0: return irr::scene::EPT_POINTS;
                    case 1: return irr::scene::EPT_LINES;
                    case 2: return irr::scene::EPT_TRIANGLES;
                    default: return irr::scene::EPT_POINTS;
                }
            }

        private:
            //! Clone the buffer
            /** \return An exact copy of this buffer. **/
            virtual IrrBuffer* clone() const
            {
                return new IrrBuffer(*this);
            }

            //! Swap 2 particles
            /** \param index0 : Index of the first particle to swap.
              * \param index1 : Index of the second particle to swap.
              * Indexes must be valid for the two particles to be swapped.
              * Warning : for performances reasons, there is no index verification ! **/
            virtual void swap(size_t index0, size_t index1)
            {
                switch(Purpose)
                {
                    case 0: { swapPoints(index0,index1); break; }
                    case 1: { swapLines(index0,index1); break; }
                    case 2: { swapQuads(index0,index1); break; }
                }
            }

            //! Internal functions
            //! Swap 2 points
            void inline swapPoints(irr::u32 i, irr::u32 j)
            {
                irr::video::S3DVertex temp = Vertices[i];
                Vertices[i] = Vertices[j];
                Vertices[j] = temp;
            }
            //! Swap 2 lines
            void inline swapLines(irr::u32 i, irr::u32 j)
            {
                irr::video::S3DVertex temp1 = Vertices[i*2];
                irr::video::S3DVertex temp2 = Vertices[i*2+1];
                Vertices[i*2] = Vertices[j*2];
                Vertices[i*2+1] = Vertices[j*2+1];
                Vertices[j*2] = temp1;
                Vertices[j*2+1] = temp2;
            }
            //! Swap 2 quads
            void inline swapQuads(irr::u32 i, irr::u32 j)
            {
                irr::video::S3DVertex temp0 = Vertices[i*4+0],
                                      temp1 = Vertices[i*4+1],
                                      temp2 = Vertices[i*4+2],
                                      temp3 = Vertices[i*4+3];
                Vertices[4*i+0] = Vertices[4*j+0];
                Vertices[4*i+0] = Vertices[4*j+1];
                Vertices[4*i+0] = Vertices[4*j+2];
                Vertices[4*i+0] = Vertices[4*j+3];
                Vertices[4*j+0] = temp0;
                Vertices[4*j+1] = temp1;
                Vertices[4*j+2] = temp2;
                Vertices[4*j+3] = temp3;
            }

            //! The purpose of this buffer
            /** 0 -> Points
              * 1 -> Lines
              * 2 -> Quads
              * default : Points
              **/
            int Purpose;
    };


    //! A buffer creator to create IrrBuffers
    class IrrBufferCreator : public BufferCreator
    {
        public:
            IrrBufferCreator(int purpose):p(purpose) {}

        private:
            virtual IrrBuffer* createBuffer(size_t nbParticles, const Group& group) const
            {
                IrrBuffer* buff = new IrrBuffer;
                buff->set(nbParticles,p);
                return buff;
            }

            int p;
    };
}
}

#endif // _SPARK_IRRLICHT_RENDERER_IRRBUFFERS_

------------------------------------------------------------------
 Benchmark for cosine functions.
 Platform: Asus Computer
          Intel Pentium M (Centrino)
          ATI Mobility Radeon 9600
          512 Mo Ram
          1,70 GHz Proc
          Windows XP
 IDE: Code::Blocks 8.02
 Compiler: MinGW GCC
 Testing environment: 3 applications are running while
                      making the test:
                            Code::Blocks IDE,
                            Windows Media Player Serie 9,
                            Notepad
                      + 1 Explorer window
                                     
 Date: 03/08/2009

 Test runned several times to allow disk caching work itself out
 (disk caching caused by test environment).
 Different configurations have been tested.

 Functions sorted by speed:
  fast_cos
  lut
  lut2
  std::cos
------------------------------------------------------------------

------------------------------------------------------------------
Precision of cosine functions. std::cos used as reference.
------------------------------------------------------------------
fast cos : avg error=0.0104858 - max error=0.0560169
lut cos : avg error=0.00146479 - max error=0.00873788
lut2 cos : avg error=1.81488e-005 - max error=9.94056e-005
------------------------------------------------------------------

------------------------------------------------------------------
Target: Release. Optimizations: O2.
------------------------------------------------------------------
[Executed from IDE]
fast cos is 254% faster than std cos
lut cos is 108% faster than std cos
lut2 cos is 104% faster than std cos
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
[Executed from IDE]
fast cos is 256% faster than std cos
lut cos is 108% faster than std cos
lut2 cos is 104% faster than std cos
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
[Executed from Explorer]
fast cos is 257% faster than std cos
lut cos is 110% faster than std cos
lut2 cos is 106% faster than std cos
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
[Executed from Explorer]
fast cos is 263% faster than std cos
lut cos is 110% faster than std cos
lut2 cos is 105% faster than std cos

------------------------------------------------------------------
Target: Release. Optimizations: O3,expensive_optimizations.
------------------------------------------------------------------
[Executed from IDE]
fast cos is 270% faster than std cos
lut cos is 112% faster than std cos
lut2 cos is 104% faster than std cos
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
[Executed from IDE]
fast cos is 274% faster than std cos
lut cos is 114% faster than std cos
lut2 cos is 105% faster than std cos
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
[Executed from Explorer]
fast cos is 271% faster than std cos
lut cos is 115% faster than std cos
lut2 cos is 106% faster than std cos
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
[Executed from Explorer]
fast cos is 275% faster than std cos
lut cos is 113% faster than std cos
lut2 cos is 104% faster than std cos

------------------------------------------------------------------
Target: Debug. No optimizations.
------------------------------------------------------------------
[Executed from IDE]
fast cos is 250% faster than std cos
lut cos is 107% faster than std cos
lut2 cos is 104% faster than std cos
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
[Executed from Explorer]
fast cos is 258% faster than std cos
lut cos is 110% faster than std cos
lut2 cos is 104% faster than std cos