Changeset 4338 in orxonox.OLD for orxonox/trunk/src/lib/graphics

Timestamp:

May 27, 2005, 9:16:53 PM (20 years ago)

Author:

bensch

Message:

orxonox/trunk: merged branches/physics back to the trunk
merged with command
svn merge -r 3866:HEAD . ../../trunk/
many conflict that i tried to resolv
@patrick: i hope i did not interfere with your stuff :/

Location:

orxonox/trunk/src/lib/graphics

Files:

• light.h (modified) (2 diffs)
• particles/particle_emitter.cc (modified) (6 diffs)
• particles/particle_emitter.h (modified) (2 diffs)
• particles/particle_engine.cc (modified) (1 diff)
• particles/particle_engine.h (modified) (2 diffs)
• particles/particle_system.cc (modified) (10 diffs)
• particles/particle_system.h (modified) (3 diffs)

orxonox/trunk/src/lib/graphics/light.h

@@ -11 +11 @@
 #define _LIGHT_H
 
-#include "world_entity.h"
+#include "p_node.h"
 #include "glincl.h"
 
@@ -21 +21 @@
 
 //! A class that handles Lights. The LightManager operates on this.
-class Light : public WorldEntity
+class Light : public PNode
 {
  public:

orxonox/trunk/src/lib/graphics/particles/particle_emitter.cc

@@ -31 +31 @@
 {
    this->setClassID(CL_PARTICLE_EMITTER, "ParticleEmitter");
+
+   this->type = EMITTER_DOT;
+   this->emitterSize = 1.0;
    this->direction = direction;
    this->setSpread(angle);
    this->setEmissionRate(emissionRate);
-   this->setVelocity(velocity);
+   this->setEmissionVelocity(velocity);
 
    this->saveTime = 0.0;
@@ -50 +53 @@
 {
   ParticleEngine::getInstance()->removeEmitter(this);
-  
 }
 
@@ -71 +73 @@
 
 /**
+   \param type the new Type of this emitter
+*/
+void ParticleEmitter::setType(EMITTER_TYPE type)
+{
+  this->type = type;
+}
+
+void ParticleEmitter::setSize(float emitterSize)
+{
+  if (emitterSize > 0.0)
+    this->emitterSize = emitterSize;
+  else
+    emitterSize = 0.0;
+}
+
+/**
    \brief set the emission rate
    \param sets the number of particles emitted per second
@@ -79 +97 @@
 void ParticleEmitter::setEmissionRate(float emissionRate)
 {
-  this->emissionRate = emissionRate;
+  if (emissionRate > 0.0)
+    this->emissionRate = emissionRate;
+  else
+    this->emissionRate = 0.0;
 }
 
@@ -104 +125 @@
    you may want to use the animation class
 */
-void ParticleEmitter::setVelocity(float velocity, float randomVelocity)
+void ParticleEmitter::setEmissionVelocity(float velocity, float randomVelocity)
 {
   this->velocity = velocity;
@@ -139 +160 @@
 
             // this should spread the Particles evenly. if the Emitter is moved around quickly
-            Vector equalSpread = this->getVelocity() * random()/RAND_MAX * dt;
+            Vector equalSpread = this->getVelocity() * rand()/RAND_MAX * dt;
+            Vector extension; // the Vector for different fields.
 
-            system->addParticle(this->getAbsCoor() - equalSpread, velocityV);
+            if (this->type & 2)
+              {
+                extension = Vector(this->emitterSize * ((float)rand()/RAND_MAX -.5), 0, this->emitterSize * ((float)rand()/RAND_MAX - .5));
+                extension = this->getAbsDir().apply(extension);
+              }
+            else if (this->type & 8)
+              {
+                extension = Vector((float)rand()/RAND_MAX -.5, (float)rand()/RAND_MAX -.5, (float)rand()/RAND_MAX -.5) * this->emitterSize;
+              }
+
+            system->addParticle(this->getAbsCoor() + extension - equalSpread, velocityV);
+            
           }
       }

orxonox/trunk/src/lib/graphics/particles/particle_emitter.h

@@ -13 +13 @@
 class ParticleSystem;
 
-typedef enum EMITTER_TYPE {EMITTER_DOT,
-                           EMITTER_PLANE,
-                           EMITTER_SPHERE,
-                           EMITTER_CUBE};
+//! The form of the Emitter to emit from
+typedef enum EMITTER_TYPE {EMITTER_DOT   = 1,
+                           EMITTER_PLANE = 2,
+                           EMITTER_SPHERE= 4,
+                           EMITTER_CUBE  = 8};
 
 //! A default singleton class.
@@ -32 +33 @@
 
   /* controlling the behavour: these can be used as Animation interfaces */
+  void setType(EMITTER_TYPE type);
+  void setSize(float emitterSize);
   void setEmissionRate(float emissionRate);
   void setSpread(float angle, float randomAngle = 0.0);
-  void setVelocity(float velocity, float randomVelocity = 0.0);
+  void setEmissionVelocity(float velocity, float randomVelocity = 0.0);
+
+  /** \returns the type of the emitter */
+  inline EMITTER_TYPE getType(void) const { return this->type; };
+  /** \returns the Size of the emitter */
+  inline float getSize(void) const { return this->emitterSize; };
+  /** \returns the emissionRate */
+  inline float getEmissionRate(void) const { return this->emissionRate; };
+  /** \returns the SpreadAngle of the emitter */
+  inline float getSpread(void) { return this->angle; };
+  /** \returns the EmissionVelocity of the emitter */
+  inline float getEmissionVelocity(void) { return this->velocity; };
 
   void debug(void);
 
  private:
+  EMITTER_TYPE type;    //!< The type of emitter this is
+  float emitterSize;    //!< The size of the emitter (not for EMITTER_DOT)
   Vector direction;     //!< emition direction
   float angle;          //!< max angle from the direction of the emitter

orxonox/trunk/src/lib/graphics/particles/particle_engine.cc

@@ -267 +267 @@
 
 /**
+   \param systemName the name of the system to search for
+   \returns the system called by systemName or NULL if not found
+*/
+ParticleSystem* ParticleEngine::getSystemByName(const char* systemName) const
+{
+  tIterator<ParticleSystem>* tmpIt = systemList->getIterator();
+  ParticleSystem* tmpSys = tmpIt->nextElement();
+  while(tmpSys)
+    {
+      if (!strcmp(systemName, tmpSys->getName()))
+        {
+          delete tmpIt;
+          return tmpSys;
+        }
+      tmpSys = tmpIt->nextElement();
+    }
+  delete tmpIt;
+  return NULL;
+}
+
+/**
+   \param number the n-th system to return
+   \returns the system called by number or NULL if not found
+*/
+ParticleSystem* ParticleEngine::getSystemByNumber(unsigned int number) const
+{
+  int count = 0;
+  tIterator<ParticleSystem>* tmpIt = systemList->getIterator();
+  ParticleSystem* tmpSys = tmpIt->nextElement();
+  while(tmpSys)
+    {
+      count++;
+      if ( count == number)
+        {
+          delete tmpIt;
+          return tmpSys;
+        }
+      tmpSys = tmpIt->nextElement();
+    }
+  delete tmpIt;
+  return NULL;
+}
+
+/**
+   \param emitterName the name of the emitter to search for
+   \returns the emitter called by emitterName or NULL if not found
+*/
+ParticleEmitter* ParticleEngine::getEmitterByName(const char* emitterName) const
+{
+  tIterator<ParticleEmitter>* tmpIt = emitterList->getIterator();
+  ParticleEmitter* tmpEmit = tmpIt->nextElement();
+  while(tmpEmit)
+    {
+      if (!strcmp(emitterName, tmpEmit->getName()))
+        {
+          delete tmpIt;
+          return tmpEmit;
+        }
+      tmpEmit = tmpIt->nextElement();
+    }
+  delete tmpIt;
+  return NULL;
+}
+
+
+/**
+   \param number the n-th emitter to return
+   \returns the emitter called by number or NULL if not found
+*/
+ParticleEmitter* ParticleEngine::getEmitterByNumber(unsigned int number) const
+{
+  int count = 0;
+  tIterator<ParticleEmitter>* tmpIt = emitterList->getIterator();
+  ParticleEmitter* tmpEmit = tmpIt->nextElement();
+  while(tmpEmit)
+    {
+      count++;
+      if ( count == number)
+        {
+          delete tmpIt;
+          return tmpEmit;
+        }
+      tmpEmit = tmpIt->nextElement();
+    }
+  delete tmpIt;
+  return NULL;
+}
+
+/**
    \brief outputs some nice debug information
 */

orxonox/trunk/src/lib/graphics/particles/particle_engine.h

@@ -13 +13 @@
 // FORWARD DEFINITION 
 template<class T> class tList;
-class ParticleSystem;
-class ParticleEmitter;
 
 struct ParticleConnection
@@ -41 +39 @@
   bool breakConnection(ParticleConnection* connection);
 
+  ParticleSystem* getSystemByName(const char* systemName) const;
+  ParticleSystem* getSystemByNumber(unsigned int number) const;
+  ParticleEmitter* getEmitterByName(const char* emitterName) const;
+  ParticleEmitter* getEmitterByNumber(unsigned int number) const;
+
   void debug();
 

orxonox/trunk/src/lib/graphics/particles/particle_system.cc

@@ -20 +20 @@
 #include "particle_emitter.h"
 #include "particle_engine.h"
+
+#include "field.h"
+
 #include "compiler.h"
 #include "material.h"
+#include "state.h"
+
+
+// needed to find the Position of the Camera
+#include "world.h"
 
 using namespace std;
@@ -34 +42 @@
 ParticleSystem::ParticleSystem (unsigned int maxCount, PARTICLE_TYPE type)
 {
-   this->setClassID(CL_PARTICLE_SYSTEM, "ParticleSystem");
-   this->material = NULL;
-   this->name = NULL;
-   this->maxCount = maxCount;
-   this->count = 0;
-   this->particles = NULL;
-   this->deadList = NULL;
-   this->setConserve(1);
-   this->setLifeSpan(1);
-   this->setInheritSpeed(0);
-   this->glID = NULL;
-   this->setRadius(1.0, 1.0, 0.0);
-   this->setType(type, 1);
-   ParticleEngine::getInstance()->addSystem(this);
+  this->setClassID(CL_PARTICLE_SYSTEM, "ParticleSystem");
+  this->material = NULL;
+  this->name = NULL;
+  this->maxCount = maxCount;
+  this->count = 0;
+  this->particles = NULL;
+  this->deadList = NULL;
+  this->setConserve(1);
+  this->setLifeSpan(1);
+  this->setInheritSpeed(0);
+  this->glID = NULL;
+  this->setRadius(1.0, 1.0, 0.0);
+  this->setType(type, 1);
+  this->setColor(1.0,1.0,1.0,1.0, .5,.5,.5,.5, .0,.0,.0,.0);
+  ParticleEngine::getInstance()->addSystem(this);
 }
 
@@ -106 +115 @@
   this->particleType = particleType;
   this->dialectCount = count;
-  if (glID != NULL)
-    delete glID;
-
-  glID = new GLuint[count];
-  for (int i = 0; i< count; i++)
-    glID[i] = 0;
-
-  glID[0] = glGenLists(count);
-  
-  material = new Material("transperencyMap");
-  material->setDiffuseMap("pictures/radialTransparency.png");
-  //  material->setTransparency(.5);
-
-  glNewList(glID[0], GL_COMPILE);
-  glBegin(GL_TRIANGLE_STRIP);
-  glTexCoord2f(1, 1);
-  glVertex3f(0.0, .5, .5);
-  glTexCoord2f(1, 0);
-  glVertex3f(0.0, -.5, .5);
-  glTexCoord2f(0, 1);
-  glVertex3f(0.0, .5, -.5);
-  glTexCoord2f(0, 0);
-  glVertex3f(0.0, -.5, -.5);
-  glEnd();
-  glEndList();
+  //  if (glID != NULL)
+  //    delete glID;
+
+  //  glID = new GLuint[count];
+  //  for (int i = 0; i< count; i++)
+  //    glID[i] = 0;
+
+  //  glID[0] = glGenLists(count);
+  if (this->material)
+    delete this->material;
+  this->material = NULL;
+
+  if (this->particleType == PARTICLE_SPRITE)
+    {
+      this->material = new Material("transperencyMap");
+      this->material->setDiffuseMap("pictures/radialTransparency.png");
+      //  material->setTransparency(.5);
+    }
 }
 
@@ -192 +194 @@
 }
 
+
+/**
+   \brief Tells the ParticleSystem how it should iterate the color over time
+   \param ....
+*/
+void ParticleSystem::setColor(GLfloat br, GLfloat bg, GLfloat bb, GLfloat ba,
+                              GLfloat mr, GLfloat mg, GLfloat mb, GLfloat ma,
+                              GLfloat er, GLfloat eg, GLfloat eb, GLfloat ea)
+{
+  this->startColor[0] = br;
+  this->startColor[1] = bg;
+  this->startColor[2] = bb;
+  this->startColor[3] = ba;
+
+  this->midColor[0] = mr;
+  this->midColor[1] = mg;
+  this->midColor[2] = mb;
+  this->midColor[3] = ma;
+
+  this->endColor[0] = er;
+  this->endColor[1] = eg;
+  this->endColor[2] = eb;
+  this->endColor[3] = ea;
+}
+
 /**
    \brief ticks the system.
@@ -207 +234 @@
       tickPart->radius += tickPart->radiusIt * dt;
 
+      // applying force to the System.
+      tickPart->velocity += tickPart->extForce * tickPart->mass;
+      tickPart->extForce = Vector(0,0,0);
+
+      // applying Color
+      //! \todo better algorithm to do this \todo also implement the midColor
+      if (tickPart->lifeCycle < .5)
+        {
+          tickPart->color[0] = this->startColor[0] *(1.0-tickPart->lifeCycle*2.0) + this->midColor[0] *(tickPart->lifeCycle*2);
+          tickPart->color[1] = this->startColor[1] *(1.0-tickPart->lifeCycle*2.0) + this->midColor[1] *(tickPart->lifeCycle*2);
+          tickPart->color[2] = this->startColor[2] *(1.0-tickPart->lifeCycle*2.0) + this->midColor[2] *(tickPart->lifeCycle*2);
+          tickPart->color[3] = this->startColor[3] *(1.0-tickPart->lifeCycle*2.0) + this->midColor[3] *(tickPart->lifeCycle*2);
+        }
+      else
+        {
+          tickPart->color[0] = this->midColor[0] *(2.0-tickPart->lifeCycle*2.0) + this->endColor[0] *(tickPart->lifeCycle*2);
+          tickPart->color[1] = this->midColor[1] *(2.0-tickPart->lifeCycle*2.0) + this->endColor[1] *(tickPart->lifeCycle*2);
+          tickPart->color[2] = this->midColor[2] *(2.0-tickPart->lifeCycle*2.0) + this->endColor[2] *(tickPart->lifeCycle*2);
+          tickPart->color[3] = this->midColor[3] *(2.0-tickPart->lifeCycle*2.0) + this->endColor[3] *(tickPart->lifeCycle*2);
+        }         
       // many more to come
-
 
       if (this->conserve < 1.0)
         tickPart->velocity = tickPart->velocity * this->conserve;
       // find out if we have to delete tickPart
-      if ((tickPart->timeToLive -= dt) <= 0)
+      if ((tickPart->lifeCycle += dt/tickPart->lifeTime) >= 1.0)
         {
           // remove the particle from the list
@@ -241 +287 @@
 }
 
+/** 
+    \brief applies some force to a Particle.
+ */
+void ParticleSystem::applyField(float dt, Field* field)
+{
+  Particle* tickPart = particles;
+  while (tickPart)
+    {
+      tickPart->extForce += field->calcForce(dt, tickPart->position);
+      tickPart = tickPart->next;
+    }
+}
+
+
 /**
    \brief draws all the Particles of this System
    \param the time passed in seconds (since the last draw)
+
+   The Cases in this Function all do the same:
+   Drawing all the particles with the appropriate Type.
+   This is just the fastest Way to do this, but will most likely be changed in the future.
 */
 void ParticleSystem::draw(float dt)
 {
   glPushAttrib(GL_ENABLE_BIT);
-  //  material->select();
+  glDisable(GL_LIGHTING);
+
   Particle* drawPart = particles;
-
+      
   switch (this->particleType)
     {
+    default:
     case PARTICLE_SPRITE:
       glMatrixMode(GL_MODELVIEW);
-      //  glDisable(GL_LIGHTING);
+      glDisable(GL_DEPTH_TEST);
+
       material->select(); 
-      glDisable(GL_DEPTH_TEST);
+      //      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+      
+
       while (likely(drawPart != NULL))
         {
-          glPushMatrix();
-          glTranslatef(drawPart->position.x, drawPart->position.y, drawPart->position.z);
-          glScalef(drawPart->radius, drawPart->radius, drawPart->radius);
-          glCallList(*this->glID);
-          
-          //glVertex3f(drawPart->position.x, drawPart->position.y, drawPart->position.z);
+          glColor4fv(drawPart->color);
+          //! \todo implement a faster code for the look-at Camera algorithm.
+
+          const PNode* camera = State::getInstance()->getCamera();  //!< \todo MUST be different
+          Vector cameraPos = camera->getAbsCoor();
+          Vector cameraTargetPos = State::getInstance()->getCameraTarget()->getAbsCoor();
+          Vector view = cameraTargetPos - cameraPos;
+          Vector up = Vector(0, 1, 0);
+          up = camera->getAbsDir().apply(up);
+          Vector h = up.cross(view);
+          Vector v = h.cross(view);
+          h.normalize();
+          v.normalize();
+          v *= .5 * drawPart->radius;
+          h *= .5 * drawPart->radius;
+
+          glBegin(GL_TRIANGLE_STRIP);
+          glTexCoord2i(1, 1);
+          glVertex3f(drawPart->position.x - h.x - v.x,
+                     drawPart->position.y - h.y - v.y,
+                     drawPart->position.z - h.z - v.z);
+          glTexCoord2i(0, 1);
+          glVertex3f(drawPart->position.x - h.x + v.x,
+                     drawPart->position.y - h.y + v.y,
+                     drawPart->position.z - h.z + v.z);
+          glTexCoord2i(1, 0);
+          glVertex3f(drawPart->position.x + h.x - v.x,
+                     drawPart->position.y + h.y - v.y,
+                     drawPart->position.z + h.z - v.z);
+          glTexCoord2i(0, 0);
+          glVertex3f(drawPart->position.x + h.x + v.x,
+                     drawPart->position.y + h.y + v.y,
+                     drawPart->position.z + h.z + v.z);
+
+          glEnd();
+  
           drawPart = drawPart->next;
-          glPopMatrix();
-        }
-      //      glEnd();
-      
-      //  glEnable(GL_LIGHTING);
-      
-      glEnable(GL_DEPTH_TEST);
+        }
+
+      
       break;
-    default:
 
     case PARTICLE_SPARK:
@@ -282 +376 @@
       while (likely(drawPart != NULL))
         {
+          glColor4fv(drawPart->color);
           glVertex3f(drawPart->position.x, drawPart->position.y, drawPart->position.z);
           glVertex3f(drawPart->position.x - drawPart->velocity.x,
@@ -295 +390 @@
       while (likely(drawPart != NULL))
         {
+          glColor4fv(drawPart->color);
+
           glLineWidth(drawPart->radius);
 
@@ -349 +446 @@
         }
       
-      particles->timeToLive = this->lifeSpan + (float)(rand()/RAND_MAX)* this->randomLifeSpan;
+      particles->lifeTime = this->lifeSpan + (float)(rand()/RAND_MAX)* this->randomLifeSpan;
+      particles->lifeCycle = 0.0;
       particles->position = position;
       particles->velocity = velocity;
@@ -357 +455 @@
       particles->radius = this->startRadius + (rand()/RAND_MAX-.5)*this->randomStartRadius;
       
-      particles->radiusIt = (this->endRadius + (rand()/RAND_MAX-.5)*this->randomEndRadius - particles->radius) / particles->timeToLive;
+      particles->radiusIt = (this->endRadius + (rand()/RAND_MAX-.5)*this->randomEndRadius - particles->radius) / particles->lifeTime;
 
       ++this->count;

orxonox/trunk/src/lib/graphics/particles/particle_system.h

@@ -31 +31 @@
 class Material;
 class ParticleEmitter;
-
+class Field;
 
 //! A struct for one Particle
 typedef struct Particle
 {
-  float timeToLive;           //!< The time this particle lives from NOW on.
+  float lifeTime;             //!< The time this particle has to live.
+  float lifeCycle;            //!< The fraction of time passed. (in percentage of its lifeTime)
+
   Vector position;            //!< The current position of this particle.
   Vector velocity;            //!< The current velocity of this particle.
+  Vector extForce;            //!< The external Force that influences this Particle.
   Quaternion rotation;        //!< The current rotation of this particle.
   float mass;                 //!< The mass of this particle.
   float radius;               //!< The current size of this particle.
   float radiusIt;             //!< The difference of the Size per second.
+
+  GLfloat color [4];          //!< A Color for the particles.
 
   PARTICLE_TYPE type;
@@ -69 +74 @@
   void setMass(float mass, float randomMass);
 
+  void setColor(GLfloat br, GLfloat bg, GLfloat bb, GLfloat ba,
+                GLfloat mr, GLfloat mg, GLfloat mb, GLfloat ma,
+                GLfloat er, GLfloat eg, GLfloat eb, GLfloat ea);
+
+  /** \returns the Type of the particles */
+  inline PARTICLE_TYPE getType(void) const { return this->particleType; };
+  /** \returns the Material that lies on this particles */
+  inline const Material* getMaterial(void) const { return this->material; };
+  /** \returns the inherit-speed-factor */
+  inline float getInheritSpeed(void) const { return this->inheritSpeed; };
+  /** \returns the lifespan of the particles */
+  inline float getLifeSpan(void) const { return this->lifeSpan; };
+  /** \returns the starting-radius of the particles */
+  inline float getStartRadius(void) const { return this->startRadius; };
+  /** \returns the end-radius of the particles */
+  inline float getEndRadius(void) const { return this->endRadius; };
+  /** \returns the conserve-factor of the particles */
+  inline float getConserve(void) const { return this->conserve; };
+  /** \returns the initial mass of the particles */
+  inline float getMass(void) const { return this->initialMass; };
+
+  void applyField(float dt, Field* field);
+
   void tick(float dt);
   void draw(float dt);
@@ -79 +107 @@
   float conserve;            //!< How much energy gets conserved to the next Tick.
   float lifeSpan;            //!< Initial lifetime of a Particle.
-  float randomLifeSpan;
-  float startRadius;
-  float endRadius;
-  float randomStartRadius;
-  float randomEndRadius;
-  float initialMass;
-  float randomInitialMass;
-  float inheritSpeed;
+  float randomLifeSpan;      //!< A random value for the Lifespan (around the initial lifetime)
+  float startRadius;         //!< The beginning Radius of the Particle
+  float endRadius;           //!< The end Radius of the Particle
+  float randomStartRadius;   //!< The Random start Radius (begin + rand*randomValue)
+  float randomEndRadius;     //!< Random end value
+  float initialMass;         //!< The initial Mass of the Particle
+  float randomInitialMass;   //!< The random initial Mass of the Particle
+  float inheritSpeed;        //!< How much speed the particle inherits from the Emitters speed \todo move this to the emitter
+
+  GLfloat startColor[4];     //!< Color of the Particle at the beginning
+  GLfloat midColor[4];       //!< Color of the Particle at the middle of its lifeSpan
+  GLfloat endColor[4];       //!< Color of the Particle at the end of its lifeSpan
 
   // particles