gl_sprite.cpp

/*
Copyright (C) 1996-1997 Id Software, Inc.

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.

 */
// gl_sprite.c

//Code to do with sprites

#include "quakedef.h"

/*
=============================================================
  SPRITE MODELS
=============================================================
 */

mspriteframe_t *R_GetSpriteFrame(entity_t *e) {
	msprite_t *psprite;
	mspritegroup_t *pspritegroup;
	mspriteframe_t *pspriteframe;
	int i, numframes, frame;
	float *pintervals, fullinterval, targettime, time;

	psprite = (msprite_t *) e->model->cache->getData();
	frame = e->frame;

	if ((frame >= psprite->numframes) || (frame < 0)) {
		Con_Printf("R_DrawSprite: no such frame %d\n", frame);
		frame = 0;
	}

	if (psprite->frames[frame].type == SPR_SINGLE) {
		pspriteframe = psprite->frames[frame].frameptr;
	} else {
		pspritegroup = (mspritegroup_t *) psprite->frames[frame].frameptr;
		pintervals = pspritegroup->intervals;
		numframes = pspritegroup->numframes;
		fullinterval = pintervals[numframes - 1];

		time = cl.time + e->syncbase;

		// when loading in Mod_LoadSpriteGroup, we guaranteed all interval values
		// are positive, so we don't have to worry about division by 0
		targettime = time - ((int) (time / fullinterval)) * fullinterval;

		for (i = 0; i < (numframes - 1); i++) {
			if (pintervals[i] > targettime)
				break;
		}

		pspriteframe = pspritegroup->frames[i];
	}

	return pspriteframe;
}

void R_DrawSpriteModel(entity_t *e) {
	vec3_t point;
	mspriteframe_t *frame;
	float *up, *right;
	vec3_t v_forward, v_right, v_up;
	msprite_t *psprite;

	// don't even bother culling, because it's just a single
	// polygon without a surface cache
	frame = R_GetSpriteFrame(e);
	psprite = (msprite_t *) e->model->cache->getData();

	if (psprite->type == SPR_ORIENTED) { // bullet marks on walls
		AngleVectors(e->angles, v_forward, v_right, v_up);
		up = v_up;
		right = v_right;
	} else { // normal sprite
		up = vup;
		right = vright;
	}

	glColor3f(1, 1, 1);

	glBindTexture(GL_TEXTURE_2D, frame->gl_texturenum);

	glDepthMask(0);
	glEnable(GL_BLEND);
	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
	glBegin(GL_QUADS);

	glTexCoord2f(0, 1);
	VectorMA(e->origin, frame->down, up, point);
	VectorMA(point, frame->left, right, point);
	glVertex3fv(point);

	glTexCoord2f(0, 0);
	VectorMA(e->origin, frame->up, up, point);
	VectorMA(point, frame->left, right, point);
	glVertex3fv(point);

	glTexCoord2f(1, 0);
	VectorMA(e->origin, frame->up, up, point);
	VectorMA(point, frame->right, right, point);
	glVertex3fv(point);

	glTexCoord2f(1, 1);
	VectorMA(e->origin, frame->down, up, point);
	VectorMA(point, frame->right, right, point);
	glVertex3fv(point);

	glEnd();

	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
	glDepthMask(1);
	glDisable(GL_BLEND);
}