mirror of
https://github.com/scp-fs2open/fs2open.github.com.git
synced 2026-11-09 17:52:08 -10:00
309 lines
7.0 KiB
C++
309 lines
7.0 KiB
C++
/*
|
|
* Copyright (C) Volition, Inc. 1999. All rights reserved.
|
|
*
|
|
* All source code herein is the property of Volition, Inc. You may not sell
|
|
* or otherwise commercially exploit the source or things you created based on the
|
|
* source.
|
|
*
|
|
*/
|
|
|
|
/*
|
|
* $Logfile: /Freespace2/code/Weapon/MuzzleFlash.cpp $
|
|
* $Revision: 2.1 $
|
|
* $Date: 2002-08-01 01:41:11 $
|
|
* $Author: penguin $
|
|
*
|
|
* all sorts of cool stuff about ships
|
|
*
|
|
* $Log: not supported by cvs2svn $
|
|
* Revision 2.0 2002/06/03 04:02:29 penguin
|
|
* Warpcore CVS sync
|
|
*
|
|
* Revision 1.1 2002/05/02 18:03:13 mharris
|
|
* Initial checkin - converted filenames and includes to lower case
|
|
*
|
|
*
|
|
* 7 7/08/99 10:53a Dave
|
|
* New multiplayer interpolation scheme. Not 100% done yet, but still
|
|
* better than the old way.
|
|
*
|
|
* 6 5/18/99 1:30p Dave
|
|
* Added muzzle flash table stuff.
|
|
*
|
|
* 5 4/25/99 3:02p Dave
|
|
* Build defines for the E3 build.
|
|
*
|
|
* 4 4/12/99 11:03p Dave
|
|
* Removed contrails and muzzle flashes from MULTIPLAYER_BETA builds.
|
|
*
|
|
* 3 3/19/99 9:52a Dave
|
|
* Checkin to repair massive source safe crash. Also added support for
|
|
* pof-style nebulae, and some new weapons code.
|
|
*
|
|
* 2 1/08/99 2:08p Dave
|
|
* Fixed software rendering for pofview. Super early support for AWACS and
|
|
* beam weapons.
|
|
*
|
|
*
|
|
* $NoKeywords: $
|
|
*/
|
|
|
|
#include "object/object.h"
|
|
#include "io/timer.h"
|
|
#include "globalincs/systemvars.h"
|
|
#include "globalincs/linklist.h"
|
|
#include "parse/parselo.h"
|
|
#include "weapon/muzzleflash.h"
|
|
#include "bmpman/bmpman.h"
|
|
#include "particle/particle.h"
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------
|
|
// MUZZLE FLASH DEFINES/VARS
|
|
//
|
|
|
|
// muzzle flash info - read from a table
|
|
#define MAX_MFLASH_NAME_LEN 32
|
|
#define MAX_MFLASH_BLOBS 5
|
|
typedef struct mflash_info {
|
|
char name[MAX_MFLASH_NAME_LEN+1];
|
|
char blob_names[MAX_MFLASH_BLOBS][MAX_MFLASH_NAME_LEN+1]; // blob anim name
|
|
int blob_anims[MAX_MFLASH_BLOBS]; // blob anim
|
|
float blob_offset[MAX_MFLASH_BLOBS]; // blob offset from muzzle
|
|
float blob_radius[MAX_MFLASH_BLOBS]; // blob radius
|
|
int num_blobs; // # of blobs
|
|
} mflash_info;
|
|
mflash_info Mflash_info[MAX_MUZZLE_FLASH_TYPES];
|
|
int Num_mflash_types = 0;
|
|
|
|
#define MAX_MFLASH 50
|
|
|
|
// Stuff for missile trails doesn't need to be saved or restored... or does it?
|
|
/*
|
|
typedef struct mflash {
|
|
struct mflash * prev;
|
|
struct mflash * next;
|
|
|
|
ubyte type; // muzzle flash type
|
|
int blobs[MAX_MFLASH_BLOBS]; // blobs
|
|
} mflash;
|
|
|
|
int Num_mflash = 0;
|
|
mflash Mflash[MAX_MFLASH];
|
|
|
|
mflash Mflash_free_list;
|
|
mflash Mflash_used_list;
|
|
*/
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------
|
|
// MUZZLE FLASH FUNCTIONS
|
|
//
|
|
|
|
// initialize muzzle flash stuff for the whole game
|
|
void mflash_game_init()
|
|
{
|
|
mflash_info bogus;
|
|
mflash_info *m;
|
|
char name[MAX_MFLASH_NAME_LEN];
|
|
float offset, radius;
|
|
int idx;
|
|
|
|
read_file_text("mflash.tbl");
|
|
reset_parse();
|
|
|
|
// header
|
|
required_string("#Muzzle flash types");
|
|
|
|
// read em in
|
|
Num_mflash_types = 0;
|
|
while(optional_string("$Mflash:")){
|
|
if(Num_mflash_types < MAX_MUZZLE_FLASH_TYPES){
|
|
m = &Mflash_info[Num_mflash_types++];
|
|
} else {
|
|
m = &bogus;
|
|
}
|
|
memset(m, 0, sizeof(mflash_info));
|
|
for(idx=0; idx<MAX_MFLASH_BLOBS; idx++){
|
|
m->blob_anims[idx] = -1;
|
|
}
|
|
|
|
required_string("+name:");
|
|
stuff_string(m->name, F_NAME, NULL);
|
|
|
|
// read in all blobs
|
|
m->num_blobs = 0;
|
|
while(optional_string("+blob_name:")){
|
|
stuff_string(name, F_NAME, NULL, MAX_MFLASH_NAME_LEN);
|
|
|
|
required_string("+blob_offset:");
|
|
stuff_float(&offset);
|
|
|
|
required_string("+blob_radius:");
|
|
stuff_float(&radius);
|
|
|
|
// if we have room left
|
|
if(m->num_blobs < MAX_MFLASH_BLOBS){
|
|
strcpy(m->blob_names[m->num_blobs], name);
|
|
m->blob_offset[m->num_blobs] = offset;
|
|
m->blob_radius[m->num_blobs] = radius;
|
|
|
|
m->num_blobs++;
|
|
}
|
|
}
|
|
}
|
|
|
|
// close
|
|
required_string("#end");
|
|
}
|
|
|
|
// initialize muzzle flash stuff for the level
|
|
void mflash_level_init()
|
|
{
|
|
int i, idx;
|
|
int num_frames, fps;
|
|
|
|
/*
|
|
Num_mflash = 0;
|
|
list_init( &Mflash_free_list );
|
|
list_init( &Mflash_used_list );
|
|
|
|
// Link all object slots into the free list
|
|
for (i=0; i<MAX_MFLASH; i++) {
|
|
memset(&Mflash[i], 0, sizeof(mflash));
|
|
list_append(&Mflash_free_list, &Mflash[i] );
|
|
}
|
|
*/
|
|
|
|
// load up all anims
|
|
for(i=0; i<Num_mflash_types; i++){
|
|
// blobs
|
|
for(idx=0; idx<Mflash_info[i].num_blobs; idx++){
|
|
Mflash_info[i].blob_anims[idx] = -1;
|
|
Mflash_info[i].blob_anims[idx] = bm_load_animation(Mflash_info[i].blob_names[idx], &num_frames, &fps, 1);
|
|
Assert(Mflash_info[i].blob_anims[idx] >= 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
// shutdown stuff for the level
|
|
void mflash_level_close()
|
|
{
|
|
}
|
|
|
|
// create a muzzle flash on the guy
|
|
void mflash_create(vector *gun_pos, vector *gun_dir, int mflash_type)
|
|
{
|
|
// mflash *mflashp;
|
|
mflash_info *mi;
|
|
particle_info p;
|
|
int idx;
|
|
|
|
// standalone server should never create trails
|
|
if(Game_mode & GM_STANDALONE_SERVER){
|
|
return;
|
|
}
|
|
|
|
// illegal value
|
|
if((mflash_type >= Num_mflash_types) || (mflash_type < 0)){
|
|
return;
|
|
}
|
|
|
|
/*
|
|
if (Num_mflash >= MAX_MFLASH ) {
|
|
#ifndef NDEBUG
|
|
mprintf(("Muzzle flash creation failed - too many trails!\n" ));
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
// Find next available trail
|
|
mflashp = GET_FIRST(&Mflash_free_list);
|
|
Assert( mflashp != &Mflash_free_list ); // shouldn't have the dummy element
|
|
|
|
// remove trailp from the free list
|
|
list_remove( &Mflash_free_list, mflashp );
|
|
|
|
// insert trailp onto the end of used list
|
|
list_append( &Mflash_used_list, mflashp );
|
|
|
|
// store some stuff
|
|
mflashp->type = (ubyte)mflash_type;
|
|
*/
|
|
|
|
// create the actual animations
|
|
mi = &Mflash_info[mflash_type];
|
|
for(idx=0; idx<mi->num_blobs; idx++){
|
|
|
|
// bogus anim
|
|
if(mi->blob_anims[idx] < 0){
|
|
continue;
|
|
}
|
|
|
|
// fire it up
|
|
memset(&p, 0, sizeof(particle_info));
|
|
vm_vec_scale_add(&p.pos, gun_pos, gun_dir, mi->blob_offset[idx]);
|
|
p.vel = vmd_zero_vector;
|
|
p.rad = mi->blob_radius[idx];
|
|
p.type = PARTICLE_BITMAP;
|
|
p.optional_data = mi->blob_anims[idx];
|
|
p.attached_objnum = -1;
|
|
p.attached_sig = 0;
|
|
particle_create(&p);
|
|
}
|
|
|
|
// increment counter
|
|
// Num_mflash++;
|
|
}
|
|
|
|
// process muzzle flash stuff
|
|
void mflash_process_all()
|
|
{
|
|
/*
|
|
mflash *mflashp;
|
|
|
|
// if the timestamp has elapsed recycle it
|
|
mflashp = GET_FIRST(&Mflash_used_list);
|
|
|
|
while ( mflashp!=END_OF_LIST(&Mflash_used_list) ) {
|
|
if((mflashp->stamp == -1) || timestamp_elapsed(mflashp->stamp)){
|
|
// delete it from the list!
|
|
mflash *next_one = GET_NEXT(mflashp);
|
|
|
|
// remove objp from the used list
|
|
list_remove( &Mflash_used_list, mflashp );
|
|
|
|
// add objp to the end of the free
|
|
list_append( &Mflash_free_list, mflashp );
|
|
|
|
// decrement counter
|
|
Num_mflash--;
|
|
|
|
Assert(Num_mflash >= 0);
|
|
|
|
mflashp = next_one;
|
|
} else {
|
|
mflashp = GET_NEXT(mflashp);
|
|
}
|
|
}
|
|
*/
|
|
}
|
|
|
|
void mflash_render_all()
|
|
{
|
|
}
|
|
|
|
// lookup type by name
|
|
int mflash_lookup(char *name)
|
|
{
|
|
int idx;
|
|
|
|
// look it up
|
|
for(idx=0; idx<Num_mflash_types; idx++){
|
|
if(!stricmp(name, Mflash_info[idx].name)){
|
|
return idx;
|
|
}
|
|
}
|
|
|
|
// couldn't find it
|
|
return -1;
|
|
}
|