source: OGRE/trunk/ogre_changes/Ogre1.2/OgreMain/src/SpriteParticleRenderer.cpp @ 768

#include "OgreStableHeaders.h"

#include "SpriteParticleRenderer.h"
#include "OgreParticle.h"
#include "OgreStringConverter.h"

#ifdef GAMETOOLS_ILLUMINATION_MODULE

namespace Ogre {

        Vector3 cameraPosition;

        class ParticleBackToFront
        {
                public:
                bool operator() (const Particle* p1, const Particle* p2)
                {
                        float dist1 = (cameraPosition - p1->position).length();
                        float dist2 = (cameraPosition - p2->position).length();
            return dist1 < dist2;
                }
        };

        class ParticleFrontToBack
        {
                public:
                bool operator() (const Particle* p1, const Particle* p2)
                {
                        float dist1 = (cameraPosition - p1->position).length();
                        float dist2 = (cameraPosition - p2->position).length();
            return dist1 > dist2;
                }
        };
 
        String SpriteName = "sprite";
    //-----------------------------------------------------------------------
    SpriteParticleRenderer::SpriteParticleRenderer()
    {
        if (createParamDictionary("SpriteParticleRenderer"))
        {
            ParamDictionary* dict = getParamDictionary();
           
        }
                particleSorting = 0;
        // Create billboard set
                mSpriteSet = new SpriteSet("", 0, true);
        // World-relative axes
        mSpriteSet->setBillboardsInWorldSpace(true);
    }
    //-----------------------------------------------------------------------
    SpriteParticleRenderer::~SpriteParticleRenderer()
    {
        delete mSpriteSet;
    }
    //-----------------------------------------------------------------------
    const String& SpriteParticleRenderer::getType(void) const
    {
        return SpriteName;
    }

        void SpriteParticleRenderer::setParticleSorting(int sorting, Camera* cam)
        {
                this->particleSorting = sorting;
                cameraPosition = cam->getWorldPosition();
        }
    //-----------------------------------------------------------------------
    void SpriteParticleRenderer::_updateRenderQueue(RenderQueue* queue, 
        std::list<Particle*>& currentParticles, bool cullIndividually)
    {
        mSpriteSet->setCullIndividually(cullIndividually);

                ////sort currentParticles
                if(particleSorting > 0)
                        currentParticles.sort(ParticleBackToFront());
                if(particleSorting < 0)
                        currentParticles.sort(ParticleFrontToBack());


        // Update billboard set geometry
        mSpriteSet->beginBillboards();
        Billboard bb;
        for (std::list<Particle*>::iterator i = currentParticles.begin();
            i != currentParticles.end(); ++i)
        {
            Particle* p = *i;
            bb.mPosition = p->position;
            bb.mDirection = p->direction;
            bb.mColour = p->colour;
            bb.mRotation = p->rotation;
            // Assign and compare at the same time
            if (bb.mOwnDimensions = p->mOwnDimensions)
            {
                bb.mWidth = p->mWidth;
                bb.mHeight = p->mHeight;
            }
            mSpriteSet->injectBillboard(bb);

        }
        
        mSpriteSet->endBillboards();

        // Update the queue
        mSpriteSet->_updateRenderQueue(queue);
    }
    //-----------------------------------------------------------------------
    void SpriteParticleRenderer::_setMaterial(MaterialPtr& mat)
    {
        mSpriteSet->setMaterialName(mat->getName());
    }
   
        void SpriteParticleRenderer::_notifyCurrentCamera(Camera* cam)
    {
        mSpriteSet->_notifyCurrentCamera(cam);
    }
    //-----------------------------------------------------------------------
    void SpriteParticleRenderer::_notifyDefaultDimensions(Real width, Real height)
    {
        mSpriteSet->setDefaultDimensions(width, height);
    }
    //-----------------------------------------------------------------------
    void SpriteParticleRenderer::_notifyParticleResized(void)
    {
        mSpriteSet->_notifyBillboardResized();
    }
    //-----------------------------------------------------------------------
    void SpriteParticleRenderer::_notifyParticleQuota(size_t quota)
    {
        mSpriteSet->setPoolSize(quota);
    }
    //-----------------------------------------------------------------------
    void SpriteParticleRenderer::_notifyAttached(Node* parent, bool isTagPoint)
    {
        mSpriteSet->_notifyAttached(parent, isTagPoint);
    }
        //-----------------------------------------------------------------------
        void SpriteParticleRenderer::setRenderQueueGroup(uint8 queueID)
        {
                mSpriteSet->setRenderQueueGroup(queueID);
        }
    //-----------------------------------------------------------------------
    //-----------------------------------------------------------------------
    //-----------------------------------------------------------------------
    const String& SpriteParticleRendererFactory::getType() const
    {
        return SpriteName;
    }
    //-----------------------------------------------------------------------
    ParticleSystemRenderer* SpriteParticleRendererFactory::createInstance( 
        const String& name )
    {
        return new SpriteParticleRenderer();
    }
    //-----------------------------------------------------------------------
    void SpriteParticleRendererFactory::destroyInstance( 
        ParticleSystemRenderer* inst)
    {
        delete inst;
    }    

}

#endif