Changeset 2065 for code/branches/objecthierarchy/src/orxonox/objects/worldentities

Timestamp:

Oct 30, 2008, 2:44:48 AM (16 years ago)

Author:

landauf

Message:

added two more graphical classes, ParticleEmitter and ParticleSpawner

Location:

code/branches/objecthierarchy/src/orxonox/objects/worldentities

Files:

• Billboard.cc (modified) (2 diffs)
• BlinkingBillboard.cc (modified) (3 diffs)
• BlinkingBillboard.h (modified) (1 diff)
• ControllableEntity.cc (modified) (6 diffs)
• Light.cc (modified) (1 diff)
• Light.h (modified) (1 diff)
• Model.cc (modified) (1 diff)
• ParticleEmitter.cc (added)
• ParticleEmitter.h (added)
• ParticleSpawner.cc (modified) (3 diffs)
• ParticleSpawner.h (modified) (1 diff)
• SpawnPoint.cc (modified) (1 diff)
• WorldEntity.h (modified) (1 diff)
• triggers/Trigger.cc (modified) (1 diff)

code/branches/objecthierarchy/src/orxonox/objects/worldentities/Billboard.cc

@@ -76 +76 @@
                 this->billboard_.setBillboardSet(this->getScene()->getSceneManager(), this->material_, this->colour_, 1);
                 this->getNode()->attachObject(this->billboard_.getBillboardSet());
+                this->billboard_.setVisible(this->isVisible());
             }
         }
@@ -90 +91 @@
                 this->billboard_.setBillboardSet(this->getScene()->getSceneManager(), this->material_, this->colour_, 1);
                 this->getNode()->attachObject(this->billboard_.getBillboardSet());
+                this->billboard_.setVisible(this->isVisible());
             }
         }

code/branches/objecthierarchy/src/orxonox/objects/worldentities/BlinkingBillboard.cc

@@ -30 +30 @@
 #include "BlinkingBillboard.h"
 
+#include "core/Core.h"
 #include "core/CoreIncludes.h"
 #include "core/XMLPort.h"
+#include "util/Math.h"
 
 namespace orxonox
@@ -44 +46 @@
         this->frequency_ = 1.0f;
         this->phase_ = 0;
+        this->bQuadratic_ = false;
         this->time_ = 0;
 
@@ -60 +63 @@
         XMLPortParam(BlinkingBillboard, "frequency", setFrequency, getFrequency, xmlelement, mode).defaultValues(1.0f);
         XMLPortParam(BlinkingBillboard, "phase",     setPhase,     getPhase,     xmlelement, mode).defaultValues(Degree(0));
+        XMLPortParam(BlinkingBillboard, "quadratic", setQuadratic, isQuadratic,  xmlelement, mode).defaultValues(false);
     }
 
     void BlinkingBillboard::registerVariables()
     {
-        REGISTERDATA(this->amplitude_, network::direction::toclient);
-        REGISTERDATA(this->frequency_, network::direction::toclient);
-        REGISTERDATA(this->phase_,     network::direction::toclient);
+//        REGISTERDATA(this->amplitude_, network::direction::toclient);
+//        REGISTERDATA(this->frequency_, network::direction::toclient);
+//        REGISTERDATA(this->phase_,     network::direction::toclient);
     }
 
     void BlinkingBillboard::tick(float dt)
     {
-        this->time_ += dt;
-        this->setScale(this->amplitude_ * sin((6.2831853 * this->time_ + this->phase_.valueRadians()) * this->frequency_));
+        if (Core::isMaster())
+        {
+            this->time_ += dt;
+            if (this->bQuadratic_)
+                this->setScale(this->amplitude_ * square(sin((6.2831853 * this->time_ + this->phase_.valueRadians()) * this->frequency_)));
+            else
+                this->setScale(this->amplitude_ * sin((6.2831853 * this->time_ + this->phase_.valueRadians()) * this->frequency_));
+        }
     }
 }

code/branches/objecthierarchy/src/orxonox/objects/worldentities/BlinkingBillboard.h

@@ -62 +62 @@
                 { return this->phase_; }
 
+            inline void setQuadratic(bool bQuadratic)
+                { this->bQuadratic_ = bQuadratic; }
+            inline bool isQuadratic() const
+                { return this->bQuadratic_; }
+
         private:
             float amplitude_;
             float frequency_;
             Degree phase_;
+            bool bQuadratic_;
             long double time_;
     };

code/branches/objecthierarchy/src/orxonox/objects/worldentities/ControllableEntity.cc

@@ -95 +95 @@
         XMLPortParam(ControllableEntity, "camerapositiontemplate", setCameraPositionTemplate, getCameraPositionTemkplate, xmlelement, mode);
 
-        XMLPortObject(ControllableEntity, WorldEntity, "camerapositions", addCameraPosition, getCameraPosition, xmlelement, mode);
+        XMLPortObject(ControllableEntity, CameraPosition, "camerapositions", addCameraPosition, getCameraPosition, xmlelement, mode);
     }
 
@@ -239 +239 @@
             else if (this->bControlled_)
             {
-                COUT(2) << "setting client position" << endl;
+//                COUT(2) << "setting client position" << endl;
                 this->client_velocity_ = this->velocity_;
                 this->client_position_ = this->node_->getPosition();
@@ -249 +249 @@
     {
         REGISTERSTRING(this->cameraPositionTemplate_, network::direction::toclient);
-        
-        
-        REGISTERDATA(this->client_overwrite_,   network::direction::toserver);
-        REGISTERDATA(this->server_overwrite_,   network::direction::toclient, new network::NetworkCallback<ControllableEntity>(this, &ControllableEntity::processOverwrite));
 
         REGISTERDATA(this->server_position_,    network::direction::toclient, new network::NetworkCallback<ControllableEntity>(this, &ControllableEntity::processServerPosition));
@@ -258 +254 @@
         REGISTERDATA(this->server_orientation_, network::direction::toclient, new network::NetworkCallback<ControllableEntity>(this, &ControllableEntity::processServerOrientation));
 
+        REGISTERDATA(this->server_overwrite_,   network::direction::toclient, new network::NetworkCallback<ControllableEntity>(this, &ControllableEntity::processOverwrite));
+        REGISTERDATA(this->client_overwrite_,   network::direction::toserver);
 
         REGISTERDATA(this->client_position_,    network::direction::toserver, new network::NetworkCallback<ControllableEntity>(this, &ControllableEntity::processClientPosition));
@@ -301 +299 @@
         if (this->server_overwrite_ == this->client_overwrite_)
         {
-            COUT(2) << "callback: setting client position" << endl;
+//            COUT(2) << "callback: setting client position" << endl;
             this->node_->setPosition(this->client_position_);
             this->server_position_ = this->client_position_;
         }
-        else
-          COUT(2) << "callback: not setting client position" << endl;
+//        else
+//          COUT(2) << "callback: not setting client position" << endl;
     }
 
@@ -458 +456 @@
         else if (this->bControlled_)
         {
-//             this->node_->lookAt(target, relativeTo, localDirectionVector);
+            this->node_->lookAt(target, relativeTo, localDirectionVector);
             this->client_orientation_ = this->node_->getOrientation();
         }

code/branches/objecthierarchy/src/orxonox/objects/worldentities/Light.cc

@@ -165 +165 @@
         this->light_->setType(this->type_);
     }
+
+    void Light::changedVisibility()
+    {
+        SUPER(Light, changedVisibility);
+
+        this->light_->setVisible(this->isVisible());
+    }
 }

code/branches/objecthierarchy/src/orxonox/objects/worldentities/Light.h

@@ -49 +49 @@
             void registerVariables();
 
+            virtual void changedVisibility();
+
             inline Ogre::Light* getLight()
                 { return this->light_; }

code/branches/objecthierarchy/src/orxonox/objects/worldentities/Model.cc

@@ -76 +76 @@
             this->getNode()->attachObject(this->mesh_.getEntity());
             this->mesh_.getEntity()->setCastShadows(this->bCastShadows_);
+            this->mesh_.setVisible(this->isVisible());
         }
     }

code/branches/objecthierarchy/src/orxonox/objects/worldentities/ParticleSpawner.cc

@@ -30 +30 @@
 #include "ParticleSpawner.h"
 
-#include <OgreSceneManager.h>
 #include "core/CoreIncludes.h"
+#include "core/EventIncludes.h"
 #include "core/Executor.h"
+#include "core/XMLPort.h"
 #include "tools/ParticleInterface.h"
-#include "GraphicsEngine.h"
 
 namespace orxonox
@@ -40 +40 @@
     CreateFactory(ParticleSpawner);
 
-    ParticleSpawner::ParticleSpawner()
+    ParticleSpawner::ParticleSpawner(BaseObject* creator) : ParticleEmitter(creator)
     {
         RegisterObject(ParticleSpawner);
-        this->particle_ = 0;
-    }
 
-    ParticleSpawner::ParticleSpawner(const std::string& templateName, LODParticle::LOD detaillevel, float lifetime, float startdelay, float destroydelay, const Vector3& direction)
-    {
-        RegisterObject(ParticleSpawner);
-        this->setParticle(templateName, detaillevel, lifetime, startdelay, destroydelay, direction);
-    }
+        this->bAutostart_ = true;
+        this->bSuppressStart_ = false;
+        this->bAutoDestroy_ = true;
+        this->bForceDestroy_ = false;
+        this->bLoop_ = false;
+        this->startdelay_ = 0;
+        this->lifetime_ = 0;
+        this->destroydelay_ = 0;
 
-    void ParticleSpawner::setParticle(const std::string& templateName, LODParticle::LOD detaillevel, float lifetime, float startdelay, float destroydelay, const Vector3& direction)
-    {
-        ExecutorMember<ParticleSpawner>* executor = createExecutor(createFunctor(&ParticleSpawner::createParticleSpawner));
-        this->destroydelay_ = destroydelay;
-        executor->setDefaultValues(lifetime);
-        this->timer_.setTimer(startdelay, false, this, executor);
-        this->particle_ = new ParticleInterface(templateName, detaillevel);
-        this->particle_->addToSceneNode(this->getNode());
-        this->particle_->setEnabled(false);
-        if (direction != Vector3::ZERO)
-        {
-            this->particle_->getAllEmitters()->setDirection(direction);
-        }
+        this->startParticleSpawner();
     }
 
     ParticleSpawner::~ParticleSpawner()
     {
-        if (this->isInitialized() && this->particle_)
-        {
-            this->particle_->detachFromSceneNode();
-            delete this->particle_;
-        }
-    };
-
-    void ParticleSpawner::destroy()
-    {
-        this->setPosition(this->getNode()->getParent()->getPosition());
-        this->getNode()->getParent()->removeChild(this->getNode());
-        this->detachFromParent();
-        if (this->particle_)
-            this->particle_->setEnabled(false);
-        if (!this->timer_.isActive() || this->timer_.getRemainingTime() > this->destroydelay_)
-            this->timer_.setTimer(this->destroydelay_, false, this, createExecutor(createFunctor(&ParticleSpawner::destroyParticleSpawner)));
     }
 
-    void ParticleSpawner::createParticleSpawner(float lifetime)
+    void ParticleSpawner::XMLPort(Element& xmlelement, XMLPort::Mode mode)
     {
-        this->particle_->setEnabled(true);
-        if (lifetime != 0)
-            this->timer_.setTimer(lifetime, false, this, createExecutor(createFunctor(&ParticleSpawner::destroyParticleSpawner)));
+        SUPER(ParticleSpawner, XMLPort, xmlelement, mode);
+
+        XMLPortParam(ParticleSpawner, "autostart",    setAutoStart,        getAutoStart,        xmlelement, mode).defaultValues(true);
+        XMLPortParam(ParticleSpawner, "autodestroy",  setDestroyAfterLife, getDestroyAfterLife, xmlelement, mode).defaultValues(false);
+        XMLPortParam(ParticleSpawner, "loop",         setLoop,             getLoop,             xmlelement, mode).defaultValues(false);
+        XMLPortParam(ParticleSpawner, "lifetime",     setLifetime,         getLifetime,         xmlelement, mode).defaultValues(0.0f);
+        XMLPortParam(ParticleSpawner, "startdelay",   setStartdelay,       getStartdelay,       xmlelement, mode).defaultValues(0.0f);
+        XMLPortParam(ParticleSpawner, "destroydelay", setDestroydelay,     getDestroydelay,     xmlelement, mode).defaultValues(0.0f);
+    }
+
+    void ParticleSpawner::processEvent(Event& event)
+    {
+        SUPER(ParticleSpawner, processEvent, event);
+
+        SetEvent(ParticleSpawner, "spawn", spawn, event);
+    }
+
+    void ParticleSpawner::configure(float lifetime, float startdelay, float destroydelay, bool autodestroy)
+    {
+        this->bAutoDestroy_ = autodestroy;
+        this->startdelay_ = startdelay;
+        this->lifetime_ = lifetime;
+        this->destroydelay_ = destroydelay;
+    }
+
+    void ParticleSpawner::startParticleSpawner()
+    {
+        if (!this->particles_)
+            return;
+
+        this->particles_->setEnabled(false);
+
+        if (this->bForceDestroy_ || this->bSuppressStart_)
+            return;
+
+        this->timer_.setTimer(this->startdelay_, false, this, createExecutor(createFunctor(&ParticleSpawner::fireParticleSpawner)));
+    }
+
+    void ParticleSpawner::fireParticleSpawner()
+    {
+        this->particles_->setEnabled(true);
+        if (this->lifetime_ != 0)
+            this->timer_.setTimer(this->lifetime_, false, this, createExecutor(createFunctor(&ParticleSpawner::stopParticleSpawner)));
+    }
+
+    void ParticleSpawner::stopParticleSpawner()
+    {
+        this->particles_->setEnabled(false);
+
+        if (this->bAutoDestroy_ || this->bForceDestroy_)
+        {
+            this->setPosition(this->getWorldPosition());
+            this->detachFromParent();
+
+            if (!this->timer_.isActive() || this->timer_.getRemainingTime() > this->destroydelay_)
+                this->timer_.setTimer(this->destroydelay_, false, this, createExecutor(createFunctor(&ParticleSpawner::destroyParticleSpawner)));
+        }
+        else if (this->bLoop_)
+        {
+            this->timer_.setTimer(this->destroydelay_, false, this, createExecutor(createFunctor(&ParticleSpawner::startParticleSpawner)));
+        }
     }
 
@@ -98 +129 @@
         delete this;
     }
-
-    void ParticleSpawner::setVisible(bool visible)
-    {
-        if (this->particle_)
-            this->particle_->setEnabled(visible);
-    }
 }

code/branches/objecthierarchy/src/orxonox/objects/worldentities/ParticleSpawner.h

@@ -32 +32 @@
 #include "OrxonoxPrereqs.h"
 
-#include "PositionableEntity.h"
+#include "ParticleEmitter.h"
 #include "tools/Timer.h"
 
 namespace orxonox
 {
-    class _OrxonoxExport ParticleSpawner : public PositionableEntity
+    class _OrxonoxExport ParticleSpawner : public ParticleEmitter
     {
         public:
-            ParticleSpawner();
-            ParticleSpawner(const std::string& templateName, LODParticle::LOD detaillevel, float lifetime = 0, float startdelay = 0, float destroydelay = 0, const Vector3& direction = Vector3::ZERO);
+            ParticleSpawner(BaseObject* creator);
             virtual ~ParticleSpawner();
-            void destroy();
 
-            void setParticle(const std::string& templateName, LODParticle::LOD detaillevel, float lifetime = 0, float startdelay = 0, float destroydelay = 0, const Vector3& direction = Vector3::ZERO);
-            inline ParticleInterface* getParticleInterface() const
-                { return this->particle_; }
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void processEvent(Event& event);
 
-            void setVisible(bool visible);
+            inline void destroy()
+                { this->bForceDestroy_ = true; this->stopParticleSpawner(); }
+            inline void spawn()
+                { this->bSuppressStart_ = false; this->startParticleSpawner(); }
+
+            void configure(float lifetime = 0, float startdelay = 0, float destroydelay = 0, bool autodestroy = true);
+
+            inline void setAutoStart(bool autostart)
+                { this->bAutostart_ = autostart; this->bSuppressStart_ = !autostart; }
+            inline bool getAutoStart() const
+                { return this->bAutostart_; }
+
+            inline void setDestroyAfterLife(bool destroy)
+                { this->bAutoDestroy_ = destroy; }
+            inline bool getDestroyAfterLife() const
+                { return this->bAutoDestroy_; }
+
+            inline void setLoop(bool loop)
+                { this->bLoop_ = loop; }
+            inline bool getLoop() const
+                { return this->bLoop_; }
+
+            inline void setLifetime(float lifetime)
+                { this->lifetime_ = lifetime; this->startParticleSpawner(); }
+            inline float getLifetime() const
+                { return this->lifetime_; }
+
+            inline void setStartdelay(float startdelay)
+                { this->startdelay_ = startdelay; this->startParticleSpawner(); }
+            inline float getStartdelay() const
+                { return this->startdelay_; }
+
+            inline void setDestroydelay(float destroydelay)
+                { this->destroydelay_ = destroydelay; this->startParticleSpawner(); }
+            inline float getDestroydelay() const
+                { return this->destroydelay_; }
 
         private:
-            void createParticleSpawner(float lifetime);
+            void startParticleSpawner();
+            void fireParticleSpawner();
+            void stopParticleSpawner();
             void destroyParticleSpawner();
 
             Timer<ParticleSpawner> timer_;
-            ParticleInterface* particle_;
+
+            bool  bSuppressStart_;
+            bool  bAutostart_;
+            bool  bForceDestroy_;
+            bool  bAutoDestroy_;
+            bool  bLoop_;
+            float startdelay_;
+            float lifetime_;
             float destroydelay_;
     };

code/branches/objecthierarchy/src/orxonox/objects/worldentities/SpawnPoint.cc

@@ -78 +78 @@
         {
             this->getGametype()->pawnPreSpawn(entity);
+
             this->spawn(entity);
+
             if (this->template_)
                 entity->addTemplate(this->template_);
+
             entity->postSpawn();
+
             this->getGametype()->pawnPostSpawn(entity);
+
+            this->fireEvent();
         }
         return entity;

code/branches/objecthierarchy/src/orxonox/objects/worldentities/WorldEntity.h

@@ -134 +134 @@
                 { parent->attach(this); }
             inline void detachFromParent()
-                { this->parent_->detach(this); }
+                { if (this->parent_) { this->parent_->detach(this); } }
             inline WorldEntity* getParent() const
                 { return this->parent_; }

code/branches/objecthierarchy/src/orxonox/objects/worldentities/triggers/Trigger.cc

@@ -128 +128 @@
       this->bTriggered_ = (newState & 0x1);
       this->bActive_ = newState & 2;
+      this->fireEvent(this->bActive_);
       this->stateChanges_.pop();
       if (this->stateChanges_.size() != 0)