void CInMapDraw::Draw(void) { glDepthMask(0); CVertexArray* va = GetVertexArray(); va->Initialize(); CVertexArray* lineva = GetVertexArray(); lineva->Initialize(); glEnable(GL_TEXTURE_2D); glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_BLEND); InMapDraw_QuadDrawer drawer; drawer.imd = this; drawer.lineva = lineva; drawer.va = va; drawer.texture = texture; readmap->GridVisibility(camera, DRAW_QUAD_SIZE, 3000.0f, &drawer); glDisable(GL_TEXTURE_2D); glLineWidth(3); lineva->DrawArrayC(GL_LINES); glLineWidth(1); glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, texture); va->DrawArrayTC(GL_QUADS); glDepthMask(1); }
void CInMapDraw::Draw(void) { GML_STDMUTEX_LOCK(inmap); //! Draw CVertexArray* va = GetVertexArray(); va->Initialize(); CVertexArray* lineva = GetVertexArray(); lineva->Initialize(); InMapDraw_QuadDrawer drawer; drawer.imd = this; drawer.lineva = lineva; drawer.va = va; drawer.visLabels = &visibleLabels; glDepthMask(0); glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_BLEND); glBindTexture(GL_TEXTURE_2D, texture); readmap->GridVisibility(camera, DRAW_QUAD_SIZE, 3000.0f, &drawer); glDisable(GL_TEXTURE_2D); glLineWidth(3.f); lineva->DrawArrayC(GL_LINES); //! draw lines // XXX hopeless drivers, retest in a year or so... // width greater than 2 causes GUI flicker on ATI hardware as of driver version 9.3 // so redraw lines with width 1 if (globalRendering->atiHacks) { glLineWidth(1.f); lineva->DrawArrayC(GL_LINES); } // draw points glLineWidth(1); glEnable(GL_TEXTURE_2D); va->DrawArrayTC(GL_QUADS); //! draw point markers if (!visibleLabels.empty()) { font->SetColors(); //! default //! draw point labels for (std::vector<MapPoint*>::iterator pi = visibleLabels.begin(); pi != visibleLabels.end(); ++pi) { float3 pos = (*pi)->pos; pos.y += 111.0f; font->SetTextColor((*pi)->color[0]/255.0f, (*pi)->color[1]/255.0f, (*pi)->color[2]/255.0f, 1.0f); //FIXME (overload!) font->glWorldPrint(pos, 26.0f, (*pi)->label); } visibleLabels.clear(); } glDepthMask(1); }
void CInMapDrawView::Draw() { CVertexArray* pointsVa = GetVertexArray(); pointsVa->Initialize(); CVertexArray* linesVa = GetVertexArray(); linesVa->Initialize(); InMapDraw_QuadDrawer drawer; drawer.linesVa = linesVa; drawer.pointsVa = pointsVa; drawer.visibleLabels = &visibleLabels; glDepthMask(0); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_BLEND); glBindTexture(GL_TEXTURE_2D, texture); readMap->GridVisibility(camera, CInMapDrawModel::DRAW_QUAD_SIZE, 1e9, &drawer); glDisable(GL_TEXTURE_2D); glLineWidth(3.f); linesVa->DrawArrayC(GL_LINES); //! draw lines // XXX hopeless drivers, retest in a year or so... // width greater than 2 causes GUI flicker on ATI hardware as of driver version 9.3 // so redraw lines with width 1 if (globalRendering->atiHacks) { glLineWidth(1.f); linesVa->DrawArrayC(GL_LINES); } // draw points glLineWidth(1); glEnable(GL_TEXTURE_2D); pointsVa->DrawArrayTC(GL_QUADS); //! draw point markers if (!visibleLabels.empty()) { font->SetColors(); //! default //! draw point labels for (std::vector<const CInMapDrawModel::MapPoint*>::const_iterator pi = visibleLabels.begin(); pi != visibleLabels.end(); ++pi) { float3 pos = (*pi)->GetPos(); pos.y += 111.0f; const unsigned char* color = (*pi)->IsBySpectator() ? color4::white : teamHandler->Team((*pi)->GetTeamID())->color; font->SetTextColor(color[0]/255.0f, color[1]/255.0f, color[2]/255.0f, 1.0f); //FIXME (overload!) font->glWorldPrint(pos, 26.0f, (*pi)->GetLabel()); } visibleLabels.clear(); } glDepthMask(1); }
void CInMapDraw::Draw(void) { GML_STDMUTEX_LOCK(inmap); //! Draw glDepthMask(0); CVertexArray* va = GetVertexArray(); va->Initialize(); CVertexArray* lineva = GetVertexArray(); lineva->Initialize(); //font->Begin(); font->SetColors(); //! default InMapDraw_QuadDrawer drawer; drawer.imd = this; drawer.lineva = lineva; drawer.va = va; drawer.texture = texture; readmap->GridVisibility(camera, DRAW_QUAD_SIZE, 3000.0f, &drawer); glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_BLEND); glDisable(GL_TEXTURE_2D); glLineWidth(3.f); lineva->DrawArrayC(GL_LINES); //! draw lines // XXX hopeless drivers, retest in a year or so... // width greater than 2 causes GUI flicker on ATI hardware as of driver version 9.3 // so redraw lines with width 1 if (gu->atiHacks) { glLineWidth(1.f); lineva->DrawArrayC(GL_LINES); } // draw points glLineWidth(1); glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, texture); va->DrawArrayTC(GL_QUADS); //! draw point markers //font->End(); //! draw point markers text glDepthMask(1); }
void CAdvWater::Draw(bool useBlending) { if (!mapInfo->water.forceRendering && (readmap->currMinHeight > 1.0f)) { return; } float3 base = camera->CalcPixelDir(globalRendering->viewPosX, globalRendering->viewSizeY); float3 dv = camera->CalcPixelDir(globalRendering->viewPosX, 0) - camera->CalcPixelDir(globalRendering->viewPosX, globalRendering->viewSizeY); float3 dh = camera->CalcPixelDir(globalRendering->viewPosX + globalRendering->viewSizeX, 0) - camera->CalcPixelDir(globalRendering->viewPosX, 0); float3 xbase; const int numDivs = 20; base *= numDivs; float maxY = -0.1f; float yInc = 1.0f / numDivs; float screenY = 1; unsigned char col[4]; col[0] = (unsigned char)(waterSurfaceColor.x * 255); col[1] = (unsigned char)(waterSurfaceColor.y * 255); col[2] = (unsigned char)(waterSurfaceColor.z * 255); glDisable(GL_ALPHA_TEST); if (useBlending) { glEnable(GL_BLEND); } else { glDisable(GL_BLEND); } glDepthMask(0); glActiveTextureARB(GL_TEXTURE1_ARB); glBindTexture(GL_TEXTURE_2D, bumpTexture); GLfloat plan[] = {0.02f, 0, 0, 0}; glTexGeni(GL_S,GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR); glTexGenfv(GL_S,GL_EYE_PLANE, plan); glEnable(GL_TEXTURE_GEN_S); GLfloat plan2[] = {0, 0, 0.02f, 0}; glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR); glTexGenfv(GL_T, GL_EYE_PLANE, plan2); glEnable(GL_TEXTURE_GEN_T); glActiveTextureARB(GL_TEXTURE0_ARB); glBindTexture(GL_TEXTURE_2D, reflectTexture); glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, waterFP); glEnable(GL_FRAGMENT_PROGRAM_ARB); float3 forward = camera->forward; forward.y = 0; forward.ANormalize(); glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, 0, forward.z, forward.x, 0, 0); glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, 1, -forward.x, forward.z, 0, 0); CVertexArray* va = GetVertexArray(); va->Initialize(); va->EnlargeArrays(5*numDivs*(numDivs + 1)*2, 5*numDivs, VA_SIZE_TC); //! alloc room for all vertexes and strips float3 dir, zpos; for (int a = 0; a < 5; ++a) { //! CAUTION: loop count must match EnlargeArrays above bool maxReached = false; for (int y = 0; y < numDivs; ++y) { dir = base; dir.ANormalize(); if (dir.y >= maxY) { maxReached = true; break; } xbase = base; for (int x = 0; x < numDivs + 1; ++x) { //! CAUTION: loop count must match EnlargeArrays above dir = xbase + dv; dir.ANormalize(); zpos = camera->pos + dir*(camera->pos.y / -dir.y); zpos.y = sin(zpos.z*0.1f + gs->frameNum*0.06f)*0.06f + 0.05f; col[3] = (unsigned char)((0.8f + 0.7f*dir.y)*255); va->AddVertexQTC(zpos, x*(1.0f/numDivs), screenY - yInc, col); dir = xbase; dir.ANormalize(); zpos = camera->pos + dir*(camera->pos.y / -dir.y); zpos.y = sin(zpos.z*0.1f + gs->frameNum*0.06f)*0.06f + 0.05f; col[3] = (unsigned char)((0.8f + 0.7f*dir.y)*255); va->AddVertexQTC(zpos, x*(1.0f/numDivs), screenY, col); xbase += dh; } va->EndStripQ(); base += dv; screenY -= yInc; } if (!maxReached) { break; } dv *= 0.5f; maxY *= 0.5f; yInc *= 0.5f; } va->DrawArrayTC(GL_TRIANGLE_STRIP); glDepthMask(1); glDisable(GL_FRAGMENT_PROGRAM_ARB); glActiveTextureARB(GL_TEXTURE1_ARB); glDisable(GL_TEXTURE_GEN_S); glDisable(GL_TEXTURE_GEN_T); glActiveTextureARB(GL_TEXTURE0_ARB); if (!useBlending) { // for translucent stuff like water, the default mode is blending and alpha testing enabled glEnable(GL_BLEND); } }
void CProjectileDrawer::UpdatePerlin() { perlinFB.Bind(); glViewport(perlintex->ixstart, perlintex->iystart, 128, 128); glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); glOrtho(0, 1, 0, 1, -1, 1); glMatrixMode(GL_MODELVIEW); glPushMatrix(); glLoadIdentity(); glDisable(GL_DEPTH_TEST); glDepthMask(GL_FALSE); glEnable(GL_BLEND); glBlendFunc(GL_ONE, GL_ONE); glEnable(GL_TEXTURE_2D); glDisable(GL_ALPHA_TEST); glDisable(GL_FOG); unsigned char col[4]; float time = globalRendering->lastFrameTime * gs->speedFactor * 3; float speed = 1.0f; float size = 1.0f; for (int a = 0; a < 4; ++a) { perlinBlend[a] += time * speed; if (perlinBlend[a] > 1) { unsigned int temp = perlinTex[a * 2]; perlinTex[a * 2 ] = perlinTex[a * 2 + 1]; perlinTex[a * 2 + 1] = temp; GenerateNoiseTex(perlinTex[a * 2 + 1], 16); perlinBlend[a] -= 1; } float tsize = 8.0f / size; if (a == 0) glDisable(GL_BLEND); CVertexArray* va = GetVertexArray(); va->Initialize(); va->CheckInitSize(4 * VA_SIZE_TC, 0); for (int b = 0; b < 4; ++b) col[b] = int((1.0f - perlinBlend[a]) * 16 * size); glBindTexture(GL_TEXTURE_2D, perlinTex[a * 2]); va->AddVertexQTC(float3(0, 0, 0), 0, 0, col); va->AddVertexQTC(float3(0, 1, 0), 0, tsize, col); va->AddVertexQTC(float3(1, 1, 0), tsize, tsize, col); va->AddVertexQTC(float3(1, 0, 0), tsize, 0, col); va->DrawArrayTC(GL_QUADS); if (a == 0) glEnable(GL_BLEND); va = GetVertexArray(); va->Initialize(); va->CheckInitSize(4 * VA_SIZE_TC, 0); for (int b = 0; b < 4; ++b) col[b] = int(perlinBlend[a] * 16 * size); glBindTexture(GL_TEXTURE_2D, perlinTex[a * 2 + 1]); va->AddVertexQTC(float3(0, 0, 0), 0, 0, col); va->AddVertexQTC(float3(0, 1, 0), 0, tsize, col); va->AddVertexQTC(float3(1, 1, 0), tsize, tsize, col); va->AddVertexQTC(float3(1, 0, 0), tsize, 0, col); va->DrawArrayTC(GL_QUADS); speed *= 0.6f; size *= 2; } perlinFB.Unbind(); glViewport(globalRendering->viewPosX, 0, globalRendering->viewSizeX, globalRendering->viewSizeY); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_DEPTH_TEST); glDepthMask(GL_TRUE); glPopMatrix(); glMatrixMode(GL_PROJECTION); glPopMatrix(); glMatrixMode(GL_MODELVIEW); }
void CGroundDecalHandler::Draw(void) { if (!drawDecals) { return; } glEnable(GL_TEXTURE_2D); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_POLYGON_OFFSET_FILL); glPolygonOffset(-10, -200); glDepthMask(0); glActiveTextureARB(GL_TEXTURE1_ARB); glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, readmap->GetShadingTexture()); SetTexGen(1.0f / (gs->pwr2mapx * SQUARE_SIZE), 1.0f / (gs->pwr2mapy * SQUARE_SIZE), 0, 0); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_PREVIOUS_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB); CBaseGroundDrawer *gd = readmap->GetGroundDrawer(); if (gd->DrawExtraTex()) { glActiveTextureARB(GL_TEXTURE3_ARB); glEnable(GL_TEXTURE_2D); glTexEnvi(GL_TEXTURE_ENV,GL_COMBINE_RGB_ARB,GL_ADD_SIGNED_ARB); glTexEnvi(GL_TEXTURE_ENV,GL_COMBINE_ALPHA_ARB,GL_MODULATE); glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE0_ALPHA_ARB,GL_PREVIOUS_ARB); glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE1_ALPHA_ARB,GL_TEXTURE); glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_COMBINE_ARB); SetTexGen(1.0f/(gs->pwr2mapx*SQUARE_SIZE),1.0f/(gs->pwr2mapy*SQUARE_SIZE),0,0); glBindTexture(GL_TEXTURE_2D, gd->infoTex); } glActiveTextureARB(GL_TEXTURE0_ARB); if (shadowHandler && shadowHandler->drawShadows) { glActiveTextureARB(GL_TEXTURE2_ARB); glEnable(GL_TEXTURE_2D); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glBindTexture(GL_TEXTURE_2D, shadowHandler->shadowTexture); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE_ARB, GL_COMPARE_R_TO_TEXTURE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC_ARB, GL_LEQUAL); glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE_ARB, GL_LUMINANCE); glActiveTextureARB(GL_TEXTURE0_ARB); if (readmap->GetShadingTexture() == 0) { glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, decalFPsm3); } else { // also used for SM3 maps with baked lighting glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, decalFPsmf); } glEnable(GL_FRAGMENT_PROGRAM_ARB); glBindProgramARB(GL_VERTEX_PROGRAM_ARB, decalVP); glEnable(GL_VERTEX_PROGRAM_ARB); const float3 ac = mapInfo->light.groundAmbientColor * (210.0f / 255.0f); glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, 10, 1.0f / (gs->pwr2mapx * SQUARE_SIZE), 1.0f / (gs->pwr2mapy * SQUARE_SIZE), 0, 1); glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, 10, ac.x, ac.y, ac.z, 1); glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, 11, 0, 0, 0, mapInfo->light.groundShadowDensity); glMatrixMode(GL_MATRIX0_ARB); glLoadMatrixf(shadowHandler->shadowMatrix.m); glMatrixMode(GL_MODELVIEW); } // create and draw the quads for each building decal for (std::vector<BuildingDecalType*>::iterator bdti = buildingDecalTypes.begin(); bdti != buildingDecalTypes.end(); ++bdti) { BuildingDecalType* bdt = *bdti; if (!bdt->buildingDecals.empty()) { glBindTexture(GL_TEXTURE_2D, bdt->texture); decalsToDraw.clear(); { GML_STDMUTEX_LOCK(decal); // Draw set<BuildingGroundDecal*>::iterator bgdi = bdt->buildingDecals.begin(); while (bgdi != bdt->buildingDecals.end()) { BuildingGroundDecal* decal = *bgdi; if (decal->owner && decal->owner->buildProgress >= 0) { decal->alpha = decal->owner->buildProgress; } else if (!decal->gbOwner) { decal->alpha -= decal->alphaFalloff * globalRendering->lastFrameTime * gs->speedFactor; } if (decal->alpha < 0.0f) { // make sure RemoveBuilding() won't try to modify this decal if (decal->owner) { decal->owner->buildingDecal = 0; } delete decal; set<BuildingGroundDecal*>::iterator next(bgdi); ++next; bdt->buildingDecals.erase(bgdi); bgdi = next; continue; } if (!decal->owner || (decal->owner->losStatus[gu->myAllyTeam] & (LOS_INLOS | LOS_PREVLOS)) || gu->spectatingFullView) { decalsToDraw.push_back(decal); } bgdi++; } } for(std::vector<BuildingGroundDecal*>::iterator di = decalsToDraw.begin(); di != decalsToDraw.end(); ++di) { BuildingGroundDecal *decal = *di; if (camera->InView(decal->pos, decal->radius)) { DrawBuildingDecal(decal); } } //glBindTexture(GL_TEXTURE_2D, 0); } } if (shadowHandler && shadowHandler->drawShadows) { glDisable(GL_FRAGMENT_PROGRAM_ARB); glDisable(GL_VERTEX_PROGRAM_ARB); glActiveTextureARB(GL_TEXTURE2_ARB); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE_ARB, GL_NONE); glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE_ARB, GL_LUMINANCE); glDisable(GL_TEXTURE_2D); glActiveTextureARB(GL_TEXTURE1_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB); glActiveTextureARB(GL_TEXTURE0_ARB); } glPolygonOffset(-10, -20); unsigned char color[4] = {255, 255, 255, 255}; unsigned char color2[4] = {255, 255, 255, 255}; { GML_STDMUTEX_LOCK(track); // Draw // Delayed addition of new tracks for (std::vector<TrackToAdd>::iterator ti = tracksToBeAdded.begin(); ti != tracksToBeAdded.end(); ++ti) { TrackToAdd *tta = &(*ti); if(tta->ts->owner == NULL) { delete tta->tp; if(tta->unit == NULL) tracksToBeDeleted.push_back(tta->ts); continue; // unit removed } CUnit *unit = tta->unit; if(unit == NULL) { unit = tta->ts->owner; trackTypes[unit->unitDef->trackType]->tracks.insert(tta->ts); } TrackPart *tp = tta->tp; //if the unit is moving in a straight line only place marks at half the rate by replacing old ones bool replace = false; if(unit->myTrack->parts.size()>1) { list<TrackPart *>::iterator pi = --unit->myTrack->parts.end(); list<TrackPart *>::iterator pi2 = pi--; if(((tp->pos1+(*pi)->pos1)*0.5f).SqDistance((*pi2)->pos1)<1) replace = true; } if(replace) { delete unit->myTrack->parts.back(); unit->myTrack->parts.back() = tp; } else { unit->myTrack->parts.push_back(tp); } } tracksToBeAdded.clear(); } for (std::vector<UnitTrackStruct *>::iterator ti = tracksToBeDeleted.begin(); ti != tracksToBeDeleted.end(); ++ti) { delete *ti; } tracksToBeDeleted.clear(); tracksToBeCleaned.clear(); // create and draw the unit footprint quads for (std::vector<TrackType*>::iterator tti = trackTypes.begin(); tti != trackTypes.end(); ++tti) { TrackType* tt = *tti; if (!tt->tracks.empty()) { set<UnitTrackStruct*>::iterator utsi = tt->tracks.begin(); CVertexArray* va = GetVertexArray(); va->Initialize(); glBindTexture(GL_TEXTURE_2D, tt->texture); while (utsi != tt->tracks.end()) { UnitTrackStruct* track = *utsi; if (track->parts.empty()) { tracksToBeCleaned.push_back(TrackToClean(track, &(tt->tracks))); continue; } if (track->parts.front()->creationTime < gs->frameNum - track->lifeTime) { tracksToBeCleaned.push_back(TrackToClean(track, &(tt->tracks))); } if (camera->InView((track->parts.front()->pos1 + track->parts.back()->pos1) * 0.5f, track->parts.front()->pos1.distance(track->parts.back()->pos1) + 500)) { list<TrackPart *>::iterator ppi = track->parts.begin(); color2[3] = std::max(0, track->trackAlpha - (int) ((gs->frameNum - (*ppi)->creationTime) * track->alphaFalloff)); va->EnlargeArrays(track->parts.size()*4,0,VA_SIZE_TC); for (list<TrackPart *>::iterator pi = ++track->parts.begin(); pi != track->parts.end(); ++pi) { color[3] = std::max(0, track->trackAlpha - (int) ((gs->frameNum - (*ppi)->creationTime) * track->alphaFalloff)); if ((*pi)->connected) { va->AddVertexQTC((*ppi)->pos1, (*ppi)->texPos, 0, color2); va->AddVertexQTC((*ppi)->pos2, (*ppi)->texPos, 1, color2); va->AddVertexQTC((*pi)->pos2, (*pi)->texPos, 1, color); va->AddVertexQTC((*pi)->pos1, (*pi)->texPos, 0, color); } color2[3] = color[3]; ppi = pi; } } utsi++; } va->DrawArrayTC(GL_QUADS); } } { GML_STDMUTEX_LOCK(track); // Draw // Cleanup old tracks for (std::vector<TrackToClean>::iterator ti = tracksToBeCleaned.begin(); ti != tracksToBeCleaned.end(); ++ti) { TrackToClean *ttc = &(*ti); UnitTrackStruct *track = ttc->track; while (!track->parts.empty() && track->parts.front()->creationTime < gs->frameNum - track->lifeTime) { delete track->parts.front(); track->parts.pop_front(); } if (track->parts.empty()) { if (track->owner) { track->owner->myTrack = 0; track->owner = 0; } ttc->tracks->erase(track); tracksToBeDeleted.push_back(track); } } } glBindTexture(GL_TEXTURE_2D, scarTex); glPolygonOffset(-10, -400); scarsToBeChecked.clear(); { GML_STDMUTEX_LOCK(scar); // Draw for (std::vector<Scar*>::iterator si = scarsToBeAdded.begin(); si != scarsToBeAdded.end(); ++si) scarsToBeChecked.push_back(*si); scarsToBeAdded.clear(); } for (std::vector<Scar*>::iterator si = scarsToBeChecked.begin(); si != scarsToBeChecked.end(); ++si) { Scar* s = *si; TestOverlaps(s); int x1 = s->x1 / 16; int x2 = min(scarFieldX - 1, s->x2 / 16); int y1 = s->y1 / 16; int y2 = min(scarFieldY - 1, s->y2 / 16); for (int y = y1; y <= y2; ++y) { for (int x = x1; x <= x2; ++x) { std::set<Scar*>* quad = &scarField[y * scarFieldX + x]; quad->insert(s); } } scars.push_back(s); } // create and draw the 16x16 quads for each ground scar for (std::list<Scar*>::iterator si = scars.begin(); si != scars.end(); ) { Scar* scar = *si; if (scar->lifeTime < gs->frameNum) { RemoveScar(*si, false); si = scars.erase(si); continue; } if (camera->InView(scar->pos, scar->radius + 16)) { DrawGroundScar(scar, groundScarAlphaFade); } ++si; } glDisable(GL_POLYGON_OFFSET_FILL); glDisable(GL_BLEND); glActiveTextureARB(GL_TEXTURE1_ARB); glDisable(GL_TEXTURE_2D); glDisable(GL_TEXTURE_GEN_S); glDisable(GL_TEXTURE_GEN_T); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_MODULATE); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_PREVIOUS_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_ARB, GL_TEXTURE); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glActiveTextureARB(GL_TEXTURE3_ARB); //! infotex glDisable(GL_TEXTURE_2D); glDisable(GL_TEXTURE_GEN_S); glDisable(GL_TEXTURE_GEN_T); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_MODULATE); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_PREVIOUS_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_ARB, GL_TEXTURE); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glActiveTextureARB(GL_TEXTURE0_ARB); }