/* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
/*================================================================
 *
 * Project : Freyja
 * Author  : Terry 'Mongoose' Hendrix II
 * Website : http://www.westga.edu/~stu7440/
 * Email   : stu7440@westga.edu
 * Object  : Emitter
 * License : No use w/o permission (C)2001Mongoose
 * Comments: Particle emitter for freyja
 *
 *
 *           This file was generated using Mongoose's C++
 *           template generator script.  <stu7440@westga.edu>
 *
 *-- History -------------------------------------------------
 *
 * 2001.06.30:
 * Mongoose - Created
 =================================================================*/

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#ifdef __APPLE__
#include <OpenGL/gl.h>
#include <OpenGL/glu.h>
#else
#include <GL/gl.h>
#include <GL/glu.h>
#endif

#include <Emitter.h>

#ifdef DEBUG_MEMORY
#include <memory_test.h>
#endif

vec_t Emitter::mFrustum[6][4];


int Emitter::compareParticleDist(const void *voidA, const void *voidB)
{
    Particle *a = (Particle *)voidA, *b = (Particle *)voidB;
    float x, y, z, distA, distB;

    if (!a || !b)
        return -1; // error really

    a->Pos(&x, &y, &z);
    distA = (Emitter::mFrustum[5][0] * x +
            Emitter::mFrustum[5][1] * y +
            Emitter::mFrustum[5][2] * z +
            Emitter::mFrustum[5][3]);

    b->Pos(&x, &y, &z);
    distB = (Emitter::mFrustum[5][0] * x +
            Emitter::mFrustum[5][1] * y +
            Emitter::mFrustum[5][2] * z +
            Emitter::mFrustum[5][3]);

    // reverse less/greater than
    // less than
    if (distA > distB)
        return -1;

    // greater than ( no need for equal )
    return 1;
}


Emitter::Emitter(const char *name, int n)
{
    _name = NULL;
    _flags = 0;
    _particle = NULL;
    _count = 0;
    _pos[0] = _pos[1] = _pos[2] = 0.0;
    _mangle[0] = _mangle[1] = _mangle[2] = 0.0;

    Name(name);
    ParticleArray(n);
}


Emitter::~Emitter()
{
    if (_name)
    {
        delete [] _name;
    }

    if (_particle)
    {
        delete [] _particle;
    }

    _count = 0;
}

Particle *Emitter::Particles()
{
    return _particle;
}


int Emitter::Count()
{
    return _count;
}


void Emitter::Pos(float *x, float *y, float *z)
{
    *x = _pos[0];
    *y = _pos[1];
    *z = _pos[2];
}


void Emitter::Pos(float x, float y, float z)
{
    _pos[0] = x;
    _pos[1] = y;
    _pos[2] = z;
}


void Emitter::Orientation(float *x, float *y, float *z)
{
    *x = _mangle[0];
    *y = _mangle[1];
    *z = _mangle[2];
}


void Emitter::Orientation(float x, float y, float z)
{
    _mangle[0] = x;
    _mangle[1] = y;
    _mangle[2] = z;
}


unsigned int Emitter::Flags()
{
    return _flags;
}


void Emitter::Flags(unsigned int flag, bool op)
{
    _flags |= flag;

    if (!op)
        _flags ^= flag;
}


void Emitter::ParticleArray(int n)
{
    if (n)
    {
        if (_particle)
        {
            _count = 0;
            delete [] _particle;
        }

        _count = n;
        _particle = new Particle[_count];
    }
}


void Emitter::Name(const char *name)
{
    int l;


    if (name && name[0])
    {
        if (_name)
        {
            delete [] _name;
        }

        l = strlen(name);
        _name = new char[l+1];

        // Mongoose 2002.01.09, Mongoose says 'Only you can prevent overflows'
        strncpy(_name, name, l);
        _name[l] = 0;
    }
}


void Emitter::SetTextureId(int id)
{
    unsigned int i;


    for (i = 0; i < _count; i++)
        _particle[i].TextureId(id);
}


void Emitter::TextureId(unsigned int particle_start,
        unsigned int particle_end, int id)
{
    unsigned int i;


    if ((particle_start < _count) &&
            (particle_end > 0 && particle_end <= _count) &&
            (particle_start < particle_end))
    {
        for (i = particle_start; i < particle_end; i++)
            _particle[i].TextureId(id);
    }
}


void Emitter::Color(unsigned int particle_start, unsigned int particle_end,
        float r, float g, float b)
{
    unsigned int i;


    if ((particle_start < _count) &&
            (particle_end > 0 && particle_end <= _count) &&
            (particle_start < particle_end))
    {
        for (i = particle_start; i < particle_end; i++)
            _particle[i].Color(r, g, b);
    }
}


void Emitter::Speed(unsigned int particle_start, unsigned int particle_end,
        float x, float y, float z)
{
    unsigned int i;


    if ((particle_start < _count) &&
            (particle_end > 0 && particle_end <= _count) &&
            (particle_start < particle_end))
    {
        for (i = particle_start; i < particle_end; i++)
            _particle[i].Speed(x, y, z);
    }
}


void Emitter::Force(unsigned int particle_start, unsigned int particle_end,
        float x, float y, float z)
{
    unsigned int i;


    if ((particle_start < _count) &&
            (particle_end > 0 && particle_end <= _count) &&
            (particle_start < particle_end))
    {
        for (i = particle_start; i < particle_end; i++)
            _particle[i].Force(x, y, z);
    }
}


void Emitter::Draw()
{
    unsigned int i, p;
    float x, y, z;
    float r, g, b;
    float life;


    if (!_count || !_particle)
    {
        printf("Emitter::Draw> No particles!\n");
        return;
    }

    glPushMatrix();

    //glRotatef(_mangle[0], 1.0, 0.0, 0.0);
    //glRotatef(_mangle[1], 0.0, 1.0, 0.0);
    //glRotatef(_mangle[2], 0.0, 0.0, 1.0);
    //glTranslatef(_pos[0], _pos[1], _pos[2]);

    if (_flags & fUseDepthSorting)
    {
        qsort(_particle, _count, sizeof(Particle), compareParticleDist);
    }

    for (i = 0; i < _count; i++)
    {
        if (_particle[i].isActive())
        {
            _particle[i].Pos(&x, &y, &z);

            if (_flags & fUseFrustumCulling)
            {
                for (p = 0; p < 6; ++p)
                {
                    if (mFrustum[p][0] * x +
                            mFrustum[p][1] * y +
                            mFrustum[p][2] * z +
                            mFrustum[p][3] < 0)
                    {
                        _particle[i].setActive(false);
                        break;
                    }
                }

                if (!_particle[i].isActive())
                    continue;
            }

            _particle[i].Color(&r, &g, &b);
            life = _particle[i].Life();

            // Mongoose 2002.01.01, Removed Texture agent dep
            glBindTexture(GL_TEXTURE_2D, _particle[i].Texture());

            // Alpha is determined by life, which is affected by blend amount
            glColor4f(r, g, b, life);

            // Render tristrip quad
            glBegin(GL_TRIANGLE_STRIP);
            glTexCoord2d(1.0, 1.0);
            glVertex3f(x + 0.5, y + 0.5, z);

            glTexCoord2d(0.0, 1.0);
            glVertex3f(x - 0.5, y + 0.5, z);

            glTexCoord2d(1.0, 0.0);
            glVertex3f(x + 0.5, y - 0.5, z);

            glTexCoord2d(0.0, 0.0);
            glVertex3f(x - 0.5, y - 0.5, z);
            glEnd();

            // Update particle's attributes for it's life cycle
            _particle[i].Update();
        }
    }

    glPopMatrix();
}