void R_DrawParticles (void)
{
particle_t *p, *kill;
float grav;
int i;
float time2, time3;
float time1;
float dvel;
float frametime;
#ifdef GLQUAKE
vec3_t up, right;
float scale;
GL_Bind(particletexture);
glEnable (GL_BLEND);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glBegin (GL_TRIANGLES);
VectorScale (vup, 1.5, up);
VectorScale (vright, 1.5, right);
#else
D_StartParticles ();
VectorScale (vright, xscaleshrink, r_pright);
VectorScale (vup, yscaleshrink, r_pup);
VectorCopy (vpn, r_ppn);
#endif
frametime = cl.time - cl.oldtime;
time3 = frametime * 15;
time2 = frametime * 10; // 15;
time1 = frametime * 5;
grav = frametime * sv_gravity.value * 0.05;
dvel = 4*frametime;
for ( ;; )
{
kill = active_particles;
if (kill && kill->die < cl.time)
{
active_particles = kill->next;
kill->next = free_particles;
free_particles = kill;
continue;
}
break;
}
for (p=active_particles ; p ; p=p->next)
{
for ( ;; )
{
kill = p->next;
if (kill && kill->die < cl.time)
{
p->next = kill->next;
kill->next = free_particles;
free_particles = kill;
continue;
}
break;
}
#ifdef GLQUAKE
// hack a scale up to keep particles from disapearing
scale = (p->org[0] - r_origin[0])*vpn[0] + (p->org[1] - r_origin[1])*vpn[1]
+ (p->org[2] - r_origin[2])*vpn[2];
if (scale < 20)
scale = 1;
else
scale = 1 + scale * 0.004;
glColor3ubv ((byte *)&d_8to24table[(int)p->color]);
glTexCoord2f (0,0);
glVertex3fv (p->org);
glTexCoord2f (1,0);
glVertex3f (p->org[0] + up[0]*scale, p->org[1] + up[1]*scale, p->org[2] + up[2]*scale);
glTexCoord2f (0,1);
glVertex3f (p->org[0] + right[0]*scale, p->org[1] + right[1]*scale, p->org[2] + right[2]*scale);
#else
D_DrawParticle (p);
#endif
p->org[0] += p->vel[0]*frametime;
p->org[1] += p->vel[1]*frametime;
p->org[2] += p->vel[2]*frametime;
switch (p->type)
{
case pt_static:
break;
case pt_fire:
p->ramp += time1;
if (p->ramp >= 6)
p->die = -1;
else
p->color = ramp3[(int)p->ramp];
p->vel[2] += grav;
break;
case pt_explode:
p->ramp += time2;
if (p->ramp >=8)
p->die = -1;
else
p->color = ramp1[(int)p->ramp];
for (i=0 ; i<3 ; i++)
p->vel[i] += p->vel[i]*dvel;
p->vel[2] -= grav;
break;
case pt_explode2:
p->ramp += time3;
if (p->ramp >=8)
p->die = -1;
else
p->color = ramp2[(int)p->ramp];
for (i=0 ; i<3 ; i++)
p->vel[i] -= p->vel[i]*frametime;
p->vel[2] -= grav;
break;
case pt_blob:
for (i=0 ; i<3 ; i++)
p->vel[i] += p->vel[i]*dvel;
p->vel[2] -= grav;
break;
case pt_blob2:
for (i=0 ; i<2 ; i++)
p->vel[i] -= p->vel[i]*dvel;
p->vel[2] -= grav;
break;
case pt_grav:
#ifdef QUAKE2
p->vel[2] -= grav * 20;
break;
#endif
case pt_slowgrav:
p->vel[2] -= grav;
break;
}
}
#ifdef GLQUAKE
glEnd ();
glDisable (GL_BLEND);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
#else
D_EndParticles ();
#endif
}
/* clamp color to 0-511: particle->type 10 and 11 (pt_c_explode
* and pt_c_explode2, e.g. Crusader's ice particles hitting a
* wall) lead to negative values, because R_UpdateParticles ()
* decrements their color against time. */
color = ((int)p->color) & 0x01ff;
if (color < 256)
glColor3ubv_fp ((byte *)&d_8to24table[color]);
else
glColor4ubv_fp ((byte *)&d_8to24TranslucentTable[color-256]);
// setup texture coordinates
i = 0;
if (p->type == pt_snow)
{
if (p->count >= 69)
i = 3; // happy snow!
else if (p->count >= 40)
i = 2;
else if (p->count >= 30)
i = 1;
}
glTexCoord2fv_fp (ptex_coord[i][0]);
glVertex3fv_fp (p->org);
glTexCoord2fv_fp (ptex_coord[i][1]);
glVertex3f_fp (p->org[0] + r_pup[0]*scale, p->org[1] + r_pup[1]*scale, p->org[2] + r_pup[2]*scale);
glTexCoord2fv_fp (ptex_coord[i][2]);
glVertex3f_fp (p->org[0] + r_pright[0]*scale, p->org[1] + r_pright[1]*scale, p->org[2] + r_pright[2]*scale);
}
glEnd_fp ();
glDisable_fp (GL_BLEND);
glTexEnvf_fp(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
}
#else /* !GLQUAKE */
void R_DrawParticles (void)
{
particle_t *p;
int i;
float vel0, vel1, vel2;
vec3_t save_org;
D_StartParticles ();
VectorScale (vright, xscaleshrink, r_pright);
VectorScale (vup, yscaleshrink, r_pup);
VectorCopy (vpn, r_ppn);
for (p = active_particles ; p ; p = p->next)
{
switch (p->type)
{
case pt_snow:
VectorCopy(p->org, save_org);
D_DrawParticle (p);
for (i = 1; i < p->count; i++)
{
switch (i)
{
// FIXME: More translucency
// on outside particles?
// case 0:
// // original
// break;
case 1:
// One to right
p->org[0] = save_org[0] + vright[0];
p->org[1] = save_org[1] + vright[1];
p->org[2] = save_org[2] + vright[2];
break;
case 2:
// One above
p->org[0] = save_org[0] + vup[0];
p->org[1] = save_org[1] + vup[1];
p->org[2] = save_org[2] + vup[2];
break;
case 3:
// One to left
p->org[0] = save_org[0] - vright[0];
p->org[1] = save_org[1] - vright[1];
p->org[2] = save_org[2] - vright[2];
break;
case 4:
// One below
p->org[0] = save_org[0] - vup[0];
p->org[1] = save_org[1] - vup[1];
p->org[2] = save_org[2] - vup[2];
break;
default:
Con_Printf ("count too big!\n");
break;
}
D_DrawParticle (p);
}
VectorCopy(save_org, p->org); // Restore origin
break;
case pt_rain:
VectorCopy(p->org, save_org);
vel0 = p->vel[0]*.001;
vel1 = p->vel[1]*.001;
vel2 = p->vel[2]*.001;
for (i = 0; i < 4; i++)
{
D_DrawParticle(p);
p->org[0] += vel0;
p->org[1] += vel1;
p->org[2] += vel2;
}
D_DrawParticle(p);
VectorCopy(save_org, p->org); // Restore origin
break;
default:
D_DrawParticle (p);
break;
}
}
D_EndParticles ();
}
/*
===============
R_DrawParticles
===============
*/
void R_DrawParticles (void)
{
particle_t *p, *kill;
float grav;
int i;
float time2, time3;
float time1;
float dvel;
float frametime;
// >>> FIX: For Nintendo Wii using devkitPPC / libogc
// Support for GX hardware:
//#ifdef GLQUAKE
#ifdef GXQUAKE
unsigned char *at;
unsigned char theAlpha;
vec3_t up, right;
float scale;
GX_Bind(particletexture);
GX_SetBlendMode(GX_BM_BLEND, gxu_blend_src_value, gxu_blend_dst_value, GX_LO_NOOP);
GX_SetTevOp(GX_TEVSTAGE0, GX_MODULATE);
VectorScale (vup, 1.5, up);
VectorScale (vright, 1.5, right);
#elif GLQUAKE
// <<< FIX
unsigned char *at;
unsigned char theAlpha;
vec3_t up, right;
float scale;
qboolean alphaTestEnabled;
GL_Bind(particletexture);
alphaTestEnabled = glIsEnabled(GL_ALPHA_TEST);
if (alphaTestEnabled)
glDisable(GL_ALPHA_TEST);
glEnable (GL_BLEND);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glBegin (GL_TRIANGLES);
VectorScale (vup, 1.5, up);
VectorScale (vright, 1.5, right);
#else
D_StartParticles ();
VectorScale (vright, xscaleshrink, r_pright);
VectorScale (vup, yscaleshrink, r_pup);
VectorCopy (vpn, r_ppn);
#endif
frametime = host_frametime;
time3 = frametime * 15;
time2 = frametime * 10; // 15;
time1 = frametime * 5;
grav = frametime * 800 * 0.05;
dvel = 4*frametime;
for ( ;; )
{
kill = active_particles;
if (kill && kill->die < cl.time)
{
active_particles = kill->next;
kill->next = free_particles;
free_particles = kill;
continue;
}
break;
}
for (p=active_particles ; p ; p=p->next)
{
for ( ;; )
{
kill = p->next;
if (kill && kill->die < cl.time)
{
p->next = kill->next;
kill->next = free_particles;
free_particles = kill;
continue;
}
break;
}
// >>> FIX: For Nintendo Wii using devkitPPC / libogc
// Support for GX hardware:
//#ifdef GLQUAKE
#ifdef GXQUAKE
// hack a scale up to keep particles from disapearing
scale = (p->org[0] - r_origin[0])*vpn[0] + (p->org[1] - r_origin[1])*vpn[1]
+ (p->org[2] - r_origin[2])*vpn[2];
if (scale < 20)
scale = 1;
else
scale = 1 + scale * 0.004;
at = (byte *)&d_8to24table[(int)p->color];
if (p->type==pt_fire)
theAlpha = 255*(6-p->ramp)/6;
// theAlpha = 192;
// else if (p->type==pt_explode || p->type==pt_explode2)
// theAlpha = 255*(8-p->ramp)/8;
else
theAlpha = 255;
gxu_cur_r = *at;
gxu_cur_g = *(at+1);
gxu_cur_b = *(at+2);
gxu_cur_a = theAlpha;
// glColor3ubv (at);
// glColor3ubv ((byte *)&d_8to24table[(int)p->color]);
GX_Begin (GX_TRIANGLES, gxu_cur_vertex_format, 3);
GX_Position3f32(p->org[0], p->org[1], p->org[2]);
GX_Color4u8(gxu_cur_r, gxu_cur_g, gxu_cur_b, gxu_cur_a);
GX_TexCoord2f32 (0,0);
GX_Position3f32(p->org[0] + up[0]*scale, p->org[1] + up[1]*scale, p->org[2] + up[2]*scale);
GX_Color4u8(gxu_cur_r, gxu_cur_g, gxu_cur_b, gxu_cur_a);
GX_TexCoord2f32 (1,0);
GX_Position3f32(p->org[0] + right[0]*scale, p->org[1] + right[1]*scale, p->org[2] + right[2]*scale);
GX_Color4u8(gxu_cur_r, gxu_cur_g, gxu_cur_b, gxu_cur_a);
GX_TexCoord2f32 (0,1);
GX_End();
#elif GLQUAKE
// <<< FIX
// hack a scale up to keep particles from disapearing
scale = (p->org[0] - r_origin[0])*vpn[0] + (p->org[1] - r_origin[1])*vpn[1]
+ (p->org[2] - r_origin[2])*vpn[2];
if (scale < 20)
scale = 1;
else
scale = 1 + scale * 0.004;
at = (byte *)&d_8to24table[(int)p->color];
if (p->type==pt_fire)
theAlpha = 255*(6-p->ramp)/6;
// theAlpha = 192;
// else if (p->type==pt_explode || p->type==pt_explode2)
// theAlpha = 255*(8-p->ramp)/8;
else
theAlpha = 255;
glColor4ub (*at, *(at+1), *(at+2), theAlpha);
// glColor3ubv (at);
// glColor3ubv ((byte *)&d_8to24table[(int)p->color]);
glTexCoord2f (0,0);
glVertex3fv (p->org);
glTexCoord2f (1,0);
glVertex3f (p->org[0] + up[0]*scale, p->org[1] + up[1]*scale, p->org[2] + up[2]*scale);
glTexCoord2f (0,1);
glVertex3f (p->org[0] + right[0]*scale, p->org[1] + right[1]*scale, p->org[2] + right[2]*scale);
#else
D_DrawParticle (p);
#endif
p->org[0] += p->vel[0]*frametime;
p->org[1] += p->vel[1]*frametime;
p->org[2] += p->vel[2]*frametime;
switch (p->type)
{
case pt_static:
break;
case pt_fire:
p->ramp += time1;
if (p->ramp >= 6)
p->die = -1;
else
p->color = ramp3[(int)p->ramp];
p->vel[2] += grav;
break;
case pt_explode:
p->ramp += time2;
if (p->ramp >=8)
p->die = -1;
else
p->color = ramp1[(int)p->ramp];
for (i=0 ; i<3 ; i++)
p->vel[i] += p->vel[i]*dvel;
p->vel[2] -= grav;
break;
case pt_explode2:
p->ramp += time3;
if (p->ramp >=8)
p->die = -1;
else
p->color = ramp2[(int)p->ramp];
for (i=0 ; i<3 ; i++)
p->vel[i] -= p->vel[i]*frametime;
p->vel[2] -= grav;
break;
case pt_blob:
for (i=0 ; i<3 ; i++)
p->vel[i] += p->vel[i]*dvel;
p->vel[2] -= grav;
break;
case pt_blob2:
for (i=0 ; i<2 ; i++)
p->vel[i] -= p->vel[i]*dvel;
p->vel[2] -= grav;
break;
case pt_slowgrav:
case pt_grav:
p->vel[2] -= grav;
break;
}
}
// >>> FIX: For Nintendo Wii using devkitPPC / libogc
// Support for GX hardware:
//#ifdef GLQUAKE
#ifdef GXQUAKE
GX_SetBlendMode(GX_BM_NONE, gxu_blend_src_value, gxu_blend_dst_value, GX_LO_NOOP);
GX_SetTevOp(GX_TEVSTAGE0, GX_REPLACE);
#elif GLQUAKE
// <<< FIX
glEnd ();
glDisable (GL_BLEND);
if (alphaTestEnabled)
glEnable(GL_ALPHA_TEST);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
#else
D_EndParticles ();
#endif
}
void R_DrawParticles (void)
{
particle_t *p, *kill;
float grav;
int i;
float time2, time3;
float time1;
float dvel;
float frametime;
#ifdef GLQUAKE
vec3_t up, right;
float scale;
GL_Bind(particletexture);
glEnable (GL_BLEND);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
//glEnable(GL_COLOR_MATERIAL);
VectorScale (vup, 1.5, up);
VectorScale (vright, 1.5, right);
#else
D_StartParticles ();
VectorScale (vright, xscaleshrink, r_pright);
VectorScale (vup, yscaleshrink, r_pup);
VectorCopy (vpn, r_ppn);
#endif
frametime = cl.time - cl.oldtime;
time3 = frametime * 15;
time2 = frametime * 10; // 15;
time1 = frametime * 5;
grav = frametime * sv_gravity.value * 0.05;
dvel = 4*frametime;
for ( ;; )
{
kill = active_particles;
if (kill && kill->die < cl.time)
{
active_particles = kill->next;
kill->next = free_particles;
free_particles = kill;
continue;
}
break;
}
for (p=active_particles ; p ; p=p->next)
{
for ( ;; )
{
kill = p->next;
if (kill && kill->die < cl.time)
{
p->next = kill->next;
kill->next = free_particles;
free_particles = kill;
continue;
}
break;
}
#ifdef GLQUAKE
// hack a scale up to keep particles from disapearing
scale = (p->org[0] - r_origin[0])*vpn[0] + (p->org[1] - r_origin[1])*vpn[1]
+ (p->org[2] - r_origin[2])*vpn[2];
if (scale < 20)
scale = 1;
else
scale = 1 + scale * 0.004;
#ifdef ESQUAKE
byte * colorEntry = (byte *)&d_8to24table[(int)p->color];
GLubyte colors[4*3] =
{
colorEntry[0], colorEntry[1], colorEntry[2], 255,
colorEntry[0], colorEntry[1], colorEntry[2], 255,
colorEntry[0], colorEntry[1], colorEntry[2], 255
};
GLfloat texCoords[2*3] =
{
0, 0, 1, 0, 0, 1
};
GLfloat verts[3*3] =
{
p->org[0], p->org[1], p->org[2],
p->org[0] + up[0]*scale, p->org[1] + up[1]*scale, p->org[2] + up[2]*scale,
p->org[0] + right[0]*scale, p->org[1] + right[1]*scale, p->org[2] + right[2]*scale
};
glEnableClientState(GL_COLOR_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glEnableClientState(GL_VERTEX_ARRAY);
glColorPointer(4, GL_UNSIGNED_BYTE, 0, colors);
glTexCoordPointer(2, GL_FLOAT, sizeof(float)*2, texCoords);
glVertexPointer(3, GL_FLOAT, sizeof(float)*3, verts);
glDrawArrays(GL_TRIANGLES, 0, 3);
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
#else
glBegin (GL_TRIANGLES);
glColor3ubv ((byte *)&d_8to24table[(int)p->color]);
glTexCoord2f (0,0);
glVertex3fv (p->org);
glTexCoord2f (1,0);
glVertex3f (p->org[0] + up[0]*scale, p->org[1] + up[1]*scale, p->org[2] + up[2]*scale);
glTexCoord2f (0,1);
glVertex3f (p->org[0] + right[0]*scale, p->org[1] + right[1]*scale, p->org[2] + right[2]*scale);
glEnd ();
#endif
#else
D_DrawParticle (p);
#endif
p->org[0] += p->vel[0]*frametime;
p->org[1] += p->vel[1]*frametime;
p->org[2] += p->vel[2]*frametime;
switch (p->type)
{
case pt_static:
break;
case pt_fire:
p->ramp += time1;
if (p->ramp >= 6)
p->die = -1;
else
p->color = ramp3[(int)p->ramp];
p->vel[2] += grav;
break;
case pt_explode:
p->ramp += time2;
if (p->ramp >=8)
p->die = -1;
else
p->color = ramp1[(int)p->ramp];
for (i=0 ; i<3 ; i++)
p->vel[i] += p->vel[i]*dvel;
p->vel[2] -= grav;
break;
case pt_explode2:
p->ramp += time3;
if (p->ramp >=8)
p->die = -1;
else
p->color = ramp2[(int)p->ramp];
for (i=0 ; i<3 ; i++)
p->vel[i] -= p->vel[i]*frametime;
p->vel[2] -= grav;
break;
case pt_blob:
for (i=0 ; i<3 ; i++)
p->vel[i] += p->vel[i]*dvel;
p->vel[2] -= grav;
break;
case pt_blob2:
for (i=0 ; i<2 ; i++)
p->vel[i] -= p->vel[i]*dvel;
p->vel[2] -= grav;
break;
case pt_grav:
#ifdef QUAKE2
p->vel[2] -= grav * 20;
break;
#endif
case pt_slowgrav:
p->vel[2] -= grav;
break;
}
}
#ifdef GLQUAKE
glDisable (GL_BLEND);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
//glDisable(GL_COLOR_MATERIAL);
#else
D_EndParticles ();
#endif
}
/*
===============
R_DrawParticles
===============
*/
void
R_DrawParticles(void)
{
particle_t *p;
#ifdef GLQUAKE
#ifdef QW_HACK
unsigned char *at;
unsigned char theAlpha;
#endif
qboolean alphaTestEnabled;
vec3_t up, right;
float scale;
#ifdef NQ_HACK
/*
* FIXME - shouldn't need to do this, just get the caller to make sure
* multitexture is not enabled.
*/
GL_DisableMultitexture();
#endif
GL_Bind(particletexture);
alphaTestEnabled = glIsEnabled(GL_ALPHA_TEST);
if (alphaTestEnabled)
glDisable(GL_ALPHA_TEST);
glEnable(GL_BLEND);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glDepthMask(GL_FALSE);
glBegin(GL_TRIANGLES);
VectorScale(vup, 1.5, up);
VectorScale(vright, 1.5, right);
#else
D_StartParticles();
VectorScale(vright, xscaleshrink, r_pright);
VectorScale(vup, yscaleshrink, r_pup);
VectorCopy(vpn, r_ppn);
#endif
for (p = active_particles; p; p = p->next) {
#ifdef GLQUAKE
// hack a scale up to keep particles from disapearing
scale =
(p->org[0] - r_origin[0]) * vpn[0] + (p->org[1] -
r_origin[1]) * vpn[1]
+ (p->org[2] - r_origin[2]) * vpn[2];
if (scale < 20)
scale = 1;
else
scale = 1 + scale * 0.004;
#ifdef QW_HACK
at = (byte *)&d_8to24table[(int)p->color];
if (p->type == pt_fire)
theAlpha = 255 * (6 - p->ramp) / 6;
else
theAlpha = 255;
glColor4ub(*at, *(at + 1), *(at + 2), theAlpha);
#endif
#ifdef NQ_HACK
glColor3ubv((byte *)&d_8to24table[(int)p->color]);
#endif
glTexCoord2f(0, 0);
glVertex3fv(p->org);
glTexCoord2f(1, 0);
glVertex3f(p->org[0] + up[0] * scale, p->org[1] + up[1] * scale,
p->org[2] + up[2] * scale);
glTexCoord2f(0, 1);
glVertex3f(p->org[0] + right[0] * scale,
p->org[1] + right[1] * scale,
p->org[2] + right[2] * scale);
#else
D_DrawParticle(p);
#endif
}
#ifdef GLQUAKE
glEnd();
glDepthMask(GL_TRUE);
glDisable(GL_BLEND);
if (alphaTestEnabled)
glEnable(GL_ALPHA_TEST);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
#else
D_EndParticles();
#endif
}
void R_DrawParticles (void)
{
particle_t *p, *kill;
float grav;
int i;
float time2, time3;
float time1;
float dvel;
float frametime;
#ifdef GLQUAKE
vec3_t up, right;
float scale;
GL_Use (gl_coloredpolygon1textureprogram);
glUniformMatrix4fv(gl_coloredpolygon1textureprogram_transform, 1, 0, gl_polygon_matrix);
GL_Bind(particletexture);
glEnable (GL_BLEND);
VectorScale (vup, 1.5, up);
VectorScale (vright, 1.5, right);
#else
D_StartParticles ();
VectorScale (vright, xscaleshrink, r_pright);
VectorScale (vup, yscaleshrink, r_pup);
VectorCopy (vpn, r_ppn);
#endif
frametime = cl.time - cl.oldtime;
time3 = frametime * 15;
time2 = frametime * 10; // 15;
time1 = frametime * 5;
grav = frametime * sv_gravity.value * 0.05;
dvel = 4*frametime;
for ( ;; )
{
kill = active_particles;
if (kill && kill->die < cl.time)
{
active_particles = kill->next;
kill->next = free_particles;
free_particles = kill;
continue;
}
break;
}
#ifdef GLQUAKE
int mark = Hunk_LowMark();
int vertexcount = 0;
for (p=active_particles ; p ; p=p->next)
{
vertexcount += 3;
}
if (vertexcount == 0) return;
GLfloat* vertices = Hunk_AllocName (vertexcount * 9 * sizeof(GLfloat), "vertex_buffer");
int vertexpos = 0;
#endif
for (p=active_particles ; p ; p=p->next)
{
for ( ;; )
{
kill = p->next;
if (kill && kill->die < cl.time)
{
p->next = kill->next;
kill->next = free_particles;
free_particles = kill;
continue;
}
break;
}
#ifdef GLQUAKE
// hack a scale up to keep particles from disapearing
scale = (p->org[0] - r_origin[0])*vpn[0] + (p->org[1] - r_origin[1])*vpn[1]
+ (p->org[2] - r_origin[2])*vpn[2];
if (scale < 20)
scale = 1;
else
scale = 1 + scale * 0.004;
unsigned c = d_8to24table[(int)p->color];
GLfloat r = (GLfloat)(c & 0xFF) / 255.0;
GLfloat g = (GLfloat)((c >> 8) & 0xFF) / 255.0;
GLfloat b = (GLfloat)((c >> 16) & 0xFF) / 255.0;
GLfloat a = (GLfloat)((c >> 24) & 0xFF) / 255.0;
vertices[vertexpos++] = p->org[0];
vertices[vertexpos++] = p->org[1];
vertices[vertexpos++] = p->org[2];
vertices[vertexpos++] = r;
vertices[vertexpos++] = g;
vertices[vertexpos++] = b;
vertices[vertexpos++] = a;
vertices[vertexpos++] = 0.0;
vertices[vertexpos++] = 0.0;
vertices[vertexpos++] = p->org[0] + up[0] * scale;
vertices[vertexpos++] = p->org[1] + up[1] * scale;
vertices[vertexpos++] = p->org[2] + up[2] * scale;
vertices[vertexpos++] = r;
vertices[vertexpos++] = g;
vertices[vertexpos++] = b;
vertices[vertexpos++] = a;
vertices[vertexpos++] = 1.0;
vertices[vertexpos++] = 0.0;
vertices[vertexpos++] = p->org[0] + right[0] * scale;
vertices[vertexpos++] = p->org[1] + right[1] * scale;
vertices[vertexpos++] = p->org[2] + right[2] * scale;
vertices[vertexpos++] = r;
vertices[vertexpos++] = g;
vertices[vertexpos++] = b;
vertices[vertexpos++] = a;
vertices[vertexpos++] = 0.0;
vertices[vertexpos++] = 1.0;
#else
D_DrawParticle (p);
#endif
p->org[0] += p->vel[0]*frametime;
p->org[1] += p->vel[1]*frametime;
p->org[2] += p->vel[2]*frametime;
switch (p->type)
{
case pt_static:
break;
case pt_fire:
p->ramp += time1;
if (p->ramp >= 6)
p->die = -1;
else
p->color = ramp3[(int)p->ramp];
p->vel[2] += grav;
break;
case pt_explode:
p->ramp += time2;
if (p->ramp >=8)
p->die = -1;
else
p->color = ramp1[(int)p->ramp];
for (i=0 ; i<3 ; i++)
p->vel[i] += p->vel[i]*dvel;
p->vel[2] -= grav;
break;
case pt_explode2:
p->ramp += time3;
if (p->ramp >=8)
p->die = -1;
else
p->color = ramp2[(int)p->ramp];
for (i=0 ; i<3 ; i++)
p->vel[i] -= p->vel[i]*frametime;
p->vel[2] -= grav;
break;
case pt_blob:
for (i=0 ; i<3 ; i++)
p->vel[i] += p->vel[i]*dvel;
p->vel[2] -= grav;
break;
case pt_blob2:
for (i=0 ; i<2 ; i++)
p->vel[i] -= p->vel[i]*dvel;
p->vel[2] -= grav;
break;
case pt_grav:
#ifdef QUAKE2
p->vel[2] -= grav * 20;
break;
#endif
case pt_slowgrav:
p->vel[2] -= grav;
break;
}
}
#ifdef GLQUAKE
GLuint vertexbuffer;
glGenBuffers(1, &vertexbuffer);
glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
glBufferData(GL_ARRAY_BUFFER, vertexcount * 9 * sizeof(GLfloat), vertices, GL_STATIC_DRAW);
glEnableVertexAttribArray(gl_coloredpolygon1textureprogram_position);
glVertexAttribPointer(gl_coloredpolygon1textureprogram_position, 3, GL_FLOAT, GL_FALSE, 9 * sizeof(GLfloat), (const GLvoid *)0);
glEnableVertexAttribArray(gl_coloredpolygon1textureprogram_color);
glVertexAttribPointer(gl_coloredpolygon1textureprogram_color, 4, GL_FLOAT, GL_FALSE, 9 * sizeof(GLfloat), (const GLvoid *)(3 * sizeof(GLfloat)));
glEnableVertexAttribArray(gl_coloredpolygon1textureprogram_texcoords);
glVertexAttribPointer(gl_coloredpolygon1textureprogram_texcoords, 2, GL_FLOAT, GL_FALSE, 9 * sizeof(GLfloat), (const GLvoid *)(7 * sizeof(GLfloat)));
glDrawArrays(GL_TRIANGLES, 0, vertexcount);
glDisableVertexAttribArray(gl_coloredpolygon1textureprogram_texcoords);
glDisableVertexAttribArray(gl_coloredpolygon1textureprogram_color);
glDisableVertexAttribArray(gl_coloredpolygon1textureprogram_position);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDeleteBuffers(1, &vertexbuffer);
Hunk_FreeToLowMark (mark);
glDisable (GL_BLEND);
#else
D_EndParticles ();
#endif
}
