---

p_type.cpp

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:15 $
// By           :       $Author: kolrabi $
// $Id: p_type.cpp,v 1.1.1.1 2002/12/07 19:02:15 kolrabi Exp $ 

/*

  $Log: p_type.cpp,v $
  Revision 1.1.1.1  2002/12/07 19:02:15  kolrabi
  initial release


*/
 
#include            "omicron/internal.h"
#include            "omicron/render.h"
#include            "omicron/texture.h"
#include            "omicron/particle.h"

#include            "omicron/array.h"
 
#define             PCOUNT_GROWTH       100

/**************************************************************************** 
 **************************************************************************** 
 * PARTICLE SYSTEM ********************************************************** 
 **************************************************************************** 
 ****************************************************************************/ 
 
particle_type_c::particle_type_c()
{
    particlecount = PCOUNT_GROWTH;
    particles = new particle_t[particlecount];

    verts = new vertex_t[4*particlecount];
    vertexcount = 4*particlecount;

    begincolor.set(1,1,1,1);
    endcolor.set(1,1,1,1);

    beginsize.set(1,1);
    endsize.set(1,1);

    anglespeed.clear();
    startangle.clear();
    
    force.set(0,0,-1);

    mass = 1;
//    friction = 0;

    sparkle = 0;
}

particle_type_c::~particle_type_c()
{
    SafeArrayDelete(particles);
    SafeArrayDelete(verts);
}

void
particle_type_c::update
()
{
    ulong i;

    for (i=0; i<particlecount; i++)
    {
        if (!particles[i].alife)
            continue;

        float   age = gv.time - particles[i].birthtime;
        float   agefrac = age / lifetime;

        if (agefrac>1)
            particles[i].alife = false;

        agefrac += frand(-sparkle, sparkle);

        if (agefrac<0) agefrac = 0;
        if (agefrac>1) agefrac = 1;

        particles[i].speed = particles[i].speed + force * gv.dtime * mass;
        particles[i].pos   = particles[i].pos   + particles[i].speed * gv.dtime;

        particles[i].size = vec2_c::linear(beginsize, endsize, agefrac);

        particles[i].angle += particles[i].anglespeed*gv.time;
    }
}

void
particle_type_c::draw
()
{
    ulong i;
    ulong activecount = 0;

    if (vertexcount<particlecount*4)
    {
        SafeArrayDelete(verts);

        verts = new vertex_t[4*particlecount];
        vertexcount = 4*particlecount;
    }

    vec3_c  vright, vup, vdirinv;

    vdirinv = gv.renderer->get_viewdir() * (-1);

    ulong   bc, ec;

    bc = color_from_vec(begincolor);
    ec = color_from_vec(endcolor);

    for (i=0; i<particlecount; i++)
    {
        if (!particles[i].alife)
            continue;

        vec3_c  pos;
        vec3_c  vecs[4];

        float   age, agefrac;
        
        age = gv.time - particles[i].birthtime;
        agefrac = (age / lifetime)+frand(-sparkle, sparkle);

        if (agefrac<0) agefrac = 0;
        if (agefrac>1) agefrac = 1;

        pos = particles[i].pos;

        vright  = gv.renderer->get_viewright().rotate_vec(particles[i].angle, vdirinv);
        vup     = gv.renderer->get_viewup2().rotate_vec(particles[i].angle, vdirinv);

        vecs[0] = pos - (vright * (particles[i].size[0]/2)) - (vup * (particles[i].size[1]/2));
        vecs[1] = pos + (vright * (particles[i].size[0]/2)) - (vup * (particles[i].size[1]/2));
        vecs[2] = pos + (vright * (particles[i].size[0]/2)) + (vup * (particles[i].size[1]/2));
        vecs[3] = pos - (vright * (particles[i].size[0]/2)) + (vup * (particles[i].size[1]/2));

        vertex_set(&verts[activecount*4+0], vecs[0][0], vecs[0][1] , vecs[0][2], 0, 0);
        vertex_set(&verts[activecount*4+1], vecs[1][0], vecs[1][1] , vecs[1][2], 1, 0);
        vertex_set(&verts[activecount*4+2], vecs[2][0], vecs[2][1] , vecs[2][2], 1, 1);
        vertex_set(&verts[activecount*4+3], vecs[3][0], vecs[3][1] , vecs[3][2], 0, 1);

        verts[activecount*4+0].diffuse =
        verts[activecount*4+1].diffuse =
        verts[activecount*4+2].diffuse =
        verts[activecount*4+3].diffuse = color_interpolate(bc, ec, agefrac);

        vdirinv.copy(verts[activecount*4+0].normal);
        vdirinv.copy(verts[activecount*4+1].normal);
        vdirinv.copy(verts[activecount*4+2].normal);
        vdirinv.copy(verts[activecount*4+3].normal);

        activecount++;
    }

    if (activecount)
    {
        gv.texman->set(texture);
        gv.renderer->set_blending(blendtype);
        gv.renderer->use_vertices(verts, activecount*4);
        
        glMatrixMode(GL_TEXTURE);
        glLoadIdentity();

        gv.renderer->push_vertices(PT_QUADS, activecount*4);
        // gv.renderer->render_verts(verts, activecount*4, PT_QUADS);
    }
}

void
particle_type_c::new_particle
(
        const vec3_t    pos,                            
        const vec3_t    speed                           
)
{
    ulong i;

    for (i=0; i<particlecount; i++)
    {
        if (particles[i].alife == false)
            break;
    }

    if (i==particlecount)
    {
        particle_t *newparticles = new particle_t[PCOUNT_GROWTH+particlecount];

        memcpy(newparticles, particles, sizeof(particle_t)*particlecount);

        SafeArrayDelete(particles);
        particles = newparticles;
        particlecount += PCOUNT_GROWTH;
    }

    particles[i].alife      = true;

    particles[i].pos        = pos;
    particles[i].speed      = speed;

    particles[i].color      = begincolor;

    particles[i].size       = beginsize;

    particles[i].birthtime  = gv.time;

    particles[i].anglespeed = frand(anglespeed[0], anglespeed[1]);
    particles[i].angle      = frand(startangle[0], startangle[1]);
}

---