r_particle.cpp

Go to the documentation of this file.

/*
Copyright (C) 2002-2020 UFO: Alien Invasion.

This program 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.

This program 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 this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#include "r_local.h"
#include "r_particle.h"
#include "r_draw.h"

ptl_t r_particleArray[MAX_PTLS];
int r_numParticles;

cvar_t* r_particles;

/*
=============================================================
PARTICLE DRAWING
=============================================================
*/

static void R_GetSpriteVectors (const ptl_t* p, vec3_t right, vec3_t up)
{
    /* get transformation */
    switch (p->style) {
    case STYLE_FACING:
        VectorScale(r_locals.right, p->size[0], right);
        VectorScale(r_locals.up, p->size[1], up);
        break;

    case STYLE_ROTATED:
        AngleVectors(p->angles, nullptr, right, up);
        VectorScale(right, p->size[0], right);
        VectorScale(up, p->size[1], up);
        break;

    case STYLE_BEAM:
    case STYLE_AXIS:
        AngleVectors(p->angles, right, nullptr, nullptr);
        CrossProduct(right, r_locals.forward, up);
        VectorNormalizeFast(up);
        VectorScale(right, p->size[0], right);
        VectorScale(up, p->size[1], up);
        break;

    default:
        Com_Error(ERR_FATAL, "R_GetSpriteVectors: unknown style");
    }
}

static inline void R_SpriteTexcoords (const ptl_t* p, float out[8])
{
    const float s = p->scrollS * refdef.time;
    const float t = p->scrollT * refdef.time;

    out[0] = 0.0 + s;
    out[1] = 1.0 + t;

    out[2] = 0.0 + s;
    out[3] = 0.0 + t;

    out[4] = 1.0 + s;
    out[5] = 0.0 + t;

    out[6] = 1.0 + s;
    out[7] = 1.0 + t;
}

static void R_DrawSprite (const ptl_t* p)
{
    const ptl_t* q;
    vec3_t up, right;
    vec3_t nup, nright;
    vec3_t pos;
    float texcoords[8];

    /* load texture set up coordinates */
    assert(p->pic);
    R_BindTexture(p->pic->art.image->texnum);

    /* calculate main position and normalised up and right vectors */
    q = p->parent ? p->parent : p;
    R_GetSpriteVectors(q, right, up);

    /* Calculate normalised */
    VectorCopy(up, nup);
    VectorCopy(right, nright);
    VectorNormalizeFast(nup);
    VectorNormalizeFast(nright);

    /* offset */
    VectorCopy(q->s, pos);
    VectorMA(pos, q->offset[0], nup, pos);
    VectorMA(pos, q->offset[1], nright, pos);

    if (p->parent) {
        /* if this is a child then calculate our own up and right vectors and offsets */
        R_GetSpriteVectors(p, right, up);

        /* but offset by our parent's nup and nright */
        VectorMA(pos, p->offset[0], nup, pos);
        VectorMA(pos, p->offset[1], nright, pos);
    }

    /* center image */
    VectorMA(pos, -0.5, up, pos);
    VectorMA(pos, -0.5, right, pos);

    R_SpriteTexcoords(p, texcoords);

    R_Color(p->color);
    {
        /* draw it */
        const vec3_t points[] = { { pos[0], pos[1], pos[2] }, { pos[0] + up[0], pos[1] + up[1], pos[2] + up[2] }, { pos[0]
                + up[0] + right[0], pos[1] + up[1] + right[1], pos[2] + up[2] + right[2] }, { pos[0] + right[0], pos[1]
                + right[1], pos[2] + right[2] } };

        R_BindArray(GL_TEXTURE_COORD_ARRAY, GL_FLOAT, texcoords);
        R_BindArray(GL_VERTEX_ARRAY, GL_FLOAT, points);
        glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
        R_BindDefaultArray(GL_VERTEX_ARRAY);
        R_BindDefaultArray(GL_TEXTURE_COORD_ARRAY);

        refdef.batchCount++;
    }
}


static void R_DrawParticleModel (ptl_t* p)
{
    modelInfo_t mi;

    /* initialize model info */
    OBJZERO(mi);
    mi.color = p->color;
    mi.origin = p->s;
    mi.angles = p->angles;
    assert(p->model);
    mi.model = p->model->art.model;
    mi.skin = p->skin;

    /* draw it */
    R_DrawModelParticle(&mi);
}

static void R_DrawPtlCircle (const ptl_t* p)
{
    const float radius = p->size[0];
    const float thickness = p->size[1];

    R_EnableTexture(&texunit_diffuse, false);

    R_DrawCircle(radius, p->color, thickness, p->s);

    R_EnableTexture(&texunit_diffuse, true);
}

static void R_DrawPtlLine (const ptl_t* p)
{
    const vec3_t points[] = { { p->s[0], p->s[1], p->s[2] }, { p->v[0], p->v[1], p->v[2] } };

    R_EnableTexture(&texunit_diffuse, false);

    glEnable(GL_LINE_SMOOTH);

    R_Color(p->color);

    /* draw line from s to v */
    R_BindArray(GL_VERTEX_ARRAY, GL_FLOAT, points);
    glDrawArrays(GL_LINE_STRIP, 0, 2);
    R_BindDefaultArray(GL_VERTEX_ARRAY);

    refdef.batchCount++;

    R_Color(nullptr);

    glDisable(GL_LINE_SMOOTH);

    R_EnableTexture(&texunit_diffuse, true);
}


/*
=============================================================
GENERIC PARTICLE FUNCTIONS
=============================================================
*/

static void R_SetBlendMode (int mode)
{
    switch (mode) {
    case BLEND_REPLACE:
        R_TexEnv(GL_REPLACE);
        break;
    case BLEND_ONE:
        R_BlendFunc(GL_SRC_ALPHA, GL_ONE);
        break;
    case BLEND_BLEND:
        R_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        break;
    case BLEND_ADD:
        R_BlendFunc(GL_ONE, GL_ONE);
        break;
    case BLEND_FILTER:
        R_BlendFunc(GL_ZERO, GL_SRC_COLOR);
        break;
    case BLEND_INVFILTER:
        R_BlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_COLOR);
        break;
    default:
        Com_Error(ERR_DROP, "unknown blend mode");
        break;
    }
}

void R_DrawParticles (void)
{
    ptl_t* p;
    int i;

    if (!r_particles->integer)
        return;

    for (i = 0, p = r_particleArray; i < r_numParticles; i++, p++)
        if (p->inuse && !p->invis) {
            /* test for visibility */
            if (p->levelFlags && !((1 << refdef.worldlevel) & p->levelFlags))
                continue;

            if (p->program != nullptr)
                R_UseProgram(p->program);

            /* set blend mode and draw gfx */
            R_SetBlendMode(p->blend);
            switch (p->style) {
            case STYLE_LINE:
                R_DrawPtlLine(p);
                break;
            case STYLE_CIRCLE:
                R_DrawPtlCircle(p);
                break;
            default:
                break;
            }
            if (p->pic)
                R_DrawSprite(p);
            if (p->model)
                R_DrawParticleModel(p);
            R_TexEnv(GL_MODULATE);

            R_UseProgram(nullptr);
        }

    R_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    R_Color(nullptr);
}