Refactor: Relocated R_IsSkySurface() to Surface

Renamed as Surface_IsSkyMasked()

doomsday/engine/portable/include/r_world.h

@@ -84,14 +84,6 @@ float R_ExtraLightDelta(void);
  */
 float R_CheckSectorLight(float lightlevel, float min, float max);
 
-/**
- * Will the specified surface be added to the sky mask?
- *
- * @param suf  Ptr to the surface to test.
- * @return boolean  @c true, iff the surface will be masked.
- */
-boolean R_IsSkySurface(const Surface* suf);
-
 boolean R_SectorContainsSkySurfaces(const Sector* sec);
 
 void R_UpdatePlanes(void);

doomsday/engine/portable/include/surface.h

@@ -35,6 +35,9 @@ void Surface_Update(Surface* surface);
 /// @return @c true= is drawable (i.e., a drawable Material is bound).
 boolean Surface_IsDrawable(Surface* surface);
 
+/// @return @c true= is sky-masked (i.e., a sky-masked Material is bound).
+boolean Surface_IsSkyMasked(const Surface* suf);
+
 /// @return @c true= is owned by some element of the Map geometry.
 boolean Surface_AttachedToMap(Surface* surface);
 

doomsday/engine/portable/src/linedef.c

@@ -362,10 +362,10 @@ boolean LineDef_MiddleMaterialCoversOpening(const LineDef *line, int side,
                     // Possibly. Check the placement of the mid texture.
                     if(LineDef_MiddleMaterialCoords(line, side, &matBottom[0], &matBottom[1],
                         &matTop[0], &matTop[1], NULL, 0 != (line->flags & DDLF_DONTPEGBOTTOM),
-                        !(R_IsSkySurface(&frontSec->SP_ceilsurface) &&
-                          R_IsSkySurface(&backSec->SP_ceilsurface)),
-                        !(R_IsSkySurface(&frontSec->SP_floorsurface) &&
-                          R_IsSkySurface(&backSec->SP_floorsurface))))
+                        !(Surface_IsSkyMasked(&frontSec->SP_ceilsurface) &&
+                          Surface_IsSkyMasked(&backSec->SP_ceilsurface)),
+                        !(Surface_IsSkyMasked(&frontSec->SP_floorsurface) &&
+                          Surface_IsSkyMasked(&backSec->SP_floorsurface))))
                     {
                         if(matTop[0] >= openTop[0] &&
                            matTop[1] >= openTop[1] &&

doomsday/engine/portable/src/p_particle.c

@@ -1000,7 +1000,7 @@ static void P_MoveParticle(ptcgen_t* gen, particle_t* pt)
         if(z > FLT2FIX(pt->sector->SP_ceilheight) - hardRadius)
         {
             // The Z is through the roof!
-            if(R_IsSkySurface(&pt->sector->SP_ceilsurface))
+            if(Surface_IsSkyMasked(&pt->sector->SP_ceilsurface))
             {
                 // Special case: particle gets lost in the sky.
                 pt->stage = -1;
@@ -1018,7 +1018,7 @@ static void P_MoveParticle(ptcgen_t* gen, particle_t* pt)
         // Also check the floor.
         if(z < FLT2FIX(pt->sector->SP_floorheight) + hardRadius)
         {
-            if(R_IsSkySurface(&pt->sector->SP_floorsurface))
+            if(Surface_IsSkyMasked(&pt->sector->SP_floorsurface))
             {
                 pt->stage = -1;
                 return;

doomsday/engine/portable/src/p_players.c

@@ -167,7 +167,7 @@ boolean P_IsInVoid(player_t* player)
         {
             Sector* sec = ddpl->mo->bspLeaf->sector;
 
-            if(R_IsSkySurface(&sec->SP_ceilsurface))
+            if(Surface_IsSkyMasked(&sec->SP_ceilsurface))
             {
                 const float skyCeil = GameMap_SkyFixCeiling(theMap);
                 if(skyCeil < DDMAXFLOAT && ddpl->mo->pos[VZ] > skyCeil - 4)
@@ -176,7 +176,7 @@ boolean P_IsInVoid(player_t* player)
             else if(ddpl->mo->pos[VZ] > sec->SP_ceilvisheight - 4)
                 return true;
 
-            if(R_IsSkySurface(&sec->SP_floorsurface))
+            if(Surface_IsSkyMasked(&sec->SP_floorsurface))
             {
                 const float skyFloor = GameMap_SkyFixFloor(theMap);
                 if(skyFloor > DDMINFLOAT && ddpl->mo->pos[VZ] < skyFloor + 4)

doomsday/engine/portable/src/r_lgrid.c

@@ -818,8 +818,8 @@ BEGIN_PROF( PROF_GRID_UPDATE );
             color = R_GetSectorLightColor(sector);
             height = (int) (sector->SP_ceilheight - sector->SP_floorheight);
 
-            isSkyFloor = R_IsSkySurface(&sector->SP_ceilsurface);
-            isSkyCeil = R_IsSkySurface(&sector->SP_floorsurface);
+            isSkyFloor = Surface_IsSkyMasked(&sector->SP_ceilsurface);
+            isSkyCeil = Surface_IsSkyMasked(&sector->SP_floorsurface);
 
             if(isSkyFloor && !isSkyCeil)
             {

doomsday/engine/portable/src/r_main.c

@@ -214,11 +214,6 @@ void R_LoadSystemFonts(void)
     Con_SetFont(fontFixed);
 }
 
-boolean R_IsSkySurface(const Surface* suf)
-{
-    return (suf && suf->material && Material_IsSkyMasked(suf->material));
-}
-
 /**
  * Update the view origin position for player @a consoleNum.
  *

doomsday/engine/portable/src/r_things.c

@@ -1590,7 +1590,7 @@ int RIT_AddSprite(void* ptr, void* paramaters)
         // that no sprites get clipped by the sky.
         // Only check
         mat = R_GetMaterialForSprite(mo->sprite, mo->frame);
-        if(mat && R_IsSkySurface(&sec->SP_ceilsurface))
+        if(mat && Surface_IsSkyMasked(&sec->SP_ceilsurface))
         {
             if(!(mo->dPlayer && mo->dPlayer->flags & DDPF_CAMERA) && // Cameramen don't exist!
                mo->pos[VZ] <= sec->SP_ceilheight &&

doomsday/engine/portable/src/r_world.c

@@ -776,8 +776,8 @@ void GameMap_UpdateSkyFixForSector(GameMap* map, Sector* sec)
 
     if(!sec || 0 == sec->lineDefCount) return;
 
-    skyFloor = R_IsSkySurface(&sec->SP_floorsurface);
-    skyCeil  = R_IsSkySurface(&sec->SP_ceilsurface);
+    skyFloor = Surface_IsSkyMasked(&sec->SP_floorsurface);
+    skyCeil  = Surface_IsSkyMasked(&sec->SP_ceilsurface);
 
     if(!skyFloor && !skyCeil) return;
 
@@ -1534,15 +1534,15 @@ boolean R_IsGlowingPlane(const Plane* pln)
         MC_MAPSURFACE, 0, 0, 0, 0, GL_REPEAT, GL_REPEAT, -1, -1, -1, true, true, false, false);
     const materialsnapshot_t* ms = Materials_Prepare(mat, spec, true);
 
-    return ((mat && !Material_IsDrawable(mat)) || ms->glowing > 0 || R_IsSkySurface(&pln->surface));
+    return ((mat && !Material_IsDrawable(mat)) || ms->glowing > 0 || Surface_IsSkyMasked(&pln->surface));
 }
 
 float R_GlowStrength(const Plane* pln)
 {
     material_t* mat = pln->surface.material;
     if(mat)
     {
-        if(Material_IsDrawable(mat) && !R_IsSkySurface(&pln->surface))
+        if(Material_IsDrawable(mat) && !Surface_IsSkyMasked(&pln->surface))
         {
             /// \fixme We should not need to prepare to determine this.
             const materialvariantspecification_t* spec = Materials_VariantSpecificationForContext(
@@ -1567,7 +1567,7 @@ boolean R_SectorContainsSkySurfaces(const Sector* sec)
     uint n = 0;
     do
     {
-        if(R_IsSkySurface(&sec->SP_planesurface(n)))
+        if(Surface_IsSkyMasked(&sec->SP_planesurface(n)))
             sectorContainsSkySurfaces = true;
         else
             n++;
@@ -1599,12 +1599,12 @@ static material_t* chooseFixMaterial(SideDef* s, sidedefsection_t section)
                        (section == SS_TOP    && frontSec->SP_ceilheight  > backSec->SP_ceilheight  && frontSec->SP_floorheight < backSec->SP_ceilheight)))
         {
             suf = &backSec->SP_plane(section == SS_BOTTOM? PLN_FLOOR : PLN_CEILING)->surface;
-            if(suf->material && !R_IsSkySurface(suf))
+            if(suf->material && !Surface_IsSkyMasked(suf))
                 choice1 = suf->material;
         }
 
         suf = &frontSec->SP_plane(section == SS_BOTTOM? PLN_FLOOR : PLN_CEILING)->surface;
-        if(suf->material && !R_IsSkySurface(suf))
+        if(suf->material && !Surface_IsSkyMasked(suf))
             choice2 = suf->material;
     }
 
@@ -1628,7 +1628,7 @@ static void updateSidedefSection(SideDef* s, sidedefsection_t section)
 
     suf = &s->sections[section];
     if(!suf->material /*&&
-       !R_IsSkySurface(&s->sector->
+       !Surface_IsSkyMasked(&s->sector->
             SP_plane(section == SS_BOTTOM? PLN_FLOOR : PLN_CEILING)->
                 surface)*/)
     {

doomsday/engine/portable/src/rend_decor.c

@@ -632,7 +632,7 @@ static void updateSideSectionDecorations(SideDef* side, sidedefsection_t section
         suf = &side->SW_topsurface;
         if(suf->material)
             if(line->L_backside && backCeil->visHeight < frontCeil->visHeight &&
-               (!R_IsSkySurface(&backCeil->surface) || !R_IsSkySurface(&frontCeil->surface)))
+               (!Surface_IsSkyMasked(&backCeil->surface) || !Surface_IsSkyMasked(&frontCeil->surface)))
             {
                 top = frontCeil->visHeight;
                 bottom  = backCeil->visHeight;
@@ -646,7 +646,7 @@ static void updateSideSectionDecorations(SideDef* side, sidedefsection_t section
         suf = &side->SW_bottomsurface;
         if(suf->material)
             if(line->L_backside && backFloor->visHeight > frontFloor->visHeight &&
-               (!R_IsSkySurface(&backFloor->surface) || !R_IsSkySurface(&frontFloor->surface)))
+               (!Surface_IsSkyMasked(&backFloor->surface) || !Surface_IsSkyMasked(&frontFloor->surface)))
             {
                 top = backFloor->visHeight;
                 bottom  = frontFloor->visHeight;

doomsday/engine/portable/src/rend_fakeradio.c

@@ -1211,9 +1211,9 @@ static uint radioEdgeHackType(const LineDef* line, const Sector* front, const Se
     // Is the back sector closed?
     if(front->SP_floorvisheight >= back->SP_ceilvisheight)
     {
-        if(R_IsSkySurface(&front->planes[isCeiling? PLN_FLOOR:PLN_CEILING]->surface))
+        if(Surface_IsSkyMasked(&front->planes[isCeiling? PLN_FLOOR:PLN_CEILING]->surface))
         {
-            if(R_IsSkySurface(&back->planes[isCeiling? PLN_FLOOR:PLN_CEILING]->surface))
+            if(Surface_IsSkyMasked(&back->planes[isCeiling? PLN_FLOOR:PLN_CEILING]->surface))
                 return 3; // Consider it fully open.
         }
         else
@@ -1326,7 +1326,7 @@ static void processEdgeShadow(const BspLeaf* bspLeaf, const LineDef* lineDef,
     plnHeight = pln->visHeight;
 
     // Glowing surfaces or missing textures shouldn't have shadows.
-    if((suf->inFlags & SUIF_NO_RADIO) || !suf->material || R_IsSkySurface(suf)) return;
+    if((suf->inFlags & SUIF_NO_RADIO) || !suf->material || Surface_IsSkyMasked(suf)) return;
 
     spec = Materials_VariantSpecificationForContext(MC_MAPSURFACE, 0, 0, 0, 0, GL_REPEAT, GL_REPEAT,
         -1, -1, -1, true, true, false, false);

doomsday/engine/portable/src/rend_main.c

@@ -407,14 +407,14 @@ static void markSideDefSectionsPVisible(HEdge* hedge)
         side->SW_middlesurface.inFlags &= ~SUIF_PVIS;
 
     // Top.
-    if((!devRendSkyMode && R_IsSkySurface(&fceil->surface) && R_IsSkySurface(&bceil->surface)) ||
-       (!devRendSkyMode && R_IsSkySurface(&bceil->surface) && (side->SW_topsurface.inFlags & SUIF_FIX_MISSING_MATERIAL)) ||
+    if((!devRendSkyMode && Surface_IsSkyMasked(&fceil->surface) && Surface_IsSkyMasked(&bceil->surface)) ||
+       (!devRendSkyMode && Surface_IsSkyMasked(&bceil->surface) && (side->SW_topsurface.inFlags & SUIF_FIX_MISSING_MATERIAL)) ||
        (fceil->visHeight <= bceil->visHeight))
         side->SW_topsurface   .inFlags &= ~SUIF_PVIS;
 
     // Bottom.
-    if((!devRendSkyMode && R_IsSkySurface(&ffloor->surface) && R_IsSkySurface(&bfloor->surface)) ||
-       (!devRendSkyMode && R_IsSkySurface(&bfloor->surface) && (side->SW_bottomsurface.inFlags & SUIF_FIX_MISSING_MATERIAL)) ||
+    if((!devRendSkyMode && Surface_IsSkyMasked(&ffloor->surface) && Surface_IsSkyMasked(&bfloor->surface)) ||
+       (!devRendSkyMode && Surface_IsSkyMasked(&bfloor->surface) && (side->SW_bottomsurface.inFlags & SUIF_FIX_MISSING_MATERIAL)) ||
        (ffloor->visHeight >= bfloor->visHeight))
         side->SW_bottomsurface.inFlags &= ~SUIF_PVIS;
 }
@@ -1825,10 +1825,10 @@ static boolean rendSegSection(BspLeaf* bspLeaf, HEdge* hedge,
 
         // Determine which Material to use.
         if(devRendSkyMode && hedge->HE_backsector &&
-           ((section == SS_BOTTOM && R_IsSkySurface(&hedge->HE_frontsector->SP_floorsurface) &&
-                                      R_IsSkySurface(&hedge->HE_backsector->SP_floorsurface)) ||
-            (section == SS_TOP    && R_IsSkySurface(&hedge->HE_frontsector->SP_ceilsurface) &&
-                                      R_IsSkySurface(&hedge->HE_backsector->SP_ceilsurface))))
+           ((section == SS_BOTTOM && Surface_IsSkyMasked(&hedge->HE_frontsector->SP_floorsurface) &&
+                                      Surface_IsSkyMasked(&hedge->HE_backsector->SP_floorsurface)) ||
+            (section == SS_TOP    && Surface_IsSkyMasked(&hedge->HE_frontsector->SP_ceilsurface) &&
+                                      Surface_IsSkyMasked(&hedge->HE_backsector->SP_ceilsurface))))
         {
             // Geometry not normally rendered however we do so in dev sky mode.
             mat = hedge->HE_frontsector->SP_planematerial(section == SS_TOP? PLN_CEILING : PLN_FLOOR);
@@ -2118,9 +2118,9 @@ boolean R_FindBottomTop(LineDef* lineDef, int side, sidedefsection_t section,
 
             if(!P_IsInVoid(viewPlayer))
             {
-                if(R_IsSkySurface(&ffloor->surface) && R_IsSkySurface(&bfloor->surface))
+                if(Surface_IsSkyMasked(&ffloor->surface) && Surface_IsSkyMasked(&bfloor->surface))
                     clipBottom = false;
-                if(R_IsSkySurface(&fceil->surface)  && R_IsSkySurface(&bceil->surface))
+                if(Surface_IsSkyMasked(&fceil->surface)  && Surface_IsSkyMasked(&bceil->surface))
                     clipTop = false;
             }
 
@@ -2441,8 +2441,8 @@ static int segSkyFixes(HEdge* hedge)
 
         if(!backSec || backSec != hedge->HE_frontsector)
         {
-            const boolean hasSkyFloor   = R_IsSkySurface(&frontSec->SP_floorsurface);
-            const boolean hasSkyCeiling = R_IsSkySurface(&frontSec->SP_ceilsurface);
+            const boolean hasSkyFloor   = Surface_IsSkyMasked(&frontSec->SP_floorsurface);
+            const boolean hasSkyCeiling = Surface_IsSkyMasked(&frontSec->SP_ceilsurface);
 
             if(hasSkyFloor || hasSkyCeiling)
             {
@@ -2455,9 +2455,9 @@ static int segSkyFixes(HEdge* hedge)
                     const Plane* bfloor = backSec? backSec->SP_plane(PLN_FLOOR) : NULL;
                     const float skyZ = skyFixFloorZ(ffloor, bfloor);
 
-                    if(hasClosedBack || (!R_IsSkySurface(&bfloor->surface) || P_IsInVoid(viewPlayer)))
+                    if(hasClosedBack || (!Surface_IsSkyMasked(&bfloor->surface) || P_IsInVoid(viewPlayer)))
                     {
-                        const Plane* floor = (bfloor && R_IsSkySurface(&bfloor->surface)? bfloor : ffloor);
+                        const Plane* floor = (bfloor && Surface_IsSkyMasked(&bfloor->surface)? bfloor : ffloor);
                         if(floor->visHeight > skyZ)
                             fixes |= SKYCAP_LOWER;
                     }
@@ -2470,9 +2470,9 @@ static int segSkyFixes(HEdge* hedge)
                     const Plane* bceil = backSec? backSec->SP_plane(PLN_CEILING) : NULL;
                     const float skyZ = skyFixCeilZ(fceil, bceil);
 
-                    if(hasClosedBack || (!R_IsSkySurface(&bceil->surface) || P_IsInVoid(viewPlayer)))
+                    if(hasClosedBack || (!Surface_IsSkyMasked(&bceil->surface) || P_IsInVoid(viewPlayer)))
                     {
-                        const Plane* ceil = (bceil && R_IsSkySurface(&bceil->surface)? bceil : fceil);
+                        const Plane* ceil = (bceil && Surface_IsSkyMasked(&bceil->surface)? bceil : fceil);
                         if(ceil->visHeight < skyZ)
                             fixes |= SKYCAP_UPPER;
                     }
@@ -2505,11 +2505,11 @@ static void skyFixZCoords(HEdge* hedge, int skyCap, float* bottom, float* top)
     if(skyCap & SKYCAP_UPPER)
     {
         if(top)    *top    = skyFixCeilZ(fceil, bceil);
-        if(bottom) *bottom = MAX_OF((backSec && R_IsSkySurface(&bceil->surface))? bceil->visHeight : fceil->visHeight, ffloor->visHeight);
+        if(bottom) *bottom = MAX_OF((backSec && Surface_IsSkyMasked(&bceil->surface))? bceil->visHeight : fceil->visHeight, ffloor->visHeight);
     }
     else
     {
-        if(top)    *top    = MIN_OF((backSec && R_IsSkySurface(&bfloor->surface)? bfloor->visHeight : ffloor->visHeight), fceil->visHeight);
+        if(top)    *top    = MIN_OF((backSec && Surface_IsSkyMasked(&bfloor->surface)? bfloor->visHeight : ffloor->visHeight), fceil->visHeight);
         if(bottom) *bottom = skyFixFloorZ(ffloor, bfloor);
     }
 }
@@ -2581,9 +2581,9 @@ static void rendBspLeafSky(BspLeaf* bspLeaf, int skyCap)
     if(!bspLeaf || !bspLeaf->hedgeCount || !bspLeaf->sector) return;
 
     // Sky caps are only necessary in sectors with skymasked planes.
-    if((skyCap & SKYCAP_LOWER) && !R_IsSkySurface(&bspLeaf->sector->SP_floorsurface))
+    if((skyCap & SKYCAP_LOWER) && !Surface_IsSkyMasked(&bspLeaf->sector->SP_floorsurface))
         skyCap &= ~SKYCAP_LOWER;
-    if((skyCap & SKYCAP_UPPER) && !R_IsSkySurface(&bspLeaf->sector->SP_ceilsurface))
+    if((skyCap & SKYCAP_UPPER) && !Surface_IsSkyMasked(&bspLeaf->sector->SP_ceilsurface))
         skyCap &= ~SKYCAP_UPPER;
 
     // Sky fixes:
@@ -2697,8 +2697,8 @@ static void occludeBspLeaf(const BspLeaf* bspLeaf, boolean forwardFacing)
             }
 
             // Do not create an occlusion for sky floors.
-            if(!R_IsSkySurface(&back->SP_floorsurface) ||
-               !R_IsSkySurface(&front->SP_floorsurface))
+            if(!Surface_IsSkyMasked(&back->SP_floorsurface) ||
+               !Surface_IsSkyMasked(&front->SP_floorsurface))
             {
                 // Do the floors create an occlusion?
                 if((backh[0] > fronth[0] && vy <= backh[0]) ||
@@ -2710,8 +2710,8 @@ static void occludeBspLeaf(const BspLeaf* bspLeaf, boolean forwardFacing)
             }
 
             // Do not create an occlusion for sky ceilings.
-            if(!R_IsSkySurface(&back->SP_ceilsurface) ||
-               !R_IsSkySurface(&front->SP_ceilsurface))
+            if(!Surface_IsSkyMasked(&back->SP_ceilsurface) ||
+               !Surface_IsSkyMasked(&front->SP_ceilsurface))
             {
                 // Do the ceilings create an occlusion?
                 if((backh[1] < fronth[1] && vy >= backh[1]) ||
@@ -2851,7 +2851,7 @@ static void Rend_RenderBspLeaf(uint bspLeafIdx)
         material_t* mat;
         int texMode;
 
-        isSkyMasked = R_IsSkySurface(suf);
+        isSkyMasked = Surface_IsSkyMasked(suf);
         if(isSkyMasked && plane->type != PLN_MID)
         {
             if(!devRendSkyMode) continue; // Not handled here.
@@ -3011,8 +3011,8 @@ void Rend_RenderSurfaceVectors(void)
 
             if(hedge->HE_backsector->SP_ceilvisheight <
                hedge->HE_frontsector->SP_ceilvisheight &&
-               !(R_IsSkySurface(&hedge->HE_frontsector->SP_ceilsurface) &&
-                 R_IsSkySurface(&hedge->HE_backsector->SP_ceilsurface)))
+               !(Surface_IsSkyMasked(&hedge->HE_frontsector->SP_ceilsurface) &&
+                 Surface_IsSkyMasked(&hedge->HE_backsector->SP_ceilsurface)))
             {
                 bottom = hedge->HE_backsector->SP_ceilvisheight;
                 top = hedge->HE_frontsector->SP_ceilvisheight;
@@ -3024,8 +3024,8 @@ void Rend_RenderSurfaceVectors(void)
 
             if(hedge->HE_backsector->SP_floorvisheight >
                hedge->HE_frontsector->SP_floorvisheight &&
-               !(R_IsSkySurface(&hedge->HE_frontsector->SP_floorsurface) &&
-                 R_IsSkySurface(&hedge->HE_backsector->SP_floorsurface)))
+               !(Surface_IsSkyMasked(&hedge->HE_frontsector->SP_floorsurface) &&
+                 Surface_IsSkyMasked(&hedge->HE_backsector->SP_floorsurface)))
             {
                 bottom = hedge->HE_frontsector->SP_floorvisheight;
                 top = hedge->HE_backsector->SP_floorvisheight;
@@ -3050,7 +3050,7 @@ void Rend_RenderSurfaceVectors(void)
             vec3_t origin;
 
             V3_Set(origin, bspLeaf->midPoint.pos[VX], bspLeaf->midPoint.pos[VY], pln->visHeight);
-            if(pln->type != PLN_MID && R_IsSkySurface(&pln->surface))
+            if(pln->type != PLN_MID && Surface_IsSkyMasked(&pln->surface))
                 origin[VZ] = GameMap_SkyFix(theMap, pln->type == PLN_CEILING);
 
             drawSurfaceTangentSpaceVectors(&pln->surface, origin);

doomsday/engine/portable/src/s_environ.c

@@ -414,8 +414,8 @@ void S_CalcSectorReverb(Sector* sec)
     if(sec->reverb[SRD_SPACE] > .99)
         sec->reverb[SRD_SPACE] = .99f;
 
-    if(R_IsSkySurface(&sec->SP_ceilsurface) ||
-       R_IsSkySurface(&sec->SP_floorsurface))
+    if(Surface_IsSkyMasked(&sec->SP_ceilsurface) ||
+       Surface_IsSkyMasked(&sec->SP_floorsurface))
     {   // An "open" sector.
         // It can still be small, in which case; reverb is diminished a bit.
         if(sec->reverb[SRD_SPACE] > .5)