30 #define SHIELD_HIT_SCALE 0.15f // Note, larger constant means smaller effect
31 #define MAX_TRIS_PER_HIT 40 // Number of triangles per shield hit, maximum.
32 #define MAX_SHIELD_HITS 20 // Maximum number of active shield hits.
33 #define MAX_SHIELD_TRI_BUFFER (MAX_SHIELD_HITS*MAX_TRIS_PER_HIT) //(MAX_SHIELD_HITS*20) // Persistent buffer of triangle comprising all active shield hits.
34 #define SHIELD_HIT_DURATION (3*F1_0/4) // Duration, in milliseconds, of shield hit effect
36 #define SH_UNUSED -1 // Indicates an unused record in Shield_hits
37 #define SH_TYPE_1 1 // Indicates Shield_hits record is of type 1.
39 #define UV_MAX (63.95f/64.0f) // max allowed value until tmapper bugs fixed, 1/24/97
75 #define MAX_SHIELD_POINTS 100
141 Global_tris[
i].
used = 0;
184 trip = &Global_tris[global_index];
226 for (i=0; i<3; i++) {
229 sv = &verts[stp->
verts[
i]];
249 for (i=0; i<Shield_hits[shnum].
num_tris; i++){
262 memset(verts, 0,
sizeof(verts));
264 for (j=0; j<4; j++ ) {
293 vertlist[0] = &verts[3];
294 vertlist[1] = &verts[2];
295 vertlist[2] = &verts[1];
296 vertlist[3] = &verts[0];
299 vertlist[0] = &verts[0];
300 vertlist[1] = &verts[1];
301 vertlist[2] = &verts[2];
302 vertlist[3] = &verts[3];
325 memset(&verts, 0,
sizeof(verts));
330 for (j=0; j<3; j++ ) {
345 verts[j] = &points[j];
360 vm_vec_perp(&norm,&verts[0]->world,&verts[1]->world,&verts[2]->world);
365 if (
vm_vec_dot(&norm,&verts[1]->world ) >= 0.0 ) {
367 vertlist[0] = verts[2];
368 vertlist[1] = verts[1];
369 vertlist[2] = verts[0];
394 Assert(Shield_hits[shield_num].objnum >= 0);
410 Shield_hits[shield_num].start_time -=
Frametime;
427 Shield_hits[shield_num].type =
SH_UNUSED;
432 Shield_hits[shield_num].type =
SH_UNUSED;
438 centerp = &objp->
pos;
440 int bitmap_id, frame_num;
453 }
else if ( frame_num < 0 ) {
454 mprintf((
"HEY! Missiontime went backwards! (Shield.cpp)\n" ));
459 float alpha = 0.9999f;
467 if ( bitmap_id != - 1 ) {
468 render_low_detail_shield_bitmap(&Global_tris[Shield_hits[shield_num].tri_list[0]], orient, centerp, Shield_hits[shield_num].rgb[0], Shield_hits[shield_num].rgb[1], Shield_hits[shield_num].rgb[2]);
471 if ( bitmap_id != - 1 ) {
472 for (i=0; i<Shield_hits[shield_num].num_tris; i++) {
473 render_shield_triangle(&Global_tris[Shield_hits[shield_num].tri_list[i]], orient, centerp, Shield_hits[shield_num].rgb[0], Shield_hits[shield_num].rgb[1], Shield_hits[shield_num].rgb[2]);
506 verts = shieldp->
verts;
510 for (j=0; j<3; j++) {
525 sv = &(shieldp->
verts[shieldp->
tris[trinum].
verts[vertex_index]]);
527 if ( (sv->
u > 0.0f) && (sv->
u <
UV_MAX) && (sv->
v > 0.0f) && (sv->
v <
UV_MAX))
557 if (shnum == MAX_SHIELD_HITS) {
561 Assert((shnum >= 0) && (shnum < MAX_SHIELD_HITS));
572 visit_children(trinum, 0, orient, shieldp, tcp, centerp, radius, rvec, uvec);
573 visit_children(trinum, 1, orient, shieldp, tcp, centerp, radius, rvec, uvec);
574 visit_children(trinum, 2, orient, shieldp, tcp, centerp, radius, rvec, uvec);
596 for (i = 0; i < shieldp->
ntris; i++ ) {
611 for (j = 0; j < 3; j++)
612 Global_tris[gi].verts[j] = shieldp->
verts[shieldp->
tris[i].
verts[j]];
613 Shield_hits[shnum].
tri_list[count++] = gi;
616 mprintf((
"Warning: Too many triangles in shield hit.\n"));
624 Shield_hits[shnum].
objnum = objnum;
626 Shield_hits[shnum].
rgb[0] = 255;
627 Shield_hits[shnum].
rgb[1] = 255;
628 Shield_hits[shnum].
rgb[2] = 255;
653 if ( (quadrant < 0) || (quadrant >= objp->
n_quadrants) )
return damage;
662 float remaining_damage;
666 return remaining_damage;
690 Global_tris[gi].
used = 1;
691 Global_tris[gi].
trinum = -1;
694 Shield_hits[shnum].
tri_list[0] = gi;
697 Shield_hits[shnum].
objnum = objnum;
699 Shield_hits[shnum].
rgb[0] = 255;
700 Shield_hits[shnum].
rgb[1] = 255;
701 Shield_hits[shnum].
rgb[2] = 255;
857 if (Shield_points[i].objnum == objnum) {
902 vec3d gnorm, v2f, tri_point;
927 else if (intensity > 255)
934 for (j=0; j<3; j++ ) {
966 if ( (quadrant >= 0) && (quadrant < obj->n_quadrants)) {
992 float closest_dist = FLT_MAX;
997 if (dist < closest_dist) {
1007 if (hit_pnt->
xyz.x < hit_pnt->
xyz.z)
1010 if (hit_pnt->
xyz.x < -hit_pnt->
xyz.z)
#define MULTIPLAYER_CLIENT
float get_max_shield_quad(object *objp)
shield_hit Shield_hits[MAX_SHIELD_HITS]
int Shield_bitmaps_loaded
void create_shield_explosion(int objnum, int model_num, matrix *orient, vec3d *centerp, vec3d *tcp, int tr0)
void vm_vec_scale_add(vec3d *dest, const vec3d *src1, const vec3d *src2, float k)
#define MISSION_FLAG_FULLNEB
polymodel * model_get(int model_num)
float shield_get_strength(object *objp)
float vm_vec_mag(const vec3d *v)
int get_quadrant(vec3d *hit_pnt, object *shipobjp)
GLsizei const GLfloat * points
int tri_list[MAX_TRIS_PER_HIT]
float ship_max_shield_strength
ubyte g3_transfer_vertex(vertex *dest, const vec3d *src)
SCP_vector< vec3d > shield_points
struct shield_point shield_point
void create_shield_from_triangle(int trinum, matrix *orient, shield_info *shieldp, vec3d *tcp, vec3d *centerp, float radius, vec3d *rvec, vec3d *uvec)
#define MAX_SHIELD_TRI_BUFFER
#define SHIELD_HIT_DURATION
#define MAX_SHIELD_POINTS
struct vec3d::@225::@227 xyz
#define TMAP_HTL_3D_UNLIT
ai_info Ai_info[MAX_AI_INFO]
vec3d * vm_vec_rotate(vec3d *dest, const vec3d *src, const matrix *m)
#define Assertion(expr, msg,...)
int Num_multi_shield_points
void render_low_detail_shield_bitmap(gshield_tri *trip, matrix *orient, vec3d *pos, ubyte r, ubyte g, ubyte b)
void vm_vec_scale_add2(vec3d *dest, const vec3d *src, float k)
void add_shield_point_multi(int objnum, int tri_num, vec3d *hit_pos)
int g3_draw_line(vertex *p0, vertex *p1)
GLenum GLenum GLenum GLenum GLenum scale
void gr_set_bitmap(int bitmap_num, int alphablend_mode, int bitblt_mode, float alpha)
void bm_page_in_xparent_texture(int bitmapnum, int nframes)
Marks a textures as being used for level and is transparant.
int bm_load_animation(const char *real_filename, int *nframes, int *fps, int *keyframe, int can_drop_frames, int dir_type)
Loads a bitmap sequance so we can draw with it.
#define CLAMP(x, min, max)
void gr_set_color(int r, int g, int b)
struct shield_hit shield_hit
void create_tris_containing(vec3d *vp, matrix *orient, shield_info *shieldp, vec3d *tcp, vec3d *centerp, float radius, vec3d *rvec, vec3d *uvec)
typedef int(SCP_EXT_CALLCONV *SCPDLL_PFVERSION)(SCPDLL_Version *)
matrix * vm_vector_2_matrix(matrix *m, const vec3d *fvec, const vec3d *uvec, const vec3d *rvec)
void vm_vec_add2(vec3d *dest, const vec3d *src)
#define GR_ALPHABLEND_FILTER
GLdouble GLdouble GLdouble r
void create_low_detail_poly(int global_index, vec3d *tcp, vec3d *rightv, vec3d *upv)
struct matrix::@228::@230 vec
#define TMAP_FLAG_GOURAUD
int get_free_global_shield_index()
ubyte g3_rotate_vertex(vertex *dest, const vec3d *src)
float vm_vec_dist(const vec3d *v0, const vec3d *v1)
#define MONITOR(function_name)
float apply_damage_to_shield(object *objp, int quadrant, float damage)
vec3d * vm_vec_unrotate(vec3d *dest, const vec3d *src, const matrix *m)
object Objects[MAX_OBJECTS]
#define MONITOR_INC(function_name, inc)
shield_point Shield_points[MAX_SHIELD_POINTS]
void add_shield_point(int objnum, int tri_num, vec3d *hit_pos)
void release_shield_hit_bitmap()
void shield_point_multi_setup()
void create_shield_explosion_all(object *objp)
typedef void(APIENTRY *PFNGLARRAYELEMENTEXTPROC)(GLint i)
void render_shield_triangle(gshield_tri *trip, matrix *orient, vec3d *pos, ubyte r, ubyte g, ubyte b)
void vm_vec_sub(vec3d *dest, const vec3d *src0, const vec3d *src1)
GLboolean GLboolean GLboolean b
void render_shield(int shield_num)
float frand()
Return random value in range 0.0..1.0- (1.0- means the closest number less than 1.0)
void visit_children(int trinum, int vertex_index, matrix *orient, shield_info *shieldp, vec3d *tcp, vec3d *centerp, float radius, vec3d *rvec, vec3d *uvec)
SCP_vector< ship_info > Ship_info
#define TMAP_FLAG_TEXTURED
SCP_vector< float > shield_quadrant
SCP_vector< species_info > Species_info
void free_global_tri_records(int shnum)
#define SIF2_MODEL_POINT_SHIELDS
void ship_draw_shield(object *objp)
GLsizei GLsizei GLuint * obj
float vm_vec_dot(const vec3d *v0, const vec3d *v1)
vec3d * vm_vec_perp(vec3d *dest, const vec3d *p0, const vec3d *p1, const vec3d *p2)
void create_shield_low_detail(int objnum, int model_num, matrix *orient, vec3d *centerp, vec3d *tcp, int tr0, shield_info *shieldp)
#define GR_BITBLT_MODE_NORMAL
int get_global_shield_tri()
void load_shield_hit_bitmap()
void copy_shield_to_globals(int objnum, shield_info *shieldp)
int g3_draw_poly(int nv, vertex **pointlist, uint tmap_flags)
GLclampf GLclampf GLclampf alpha
struct gshield_tri gshield_tri
gshield_tri Global_tris[MAX_SHIELD_TRI_BUFFER]
void rs_compute_uvs(shield_tri *stp, shield_vertex *verts, vec3d *tcp, float radius, vec3d *rightv, vec3d *upv)
void shield_hit_page_in()
int ship_is_shield_up(object *obj, int quadrant)