| /* |
| 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. |
| |
| */ |
| |
| #include "quakedef.h" |
| #include "r_local.h" |
| |
| #define MAX_PARTICLES 2048 // default max # of particles at one |
| // time |
| #define ABSOLUTE_MIN_PARTICLES 512 // no fewer than this no matter what's |
| // on the command line |
| |
| int ramp1[8] = {0x6f, 0x6d, 0x6b, 0x69, 0x67, 0x65, 0x63, 0x61}; |
| int ramp2[8] = {0x6f, 0x6e, 0x6d, 0x6c, 0x6b, 0x6a, 0x68, 0x66}; |
| int ramp3[8] = {0x6d, 0x6b, 6, 5, 4, 3}; |
| |
| particle_t *active_particles, *free_particles; |
| |
| particle_t *particles; |
| int r_numparticles; |
| |
| vec3_t r_pright, r_pup, r_ppn; |
| |
| |
| /* |
| =============== |
| R_InitParticles |
| =============== |
| */ |
| void R_InitParticles (void) |
| { |
| int i; |
| |
| i = COM_CheckParm ("-particles"); |
| |
| if (i) |
| { |
| r_numparticles = (int)(Q_atoi(com_argv[i+1])); |
| if (r_numparticles < ABSOLUTE_MIN_PARTICLES) |
| r_numparticles = ABSOLUTE_MIN_PARTICLES; |
| } |
| else |
| { |
| r_numparticles = MAX_PARTICLES; |
| } |
| |
| particles = (particle_t *) |
| Hunk_AllocName (r_numparticles * sizeof(particle_t), "particles"); |
| } |
| |
| #ifdef QUAKE2 |
| void R_DarkFieldParticles (entity_t *ent) |
| { |
| int i, j, k; |
| particle_t *p; |
| float vel; |
| vec3_t dir; |
| vec3_t org; |
| |
| org[0] = ent->origin[0]; |
| org[1] = ent->origin[1]; |
| org[2] = ent->origin[2]; |
| for (i=-16 ; i<16 ; i+=8) |
| for (j=-16 ; j<16 ; j+=8) |
| for (k=0 ; k<32 ; k+=8) |
| { |
| if (!free_particles) |
| return; |
| p = free_particles; |
| free_particles = p->next; |
| p->next = active_particles; |
| active_particles = p; |
| |
| p->die = cl.time + 0.2 + (rand()&7) * 0.02; |
| p->color = 150 + rand()%6; |
| p->type = pt_slowgrav; |
| |
| dir[0] = j*8; |
| dir[1] = i*8; |
| dir[2] = k*8; |
| |
| p->org[0] = org[0] + i + (rand()&3); |
| p->org[1] = org[1] + j + (rand()&3); |
| p->org[2] = org[2] + k + (rand()&3); |
| |
| VectorNormalize (dir); |
| vel = 50 + (rand()&63); |
| VectorScale (dir, vel, p->vel); |
| } |
| } |
| #endif |
| |
| |
| /* |
| =============== |
| R_EntityParticles |
| =============== |
| */ |
| |
| #define NUMVERTEXNORMALS 162 |
| extern float r_avertexnormals[NUMVERTEXNORMALS][3]; |
| vec3_t avelocities[NUMVERTEXNORMALS]; |
| float beamlength = 16; |
| vec3_t avelocity = {23, 7, 3}; |
| float partstep = 0.01; |
| float timescale = 0.01; |
| |
| void R_EntityParticles (entity_t *ent) |
| { |
| int count; |
| int i; |
| particle_t *p; |
| float angle; |
| float sr, sp, sy, cr, cp, cy; |
| vec3_t forward; |
| float dist; |
| |
| dist = 64; |
| count = 50; |
| |
| if (!avelocities[0][0]) |
| { |
| for (i=0 ; i<NUMVERTEXNORMALS*3 ; i++) |
| avelocities[0][i] = (rand()&255) * 0.01; |
| } |
| |
| |
| for (i=0 ; i<NUMVERTEXNORMALS ; i++) |
| { |
| angle = cl.time * avelocities[i][0]; |
| sy = sin(angle); |
| cy = cos(angle); |
| angle = cl.time * avelocities[i][1]; |
| sp = sin(angle); |
| cp = cos(angle); |
| angle = cl.time * avelocities[i][2]; |
| sr = sin(angle); |
| cr = cos(angle); |
| |
| forward[0] = cp*cy; |
| forward[1] = cp*sy; |
| forward[2] = -sp; |
| |
| if (!free_particles) |
| return; |
| p = free_particles; |
| free_particles = p->next; |
| p->next = active_particles; |
| active_particles = p; |
| |
| p->die = cl.time + 0.01; |
| p->color = 0x6f; |
| p->type = pt_explode; |
| |
| p->org[0] = ent->origin[0] + r_avertexnormals[i][0]*dist + forward[0]*beamlength; |
| p->org[1] = ent->origin[1] + r_avertexnormals[i][1]*dist + forward[1]*beamlength; |
| p->org[2] = ent->origin[2] + r_avertexnormals[i][2]*dist + forward[2]*beamlength; |
| } |
| } |
| |
| |
| /* |
| =============== |
| R_ClearParticles |
| =============== |
| */ |
| void R_ClearParticles (void) |
| { |
| int i; |
| |
| free_particles = &particles[0]; |
| active_particles = NULL; |
| |
| for (i=0 ;i<r_numparticles ; i++) |
| particles[i].next = &particles[i+1]; |
| particles[r_numparticles-1].next = NULL; |
| } |
| |
| |
| void R_ReadPointFile_f (void) |
| { |
| FILE *f; |
| vec3_t org; |
| int r; |
| int c; |
| particle_t *p; |
| char name[MAX_OSPATH]; |
| |
| sprintf (name,"maps/%s.pts", sv.name); |
| |
| COM_FOpenFile (name, &f); |
| if (!f) |
| { |
| Con_Printf ("couldn't open %s\n", name); |
| return; |
| } |
| |
| Con_Printf ("Reading %s...\n", name); |
| c = 0; |
| for ( ;; ) |
| { |
| r = fscanf (f,"%f %f %f\n", &org[0], &org[1], &org[2]); |
| if (r != 3) |
| break; |
| c++; |
| |
| if (!free_particles) |
| { |
| Con_Printf ("Not enough free particles\n"); |
| break; |
| } |
| p = free_particles; |
| free_particles = p->next; |
| p->next = active_particles; |
| active_particles = p; |
| |
| p->die = 99999; |
| p->color = (-c)&15; |
| p->type = pt_static; |
| VectorCopy (vec3_origin, p->vel); |
| VectorCopy (org, p->org); |
| } |
| |
| fclose (f); |
| Con_Printf ("%i points read\n", c); |
| } |
| |
| /* |
| =============== |
| R_ParseParticleEffect |
| |
| Parse an effect out of the server message |
| =============== |
| */ |
| void R_ParseParticleEffect (void) |
| { |
| vec3_t org, dir; |
| int i, count, msgcount, color; |
| |
| for (i=0 ; i<3 ; i++) |
| org[i] = MSG_ReadCoord (); |
| for (i=0 ; i<3 ; i++) |
| dir[i] = MSG_ReadChar () * (1.0/16); |
| msgcount = MSG_ReadByte (); |
| color = MSG_ReadByte (); |
| |
| if (msgcount == 255) |
| count = 1024; |
| else |
| count = msgcount; |
| |
| R_RunParticleEffect (org, dir, color, count); |
| } |
| |
| /* |
| =============== |
| R_ParticleExplosion |
| |
| =============== |
| */ |
| void R_ParticleExplosion (vec3_t org) |
| { |
| int i, j; |
| particle_t *p; |
| |
| for (i=0 ; i<1024 ; i++) |
| { |
| if (!free_particles) |
| return; |
| p = free_particles; |
| free_particles = p->next; |
| p->next = active_particles; |
| active_particles = p; |
| |
| p->die = cl.time + 5; |
| p->color = ramp1[0]; |
| p->ramp = rand()&3; |
| if (i & 1) |
| { |
| p->type = pt_explode; |
| for (j=0 ; j<3 ; j++) |
| { |
| p->org[j] = org[j] + ((rand()%32)-16); |
| p->vel[j] = (rand()%512)-256; |
| } |
| } |
| else |
| { |
| p->type = pt_explode2; |
| for (j=0 ; j<3 ; j++) |
| { |
| p->org[j] = org[j] + ((rand()%32)-16); |
| p->vel[j] = (rand()%512)-256; |
| } |
| } |
| } |
| } |
| |
| /* |
| =============== |
| R_ParticleExplosion2 |
| |
| =============== |
| */ |
| void R_ParticleExplosion2 (vec3_t org, int colorStart, int colorLength) |
| { |
| int i, j; |
| particle_t *p; |
| int colorMod = 0; |
| |
| for (i=0; i<512; i++) |
| { |
| if (!free_particles) |
| return; |
| p = free_particles; |
| free_particles = p->next; |
| p->next = active_particles; |
| active_particles = p; |
| |
| p->die = cl.time + 0.3; |
| p->color = colorStart + (colorMod % colorLength); |
| colorMod++; |
| |
| p->type = pt_blob; |
| for (j=0 ; j<3 ; j++) |
| { |
| p->org[j] = org[j] + ((rand()%32)-16); |
| p->vel[j] = (rand()%512)-256; |
| } |
| } |
| } |
| |
| /* |
| =============== |
| R_BlobExplosion |
| |
| =============== |
| */ |
| void R_BlobExplosion (vec3_t org) |
| { |
| int i, j; |
| particle_t *p; |
| |
| for (i=0 ; i<1024 ; i++) |
| { |
| if (!free_particles) |
| return; |
| p = free_particles; |
| free_particles = p->next; |
| p->next = active_particles; |
| active_particles = p; |
| |
| p->die = cl.time + 1 + (rand()&8)*0.05; |
| |
| if (i & 1) |
| { |
| p->type = pt_blob; |
| p->color = 66 + rand()%6; |
| for (j=0 ; j<3 ; j++) |
| { |
| p->org[j] = org[j] + ((rand()%32)-16); |
| p->vel[j] = (rand()%512)-256; |
| } |
| } |
| else |
| { |
| p->type = pt_blob2; |
| p->color = 150 + rand()%6; |
| for (j=0 ; j<3 ; j++) |
| { |
| p->org[j] = org[j] + ((rand()%32)-16); |
| p->vel[j] = (rand()%512)-256; |
| } |
| } |
| } |
| } |
| |
| /* |
| =============== |
| R_RunParticleEffect |
| |
| =============== |
| */ |
| void R_RunParticleEffect (vec3_t org, vec3_t dir, int color, int count) |
| { |
| int i, j; |
| particle_t *p; |
| |
| for (i=0 ; i<count ; i++) |
| { |
| if (!free_particles) |
| return; |
| p = free_particles; |
| free_particles = p->next; |
| p->next = active_particles; |
| active_particles = p; |
| |
| if (count == 1024) |
| { // rocket explosion |
| p->die = cl.time + 5; |
| p->color = ramp1[0]; |
| p->ramp = rand()&3; |
| if (i & 1) |
| { |
| p->type = pt_explode; |
| for (j=0 ; j<3 ; j++) |
| { |
| p->org[j] = org[j] + ((rand()%32)-16); |
| p->vel[j] = (rand()%512)-256; |
| } |
| } |
| else |
| { |
| p->type = pt_explode2; |
| for (j=0 ; j<3 ; j++) |
| { |
| p->org[j] = org[j] + ((rand()%32)-16); |
| p->vel[j] = (rand()%512)-256; |
| } |
| } |
| } |
| else |
| { |
| p->die = cl.time + 0.1*(rand()%5); |
| p->color = (color&~7) + (rand()&7); |
| p->type = pt_slowgrav; |
| for (j=0 ; j<3 ; j++) |
| { |
| p->org[j] = org[j] + ((rand()&15)-8); |
| p->vel[j] = dir[j]*15;// + (rand()%300)-150; |
| } |
| } |
| } |
| } |
| |
| |
| /* |
| =============== |
| R_LavaSplash |
| |
| =============== |
| */ |
| void R_LavaSplash (vec3_t org) |
| { |
| int i, j, k; |
| particle_t *p; |
| float vel; |
| vec3_t dir; |
| |
| for (i=-16 ; i<16 ; i++) |
| for (j=-16 ; j<16 ; j++) |
| for (k=0 ; k<1 ; k++) |
| { |
| if (!free_particles) |
| return; |
| p = free_particles; |
| free_particles = p->next; |
| p->next = active_particles; |
| active_particles = p; |
| |
| p->die = cl.time + 2 + (rand()&31) * 0.02; |
| p->color = 224 + (rand()&7); |
| p->type = pt_slowgrav; |
| |
| dir[0] = j*8 + (rand()&7); |
| dir[1] = i*8 + (rand()&7); |
| dir[2] = 256; |
| |
| p->org[0] = org[0] + dir[0]; |
| p->org[1] = org[1] + dir[1]; |
| p->org[2] = org[2] + (rand()&63); |
| |
| VectorNormalize (dir); |
| vel = 50 + (rand()&63); |
| VectorScale (dir, vel, p->vel); |
| } |
| } |
| |
| /* |
| =============== |
| R_TeleportSplash |
| |
| =============== |
| */ |
| void R_TeleportSplash (vec3_t org) |
| { |
| int i, j, k; |
| particle_t *p; |
| float vel; |
| vec3_t dir; |
| |
| for (i=-16 ; i<16 ; i+=4) |
| for (j=-16 ; j<16 ; j+=4) |
| for (k=-24 ; k<32 ; k+=4) |
| { |
| if (!free_particles) |
| return; |
| p = free_particles; |
| free_particles = p->next; |
| p->next = active_particles; |
| active_particles = p; |
| |
| p->die = cl.time + 0.2 + (rand()&7) * 0.02; |
| p->color = 7 + (rand()&7); |
| p->type = pt_slowgrav; |
| |
| dir[0] = j*8; |
| dir[1] = i*8; |
| dir[2] = k*8; |
| |
| p->org[0] = org[0] + i + (rand()&3); |
| p->org[1] = org[1] + j + (rand()&3); |
| p->org[2] = org[2] + k + (rand()&3); |
| |
| VectorNormalize (dir); |
| vel = 50 + (rand()&63); |
| VectorScale (dir, vel, p->vel); |
| } |
| } |
| |
| void R_RocketTrail (vec3_t start, vec3_t end, int type) |
| { |
| vec3_t vec; |
| float len; |
| int j; |
| particle_t *p; |
| int dec; |
| static int tracercount; |
| |
| VectorSubtract (end, start, vec); |
| len = VectorNormalize (vec); |
| if (type < 128) |
| dec = 3; |
| else |
| { |
| dec = 1; |
| type -= 128; |
| } |
| |
| while (len > 0) |
| { |
| len -= dec; |
| |
| if (!free_particles) |
| return; |
| p = free_particles; |
| free_particles = p->next; |
| p->next = active_particles; |
| active_particles = p; |
| |
| VectorCopy (vec3_origin, p->vel); |
| p->die = cl.time + 2; |
| |
| switch (type) |
| { |
| case 0: // rocket trail |
| p->ramp = (rand()&3); |
| p->color = ramp3[(int)p->ramp]; |
| p->type = pt_fire; |
| for (j=0 ; j<3 ; j++) |
| p->org[j] = start[j] + ((rand()%6)-3); |
| break; |
| |
| case 1: // smoke smoke |
| p->ramp = (rand()&3) + 2; |
| p->color = ramp3[(int)p->ramp]; |
| p->type = pt_fire; |
| for (j=0 ; j<3 ; j++) |
| p->org[j] = start[j] + ((rand()%6)-3); |
| break; |
| |
| case 2: // blood |
| p->type = pt_grav; |
| p->color = 67 + (rand()&3); |
| for (j=0 ; j<3 ; j++) |
| p->org[j] = start[j] + ((rand()%6)-3); |
| break; |
| |
| case 3: |
| case 5: // tracer |
| p->die = cl.time + 0.5; |
| p->type = pt_static; |
| if (type == 3) |
| p->color = 52 + ((tracercount&4)<<1); |
| else |
| p->color = 230 + ((tracercount&4)<<1); |
| |
| tracercount++; |
| |
| VectorCopy (start, p->org); |
| if (tracercount & 1) |
| { |
| p->vel[0] = 30*vec[1]; |
| p->vel[1] = 30*-vec[0]; |
| } |
| else |
| { |
| p->vel[0] = 30*-vec[1]; |
| p->vel[1] = 30*vec[0]; |
| } |
| break; |
| |
| case 4: // slight blood |
| p->type = pt_grav; |
| p->color = 67 + (rand()&3); |
| for (j=0 ; j<3 ; j++) |
| p->org[j] = start[j] + ((rand()%6)-3); |
| len -= 3; |
| break; |
| |
| case 6: // voor trail |
| p->color = 9*16 + 8 + (rand()&3); |
| p->type = pt_static; |
| p->die = cl.time + 0.3; |
| for (j=0 ; j<3 ; j++) |
| p->org[j] = start[j] + ((rand()&15)-8); |
| break; |
| } |
| |
| |
| VectorAdd (start, vec, start); |
| } |
| } |
| |
| |
| /* |
| =============== |
| R_DrawParticles |
| =============== |
| */ |
| extern cvar_t sv_gravity; |
| |
| void R_DrawParticles (void) |
| { |
| particle_t *p, *kill; |
| float grav; |
| int i; |
| float time2, time3; |
| float time1; |
| float dvel; |
| float frametime; |
| #ifdef USE_OPENGLES |
| float* pPos = gVertexBuffer; |
| unsigned char* pColor = (unsigned char*) gColorBuffer; |
| unsigned char* pUV = (unsigned char*) gTexCoordBuffer; |
| int particleIndex = 0; |
| int maxParticleIndex = (int) sizeof(gVertexBuffer) / (sizeof(float) * 3) - 3; |
| #endif |
| #ifdef GLQUAKE |
| vec3_t up, right; |
| float scale; |
| |
| GL_Bind(particletexture); |
| |
| glEnable (GL_BLEND); |
| glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); |
| |
| #ifdef USE_OPENGLES |
| glEnableClientState(GL_COLOR_ARRAY); |
| glVertexPointer(3, GL_FLOAT, 0, gVertexBuffer); |
| glTexCoordPointer(2, GL_BYTE, 0, gTexCoordBuffer); |
| glColorPointer(4, GL_UNSIGNED_BYTE, 0, gColorBuffer); |
| glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST); |
| #else |
| glBegin (GL_TRIANGLES); |
| #endif |
| |
| 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 USE_OPENGLES |
| |
| if(particleIndex >= maxParticleIndex) |
| { |
| glDrawArrays(GL_TRIANGLES, 0, particleIndex); |
| particleIndex = 0; |
| pPos = gVertexBuffer; |
| pColor = (unsigned char*) gColorBuffer; |
| pUV = (unsigned char*) gTexCoordBuffer; |
| } |
| |
| memcpy(pColor, (byte *)&d_8to24table[(int)p->color], 3); |
| pColor[3] = 255; |
| pColor += 4; |
| *pUV++ = 0; |
| *pUV++ = 0; |
| *pPos++ = p->org[0]; |
| *pPos++ = p->org[1]; |
| *pPos++ = p->org[2]; |
| |
| memcpy(pColor, (byte *)&d_8to24table[(int)p->color], 3); |
| pColor[3] = 255; |
| pColor += 4; |
| *pUV++ = 1; |
| *pUV++ = 0; |
| *pPos++ = p->org[0] + up[0]*scale; |
| *pPos++ = p->org[1] + up[1]*scale; |
| *pPos++ = p->org[2] + up[2]*scale; |
| |
| memcpy(pColor, (byte *)&d_8to24table[(int)p->color], 3); |
| pColor[3] = 255; |
| pColor += 4; |
| *pUV++ = 0; |
| *pUV++ = 1; |
| *pPos++ = p->org[0] + right[0]*scale; |
| *pPos++ = p->org[1] + right[1]*scale; |
| *pPos++ = p->org[2] + right[2]*scale; |
| |
| particleIndex += 3; |
| |
| #else |
| 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); |
| #endif // !USE_OPENGLES |
| #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; |
| default: |
| break; |
| } |
| } |
| |
| #ifdef GLQUAKE |
| #ifdef USE_OPENGLES |
| glDrawArrays(GL_TRIANGLES, 0, particleIndex); |
| glDisableClientState(GL_COLOR_ARRAY); |
| glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); |
| #else |
| glEnd (); |
| #endif |
| glDisable (GL_BLEND); |
| glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); |
| #else |
| D_EndParticles (); |
| #endif |
| } |
| |