---

particle.h

Go to the documentation of this file.

// OMICRON ENGINE HEADER FILE
//
// --------------------------------------------------------------------------
// Copyright (C) 2001-2002 by Bjoern Paetzel <kolrabi@gmx.de>
//
// This file is part of the Omicron Engine.
//
// The Omicron Engine is free software; you can redistribute it and/or modify
// it under the terms of the  GNU General Public License  as published by the
// Free Software Foundation;  either version  2  of the License,  or (at your
// option) any later version.
//
// The Omicron Engine  is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
// or  FITNESS FOR A PARTICULAR PURPOSE.  See the  GNU General Public License
// for more details.
//
// You should have  received a copy of the  GNU General Public License  along
// with The Omicron Engine;  if not,  write to the  Free Software Foundation,
// Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
//
// --------------------------------------------------------------------------
// Last modified:       $Date: 2002/12/07 19:02:17 $
// By           :       $Author: kolrabi $
// $Id: particle.h,v 1.1.1.1 2002/12/07 19:02:17 kolrabi Exp $ 

/*

  $Log: particle.h,v $
  Revision 1.1.1.1  2002/12/07 19:02:17  kolrabi
  initial release


*/
 
#include            "forward.h"
#include            "vector.h"

/**************************************************************************** 
 **************************************************************************** 
 * DEFINES ****************************************************************** 
 **************************************************************************** 
 ****************************************************************************/ 
 
/* PARTICLE FLAGS ***********************************************************/ 
#define         PF_ACTIVE                   (1<<0)  
#define         PF_ALIGNTOMOTION            (1<<1)  
#define         PF_ALIGNEDTOMOTION          (1<<2)  
#define         PF_KEEPALIGNEDTOMOTION      (1<<3)  
#define         PF_SPEEDSCALEX              (1<<4)  
#define         PF_SPEEDSCALEY              (1<<5)  
 
/* EMITTER SHAPES ***********************************************************/ 
#define         ES_POINT                    0       
#define         ES_BOX                      1       
#define         ES_SPHERE                   2       
#define         ES_EMERGE                   0x4000  
#define         ES_HOLLOW                   0x8000  

/**************************************************************************** 
 **************************************************************************** 
 * TYPES ******************************************************************** 
 **************************************************************************** 
 ****************************************************************************/ 
 
#ifndef OMICRON_TYPES_PARTICLE_DEFINED 
#define OMICRON_TYPES_PARTICLE_DEFINED 

typedef struct particle_s
{
    particle_s();

    // current state 
    vec3_c      pos;                
    vec3_c      speed;              
    vec3_c      accel;              

    vec4_c      color;              
    vec2_c      size;               

    float       angle;              
    float       anglespeed;
    vec3_c      dir;                

    float       birthtime;          

//    bool        alignmotiondone;
    bool        alife;              
} particle_t;

class particle_system_c
{
protected:

    /*
    typedef struct
    {
        brush_c     volume;
        ulong       type;
    } effect_volume_t;
    */
    // array_c<effect_volume_t>           

    array_c<class particle_emitter_c>   
        *emitters;

    array_c<class particle_type_c>      
        *types;

    friend class particle_emitter_c;    

public:

    particle_system_c();                
    virtual ~particle_system_c();       

    void                                
        update();

    void                                
        draw();

    void                                
        remove_all_emitters();

    void                                
        remove_all_types();

    slong                               
        add_emitter(class particle_emitter_c *);

    void                                
        remove_emitter(class particle_emitter_c *);

    slong                               
        add_type(class particle_type_c *);
};

class particle_emitter_c
{
public:

    slong           particletype;

    float           birthrate;          
 
    vec3_c          minangles;          
    vec3_c          maxangles; 
 
    int             shape;              
    vec3_c          scale;              

    vec3_c          pos,                
                    lastpos;            

    float           newparts;           

//    bool            selfdestruct;

    float           duration;           

protected:

    float           lastupdate;         
    float           starttime;          
    float           endtime;            

    particle_system_c   *psystem;       

    friend class    particle_system_c;  

    void                                
        update();
public:

    particle_emitter_c();               
    virtual ~particle_emitter_c();      

    void                                
        start();
};

class particle_type_c
{
protected:

    vertex_t        *verts;         
    ulong           vertexcount;    

    particle_t      *particles;     
    ulong           particlecount;  

public:

    // setup 
    vec2_c      anglespeed;         
    vec2_c      startangle;

    float       lifetime;           

    vec4_c      begincolor,         
                endcolor; 

    vec2_c      beginsize,          
                endsize; 

    vec3_c      force;              

    float       mass;               

    float       sparkle;            

    // other 
    // struct shader_s *shader;        ///< particle's texture 
    sshort      texture;
    sshort      blendtype;

protected:

    particle_system_c   *psystem;   
    friend class    particle_system_c;
    friend class    particle_emitter_c;

    void                            
        update();

    void                            
        draw();

    void                            
        new_particle(const vec3_t pos, const vec3_t speed);

public:
//    particle_t  reference;          ///< 
    particle_type_c();              
    virtual ~particle_type_c();     

    // TODO:
//    void
//        load(const char *fname);
};

#endif 

---