| 0,0 → 1,401 |
|---|
| /* |
| 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. |
| |
| */ |
| // r_sprite.c |
| |
| #include "quakedef.h" |
| #include "r_local.h" |
| |
| static int clip_current; |
| static vec5_t clip_verts[2][MAXWORKINGVERTS]; |
| static int sprite_width, sprite_height; |
| |
| spritedesc_t r_spritedesc; |
| |
| |
| /* |
| ================ |
| R_RotateSprite |
| ================ |
| */ |
| void R_RotateSprite (float beamlength) |
| { |
| vec3_t vec; |
| |
| if (beamlength == 0.0) |
| return; |
| |
| VectorScale (r_spritedesc.vpn, -beamlength, vec); |
| VectorAdd (r_entorigin, vec, r_entorigin); |
| VectorSubtract (modelorg, vec, modelorg); |
| } |
| |
| |
| /* |
| ============= |
| R_ClipSpriteFace |
| |
| Clips the winding at clip_verts[clip_current] and changes clip_current |
| Throws out the back side |
| ============== |
| */ |
| int R_ClipSpriteFace (int nump, clipplane_t *pclipplane) |
| { |
| int i, outcount; |
| float dists[MAXWORKINGVERTS+1]; |
| float frac, clipdist, *pclipnormal; |
| float *in, *instep, *outstep, *vert2; |
| |
| clipdist = pclipplane->dist; |
| pclipnormal = pclipplane->normal; |
| |
| // calc dists |
| if (clip_current) |
| { |
| in = clip_verts[1][0]; |
| outstep = clip_verts[0][0]; |
| clip_current = 0; |
| } |
| else |
| { |
| in = clip_verts[0][0]; |
| outstep = clip_verts[1][0]; |
| clip_current = 1; |
| } |
| |
| instep = in; |
| for (i=0 ; i<nump ; i++, instep += sizeof (vec5_t) / sizeof (float)) |
| { |
| dists[i] = DotProduct (instep, pclipnormal) - clipdist; |
| } |
| |
| // handle wraparound case |
| dists[nump] = dists[0]; |
| Q_memcpy (instep, in, sizeof (vec5_t)); |
| |
| |
| // clip the winding |
| instep = in; |
| outcount = 0; |
| |
| for (i=0 ; i<nump ; i++, instep += sizeof (vec5_t) / sizeof (float)) |
| { |
| if (dists[i] >= 0) |
| { |
| Q_memcpy (outstep, instep, sizeof (vec5_t)); |
| outstep += sizeof (vec5_t) / sizeof (float); |
| outcount++; |
| } |
| |
| if (dists[i] == 0 || dists[i+1] == 0) |
| continue; |
| |
| if ( (dists[i] > 0) == (dists[i+1] > 0) ) |
| continue; |
| |
| // split it into a new vertex |
| frac = dists[i] / (dists[i] - dists[i+1]); |
| |
| vert2 = instep + sizeof (vec5_t) / sizeof (float); |
| |
| outstep[0] = instep[0] + frac*(vert2[0] - instep[0]); |
| outstep[1] = instep[1] + frac*(vert2[1] - instep[1]); |
| outstep[2] = instep[2] + frac*(vert2[2] - instep[2]); |
| outstep[3] = instep[3] + frac*(vert2[3] - instep[3]); |
| outstep[4] = instep[4] + frac*(vert2[4] - instep[4]); |
| |
| outstep += sizeof (vec5_t) / sizeof (float); |
| outcount++; |
| } |
| |
| return outcount; |
| } |
| |
| |
| /* |
| ================ |
| R_SetupAndDrawSprite |
| ================ |
| */ |
| void R_SetupAndDrawSprite () |
| { |
| int i, nump; |
| float dot, scale, *pv; |
| vec5_t *pverts; |
| vec3_t left, up, right, down, transformed, local; |
| emitpoint_t outverts[MAXWORKINGVERTS+1], *pout; |
| |
| dot = DotProduct (r_spritedesc.vpn, modelorg); |
| |
| // backface cull |
| if (dot >= 0) |
| return; |
| |
| // build the sprite poster in worldspace |
| VectorScale (r_spritedesc.vright, r_spritedesc.pspriteframe->right, right); |
| VectorScale (r_spritedesc.vup, r_spritedesc.pspriteframe->up, up); |
| VectorScale (r_spritedesc.vright, r_spritedesc.pspriteframe->left, left); |
| VectorScale (r_spritedesc.vup, r_spritedesc.pspriteframe->down, down); |
| |
| pverts = clip_verts[0]; |
| |
| pverts[0][0] = r_entorigin[0] + up[0] + left[0]; |
| pverts[0][1] = r_entorigin[1] + up[1] + left[1]; |
| pverts[0][2] = r_entorigin[2] + up[2] + left[2]; |
| pverts[0][3] = 0; |
| pverts[0][4] = 0; |
| |
| pverts[1][0] = r_entorigin[0] + up[0] + right[0]; |
| pverts[1][1] = r_entorigin[1] + up[1] + right[1]; |
| pverts[1][2] = r_entorigin[2] + up[2] + right[2]; |
| pverts[1][3] = sprite_width; |
| pverts[1][4] = 0; |
| |
| pverts[2][0] = r_entorigin[0] + down[0] + right[0]; |
| pverts[2][1] = r_entorigin[1] + down[1] + right[1]; |
| pverts[2][2] = r_entorigin[2] + down[2] + right[2]; |
| pverts[2][3] = sprite_width; |
| pverts[2][4] = sprite_height; |
| |
| pverts[3][0] = r_entorigin[0] + down[0] + left[0]; |
| pverts[3][1] = r_entorigin[1] + down[1] + left[1]; |
| pverts[3][2] = r_entorigin[2] + down[2] + left[2]; |
| pverts[3][3] = 0; |
| pverts[3][4] = sprite_height; |
| |
| // clip to the frustum in worldspace |
| nump = 4; |
| clip_current = 0; |
| |
| for (i=0 ; i<4 ; i++) |
| { |
| nump = R_ClipSpriteFace (nump, &view_clipplanes[i]); |
| if (nump < 3) |
| return; |
| if (nump >= MAXWORKINGVERTS) |
| Sys_Error("R_SetupAndDrawSprite: too many points"); |
| } |
| |
| // transform vertices into viewspace and project |
| pv = &clip_verts[clip_current][0][0]; |
| r_spritedesc.nearzi = -999999; |
| |
| for (i=0 ; i<nump ; i++) |
| { |
| VectorSubtract (pv, r_origin, local); |
| TransformVector (local, transformed); |
| |
| if (transformed[2] < NEAR_CLIP) |
| transformed[2] = NEAR_CLIP; |
| |
| pout = &outverts[i]; |
| pout->zi = 1.0 / transformed[2]; |
| if (pout->zi > r_spritedesc.nearzi) |
| r_spritedesc.nearzi = pout->zi; |
| |
| pout->s = pv[3]; |
| pout->t = pv[4]; |
| |
| scale = xscale * pout->zi; |
| pout->u = (xcenter + scale * transformed[0]); |
| |
| scale = yscale * pout->zi; |
| pout->v = (ycenter - scale * transformed[1]); |
| |
| pv += sizeof (vec5_t) / sizeof (*pv); |
| } |
| |
| // draw it |
| r_spritedesc.nump = nump; |
| r_spritedesc.pverts = outverts; |
| D_DrawSprite (); |
| } |
| |
| |
| /* |
| ================ |
| R_GetSpriteframe |
| ================ |
| */ |
| mspriteframe_t *R_GetSpriteframe (msprite_t *psprite) |
| { |
| mspritegroup_t *pspritegroup; |
| mspriteframe_t *pspriteframe; |
| int i, numframes, frame; |
| float *pintervals, fullinterval, targettime, time; |
| |
| frame = currententity->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 + currententity->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; |
| } |
| |
| |
| /* |
| ================ |
| R_DrawSprite |
| ================ |
| */ |
| void R_DrawSprite (void) |
| { |
| int i; |
| msprite_t *psprite; |
| vec3_t tvec; |
| float dot, angle, sr, cr; |
| |
| psprite = currententity->model->cache.data; |
| |
| r_spritedesc.pspriteframe = R_GetSpriteframe (psprite); |
| |
| sprite_width = r_spritedesc.pspriteframe->width; |
| sprite_height = r_spritedesc.pspriteframe->height; |
| |
| // TODO: make this caller-selectable |
| if (psprite->type == SPR_FACING_UPRIGHT) |
| { |
| // generate the sprite's axes, with vup straight up in worldspace, and |
| // r_spritedesc.vright perpendicular to modelorg. |
| // This will not work if the view direction is very close to straight up or |
| // down, because the cross product will be between two nearly parallel |
| // vectors and starts to approach an undefined state, so we don't draw if |
| // the two vectors are less than 1 degree apart |
| tvec[0] = -modelorg[0]; |
| tvec[1] = -modelorg[1]; |
| tvec[2] = -modelorg[2]; |
| VectorNormalize (tvec); |
| dot = tvec[2]; // same as DotProduct (tvec, r_spritedesc.vup) because |
| // r_spritedesc.vup is 0, 0, 1 |
| if ((dot > 0.999848) || (dot < -0.999848)) // cos(1 degree) = 0.999848 |
| return; |
| r_spritedesc.vup[0] = 0; |
| r_spritedesc.vup[1] = 0; |
| r_spritedesc.vup[2] = 1; |
| r_spritedesc.vright[0] = tvec[1]; |
| // CrossProduct(r_spritedesc.vup, -modelorg, |
| r_spritedesc.vright[1] = -tvec[0]; |
| // r_spritedesc.vright) |
| r_spritedesc.vright[2] = 0; |
| VectorNormalize (r_spritedesc.vright); |
| r_spritedesc.vpn[0] = -r_spritedesc.vright[1]; |
| r_spritedesc.vpn[1] = r_spritedesc.vright[0]; |
| r_spritedesc.vpn[2] = 0; |
| // CrossProduct (r_spritedesc.vright, r_spritedesc.vup, |
| // r_spritedesc.vpn) |
| } |
| else if (psprite->type == SPR_VP_PARALLEL) |
| { |
| // generate the sprite's axes, completely parallel to the viewplane. There |
| // are no problem situations, because the sprite is always in the same |
| // position relative to the viewer |
| for (i=0 ; i<3 ; i++) |
| { |
| r_spritedesc.vup[i] = vup[i]; |
| r_spritedesc.vright[i] = vright[i]; |
| r_spritedesc.vpn[i] = vpn[i]; |
| } |
| } |
| else if (psprite->type == SPR_VP_PARALLEL_UPRIGHT) |
| { |
| // generate the sprite's axes, with vup straight up in worldspace, and |
| // r_spritedesc.vright parallel to the viewplane. |
| // This will not work if the view direction is very close to straight up or |
| // down, because the cross product will be between two nearly parallel |
| // vectors and starts to approach an undefined state, so we don't draw if |
| // the two vectors are less than 1 degree apart |
| dot = vpn[2]; // same as DotProduct (vpn, r_spritedesc.vup) because |
| // r_spritedesc.vup is 0, 0, 1 |
| if ((dot > 0.999848) || (dot < -0.999848)) // cos(1 degree) = 0.999848 |
| return; |
| r_spritedesc.vup[0] = 0; |
| r_spritedesc.vup[1] = 0; |
| r_spritedesc.vup[2] = 1; |
| r_spritedesc.vright[0] = vpn[1]; |
| // CrossProduct (r_spritedesc.vup, vpn, |
| r_spritedesc.vright[1] = -vpn[0]; // r_spritedesc.vright) |
| r_spritedesc.vright[2] = 0; |
| VectorNormalize (r_spritedesc.vright); |
| r_spritedesc.vpn[0] = -r_spritedesc.vright[1]; |
| r_spritedesc.vpn[1] = r_spritedesc.vright[0]; |
| r_spritedesc.vpn[2] = 0; |
| // CrossProduct (r_spritedesc.vright, r_spritedesc.vup, |
| // r_spritedesc.vpn) |
| } |
| else if (psprite->type == SPR_ORIENTED) |
| { |
| // generate the sprite's axes, according to the sprite's world orientation |
| AngleVectors (currententity->angles, r_spritedesc.vpn, |
| r_spritedesc.vright, r_spritedesc.vup); |
| } |
| else if (psprite->type == SPR_VP_PARALLEL_ORIENTED) |
| { |
| // generate the sprite's axes, parallel to the viewplane, but rotated in |
| // that plane around the center according to the sprite entity's roll |
| // angle. So vpn stays the same, but vright and vup rotate |
| angle = currententity->angles[ROLL] * (M_PI*2 / 360); |
| sr = sin(angle); |
| cr = cos(angle); |
| |
| for (i=0 ; i<3 ; i++) |
| { |
| r_spritedesc.vpn[i] = vpn[i]; |
| r_spritedesc.vright[i] = vright[i] * cr + vup[i] * sr; |
| r_spritedesc.vup[i] = vright[i] * -sr + vup[i] * cr; |
| } |
| } |
| else |
| { |
| Sys_Error ("R_DrawSprite: Bad sprite type %d", psprite->type); |
| } |
| |
| R_RotateSprite (psprite->beamlength); |
| |
| R_SetupAndDrawSprite (); |
| } |
| |