Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Nov 1, 2008, 7:04:09 PM (16 years ago)
Author:
landauf
Message:

merged objecthierarchy branch back to trunk

Location:
code/trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • code/trunk

  • code/trunk/src/orxonox/tools/ParticleInterface.cc

    r1755 r2087  
    11/*
    2 *   ORXONOX - the hottest 3D action shooter ever to exist
    3 *
    4 *
    5 *   License notice:
    6 *
    7 *   This program is free software; you can redistribute it and/or
    8 *   modify it under the terms of the GNU General Public License
    9 *   as published by the Free Software Foundation; either version 2
    10 *   of the License, or (at your option) any later version.
    11 *
    12 *   This program is distributed in the hope that it will be useful,
    13 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
    14 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    15 *   GNU General Public License for more details.
    16 *
    17 *   You should have received a copy of the GNU General Public License
    18 *   along with this program; if not, write to the Free Software
    19 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
    20 *
    21 *   Author:
    22 *      ...
    23 *   Co-authors:
    24 *      ...
    25 *
    26 */
     2 *   ORXONOX - the hottest 3D action shooter ever to exist
     3 *                    > www.orxonox.net <
     4 *
     5 *
     6 *   License notice:
     7 *
     8 *   This program is free software; you can redistribute it and/or
     9 *   modify it under the terms of the GNU General Public License
     10 *   as published by the Free Software Foundation; either version 2
     11 *   of the License, or (at your option) any later version.
     12 *
     13 *   This program is distributed in the hope that it will be useful,
     14 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
     15 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     16 *   GNU General Public License for more details.
     17 *
     18 *   You should have received a copy of the GNU General Public License
     19 *   along with this program; if not, write to the Free Software
     20 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
     21 *
     22 *   Author:
     23 *      Fabian 'x3n' Landau
     24 *   Co-authors:
     25 *      ...
     26 *
     27 */
    2728
    2829/**
    … …  
    3738#include <OgreParticleEmitter.h>
    3839#include <OgreSceneManager.h>
     40#include <cassert>
    3941
    4042#include "GraphicsEngine.h"
    … …  
    4446namespace orxonox
    4547{
    46   unsigned int ParticleInterface::counter_s = 0;
    47   ParticleInterface* ParticleInterface::currentParticleInterface_s = 0;
    48 
    49   ParticleInterface::ParticleInterface(const std::string& templateName, LODParticle::LOD detaillevel)
    50   {
    51     RegisterRootObject(ParticleInterface);
    52 
    53     this->sceneNode_ = 0;
    54     this->bEnabled_ = true;
    55     this->detaillevel_ = (unsigned int)detaillevel;
    56     this->particleSystem_ = GraphicsEngine::getInstance().getLevelSceneManager()->createParticleSystem("particles" + getConvertedValue<unsigned int, std::string>(ParticleInterface::counter_s++), templateName);
    57     //this->particleSystem_->setSpeedFactor(Orxonox::getInstance().getTimeFactor());
    58     this->particleSystem_->setSpeedFactor(1.0f);
    59 
    60     if (GraphicsEngine::getInstance().getDetailLevelParticle() < (unsigned int)this->detaillevel_)
    61     {
    62       this->bVisible_ = false;
    63       this->updateVisibility();
    64     }
    65     else
    66     {
    67       this->bVisible_ = true;
    68     }
    69   }
    70 
    71   ParticleInterface::~ParticleInterface()
    72   {
    73     this->particleSystem_->removeAllEmitters();
    74     GraphicsEngine::getInstance().getLevelSceneManager()->destroyParticleSystem(particleSystem_);
    75   }
    76 
    77   void ParticleInterface::addToSceneNode(Ogre::SceneNode* sceneNode)
    78   {
    79     this->sceneNode_ = sceneNode;
    80     this->sceneNode_->attachObject(this->particleSystem_);
    81   }
    82 
    83   void ParticleInterface::detachFromSceneNode()
    84   {
    85     if (this->sceneNode_)
    86     {
    87       this->sceneNode_->detachObject(this->particleSystem_);
    88       this->sceneNode_ = 0;
    89     }
    90   }
    91 
    92   Ogre::ParticleEmitter* ParticleInterface::createNewEmitter()
    93   {
    94     if (this->particleSystem_->getNumEmitters() > 0)
    95     {
    96       Ogre::ParticleEmitter* newemitter = this->particleSystem_->addEmitter(this->particleSystem_->getEmitter(0)->getType());
    97       this->particleSystem_->getEmitter(0)->copyParametersTo(newemitter);
    98       return newemitter;
    99     }
    100     else
    101       return 0;
    102   }
    103   Ogre::ParticleEmitter* ParticleInterface::getEmitter(unsigned int emitterNr) const
    104   {
    105     if (emitterNr < this->particleSystem_->getNumEmitters())
    106       return this->particleSystem_->getEmitter(emitterNr);
    107     else
    108       return 0;
    109   }
    110   void ParticleInterface::removeEmitter(unsigned int emitterNr)
    111   {
    112     if (emitterNr < this->particleSystem_->getNumEmitters())
    113       this->particleSystem_->removeEmitter(emitterNr);
    114   }
    115   void ParticleInterface::removeAllEmitters()
    116   {
    117     this->particleSystem_->removeAllEmitters();
    118   }
    119   unsigned int ParticleInterface::getNumEmitters() const
    120   {
    121     return this->particleSystem_->getNumEmitters();
    122   }
    123 
    124   Ogre::ParticleAffector* ParticleInterface::addAffector(const std::string& name)
    125   {
    126     return this->particleSystem_->addAffector(name);
    127   }
    128   Ogre::ParticleAffector* ParticleInterface::getAffector(unsigned int affectorNr) const
    129   {
    130     if (affectorNr < this->particleSystem_->getNumAffectors())
    131       return this->particleSystem_->getAffector(affectorNr);
    132     else
    133       return 0;
    134   }
    135   void ParticleInterface::removeAffector(unsigned int affectorNr)
    136   {
    137     if (affectorNr < this->particleSystem_->getNumAffectors())
    138       this->particleSystem_->removeAffector(affectorNr);
    139   }
    140   void ParticleInterface::removeAllAffectors()
    141   {
    142     this->particleSystem_->removeAllAffectors();
    143   }
    144   unsigned int ParticleInterface::getNumAffectors() const
    145   {
    146     return this->particleSystem_->getNumAffectors();
    147   }
    148 
    149   void ParticleInterface::setEnabled(bool enable)
    150   {
    151     this->bEnabled_ = enable;
    152     this->updateVisibility();
    153   }
    154 
    155   void ParticleInterface::detailLevelChanged(unsigned int newlevel)
    156   {
    157     if (newlevel >= (unsigned int)this->detaillevel_)
    158       this->bVisible_ = true;
    159     else
    160       this->bVisible_ = false;
    161 
    162     this->updateVisibility();
    163   }
    164 
    165   void ParticleInterface::updateVisibility()
    166   {
    167     for (unsigned int i = 0; i < this->particleSystem_->getNumEmitters(); i++)
    168       this->particleSystem_->getEmitter(i)->setEnabled(this->bEnabled_ && this->bVisible_);
    169   }
    170 
    171   void ParticleInterface::setSpeedFactor(float factor)
    172   {
    173     //this->particleSystem_->setSpeedFactor(Orxonox::getInstance().getTimeFactor() * factor);
    174     this->particleSystem_->setSpeedFactor(1.0f * factor);
    175   }
    176   float ParticleInterface::getSpeedFactor() const
    177   {
    178     //return (this->particleSystem_->getSpeedFactor() / Orxonox::getInstance().getTimeFactor());
    179     return (this->particleSystem_->getSpeedFactor() / 1.0f);
    180   }
    181 
    182   bool ParticleInterface::getKeepParticlesInLocalSpace() const
    183   {
    184     return this->particleSystem_->getKeepParticlesInLocalSpace();
    185   }
    186   void ParticleInterface::setKeepParticlesInLocalSpace(bool keep)
    187   {
    188     this->particleSystem_->setKeepParticlesInLocalSpace(keep);
    189   }
     48    unsigned int ParticleInterface::counter_s = 0;
     49    ParticleInterface* ParticleInterface::currentParticleInterface_s = 0;
     50
     51    ParticleInterface::ParticleInterface(Ogre::SceneManager* scenemanager, const std::string& templateName, LODParticle::LOD detaillevel)
     52    {
     53        RegisterRootObject(ParticleInterface);
     54
     55        assert(scenemanager);
     56
     57        this->scenemanager_ = scenemanager;
     58        this->sceneNode_ = 0;
     59
     60        this->bEnabled_ = true;
     61        this->bVisible_ = true;
     62        this->bAllowedByLOD_ = true;
     63
     64        this->particleSystem_ = this->scenemanager_->createParticleSystem("particles" + getConvertedValue<unsigned int, std::string>(ParticleInterface::counter_s++), templateName);
     65        this->particleSystem_->setSpeedFactor(1.0f);
     66        //this->particleSystem_->setSpeedFactor(Orxonox::getInstance().getTimeFactor());
     67
     68        this->setDetailLevel((unsigned int)detaillevel);
     69    }
     70
     71    ParticleInterface::~ParticleInterface()
     72    {
     73        this->particleSystem_->removeAllEmitters();
     74        this->detachFromSceneNode();
     75        this->scenemanager_->destroyParticleSystem(particleSystem_);
     76    }
     77
     78    void ParticleInterface::addToSceneNode(Ogre::SceneNode* sceneNode)
     79    {
     80        if (this->sceneNode_)
     81            this->detachFromSceneNode();
     82
     83        this->sceneNode_ = sceneNode;
     84        this->sceneNode_->attachObject(this->particleSystem_);
     85    }
     86
     87    void ParticleInterface::detachFromSceneNode()
     88    {
     89        if (this->sceneNode_)
     90        {
     91            this->sceneNode_->detachObject(this->particleSystem_);
     92            this->sceneNode_ = 0;
     93        }
     94    }
     95
     96    Ogre::ParticleEmitter* ParticleInterface::createNewEmitter()
     97    {
     98        if (this->particleSystem_->getNumEmitters() > 0)
     99        {
     100            Ogre::ParticleEmitter* newemitter = this->particleSystem_->addEmitter(this->particleSystem_->getEmitter(0)->getType());
     101            this->particleSystem_->getEmitter(0)->copyParametersTo(newemitter);
     102            return newemitter;
     103        }
     104        else
     105            return 0;
     106    }
     107    Ogre::ParticleEmitter* ParticleInterface::getEmitter(unsigned int emitterNr) const
     108    {
     109        if (emitterNr < this->particleSystem_->getNumEmitters())
     110            return this->particleSystem_->getEmitter(emitterNr);
     111        else
     112            return 0;
     113    }
     114    void ParticleInterface::removeEmitter(unsigned int emitterNr)
     115    {
     116        if (emitterNr < this->particleSystem_->getNumEmitters())
     117            this->particleSystem_->removeEmitter(emitterNr);
     118    }
     119    void ParticleInterface::removeAllEmitters()
     120    {
     121        this->particleSystem_->removeAllEmitters();
     122    }
     123    unsigned int ParticleInterface::getNumEmitters() const
     124    {
     125        return this->particleSystem_->getNumEmitters();
     126    }
     127
     128    Ogre::ParticleAffector* ParticleInterface::addAffector(const std::string& name)
     129    {
     130        return this->particleSystem_->addAffector(name);
     131    }
     132    Ogre::ParticleAffector* ParticleInterface::getAffector(unsigned int affectorNr) const
     133    {
     134        if (affectorNr < this->particleSystem_->getNumAffectors())
     135            return this->particleSystem_->getAffector(affectorNr);
     136        else
     137            return 0;
     138    }
     139    void ParticleInterface::removeAffector(unsigned int affectorNr)
     140    {
     141        if (affectorNr < this->particleSystem_->getNumAffectors())
     142            this->particleSystem_->removeAffector(affectorNr);
     143    }
     144    void ParticleInterface::removeAllAffectors()
     145    {
     146        this->particleSystem_->removeAllAffectors();
     147    }
     148    unsigned int ParticleInterface::getNumAffectors() const
     149    {
     150        return this->particleSystem_->getNumAffectors();
     151    }
     152
     153    void ParticleInterface::setEnabled(bool enable)
     154    {
     155        this->bEnabled_ = enable;
     156
     157        for (unsigned int i = 0; i < this->particleSystem_->getNumEmitters(); i++)
     158            this->particleSystem_->getEmitter(i)->setEnabled(this->bEnabled_ && this->bAllowedByLOD_);
     159    }
     160
     161    void ParticleInterface::setVisible(bool visible)
     162    {
     163        this->bVisible_ = visible;
     164
     165        this->particleSystem_->setVisible(this->bVisible_ && this->bAllowedByLOD_);
     166    }
     167
     168    void ParticleInterface::setDetailLevel(unsigned int level)
     169    {
     170        this->detaillevel_ = level;
     171        this->detailLevelChanged(GraphicsEngine::getInstance().getDetailLevelParticle());
     172    }
     173
     174    void ParticleInterface::detailLevelChanged(unsigned int newlevel)
     175    {
     176        if (newlevel >= (unsigned int)this->detaillevel_)
     177            this->bAllowedByLOD_ = true;
     178        else
     179            this->bAllowedByLOD_ = false;
     180
     181        this->updateVisibility();
     182    }
     183
     184    void ParticleInterface::updateVisibility()
     185    {
     186        this->setEnabled(this->isEnabled());
     187        this->setVisible(this->isVisible());
     188    }
     189
     190    void ParticleInterface::setSpeedFactor(float factor)
     191    {
     192        //this->particleSystem_->setSpeedFactor(Orxonox::getInstance().getTimeFactor() * factor);
     193        this->particleSystem_->setSpeedFactor(1.0f * factor);
     194    }
     195    float ParticleInterface::getSpeedFactor() const
     196    {
     197        //return (this->particleSystem_->getSpeedFactor() / Orxonox::getInstance().getTimeFactor());
     198        return (this->particleSystem_->getSpeedFactor() / 1.0f);
     199    }
     200
     201    bool ParticleInterface::getKeepParticlesInLocalSpace() const
     202    {
     203        return this->particleSystem_->getKeepParticlesInLocalSpace();
     204    }
     205    void ParticleInterface::setKeepParticlesInLocalSpace(bool keep)
     206    {
     207        this->particleSystem_->setKeepParticlesInLocalSpace(keep);
     208    }
    190209}
Note: See TracChangeset for help on using the changeset viewer.