diff --git a/doomsday/engine/api/dd_maptypes.h b/doomsday/engine/api/dd_maptypes.h
index 03b1fc666f..e6541a5293 100644
--- a/doomsday/engine/api/dd_maptypes.h
+++ b/doomsday/engine/api/dd_maptypes.h
@@ -6,21 +6,21 @@
 #define DMT_VERTEX_POS  DDVT_FLOAT
 
 
-#define DMT_SEG_SIDEDEF         DDVT_PTR
+#define DMT_HEDGE_SIDEDEF         DDVT_PTR
 
-#define DMT_SEG_V DDVT_PTR             // [Start, End] of the segment.
-#define DMT_SEG_LINEDEF DDVT_PTR
-#define DMT_SEG_SEC DDVT_PTR
-#define DMT_SEG_SUBSECTOR DDVT_PTR
-#define DMT_SEG_BACKSEG DDVT_PTR
-#define DMT_SEG_ANGLE DDVT_ANGLE
-#define DMT_SEG_SIDE DDVT_BYTE         // 0=front, 1=back
-#define DMT_SEG_FLAGS DDVT_BYTE
-#define DMT_SEG_LENGTH DDVT_FLOAT      // Accurate length of the segment (v1 -> v2).
-#define DMT_SEG_OFFSET DDVT_FLOAT
+#define DMT_HEDGE_V DDVT_PTR             // [Start, End] of the segment.
+#define DMT_HEDGE_LINEDEF DDVT_PTR
+#define DMT_HEDGE_SEC DDVT_PTR
+#define DMT_HEDGE_SUBSECTOR DDVT_PTR
+#define DMT_HEDGE_TWIN DDVT_PTR
+#define DMT_HEDGE_ANGLE DDVT_ANGLE
+#define DMT_HEDGE_SIDE DDVT_BYTE         // 0=front, 1=back
+#define DMT_HEDGE_FLAGS DDVT_BYTE
+#define DMT_HEDGE_LENGTH DDVT_FLOAT      // Accurate length of the segment (v1 -> v2).
+#define DMT_HEDGE_OFFSET DDVT_FLOAT
 
-#define DMT_SUBSECTOR_SEGCOUNT DDVT_UINT
-#define DMT_SUBSECTOR_SEGS DDVT_PTR    // [segcount] size.
+#define DMT_SUBSECTOR_HEDGECOUNT DDVT_UINT
+#define DMT_SUBSECTOR_HEDGES DDVT_PTR    // [hedgeCount] size.
 #define DMT_SUBSECTOR_POLYOBJ DDVT_PTR // NULL, if there is no polyobj.
 #define DMT_SUBSECTOR_SECTOR DDVT_PTR
 
@@ -57,8 +57,8 @@
 #define DMT_SECTOR_PLANECOUNT DDVT_UINT
 #define DMT_SECTOR_REVERB DDVT_FLOAT
 
-#define DMT_SIDEDEF_SEGCOUNT DDVT_UINT
-#define DMT_SIDEDEF_SEGS DDVT_PTR      // [segcount] size, segs arranged left>right
+#define DMT_SIDEDEF_HEDGECOUNT DDVT_UINT
+#define DMT_SIDEDEF_HEDGES DDVT_PTR      // [hedgeCount] size, hedges arranged left>right
 #define DMT_SIDEDEF_LINE DDVT_PTR
 #define DMT_SIDEDEF_SECTOR DDVT_PTR
 #define DMT_SIDEDEF_FLAGS DDVT_SHORT
diff --git a/doomsday/engine/api/dd_share.h b/doomsday/engine/api/dd_share.h
index a27d971034..4980c1c2f9 100644
--- a/doomsday/engine/api/dd_share.h
+++ b/doomsday/engine/api/dd_share.h
@@ -276,7 +276,7 @@ enum {
     DD_LINE_COUNT,
     DD_SIDE_COUNT,
     DD_VERTEX_COUNT,
-    DD_SEG_COUNT,
+    DD_HEDGE_COUNT,
     DD_SUBSECTOR_COUNT,
     DD_NODE_COUNT,
     DD_POLYOBJ_COUNT,
@@ -653,7 +653,7 @@ enum {
     DMU_NONE = 0,
 
     DMU_VERTEX = 1,
-    DMU_SEG,
+    DMU_HEDGE,
     DMU_LINEDEF,
     DMU_SIDEDEF,
     DMU_NODE,
@@ -724,7 +724,7 @@ enum {
     DMU_HEIGHT,
     DMU_TARGET_HEIGHT,
     DMU_SPEED,
-    DMU_SEG_COUNT
+    DMU_HEDGE_COUNT
 };
 
 /**
@@ -1066,8 +1066,8 @@ typedef struct aaboxf_s {
     angle_t         angle; \
     angle_t         destAngle; /* Destination angle. */ \
     angle_t         angleSpeed; /* Rotation speed. */ \
-    unsigned int    numSegs; \
-    struct seg_s**  segs; \
+    unsigned int    numHEdges; \
+    struct hedge_s** hedges; \
     struct fvertex_s* originalPts; /* Used as the base for the rotations. */ \
     struct fvertex_s* prevPts; /* Use to restore the old point values. */ \
     float           speed; /* Movement speed. */ \
diff --git a/doomsday/engine/api/dd_types.h b/doomsday/engine/api/dd_types.h
index d908e87a18..115c5a1d20 100644
--- a/doomsday/engine/api/dd_types.h
+++ b/doomsday/engine/api/dd_types.h
@@ -208,7 +208,7 @@ struct node_s;
 struct vertex_s;
 struct linedef_s;
 struct side_s;
-struct seg_s;
+struct hedge_s;
 struct subsector_s;
 struct sector_s;
 struct polyblock_s;
diff --git a/doomsday/engine/api/doomsday.h b/doomsday/engine/api/doomsday.h
index e5cdbf574b..b9c1a06a2b 100644
--- a/doomsday/engine/api/doomsday.h
+++ b/doomsday/engine/api/doomsday.h
@@ -69,7 +69,7 @@ extern "C" {
     typedef struct vertex_s {int type; } vertex_t;
     typedef struct linedef_s { int type; } linedef_t;
     typedef struct sidedef_s { int type; } sidedef_t;
-    typedef struct seg_s { int type; } seg_t;
+    typedef struct hedge_s { int type; } HEdge;
     typedef struct subsector_s { int type; } subsector_t;
     typedef struct sector_s { int type; } sector_t;
     typedef struct plane_s { int type; } plane_t;
diff --git a/doomsday/engine/data/cphelp.txt b/doomsday/engine/data/cphelp.txt
index 6ae1336842..a92ce183a0 100644
--- a/doomsday/engine/data/cphelp.txt
+++ b/doomsday/engine/data/cphelp.txt
@@ -1045,7 +1045,7 @@ desc = 1=Filter camera movement between game tics (OBSOLETE).
 desc = 1=Load generated GL nodes data from the bspcache directory. 0=Always generate new GL data.
 
 [bsp-factor]
-desc = glBSP: changes the cost assigned to SEG splits (default: 7).
+desc = glBSP: changes the cost assigned to edge splits (default: 7).
 
 [con-show-during-setup]
 desc = 1=Show console when a map is being loaded.
diff --git a/doomsday/engine/portable/include/p_linedef.h b/doomsday/engine/portable/include/p_linedef.h
index b31ba8a0fa..294361b4fd 100644
--- a/doomsday/engine/portable/include/p_linedef.h
+++ b/doomsday/engine/portable/include/p_linedef.h
@@ -87,7 +87,7 @@ boolean LineDef_BackClosed(const linedef_t* lineDef, int side, boolean ignoreOpa
 
 /**
  * The DOOM lighting model applies a sector light level delta when drawing
- * Segs based on their 2D world angle.
+ * line segments based on their 2D world angle.
  *
  * @param lineDef  LineDef to calculate delta for.
  * @param side  Side of the LineDef we are interested in.
diff --git a/doomsday/engine/portable/include/p_mapdata.h b/doomsday/engine/portable/include/p_mapdata.h
index bc154af00c..9f47c6bdce 100644
--- a/doomsday/engine/portable/include/p_mapdata.h
+++ b/doomsday/engine/portable/include/p_mapdata.h
@@ -47,14 +47,14 @@
 #define GET_SIDE_IDX(si)        ( (int) ((si) - sideDefs) )
 #define GET_SECTOR_IDX(sec)     ( (int) ((sec) - sectors) )
 #define GET_SUBSECTOR_IDX(sub)  ( (int) ((sub) - ssectors) )
-#define GET_SEG_IDX(seg)        ( (int) ((seg) - segs) )
+#define GET_HEDGE_IDX(he)       ( (int) ((he) - hedges) )
 #define GET_NODE_IDX(nd)        ( (int) ((nd) - nodes) )
 
 // Return the index of plane within a sector's planes array.
 #define GET_PLANE_IDX(pln)      ( (int) ((pln) - (pln)->sector->planes[0]) )
 
 #define VERTEX_PTR(i)       (&vertexes[i])
-#define SEG_PTR(i)          (&segs[i])
+#define HEDGE_PTR(i)        (&hedges[i])
 #define SECTOR_PTR(i)       (&sectors[i])
 #define SUBSECTOR_PTR(i)    (&ssectors[i])
 #define NODE_PTR(i)         (&nodes[i])
@@ -268,8 +268,8 @@ extern Uri* mapUri;
 extern uint numVertexes;
 extern vertex_t* vertexes;
 
-extern uint numSegs;
-extern seg_t* segs;
+extern uint numHEdges;
+extern HEdge* hedges;
 
 extern uint numSectors;
 extern sector_t* sectors;
@@ -302,8 +302,8 @@ typedef struct gamemap_s {
     uint            numVertexes;
     vertex_t*       vertexes;
 
-    uint            numSegs;
-    seg_t*          segs;
+    uint            numHEdges;
+    HEdge*          hedges;
 
     uint            numSectors;
     sector_t*       sectors;
diff --git a/doomsday/engine/portable/include/p_maptypes.h b/doomsday/engine/portable/include/p_maptypes.h
index 2d6ebf428d..35add283ad 100644
--- a/doomsday/engine/portable/include/p_maptypes.h
+++ b/doomsday/engine/portable/include/p_maptypes.h
@@ -49,38 +49,38 @@ typedef struct vertex_s {
     mvertex_t           buildData;
 } vertex_t;
 
-// Helper macros for accessing seg data elements.
+// Helper macros for accessing hedge data elements.
 #define FRONT 0
 #define BACK  1
 
-#define SG_v(n)                 v[(n)]
-#define SG_vpos(n)              SG_v(n)->V_pos
+#define HE_v(n)                 v[(n)? 1:0]
+#define HE_vpos(n)              HE_v(n)->V_pos
 
-#define SG_v1                   SG_v(0)
-#define SG_v1pos                SG_v(0)->V_pos
+#define HE_v1                   HE_v(0)
+#define HE_v1pos                HE_v(0)->V_pos
 
-#define SG_v2                   SG_v(1)
-#define SG_v2pos                SG_v(1)->V_pos
+#define HE_v2                   HE_v(1)
+#define HE_v2pos                HE_v(1)->V_pos
 
-#define SG_sector(n)            sec[(n)]
-#define SG_frontsector          SG_sector(FRONT)
-#define SG_backsector           SG_sector(BACK)
+#define HE_sector(n)            sec[(n)? 1:0]
+#define HE_frontsector          HE_sector(FRONT)
+#define HE_backsector           HE_sector(BACK)
 
-#define SEG_SIDEDEF(s)          ((s)->lineDef->sideDefs[(s)->side])
+#define HEDGE_SIDEDEF(s)          ((s)->lineDef->sideDefs[(s)->side])
 
-// Seg flags
-#define SEGF_POLYOBJ            0x1 // Seg is part of a poly object.
+// HEdge flags
+#define HEDGEF_POLYOBJ            0x1 // HEdge is part of a poly object.
 
-// Seg frame flags
-#define SEGINF_FACINGFRONT      0x0001
+// HEdge frame flags
+#define HEDGEINF_FACINGFRONT      0x0001
 
-typedef struct seg_s {
+typedef struct hedge_s {
     runtime_mapdata_header_t header;
     struct vertex_s*    v[2];          // [Start, End] of the segment.
     struct linedef_s*   lineDef;
     struct sector_s*    sec[2];
     struct subsector_s* subsector;
-    struct seg_s*       backSeg;
+    struct hedge_s*     twin;
     angle_t             angle;
     byte                side;          // 0=front, 1=back
     byte                flags;
@@ -88,14 +88,14 @@ typedef struct seg_s {
     float               offset;
     biassurface_t*      bsuf[3];       // 0=middle, 1=top, 2=bottom
     short               frameFlags;
-} seg_t;
+} HEdge;
 
 #define SUBF_MIDPOINT         0x80    // Midpoint is tri-fan centre.
 
 typedef struct subsector_s {
     runtime_mapdata_header_t header;
-    unsigned int        segCount;
-    struct seg_s**      segs;          // [segcount] size.
+    unsigned int        hedgeCount;
+    struct hedge_s**    hedges;        // [hedgeCount] size.
     struct polyobj_s*   polyObj;       // NULL, if there is no polyobj.
     struct sector_s*    sector;
     int                 addSpriteCount; // frame number of last R_AddSprites
@@ -306,12 +306,12 @@ typedef struct sector_s {
     msector_t           buildData;
 } sector_t;
 
-// Parts of a wall segment.
-typedef enum segsection_e {
-    SEG_MIDDLE,
-    SEG_TOP,
-    SEG_BOTTOM
-} segsection_t;
+// Sidedef sections.
+typedef enum sidedefsection_e {
+    SS_MIDDLE,
+    SS_TOP,
+    SS_BOTTOM
+} sidedefsection_t;
 
 // Helper macros for accessing sidedef top/middle/bottom section data elements.
 #define SW_surface(n)           sections[(n)]
@@ -326,42 +326,42 @@ typedef enum segsection_e {
 #define SW_surfacergba(n)       SW_surface(n).rgba
 #define SW_surfaceblendmode(n)  SW_surface(n).blendMode
 
-#define SW_middlesurface        SW_surface(SEG_MIDDLE)
-#define SW_middleflags          SW_surfaceflags(SEG_MIDDLE)
-#define SW_middleinflags        SW_surfaceinflags(SEG_MIDDLE)
-#define SW_middlematerial       SW_surfacematerial(SEG_MIDDLE)
-#define SW_middletangent        SW_surfacetangent(SEG_MIDDLE)
-#define SW_middlebitangent      SW_surfacebitangent(SEG_MIDDLE)
-#define SW_middlenormal         SW_surfacenormal(SEG_MIDDLE)
-#define SW_middletexmove        SW_surfacetexmove(SEG_MIDDLE)
-#define SW_middleoffset         SW_surfaceoffset(SEG_MIDDLE)
-#define SW_middlevisoffset      SW_surfacevisoffset(SEG_MIDDLE)
-#define SW_middlergba           SW_surfacergba(SEG_MIDDLE)
-#define SW_middleblendmode      SW_surfaceblendmode(SEG_MIDDLE)
-
-#define SW_topsurface           SW_surface(SEG_TOP)
-#define SW_topflags             SW_surfaceflags(SEG_TOP)
-#define SW_topinflags           SW_surfaceinflags(SEG_TOP)
-#define SW_topmaterial          SW_surfacematerial(SEG_TOP)
-#define SW_toptangent           SW_surfacetangent(SEG_TOP)
-#define SW_topbitangent         SW_surfacebitangent(SEG_TOP)
-#define SW_topnormal            SW_surfacenormal(SEG_TOP)
-#define SW_toptexmove           SW_surfacetexmove(SEG_TOP)
-#define SW_topoffset            SW_surfaceoffset(SEG_TOP)
-#define SW_topvisoffset         SW_surfacevisoffset(SEG_TOP)
-#define SW_toprgba              SW_surfacergba(SEG_TOP)
-
-#define SW_bottomsurface        SW_surface(SEG_BOTTOM)
-#define SW_bottomflags          SW_surfaceflags(SEG_BOTTOM)
-#define SW_bottominflags        SW_surfaceinflags(SEG_BOTTOM)
-#define SW_bottommaterial       SW_surfacematerial(SEG_BOTTOM)
-#define SW_bottomtangent        SW_surfacetangent(SEG_BOTTOM)
-#define SW_bottombitangent      SW_surfacebitangent(SEG_BOTTOM)
-#define SW_bottomnormal         SW_surfacenormal(SEG_BOTTOM)
-#define SW_bottomtexmove        SW_surfacetexmove(SEG_BOTTOM)
-#define SW_bottomoffset         SW_surfaceoffset(SEG_BOTTOM)
-#define SW_bottomvisoffset      SW_surfacevisoffset(SEG_BOTTOM)
-#define SW_bottomrgba           SW_surfacergba(SEG_BOTTOM)
+#define SW_middlesurface        SW_surface(SS_MIDDLE)
+#define SW_middleflags          SW_surfaceflags(SS_MIDDLE)
+#define SW_middleinflags        SW_surfaceinflags(SS_MIDDLE)
+#define SW_middlematerial       SW_surfacematerial(SS_MIDDLE)
+#define SW_middletangent        SW_surfacetangent(SS_MIDDLE)
+#define SW_middlebitangent      SW_surfacebitangent(SS_MIDDLE)
+#define SW_middlenormal         SW_surfacenormal(SS_MIDDLE)
+#define SW_middletexmove        SW_surfacetexmove(SS_MIDDLE)
+#define SW_middleoffset         SW_surfaceoffset(SS_MIDDLE)
+#define SW_middlevisoffset      SW_surfacevisoffset(SS_MIDDLE)
+#define SW_middlergba           SW_surfacergba(SS_MIDDLE)
+#define SW_middleblendmode      SW_surfaceblendmode(SS_MIDDLE)
+
+#define SW_topsurface           SW_surface(SS_TOP)
+#define SW_topflags             SW_surfaceflags(SS_TOP)
+#define SW_topinflags           SW_surfaceinflags(SS_TOP)
+#define SW_topmaterial          SW_surfacematerial(SS_TOP)
+#define SW_toptangent           SW_surfacetangent(SS_TOP)
+#define SW_topbitangent         SW_surfacebitangent(SS_TOP)
+#define SW_topnormal            SW_surfacenormal(SS_TOP)
+#define SW_toptexmove           SW_surfacetexmove(SS_TOP)
+#define SW_topoffset            SW_surfaceoffset(SS_TOP)
+#define SW_topvisoffset         SW_surfacevisoffset(SS_TOP)
+#define SW_toprgba              SW_surfacergba(SS_TOP)
+
+#define SW_bottomsurface        SW_surface(SS_BOTTOM)
+#define SW_bottomflags          SW_surfaceflags(SS_BOTTOM)
+#define SW_bottominflags        SW_surfaceinflags(SS_BOTTOM)
+#define SW_bottommaterial       SW_surfacematerial(SS_BOTTOM)
+#define SW_bottomtangent        SW_surfacetangent(SS_BOTTOM)
+#define SW_bottombitangent      SW_surfacebitangent(SS_BOTTOM)
+#define SW_bottomnormal         SW_surfacenormal(SS_BOTTOM)
+#define SW_bottomtexmove        SW_surfacetexmove(SS_BOTTOM)
+#define SW_bottomoffset         SW_surfaceoffset(SS_BOTTOM)
+#define SW_bottomvisoffset      SW_surfacevisoffset(SS_BOTTOM)
+#define SW_bottomrgba           SW_surfacergba(SS_BOTTOM)
 
 #define FRONT                   0
 #define BACK                    1
@@ -375,8 +375,8 @@ typedef struct msidedef_s {
 typedef struct sidedef_s {
     runtime_mapdata_header_t header;
     surface_t           sections[3];
-    unsigned int        segCount;
-    struct seg_s**      segs;          // [segcount] size, segs arranged left>right
+    unsigned int        hedgeCount;
+    struct hedge_s**    hedges;          // [hedgeCount] size, hedges arranged left>right
     struct linedef_s*   line;
     struct sector_s*    sector;
     short               flags;
@@ -433,7 +433,7 @@ typedef struct mlinedef_s {
 
     // Normally NULL, except when this linedef directly overlaps an earlier
     // one (a rarely-used trick to create higher mid-masked textures).
-    // No segs should be created for these overlapping linedefs.
+    // No hedges should be created for these overlapping linedefs.
     struct linedef_s *overlap;
 } mlinedef_t;
 
diff --git a/doomsday/engine/portable/include/p_seg.h b/doomsday/engine/portable/include/p_seg.h
index d32a3daec6..09b58f2805 100644
--- a/doomsday/engine/portable/include/p_seg.h
+++ b/doomsday/engine/portable/include/p_seg.h
@@ -1,4 +1,4 @@
-/**\file p_seg.h
+/**\file p_hedge.h
  *\section License
  * License: GPL
  * Online License Link: http://www.gnu.org/licenses/gpl.html
@@ -23,23 +23,23 @@
  */
 
 /**
- * Map Seg.
+ * Map Half-edge.
  */
 
-#ifndef LIBDENG_MAP_SEG_H
-#define LIBDENG_MAP_SEG_H
+#ifndef LIBDENG_MAP_HEDGE_H
+#define LIBDENG_MAP_HEDGE_H
 
 #include "r_data.h"
 #include "p_dmu.h"
 
 /**
- * Update the seg, property is selected by DMU_* name.
+ * Update the half-edge, property is selected by DMU_* name.
  */
-int Seg_GetProperty(const seg_t* seg, setargs_t* args);
+int HEdge_GetProperty(const HEdge* hedge, setargs_t* args);
 
 /**
- * Get the value of a seg property, selected by DMU_* name.
+ * Get the value of a half-edge property, selected by DMU_* name.
  */
-int Seg_SetProperty(seg_t* seg, const setargs_t* args);
+int HEdge_SetProperty(HEdge* hedge, const setargs_t* args);
 
-#endif /* LIBDENG_MAP_SEG_H */
+#endif /* LIBDENG_MAP_HEDGE_H */
diff --git a/doomsday/engine/portable/include/r_fakeradio.h b/doomsday/engine/portable/include/r_fakeradio.h
index f810196df8..ac79fbbe9c 100644
--- a/doomsday/engine/portable/include/r_fakeradio.h
+++ b/doomsday/engine/portable/include/r_fakeradio.h
@@ -32,7 +32,7 @@
  * wall segments and determining, which subsector vertices will be
  * shadowed.
  *
- * In other words, walls use shadow polygons (over entire segs), while
+ * In other words, walls use shadow polygons (over entire hedges), while
  * planes use vertex lighting.  Since planes are usually tesselated
  * into a great deal of subsectors (and triangles), they are better
  * suited for vertex lighting.  In some cases we will be forced to
diff --git a/doomsday/engine/portable/include/r_lumobjs.h b/doomsday/engine/portable/include/r_lumobjs.h
index 333c2e115f..359565b841 100644
--- a/doomsday/engine/portable/include/r_lumobjs.h
+++ b/doomsday/engine/portable/include/r_lumobjs.h
@@ -155,7 +155,7 @@ void LO_ClipInSubsector(uint ssecidx);
 /**
  * In the situation where a subsector contains both lumobjs and a polyobj,
  * the lumobjs must be clipped more carefully. Here we check if the line of
- * sight intersects any of the polyobj segs that face the camera.
+ * sight intersects any of the polyobj hedges that face the camera.
  *
  * @param ssecidx  Subsector index in which lumobjs will be clipped.
  */
diff --git a/doomsday/engine/portable/include/r_world.h b/doomsday/engine/portable/include/r_world.h
index 9f13ea3c7a..b40b2ee4bc 100644
--- a/doomsday/engine/portable/include/r_world.h
+++ b/doomsday/engine/portable/include/r_world.h
@@ -104,7 +104,7 @@ void R_MapInitSurfaceLists(void);
 void            R_UpdateSkyFixForSec(const sector_t* sec);
 void            R_OrderVertices(const linedef_t* line, const sector_t* sector,
                                 vertex_t* verts[2]);
-boolean         R_FindBottomTop(linedef_t* lineDef, int side, segsection_t section,
+boolean         R_FindBottomTop(linedef_t* lineDef, int side, sidedefsection_t section,
                                 float matOffsetX, float matOffsetY,
                                 const plane_t* ffloor, const plane_t* fceil,
                                 const plane_t* bfloor, const plane_t* bceil,
diff --git a/doomsday/engine/portable/include/rend_bias.h b/doomsday/engine/portable/include/rend_bias.h
index 4128f9ad87..54287a6202 100644
--- a/doomsday/engine/portable/include/rend_bias.h
+++ b/doomsday/engine/portable/include/rend_bias.h
@@ -97,7 +97,7 @@ void            SB_RendPoly(struct ColorRawf_s* rcolors,
                             const struct rvertex_s* rvertices,
                             size_t numVertices, const vectorcomp_t* normal,
                             float sectorLightLevel,
-                            void* mapObject, uint elmIdx, boolean isSeg);
+                            void* mapObject, uint elmIdx, boolean isHEdge);
 void            SB_EndFrame(void);
 
 int             SB_NewSourceAt(float x, float y, float z, float size, float minLight,
diff --git a/doomsday/engine/portable/include/rend_fakeradio.h b/doomsday/engine/portable/include/rend_fakeradio.h
index 6399c0306b..1ee6b6ac8b 100644
--- a/doomsday/engine/portable/include/rend_fakeradio.h
+++ b/doomsday/engine/portable/include/rend_fakeradio.h
@@ -48,7 +48,7 @@ float Rend_RadioCalcShadowDarkness(float lightLevel);
 void Rend_RadioUpdateLinedef(linedef_t* line, boolean backSide);
 
 /**
- * Render FakeRadio for the given seg section.
+ * Render FakeRadio for the given hedge section.
  */
 void Rend_RadioSegSection(const rvertex_t* rvertices, const walldiv_t* divs,
     const rendsegradio_params_t* params);
diff --git a/doomsday/engine/portable/src/bsp_edge.c b/doomsday/engine/portable/src/bsp_edge.c
index 093b31ae6d..3633062642 100644
--- a/doomsday/engine/portable/src/bsp_edge.c
+++ b/doomsday/engine/portable/src/bsp_edge.c
@@ -266,7 +266,7 @@ Con_Message("Splitting hEdge->twin %p\n", oldHEdge->twin);
 
         newHEdge->twin = allocHEdge();
 
-        // Copy seg info.
+        // Copy hedge info.
         memcpy(newHEdge->twin, oldHEdge->twin, sizeof(bsp_hedge_t));
 
         // It is important to keep the twin relationship valid.
diff --git a/doomsday/engine/portable/src/bsp_main.c b/doomsday/engine/portable/src/bsp_main.c
index b8e57fedc0..1d63e4afd6 100644
--- a/doomsday/engine/portable/src/bsp_main.c
+++ b/doomsday/engine/portable/src/bsp_main.c
@@ -319,9 +319,9 @@ boolean BSP_Build(gamemap_t* map, vertex_t*** vertexes, uint* numVertexes)
         else
             rHeight = lHeight = 0;
 
-        VERBOSE( Con_Printf("BSP built: %d Nodes, %d Subsectors, %d Segs, %d Vertexes\n"
+        VERBOSE( Con_Printf("BSP built: %d Nodes, %d Subsectors, %d HEdges, %d Vertexes\n"
                    "  Balance %+ld (l%ld - r%ld).\n",
-                   map->numNodes, map->numSSectors, map->numSegs, map->numVertexes,
+                   map->numNodes, map->numSSectors, map->numHEdges, map->numVertexes,
                    lHeight - rHeight, lHeight, rHeight) )
     }
 
diff --git a/doomsday/engine/portable/src/bsp_map.c b/doomsday/engine/portable/src/bsp_map.c
index f57629efff..d62e09daf5 100644
--- a/doomsday/engine/portable/src/bsp_map.c
+++ b/doomsday/engine/portable/src/bsp_map.c
@@ -52,8 +52,8 @@
 
 // CODE --------------------------------------------------------------------
 
-static void hardenSideSegList(gamemap_t* map, sidedef_t* side, seg_t* seg,
-                              bsp_hedge_t* hEdge)
+static void hardenSidedefHEdgeList(gamemap_t* map, sidedef_t* side, HEdge* hedge,
+    bsp_hedge_t* bspHEdge)
 {
     uint count;
     bsp_hedge_t* first, *other;
@@ -62,15 +62,15 @@ static void hardenSideSegList(gamemap_t* map, sidedef_t* side, seg_t* seg,
         return;
 
     // Have we already processed this side?
-    if(side->segs)
+    if(side->hedges)
         return;
 
-    // Find the first seg.
-    first = hEdge;
+    // Find the first hedge.
+    first = bspHEdge;
     while(first->prevOnSide)
         first = first->prevOnSide;
 
-    // Count the segs for this side.
+    // Count the hedges for this side.
     count = 0;
     other = first;
     while(other)
@@ -79,19 +79,19 @@ static void hardenSideSegList(gamemap_t* map, sidedef_t* side, seg_t* seg,
         count++;
     }
 
-    // Allocate the final side seg table.
-    side->segCount = count;
-    side->segs =
-        Z_Malloc(sizeof(seg_t*) * (side->segCount + 1), PU_MAPSTATIC, 0);
+    // Allocate the final side hedge table.
+    side->hedgeCount = count;
+    side->hedges =
+        Z_Malloc(sizeof(HEdge*) * (side->hedgeCount + 1), PU_MAPSTATIC, 0);
 
     count = 0;
     other = first;
     while(other)
     {
-        side->segs[count++] = &map->segs[other->index];
+        side->hedges[count++] = &map->hedges[other->index];
         other = other->nextOnSide;
     }
-    side->segs[count] = NULL; // Terminate.
+    side->hedges[count] = NULL; // Terminate.
 }
 
 static int C_DECL hEdgeCompare(const void* p1, const void* p2)
@@ -139,7 +139,7 @@ static boolean hEdgeCollector(binarytree_t* tree, void* data)
     return true; // Continue traversal.
 }
 
-static void buildSegsFromHEdges(gamemap_t* dest, binarytree_t* rootNode)
+static void buildHEdgesFromBSPHEdges(gamemap_t* dest, binarytree_t* rootNode)
 {
     uint i;
     bsp_hedge_t** index;
@@ -155,7 +155,7 @@ static void buildSegsFromHEdges(gamemap_t* dest, binarytree_t* rootNode)
     BinaryTree_InOrder(rootNode, hEdgeCollector, &params);
 
     if(!(params.curIdx > 0))
-        Con_Error("buildSegsFromHEdges: No halfedges?");
+        Con_Error("buildHEdgesFromBSPHEdges: No hedges?");
 
     // Allocate the sort buffer.
     index = M_Malloc(sizeof(bsp_hedge_t*) * params.curIdx);
@@ -168,76 +168,76 @@ static void buildSegsFromHEdges(gamemap_t* dest, binarytree_t* rootNode)
     // Sort the half-edges into ascending index order.
     qsort(index, params.curIdx, sizeof(bsp_hedge_t*), hEdgeCompare);
 
-    dest->numSegs = (uint) params.curIdx;
-    dest->segs = Z_Calloc(dest->numSegs * sizeof(seg_t), PU_MAPSTATIC, 0);
-    for(i = 0; i < dest->numSegs; ++i)
+    dest->numHEdges = (uint) params.curIdx;
+    dest->hedges = Z_Calloc(dest->numHEdges * sizeof(HEdge), PU_MAPSTATIC, 0);
+    for(i = 0; i < dest->numHEdges; ++i)
     {
-        seg_t* seg = &dest->segs[i];
-        bsp_hedge_t* hEdge = index[i];
+        HEdge* hedge = &dest->hedges[i];
+        bsp_hedge_t* bspHEdge = index[i];
 
-        seg->header.type = DMU_SEG;
+        hedge->header.type = DMU_HEDGE;
 
-        seg->SG_v1 = &dest->vertexes[hEdge->v[0]->buildData.index - 1];
-        seg->SG_v2 = &dest->vertexes[hEdge->v[1]->buildData.index - 1];
+        hedge->HE_v1 = &dest->vertexes[bspHEdge->v[0]->buildData.index - 1];
+        hedge->HE_v2 = &dest->vertexes[bspHEdge->v[1]->buildData.index - 1];
 
-        seg->side  = hEdge->side;
-        if(hEdge->lineDef)
-            seg->lineDef = &dest->lineDefs[hEdge->lineDef->buildData.index - 1];
-        if(hEdge->twin)
-            seg->backSeg = &dest->segs[hEdge->twin->index];
+        hedge->side  = bspHEdge->side;
+        if(bspHEdge->lineDef)
+            hedge->lineDef = &dest->lineDefs[bspHEdge->lineDef->buildData.index - 1];
+        if(bspHEdge->twin)
+            hedge->twin = &dest->hedges[bspHEdge->twin->index];
 
-        seg->flags = 0;
-        if(seg->lineDef)
+        hedge->flags = 0;
+        if(hedge->lineDef)
         {
-            linedef_t*          ldef = seg->lineDef;
-            vertex_t*           vtx = seg->lineDef->L_v(seg->side);
+            linedef_t*          ldef = hedge->lineDef;
+            vertex_t*           vtx = hedge->lineDef->L_v(hedge->side);
 
-            if(ldef->L_side(seg->side))
-                seg->SG_frontsector = ldef->L_side(seg->side)->sector;
+            if(ldef->L_side(hedge->side))
+                hedge->HE_frontsector = ldef->L_side(hedge->side)->sector;
 
             if(ldef->L_frontside && ldef->L_backside)
             {
-                seg->SG_backsector = ldef->L_side(seg->side ^ 1)->sector;
+                hedge->HE_backsector = ldef->L_side(hedge->side ^ 1)->sector;
             }
             else
             {
-                seg->SG_backsector = 0;
+                hedge->HE_backsector = 0;
             }
 
-            seg->offset = P_AccurateDistance(seg->SG_v1pos[VX] - vtx->V_pos[VX],
-                                             seg->SG_v1pos[VY] - vtx->V_pos[VY]);
+            hedge->offset = P_AccurateDistance(hedge->HE_v1pos[VX] - vtx->V_pos[VX],
+                                             hedge->HE_v1pos[VY] - vtx->V_pos[VY]);
         }
         else
         {
-            seg->lineDef = NULL;
-            seg->SG_frontsector = NULL;
-            seg->SG_backsector = NULL;
+            hedge->lineDef = NULL;
+            hedge->HE_frontsector = NULL;
+            hedge->HE_backsector = NULL;
         }
 
-        if(seg->lineDef)
-            hardenSideSegList(dest, SEG_SIDEDEF(seg), seg, hEdge);
+        if(hedge->lineDef)
+            hardenSidedefHEdgeList(dest, HEDGE_SIDEDEF(hedge), hedge, bspHEdge);
 
-        seg->angle =
-            bamsAtan2((int) (seg->SG_v2pos[VY] - seg->SG_v1pos[VY]),
-                      (int) (seg->SG_v2pos[VX] - seg->SG_v1pos[VX])) << FRACBITS;
+        hedge->angle =
+            bamsAtan2((int) (hedge->HE_v2pos[VY] - hedge->HE_v1pos[VY]),
+                      (int) (hedge->HE_v2pos[VX] - hedge->HE_v1pos[VX])) << FRACBITS;
 
         // Calculate the length of the segment. We need this for
         // the texture coordinates. -jk
-        seg->length = P_AccurateDistance(seg->SG_v2pos[VX] - seg->SG_v1pos[VX],
-                                         seg->SG_v2pos[VY] - seg->SG_v1pos[VY]);
+        hedge->length = P_AccurateDistance(hedge->HE_v2pos[VX] - hedge->HE_v1pos[VX],
+                                         hedge->HE_v2pos[VY] - hedge->HE_v1pos[VY]);
 
-        if(seg->length == 0)
-            seg->length = 0.01f; // Hmm...
+        if(hedge->length == 0)
+            hedge->length = 0.01f; // Hmm...
 
         // Calculate the tangent space surface vectors.
         // Front first
-        if(seg->lineDef && SEG_SIDEDEF(seg))
+        if(hedge->lineDef && HEDGE_SIDEDEF(hedge))
         {
-            sidedef_t* side = SEG_SIDEDEF(seg);
+            sidedef_t* side = HEDGE_SIDEDEF(hedge);
             surface_t* surface = &side->SW_topsurface;
 
-            surface->normal[VY] = (seg->SG_v1pos[VX] - seg->SG_v2pos[VX]) / seg->length;
-            surface->normal[VX] = (seg->SG_v2pos[VY] - seg->SG_v1pos[VY]) / seg->length;
+            surface->normal[VY] = (hedge->HE_v1pos[VX] - hedge->HE_v2pos[VX]) / hedge->length;
+            surface->normal[VX] = (hedge->HE_v2pos[VY] - hedge->HE_v1pos[VY]) / hedge->length;
             surface->normal[VZ] = 0;
             V3_BuildTangents(surface->tangent, surface->bitangent, surface->normal);
 
@@ -256,29 +256,29 @@ static void buildSegsFromHEdges(gamemap_t* dest, binarytree_t* rootNode)
     M_Free(index);
 }
 
-static void hardenSSecSegList(gamemap_t* dest, subsector_t* ssec,
-                              bsp_hedge_t* list, size_t segCount)
+static void hardenSubsectorHEdgeList(gamemap_t* dest, subsector_t* ssec,
+                              bsp_hedge_t* list, size_t hedgeCount)
 {
     size_t i;
     bsp_hedge_t* cur;
-    seg_t** segs;
+    HEdge** hedges;
 
-    segs = Z_Malloc(sizeof(seg_t*) * (segCount + 1), PU_MAPSTATIC, 0);
+    hedges = Z_Malloc(sizeof(HEdge*) * (hedgeCount + 1), PU_MAPSTATIC, 0);
 
     for(cur = list, i = 0; cur; cur = cur->next, ++i)
-        segs[i] = &dest->segs[cur->index];
-    segs[segCount] = NULL; // Terminate.
+        hedges[i] = &dest->hedges[cur->index];
+    hedges[hedgeCount] = NULL; // Terminate.
 
-    if(i != segCount)
-        Con_Error("hardenSSecSegList: Miscounted?");
+    if(i != hedgeCount)
+        Con_Error("hardenSubsectorHEdgeList: Miscounted?");
 
-    ssec->segs = segs;
+    ssec->hedges = hedges;
 }
 
 static void hardenLeaf(gamemap_t* map, subsector_t* dest,
                        const bspleafdata_t* src)
 {
-    seg_t** segp;
+    HEdge** segp;
     boolean found;
     size_t hEdgeCount;
     bsp_hedge_t* hEdge;
@@ -291,25 +291,25 @@ static void hardenLeaf(gamemap_t* map, subsector_t* dest,
     } while((hEdge = hEdge->next) != NULL);
 
     dest->header.type = DMU_SUBSECTOR;
-    dest->segCount = (uint) hEdgeCount;
+    dest->hedgeCount = (uint) hEdgeCount;
     dest->shadows = NULL;
     dest->vertices = NULL;
 
-    hardenSSecSegList(map, dest, src->hEdges, hEdgeCount);
+    hardenSubsectorHEdgeList(map, dest, src->hEdges, hEdgeCount);
 
     // Determine which sector this subsector belongs to.
-    segp = dest->segs;
+    segp = dest->hedges;
     found = false;
     while(*segp)
     {
-        seg_t* seg = *segp;
-        if(!found && seg->lineDef && SEG_SIDEDEF(seg))
+        HEdge* hedge = *segp;
+        if(!found && hedge->lineDef && HEDGE_SIDEDEF(hedge))
         {
-            sidedef_t* side = SEG_SIDEDEF(seg);
+            sidedef_t* side = HEDGE_SIDEDEF(hedge);
             dest->sector = side->sector;
             found = true;
         }
-        seg->subsector = dest;
+        hedge->subsector = dest;
         segp++;
     }
 
@@ -521,7 +521,7 @@ void SaveMap(gamemap_t* dest, void* rootNode, vertex_t*** vertexes,
 
     hardenVertexes(dest, vertexes, numVertexes);
     updateVertexLinks(dest);
-    buildSegsFromHEdges(dest, rn);
+    buildHEdgesFromBSPHEdges(dest, rn);
     hardenBSP(dest, rn);
 
     // How much time did we spend?
diff --git a/doomsday/engine/portable/src/bsp_node.c b/doomsday/engine/portable/src/bsp_node.c
index 1099932e77..f819727c42 100644
--- a/doomsday/engine/portable/src/bsp_node.c
+++ b/doomsday/engine/portable/src/bsp_node.c
@@ -138,8 +138,8 @@ void BSP_AddHEdgeToSuperBlock(superblock_t *block, bsp_hedge_t *hEdge)
             return;
         }
 
-        // The seg lies in one half of this block. Create the block if it
-        // doesn't already exist, and loop back to add the seg.
+        // The hedge lies in one half of this block. Create the block if it
+        // doesn't already exist, and loop back to add the hedge.
         if(!block->subs[child])
         {
             block->subs[child] = sub = BSP_SuperBlockCreate();
diff --git a/doomsday/engine/portable/src/bsp_superblock.c b/doomsday/engine/portable/src/bsp_superblock.c
index 8f9e4560d0..eec5fe5925 100644
--- a/doomsday/engine/portable/src/bsp_superblock.c
+++ b/doomsday/engine/portable/src/bsp_superblock.c
@@ -261,7 +261,7 @@ void BSP_DivideOneHEdge(bsp_hedge_t* cur, const bspartition_t* part,
         makeIntersection(cutList, cur->v[0], part, selfRef);
         makeIntersection(cutList, cur->v[1], part, selfRef);
 
-        // This seg runs along the same line as the partition. Check
+        // This hedge runs along the same line as the partition. Check
         // whether it goes in the same direction or the opposite.
         if(cur->pDX * part->pDX + cur->pDY * part->pDY < 0)
         {
@@ -588,7 +588,7 @@ static int evalPartition(const superblock_t* hEdgeList, bsp_hedge_t* part,
     if(evalPartitionWorker(hEdgeList, part, bestCost, &info))
         return -1;
 
-    // Make sure there is at least one real seg on each side.
+    // Make sure there is at least one real hedge on each side.
     if(!info.realLeft || !info.realRight)
     {
 /*#if _DEBUG
@@ -636,7 +636,7 @@ static boolean pickHEdgeWorker(const superblock_t* partList,
     for(part = partList->hEdges; part; part = part->next)
     {
 /*#if _DEBUG
-Con_Message("BSP_PickHEdge: %sSEG %p sector=%d  (%1.1f,%1.1f) -> "
+Con_Message("BSP_PickHEdge: %sHEdge %p sector=%d  (%1.1f,%1.1f) -> "
             "(%1.1f,%1.1f)\n", (part->lineDef? "" : "MINI"), part,
             (part->sector? part->sector->index : -1),
             part->v[0]->V_pos[VX], part->v[0]->V_pos[VY],
diff --git a/doomsday/engine/portable/src/dam_file.c b/doomsday/engine/portable/src/dam_file.c
index 447c15e845..da307e4371 100644
--- a/doomsday/engine/portable/src/dam_file.c
+++ b/doomsday/engine/portable/src/dam_file.c
@@ -66,7 +66,7 @@ typedef enum damsegment_e {
     DAMSEG_SIDES,
     DAMSEG_SECTORS,
     DAMSEG_SSECTORS,
-    DAMSEG_SEGS,
+    DAMSEG_HEDGES,
     DAMSEG_NODES,
     DAMSEG_BLOCKMAP,
     DAMSEG_REJECT
@@ -465,9 +465,9 @@ static void writeSide(const gamemap_t *map, uint idx)
     }
     writeLong(s->sector? ((s->sector - map->sectors) + 1) : 0);
     writeShort(s->flags);
-    writeLong((long) s->segCount);
-    for(i = 0; i < s->segCount; ++i)
-        writeLong((s->segs[i] - map->segs) + 1);
+    writeLong((long) s->hedgeCount);
+    for(i = 0; i < s->hedgeCount; ++i)
+        writeLong((s->hedges[i] - map->hedges) + 1);
 }
 
 static void readSide(const gamemap_t *map, uint idx)
@@ -501,11 +501,11 @@ static void readSide(const gamemap_t *map, uint idx)
     secIdx = readLong();
     s->sector = (secIdx == 0? NULL : &map->sectors[secIdx -1]);
     s->flags = readShort();
-    s->segCount = (uint) readLong();
-    s->segs = Z_Malloc(sizeof(seg_t*) * (s->segCount + 1), PU_MAP, 0);
-    for(i = 0; i < s->segCount; ++i)
-        s->segs[i] = &map->segs[(unsigned) readLong() - 1];
-    s->segs[i] = NULL; // Terminate.
+    s->hedgeCount = (uint) readLong();
+    s->hedges = Z_Malloc(sizeof(HEdge*) * (s->hedgeCount + 1), PU_MAP, 0);
+    for(i = 0; i < s->hedgeCount; ++i)
+        s->hedges[i] = &map->hedges[(unsigned) readLong() - 1];
+    s->hedges[i] = NULL; // Terminate.
 }
 
 static void archiveSides(gamemap_t *map, boolean write)
@@ -745,10 +745,10 @@ static void writeSubsector(const gamemap_t *map, uint idx)
     for(i = 0; i < NUM_REVERB_DATA; ++i)
         writeLong((long) s->reverb[i]);
 
-    // Subsector segs list.
-    writeLong((long) s->segCount);
-    for(i = 0; i < s->segCount; ++i)
-        writeLong((s->segs[i] - map->segs) + 1);
+    // Subsector hedges list.
+    writeLong((long) s->hedgeCount);
+    for(i = 0; i < s->hedgeCount; ++i)
+        writeLong((s->hedges[i] - map->hedges) + 1);
 }
 
 static void readSubsector(const gamemap_t *map, uint idx)
@@ -773,12 +773,12 @@ static void readSubsector(const gamemap_t *map, uint idx)
     for(i = 0; i < NUM_REVERB_DATA; ++i)
         s->reverb[i] = (uint) readLong();
 
-    // Subsector segs list.
-    s->segCount = (uint) readLong();
-    s->segs = Z_Malloc(sizeof(seg_t*) * (s->segCount + 1), PU_MAP, 0);
-    for(i = 0; i < s->segCount; ++i)
-        s->segs[i] = &map->segs[(unsigned) readLong() - 1];
-    s->segs[i] = NULL; // Terminate.
+    // Subsector hedges list.
+    s->hedgeCount = (uint) readLong();
+    s->hedges = Z_Malloc(sizeof(HEdge*) * (s->hedgeCount + 1), PU_MAP, 0);
+    for(i = 0; i < s->hedgeCount; ++i)
+        s->hedges[i] = &map->hedges[(unsigned) readLong() - 1];
+    s->hedges[i] = NULL; // Terminate.
 }
 
 static void archiveSubsectors(gamemap_t *map, boolean write)
@@ -811,7 +811,7 @@ static void archiveSubsectors(gamemap_t *map, boolean write)
 
 static void writeSeg(const gamemap_t *map, uint idx)
 {
-    seg_t              *s = &map->segs[idx];
+    HEdge              *s = &map->hedges[idx];
 
     writeLong((s->v[0] - map->vertexes) + 1);
     writeLong((s->v[1] - map->vertexes) + 1);
@@ -821,7 +821,7 @@ static void writeSeg(const gamemap_t *map, uint idx)
     writeLong(s->sec[FRONT]? ((s->sec[FRONT] - map->sectors) + 1) : 0);
     writeLong(s->sec[BACK]? ((s->sec[BACK] - map->sectors) + 1) : 0);
     writeLong(s->subsector? ((s->subsector - map->ssectors) + 1) : 0);
-    writeLong(s->backSeg? ((s->backSeg - map->segs) + 1) : 0);
+    writeLong(s->twin? ((s->twin - map->hedges) + 1) : 0);
     writeLong((long) s->angle);
     writeByte(s->side);
     writeByte(s->flags);
@@ -830,7 +830,7 @@ static void writeSeg(const gamemap_t *map, uint idx)
 static void readSeg(const gamemap_t *map, uint idx)
 {
     long                obIdx;
-    seg_t              *s = &map->segs[idx];
+    HEdge              *s = &map->hedges[idx];
 
     s->v[0] = &map->vertexes[(unsigned) readLong() - 1];
     s->v[1] = &map->vertexes[(unsigned) readLong() - 1];
@@ -845,7 +845,7 @@ static void readSeg(const gamemap_t *map, uint idx)
     obIdx = readLong();
     s->subsector = (obIdx == 0? NULL : &map->ssectors[(unsigned) obIdx - 1]);
     obIdx = readLong();
-    s->backSeg = (obIdx == 0? NULL : &map->segs[(unsigned) obIdx - 1]);
+    s->twin = (obIdx == 0? NULL : &map->hedges[(unsigned) obIdx - 1]);
     s->angle = (angle_t) readLong();
     s->side = readByte();
     s->flags = readByte();
@@ -856,20 +856,20 @@ static void archiveSegs(gamemap_t *map, boolean write)
     uint                i;
 
     if(write)
-        beginSegment(DAMSEG_SEGS);
+        beginSegment(DAMSEG_HEDGES);
     else
-        assertSegment(DAMSEG_SEGS);
+        assertSegment(DAMSEG_HEDGES);
 
     if(write)
     {
-        writeLong(map->numSegs);
-        for(i = 0; i < map->numSegs; ++i)
+        writeLong(map->numHEdges);
+        for(i = 0; i < map->numHEdges; ++i)
             writeSeg(map, i);
     }
     else
     {
-        map->numSegs = readLong();
-        for(i = 0; i < map->numSegs; ++i)
+        map->numHEdges = readLong();
+        for(i = 0; i < map->numHEdges; ++i)
             readSeg(map, i);
     }
 
@@ -996,10 +996,10 @@ static void writePolyobj(const gamemap_t *map, uint idx)
     writeByte(p->crush? 1 : 0);
     writeLong((long) p->seqType);
 
-    writeLong((long) p->numSegs);
-    for(i = 0; i < p->numSegs; ++i)
+    writeLong((long) p->numHEdges);
+    for(i = 0; i < p->numHEdges; ++i)
     {
-        seg_t              *s = p->segs[i];
+        HEdge              *s = p->hedges[i];
 
         writeLong((s->v[0] - map->vertexes) + 1);
         writeLong((s->v[1] - map->vertexes) + 1);
@@ -1037,12 +1037,12 @@ static void readPolyobj(const gamemap_t *map, uint idx)
     p->crush = (readByte()? true : false);
     p->seqType = (int) readLong();
 
-    // Polyobj seg list.
-    p->numSegs = (uint) readLong();
-    p->segs = Z_Malloc(sizeof(seg_t*) * (p->numSegs + 1), PU_MAP, 0);
-    for(i = 0; i < p->numSegs; ++i)
+    // Polyobj hedge list.
+    p->numHEdges = (uint) readLong();
+    p->hedges = Z_Malloc(sizeof(HEdge*) * (p->numHEdges + 1), PU_MAP, 0);
+    for(i = 0; i < p->numHEdges; ++i)
     {
-        seg_t              *s =
+        HEdge              *s =
             Z_Calloc(sizeof(*s), PU_MAP, 0);
 
         s->v[0] = &map->vertexes[(unsigned) readLong() - 1];
@@ -1057,9 +1057,9 @@ static void readPolyobj(const gamemap_t *map, uint idx)
         s->side = (readByte()? 1 : 0);
         s->flags = readByte();
 
-        p->segs[i] = s;
+        p->hedges[i] = s;
     }
-    p->segs[i] = NULL; // Terminate.
+    p->hedges[i] = NULL; // Terminate.
 }
 
 static void archivePolyobjs(gamemap_t *map, boolean write)
diff --git a/doomsday/engine/portable/src/dd_main.c b/doomsday/engine/portable/src/dd_main.c
index 2c90ea2ba6..6e3af8479f 100644
--- a/doomsday/engine/portable/src/dd_main.c
+++ b/doomsday/engine/portable/src/dd_main.c
@@ -2102,8 +2102,8 @@ void* DD_GetVariable(int ddvalue)
     case DD_POLYOBJ_COUNT:
         return &numPolyObjs;
 
-    case DD_SEG_COUNT:
-        return &numSegs;
+    case DD_HEDGE_COUNT:
+        return &numHEdges;
 
     case DD_SUBSECTOR_COUNT:
         return &numSSectors;
diff --git a/doomsday/engine/portable/src/edit_map.c b/doomsday/engine/portable/src/edit_map.c
index 4522d8b869..00b7b7d491 100644
--- a/doomsday/engine/portable/src/edit_map.c
+++ b/doomsday/engine/portable/src/edit_map.c
@@ -861,7 +861,7 @@ static void finishLineDefs(gamemap_t* map)
     uint                i;
     linedef_t          *ld;
     vertex_t           *v[2];
-    seg_t              *startSeg, *endSeg;
+    HEdge              *startSeg, *endSeg;
 
     VERBOSE2( Con_Message("Finalizing Linedefs...\n") )
 
@@ -869,13 +869,13 @@ static void finishLineDefs(gamemap_t* map)
     {
         ld = &map->lineDefs[i];
 
-        if(!ld->sideDefs[0]->segCount)
+        if(!ld->sideDefs[0]->hedgeCount)
             continue;
 
-        startSeg = ld->sideDefs[0]->segs[0];
-        endSeg = ld->sideDefs[0]->segs[ld->sideDefs[0]->segCount - 1];
-        ld->v[0] = v[0] = startSeg->SG_v1;
-        ld->v[1] = v[1] = endSeg->SG_v2;
+        startSeg = ld->sideDefs[0]->hedges[0];
+        endSeg = ld->sideDefs[0]->hedges[ld->sideDefs[0]->hedgeCount - 1];
+        ld->v[0] = v[0] = startSeg->HE_v1;
+        ld->v[1] = v[1] = endSeg->HE_v2;
         ld->dX = v[1]->V_pos[VX] - v[0]->V_pos[VX];
         ld->dY = v[1]->V_pos[VY] - v[0]->V_pos[VY];
 
@@ -947,19 +947,19 @@ static void updateMapBounds(gamemap_t* map)
 
 static void updateSSecMidPoint(subsector_t *sub)
 {
-    seg_t             **ptr;
+    HEdge             **ptr;
     fvertex_t          *vtx;
 
     // Find the center point. First calculate the bounding box.
-    ptr = sub->segs;
-    vtx = &((*ptr)->SG_v1->v);
+    ptr = sub->hedges;
+    vtx = &((*ptr)->HE_v1->v);
     sub->aaBox.minX = sub->aaBox.maxX = sub->midPoint.pos[VX] = vtx->pos[VX];
     sub->aaBox.minY = sub->aaBox.maxY = sub->midPoint.pos[VY] = vtx->pos[VY];
 
     ptr++;
     while(*ptr)
     {
-        vtx = &((*ptr)->SG_v1->v);
+        vtx = &((*ptr)->HE_v1->v);
         if(vtx->pos[VX] < sub->aaBox.minX)
             sub->aaBox.minX = vtx->pos[VX];
         if(vtx->pos[VY] < sub->aaBox.minY)
@@ -974,8 +974,8 @@ static void updateSSecMidPoint(subsector_t *sub)
         ptr++;
     }
 
-    sub->midPoint.pos[VX] /= sub->segCount; // num vertices.
-    sub->midPoint.pos[VY] /= sub->segCount;
+    sub->midPoint.pos[VX] /= sub->hedgeCount; // num vertices.
+    sub->midPoint.pos[VY] /= sub->hedgeCount;
 
     // Calculate the worldwide grid offset.
     sub->worldGridOffset[VX] = fmod(sub->aaBox.minX, 64);
@@ -1390,7 +1390,7 @@ static void hardenPolyobjs(gamemap_t* dest, editmap_t* src)
     {
         uint                j;
         polyobj_t*          destP, *srcP = src->polyObjs[i];
-        seg_t*              segs;
+        HEdge*              hedges;
 
         destP = Z_Calloc(POLYOBJ_SIZE, PU_MAP, 0);
         destP->idx = i;
@@ -1400,40 +1400,40 @@ static void hardenPolyobjs(gamemap_t* dest, editmap_t* src)
         destP->pos[VX] = srcP->pos[VX];
         destP->pos[VY] = srcP->pos[VY];
 
-        destP->numSegs = srcP->buildData.lineCount;
+        destP->numHEdges = srcP->buildData.lineCount;
 
         destP->originalPts =
-            Z_Malloc(destP->numSegs * sizeof(fvertex_t), PU_MAP, 0);
+            Z_Malloc(destP->numHEdges * sizeof(fvertex_t), PU_MAP, 0);
         destP->prevPts =
-            Z_Malloc(destP->numSegs * sizeof(fvertex_t), PU_MAP, 0);
+            Z_Malloc(destP->numHEdges * sizeof(fvertex_t), PU_MAP, 0);
 
-        // Create a seg for each line of this polyobj.
-        segs = Z_Calloc(sizeof(seg_t) * destP->numSegs, PU_MAP, 0);
-        destP->segs = Z_Malloc(sizeof(seg_t*) * (destP->numSegs+1), PU_MAP, 0);
-        for(j = 0; j < destP->numSegs; ++j)
+        // Create a hedge for each line of this polyobj.
+        hedges = Z_Calloc(sizeof(HEdge) * destP->numHEdges, PU_MAP, 0);
+        destP->hedges = Z_Malloc(sizeof(HEdge*) * (destP->numHEdges+1), PU_MAP, 0);
+        for(j = 0; j < destP->numHEdges; ++j)
         {
             linedef_t*          line =
                 &dest->lineDefs[srcP->buildData.lineDefs[j]->buildData.index - 1];
-            seg_t*              seg = &segs[j];
+            HEdge*              hedge = &hedges[j];
             float               dx, dy;
 
             // This line is part of a polyobj.
             line->inFlags |= LF_POLYOBJ;
 
-            seg->header.type = DMU_SEG;
-            seg->lineDef = line;
+            hedge->header.type = DMU_HEDGE;
+            hedge->lineDef = line;
             dx = line->L_v2pos[VX] - line->L_v1pos[VX];
             dy = line->L_v2pos[VY] - line->L_v1pos[VY];
-            seg->length = P_AccurateDistance(dx, dy);
-            seg->backSeg = NULL;
-            seg->subsector = NULL;
-            seg->SG_frontsector = line->L_frontsector;
-            seg->SG_backsector = NULL;
-            seg->flags |= SEGF_POLYOBJ;
-
-            destP->segs[j] = seg;
+            hedge->length = P_AccurateDistance(dx, dy);
+            hedge->twin = NULL;
+            hedge->subsector = NULL;
+            hedge->HE_frontsector = line->L_frontsector;
+            hedge->HE_backsector = NULL;
+            hedge->flags |= HEDGEF_POLYOBJ;
+
+            destP->hedges[j] = hedge;
         }
-        destP->segs[j] = NULL; // Terminate.
+        destP->hedges[j] = NULL; // Terminate.
 
         // Add this polyobj to the global list.
         dest->polyObjs[i] = destP;
@@ -1863,22 +1863,22 @@ boolean MPE_End(void)
     for(i = 0; i < gamemap->numPolyObjs; ++i)
     {
         polyobj_t* po = gamemap->polyObjs[i];
-        seg_t** segPtr;
+        HEdge** segPtr;
         size_t n;
 
-        segPtr = po->segs;
+        segPtr = po->hedges;
         n = 0;
         while(*segPtr)
         {
-            seg_t* seg = *segPtr;
+            HEdge* hedge = *segPtr;
 
-            seg->SG_v1 = seg->lineDef->L_v1;
-            seg->SG_v2 = seg->lineDef->L_v2;
+            hedge->HE_v1 = hedge->lineDef->L_v1;
+            hedge->HE_v2 = hedge->lineDef->L_v2;
 
             // The original Pts are based off the anchor Pt, and are unique
-            // to each seg, not each linedef.
-            po->originalPts[n].pos[VX] = seg->SG_v1pos[VX] - po->pos[VX];
-            po->originalPts[n].pos[VY] = seg->SG_v1pos[VY] - po->pos[VY];
+            // to each hedge, not each linedef.
+            po->originalPts[n].pos[VX] = hedge->HE_v1pos[VX] - po->pos[VX];
+            po->originalPts[n].pos[VY] = hedge->HE_v1pos[VY] - po->pos[VY];
 
             segPtr++;
             n++;
diff --git a/doomsday/engine/portable/src/p_bmap.c b/doomsday/engine/portable/src/p_bmap.c
index 84ea0cee95..081c783f74 100644
--- a/doomsday/engine/portable/src/p_bmap.c
+++ b/doomsday/engine/portable/src/p_bmap.c
@@ -861,15 +861,15 @@ static int rendSubsector(subsector_t* ssec, void* paramaters)
     const float scale = MAX_OF(bmapDebugSize, 1);
     const float width = (theWindow->geometry.size.width / 16) / scale;
     float length, dx, dy, normal[2], unit[2];
-    seg_t** segIter, *seg;
+    HEdge** hedgeIter, *hedge;
     vec2_t start, end;
 
-    for(segIter = ssec->segs; *segIter; segIter++)
+    for(hedgeIter = ssec->hedges; *hedgeIter; hedgeIter++)
     {
-        seg = *segIter;
+        hedge = *hedgeIter;
 
-        V2_Set(start, seg->SG_v1pos[VX], seg->SG_v1pos[VY]);
-        V2_Set(end,   seg->SG_v2pos[VX], seg->SG_v2pos[VY]);
+        V2_Set(start, hedge->HE_v1pos[VX], hedge->HE_v1pos[VY]);
+        V2_Set(end,   hedge->HE_v2pos[VX], hedge->HE_v2pos[VY]);
 
         glBegin(GL_LINES);
             glVertex2fv(start);
diff --git a/doomsday/engine/portable/src/p_data.c b/doomsday/engine/portable/src/p_data.c
index 74b8c76785..ca2ff39104 100644
--- a/doomsday/engine/portable/src/p_data.c
+++ b/doomsday/engine/portable/src/p_data.c
@@ -74,8 +74,8 @@ Uri* mapUri; // Name by which the game referred to the current map.
 uint numVertexes = 0;
 vertex_t* vertexes = NULL;
 
-uint numSegs = 0;
-seg_t* segs = NULL;
+uint numHEdges = 0;
+HEdge* hedges = NULL;
 
 uint numSectors = 0;
 sector_t* sectors = NULL;
@@ -118,18 +118,18 @@ static gamemapobjdef_t* gameMapObjDefs;
 
 void P_PolyobjChanged(polyobj_t* po)
 {
-    seg_t** segIter = po->segs;
+    HEdge** hedgeIter = po->hedges;
     uint i;
 
-    for(i = 0; i < po->numSegs; ++i, segIter++)
+    for(i = 0; i < po->numHEdges; ++i, hedgeIter++)
     {
-        seg_t* seg = *segIter;
+        HEdge* hedge = *hedgeIter;
         int j;
 
         // Shadow bias must be told.
         for(j = 0; j < 3; ++j)
         {
-            SB_SurfaceMoved(seg->bsuf[j]);
+            SB_SurfaceMoved(hedge->bsuf[j]);
         }
     }
 }
@@ -181,8 +181,8 @@ void P_SetCurrentMap(gamemap_t* map)
         numVertexes = 0;
         vertexes = 0;
 
-        numSegs = 0;
-        segs = 0;
+        numHEdges = 0;
+        hedges = 0;
 
         numSectors = 0;
         sectors = 0;
@@ -222,8 +222,8 @@ void P_SetCurrentMap(gamemap_t* map)
     numVertexes = map->numVertexes;
     vertexes = map->vertexes;
 
-    numSegs = map->numSegs;
-    segs = map->segs;
+    numHEdges = map->numHEdges;
+    hedges = map->hedges;
 
     numSectors = map->numSectors;
     sectors = map->sectors;
diff --git a/doomsday/engine/portable/src/p_dmu.c b/doomsday/engine/portable/src/p_dmu.c
index 7fcc8e233f..60b727b7c5 100644
--- a/doomsday/engine/portable/src/p_dmu.c
+++ b/doomsday/engine/portable/src/p_dmu.c
@@ -97,7 +97,7 @@ const char* DMU_Str(uint prop)
     {
         { DMU_NONE, "(invalid)" },
         { DMU_VERTEX, "DMU_VERTEX" },
-        { DMU_SEG, "DMU_SEG" },
+        { DMU_HEDGE, "DMU_HEDGE" },
         { DMU_LINEDEF, "DMU_LINEDEF" },
         { DMU_SIDEDEF, "DMU_SIDEDEF" },
         { DMU_NODE, "DMU_NODE" },
@@ -156,7 +156,7 @@ const char* DMU_Str(uint prop)
         { DMU_WIDTH, "DMU_WIDTH" },
         { DMU_HEIGHT, "DMU_HEIGHT" },
         { DMU_TARGET_HEIGHT, "DMU_TARGET_HEIGHT" },
-        { DMU_SEG_COUNT, "DMU_SEG_COUNT" },
+        { DMU_HEDGE_COUNT, "DMU_HEDGE_COUNT" },
         { DMU_SPEED, "DMU_SPEED" },
         { 0, NULL }
     };
@@ -189,7 +189,7 @@ int DMU_GetType(const void* ptr)
     switch(type)
     {
         case DMU_VERTEX:
-        case DMU_SEG:
+        case DMU_HEDGE:
         case DMU_LINEDEF:
         case DMU_SIDEDEF:
         case DMU_SUBSECTOR:
@@ -424,8 +424,8 @@ uint P_ToIndex(const void* ptr)
     case DMU_VERTEX:
         return GET_VERTEX_IDX((vertex_t*) ptr);
 
-    case DMU_SEG:
-        return GET_SEG_IDX((seg_t*) ptr);
+    case DMU_HEDGE:
+        return GET_HEDGE_IDX((HEdge*) ptr);
 
     case DMU_LINEDEF:
         return GET_LINE_IDX((linedef_t*) ptr);
@@ -464,8 +464,8 @@ void* P_ToPtr(int type, uint index)
     case DMU_VERTEX:
         return VERTEX_PTR(index);
 
-    case DMU_SEG:
-        return SEG_PTR(index);
+    case DMU_HEDGE:
+        return HEDGE_PTR(index);
 
     case DMU_LINEDEF:
         return LINE_PTR(index);
@@ -551,14 +551,14 @@ int P_Iteratep(void *ptr, uint prop, void* context, int (*callback) (void* p, vo
     case DMU_SUBSECTOR:
         switch(prop)
         {
-        case DMU_SEG:
+        case DMU_HEDGE:
             {
             subsector_t*        ssec = (subsector_t*) ptr;
             int                 result = false; // Continue iteration.
 
-            if(ssec->segs)
+            if(ssec->hedges)
             {
-                seg_t** segPtr = ssec->segs;
+                HEdge** segPtr = ssec->hedges;
                 while(*segPtr && !(result = callback(*segPtr, context)))
                     segPtr++;
             }
@@ -600,9 +600,9 @@ int P_Callback(int type, uint index, void* context,
             return callback(VERTEX_PTR(index), context);
         break;
 
-    case DMU_SEG:
-        if(index < numSegs)
-            return callback(SEG_PTR(index), context);
+    case DMU_HEDGE:
+        if(index < numHEdges)
+            return callback(HEDGE_PTR(index), context);
         break;
 
     case DMU_LINEDEF:
@@ -671,7 +671,7 @@ int P_Callbackp(int type, void* ptr, void* context,
     switch(type)
     {
     case DMU_VERTEX:
-    case DMU_SEG:
+    case DMU_HEDGE:
     case DMU_LINEDEF:
     case DMU_SIDEDEF:
     case DMU_NODE:
@@ -1081,8 +1081,8 @@ static int setProperty(void* obj, void* context)
         Vertex_SetProperty(obj, args);
         break;
 
-    case DMU_SEG:
-        Seg_SetProperty(obj, args);
+    case DMU_HEDGE:
+        HEdge_SetProperty(obj, args);
         break;
 
     case DMU_LINEDEF:
@@ -1526,8 +1526,8 @@ static int getProperty(void* obj, void* context)
         Vertex_GetProperty(obj, args);
         break;
 
-    case DMU_SEG:
-        Seg_GetProperty(obj, args);
+    case DMU_HEDGE:
+        HEdge_GetProperty(obj, args);
         break;
 
     case DMU_LINEDEF:
diff --git a/doomsday/engine/portable/src/p_objlink.c b/doomsday/engine/portable/src/p_objlink.c
index e86d8f8d72..9f2c37855e 100644
--- a/doomsday/engine/portable/src/p_objlink.c
+++ b/doomsday/engine/portable/src/p_objlink.c
@@ -80,7 +80,7 @@ typedef struct {
     objcontact_t* head[NUM_OBJ_TYPES];
 } objcontactlist_t;
 
-static void processSeg(seg_t* seg, void* data);
+static void processSeg(HEdge* hedge, void* data);
 
 static objlink_t* objlinks = NULL;
 static objlink_t* objlinkFirst = NULL, *objlinkCursor = NULL;
@@ -332,11 +332,11 @@ int RIT_LinkObjToSubsector(subsector_t* subsector, void* paramaters)
  */
 static void spreadInSubsector(subsector_t* ssec, void* paramaters)
 {
-    seg_t** segPtr = ssec->segs;
+    HEdge** segPtr = ssec->hedges;
     while(*segPtr) { processSeg(*segPtr++, paramaters); }
 }
 
-static void processSeg(seg_t* seg, void* paramaters)
+static void processSeg(HEdge* hedge, void* paramaters)
 {
     contactfinderparams_t* p = (contactfinderparams_t*) paramaters;
     linkobjtossecparams_t loParams;
@@ -344,16 +344,16 @@ static void processSeg(seg_t* seg, void* paramaters)
     float distance;
     vertex_t* vtx;
 
-    // Seg must be between two different ssecs.
-    if(seg->lineDef && (!seg->backSeg || seg->subsector == seg->backSeg->subsector))
+    // HEdge must be between two different ssecs.
+    if(hedge->lineDef && (!hedge->twin || hedge->subsector == hedge->twin->subsector))
         return;
 
     // Which way does the spread go?
-    if(seg->subsector->validCount == validCount &&
-       seg->backSeg->subsector->validCount != validCount)
+    if(hedge->subsector->validCount == validCount &&
+       hedge->twin->subsector->validCount != validCount)
     {
-        source = seg->subsector;
-        dest = seg->backSeg->subsector;
+        source = hedge->subsector;
+        dest = hedge->twin->subsector;
     }
     else
     {
@@ -372,7 +372,7 @@ static void processSeg(seg_t* seg, void* paramaters)
     }
 
     // Can the spread happen?
-    if(seg->lineDef)
+    if(hedge->lineDef)
     {
         if(dest->sector)
         {
@@ -387,24 +387,24 @@ static void processSeg(seg_t* seg, void* paramaters)
 
         // Don't spread if the middle material completely fills the gap between
         // floor and ceiling (direction is from dest to source).
-        if(LineDef_MiddleMaterialCoversOpening(seg->lineDef,
-            dest == seg->backSeg->subsector? false : true, false))
+        if(LineDef_MiddleMaterialCoversOpening(hedge->lineDef,
+            dest == hedge->twin->subsector? false : true, false))
             return;
     }
 
-    // Calculate 2D distance to seg.
+    // Calculate 2D distance to hedge.
     {
-    const float dx = seg->SG_v2pos[VX] - seg->SG_v1pos[VX];
-    const float dy = seg->SG_v2pos[VY] - seg->SG_v1pos[VY];
-    vtx = seg->SG_v1;
+    const float dx = hedge->HE_v2pos[VX] - hedge->HE_v1pos[VX];
+    const float dy = hedge->HE_v2pos[VY] - hedge->HE_v1pos[VY];
+    vtx = hedge->HE_v1;
     distance = ((vtx->V_pos[VY] - p->objPos[VY]) * dx -
-                (vtx->V_pos[VX] - p->objPos[VX]) * dy) / seg->length;
+                (vtx->V_pos[VX] - p->objPos[VX]) * dy) / hedge->length;
     }
 
-    if(seg->lineDef)
+    if(hedge->lineDef)
     {
-        if((source == seg->subsector && distance < 0) ||
-           (source == seg->backSeg->subsector && distance > 0))
+        if((source == hedge->subsector && distance < 0) ||
+           (source == hedge->twin->subsector && distance > 0))
         {
             // Can't spread in this direction.
             return;
diff --git a/doomsday/engine/portable/src/p_polyob.c b/doomsday/engine/portable/src/p_polyob.c
index 0cb487534c..2c5a15b13a 100644
--- a/doomsday/engine/portable/src/p_polyob.c
+++ b/doomsday/engine/portable/src/p_polyob.c
@@ -27,7 +27,7 @@
 #include "de_misc.h"
 
 static void rotatePoint(int an, float* x, float* y, float startSpotX, float startSpotY);
-static boolean checkMobjBlocking(seg_t* seg, polyobj_t* po);
+static boolean checkMobjBlocking(HEdge* hedge, polyobj_t* po);
 
 // Called when the polyobj hits a mobj.
 static void (*po_callback) (mobj_t* mobj, void* lineDef, void* polyobj);
@@ -77,49 +77,49 @@ polyobj_t* P_PolyobjByOrigin(void* ddMobjBase)
 
 void Polyobj_UpdateAABox(polyobj_t* po)
 {
-    seg_t** segIter;
+    HEdge** hedgeIter;
     linedef_t* line;
     uint i;
     assert(po);
 
-    segIter = po->segs;
-    line = (*segIter)->lineDef;
+    hedgeIter = po->hedges;
+    line = (*hedgeIter)->lineDef;
     V2_InitBox(po->aaBox.arvec2, line->L_v1pos);
 
-    for(i = 0; i < po->numSegs; ++i, segIter++)
+    for(i = 0; i < po->numHEdges; ++i, hedgeIter++)
     {
-        seg_t* seg = *segIter;
-        line = seg->lineDef;
+        HEdge* hedge = *hedgeIter;
+        line = hedge->lineDef;
         V2_AddToBox(po->aaBox.arvec2, line->L_v1pos);
     }
 }
 
 void Polyobj_UpdateSurfaceTangents(polyobj_t* po)
 {
-    seg_t** segIter;
+    HEdge** hedgeIter;
     assert(po);
 
-    for(segIter = po->segs; *segIter; segIter++)
+    for(hedgeIter = po->hedges; *hedgeIter; hedgeIter++)
     {
-        seg_t* seg = *segIter;
-        SideDef_UpdateSurfaceTangents(SEG_SIDEDEF(seg));
+        HEdge* hedge = *hedgeIter;
+        SideDef_UpdateSurfaceTangents(HEDGE_SIDEDEF(hedge));
     }
 }
 
 void P_MapInitPolyobj(polyobj_t* po)
 {
-    seg_t** segIter;
+    HEdge** hedgeIter;
     subsector_t* ssec;
     vec2_t avg; // < Used to find a polyobj's center, and hence subsector.
 
     if(!po) return;
 
     V2_Set(avg, 0, 0);
-    for(segIter = po->segs; *segIter; segIter++)
+    for(hedgeIter = po->hedges; *hedgeIter; hedgeIter++)
     {
-        seg_t* seg = *segIter;
-        linedef_t* line = seg->lineDef;
-        sidedef_t* side = SEG_SIDEDEF(seg);
+        HEdge* hedge = *hedgeIter;
+        linedef_t* line = hedge->lineDef;
+        sidedef_t* side = HEDGE_SIDEDEF(hedge);
 
         side->SW_topinflags |= SUIF_NO_RADIO;
         side->SW_middleinflags |= SUIF_NO_RADIO;
@@ -127,7 +127,7 @@ void P_MapInitPolyobj(polyobj_t* po)
 
         V2_Sum(avg, avg, line->L_v1pos);
     }
-    V2_Scale(avg, 1.f / po->numSegs);
+    V2_Scale(avg, 1.f / po->numHEdges);
 
     ssec = R_PointInSubsector(avg[VX], avg[VY]);
     if(ssec)
@@ -160,15 +160,15 @@ void P_MapInitPolyobjs(void)
 
 static boolean mobjIsBlockingPolyobj(polyobj_t* po)
 {
-    seg_t** segIter;
+    HEdge** hedgeIter;
     uint i;
     if(!po) return false;
 
-    segIter = po->segs;
-    for(i = 0; i < po->numSegs; ++i, segIter++)
+    hedgeIter = po->hedges;
+    for(i = 0; i < po->numHEdges; ++i, hedgeIter++)
     {
-        seg_t* seg = *segIter;
-        if(checkMobjBlocking(seg, po))
+        HEdge* hedge = *hedgeIter;
+        if(checkMobjBlocking(hedge, po))
         {
             return true;
         }
@@ -180,22 +180,22 @@ static boolean mobjIsBlockingPolyobj(polyobj_t* po)
 boolean P_PolyobjMove(polyobj_t* po, float delta[2])
 {
     fvertex_t* prevPts;
-    seg_t** segIter;
+    HEdge** hedgeIter;
     uint i;
 
     if(!po) return false;
 
     P_PolyobjUnlink(po);
 
-    segIter = po->segs;
+    hedgeIter = po->hedges;
     prevPts = po->prevPts;
-    for(i = 0; i < po->numSegs; ++i, segIter++, prevPts++)
+    for(i = 0; i < po->numHEdges; ++i, hedgeIter++, prevPts++)
     {
-        seg_t* seg = *segIter;
-        linedef_t* line = seg->lineDef;
-        seg_t** veryTempSeg;
+        HEdge* hedge = *hedgeIter;
+        linedef_t* line = hedge->lineDef;
+        HEdge** veryTempSeg;
 
-        for(veryTempSeg = po->segs; veryTempSeg != segIter; veryTempSeg++)
+        for(veryTempSeg = po->hedges; veryTempSeg != hedgeIter; veryTempSeg++)
         {
             if((*veryTempSeg)->lineDef->L_v1 == line->L_v1)
             {
@@ -203,21 +203,21 @@ boolean P_PolyobjMove(polyobj_t* po, float delta[2])
             }
         }
 
-        if(veryTempSeg == segIter)
+        if(veryTempSeg == hedgeIter)
         {
             line->L_v1pos[VX] += delta[VX];
             line->L_v1pos[VY] += delta[VY];
         }
 
-        (*prevPts).pos[VX] += delta[VX]; // Previous points are unique for each seg.
+        (*prevPts).pos[VX] += delta[VX]; // Previous points are unique for each hedge.
         (*prevPts).pos[VY] += delta[VY];
     }
 
-    segIter = po->segs;
-    for(i = 0; i < po->numSegs; ++i, segIter++)
+    hedgeIter = po->hedges;
+    for(i = 0; i < po->numHEdges; ++i, hedgeIter++)
     {
-        seg_t* seg = *segIter;
-        linedef_t* line = seg->lineDef;
+        HEdge* hedge = *hedgeIter;
+        linedef_t* line = hedge->lineDef;
         LineDef_UpdateAABox(line);
     }
     po->pos[VX] += delta[VX];
@@ -232,15 +232,15 @@ boolean P_PolyobjMove(polyobj_t* po, float delta[2])
         P_PolyobjUnlink(po);
 
         i = 0;
-        segIter = po->segs;
+        hedgeIter = po->hedges;
         prevPts = po->prevPts;
-        for(i = 0; i < po->numSegs; ++i, segIter++, prevPts++)
+        for(i = 0; i < po->numHEdges; ++i, hedgeIter++, prevPts++)
         {
-            seg_t* seg = *segIter;
-            linedef_t* line = seg->lineDef;
-            seg_t** veryTempSeg;
+            HEdge* hedge = *hedgeIter;
+            linedef_t* line = hedge->lineDef;
+            HEdge** veryTempSeg;
 
-            for(veryTempSeg = po->segs; veryTempSeg != segIter; veryTempSeg++)
+            for(veryTempSeg = po->hedges; veryTempSeg != hedgeIter; veryTempSeg++)
             {
                 if((*veryTempSeg)->lineDef->L_v1 == line->L_v1)
                 {
@@ -248,7 +248,7 @@ boolean P_PolyobjMove(polyobj_t* po, float delta[2])
                 }
             }
 
-            if(veryTempSeg == segIter)
+            if(veryTempSeg == hedgeIter)
             {
                 line->L_v1pos[VX] -= delta[VX];
                 line->L_v1pos[VY] -= delta[VY];
@@ -258,11 +258,11 @@ boolean P_PolyobjMove(polyobj_t* po, float delta[2])
             (*prevPts).pos[VY] -= delta[VY];
         }
 
-        segIter = po->segs;
-        for(i = 0; i < po->numSegs; ++i, segIter++)
+        hedgeIter = po->hedges;
+        for(i = 0; i < po->numHEdges; ++i, hedgeIter++)
         {
-            seg_t* seg = *segIter;
-            linedef_t* line = seg->lineDef;
+            HEdge* hedge = *hedgeIter;
+            linedef_t* line = hedge->lineDef;
             LineDef_UpdateAABox(line);
         }
         po->pos[VX] -= delta[VX];
@@ -307,21 +307,21 @@ boolean P_PolyobjRotate(polyobj_t* po, angle_t angle)
 {
     fvertex_t* originalPts, *prevPts;
     uint i, fineAngle;
-    seg_t** segIter;
+    HEdge** hedgeIter;
 
     if(!po) return false;
 
     P_PolyobjUnlink(po);
 
-    segIter = po->segs;
+    hedgeIter = po->hedges;
     originalPts = po->originalPts;
     prevPts = po->prevPts;
 
     fineAngle = (po->angle + angle) >> ANGLETOFINESHIFT;
-    for(i = 0; i < po->numSegs; ++i, segIter++, originalPts++, prevPts++)
+    for(i = 0; i < po->numHEdges; ++i, hedgeIter++, originalPts++, prevPts++)
     {
-        seg_t* seg = *segIter;
-        vertex_t* vtx = seg->lineDef->L_v1;
+        HEdge* hedge = *hedgeIter;
+        vertex_t* vtx = hedge->lineDef->L_v1;
 
         prevPts->pos[VX] = vtx->V_pos[VX];
         prevPts->pos[VY] = vtx->V_pos[VY];
@@ -331,18 +331,18 @@ boolean P_PolyobjRotate(polyobj_t* po, angle_t angle)
         rotatePoint2d(vtx->V_pos, po->pos, fineAngle);
     }
 
-    segIter = po->segs;
-    for(i = 0; i < po->numSegs; ++i, segIter++)
+    hedgeIter = po->hedges;
+    for(i = 0; i < po->numHEdges; ++i, hedgeIter++)
     {
-        seg_t* seg = *segIter;
-        linedef_t* line = seg->lineDef;
+        HEdge* hedge = *hedgeIter;
+        linedef_t* line = hedge->lineDef;
 
         LineDef_UpdateAABox(line);
         LineDef_UpdateSlope(line);
         line->angle += ANGLE_TO_BANG(angle);
 
-        // Seg angle must be kept in sync.
-        seg->angle = BANG_TO_ANGLE(line->angle);
+        // HEdge angle must be kept in sync.
+        hedge->angle = BANG_TO_ANGLE(line->angle);
     }
     Polyobj_UpdateAABox(po);
     po->angle += angle;
@@ -354,28 +354,28 @@ boolean P_PolyobjRotate(polyobj_t* po, angle_t angle)
         // Something is blocking our path. We must undo...
         P_PolyobjUnlink(po);
 
-        segIter = po->segs;
+        hedgeIter = po->hedges;
         prevPts = po->prevPts;
-        for(i = 0; i < po->numSegs; ++i, segIter++, prevPts++)
+        for(i = 0; i < po->numHEdges; ++i, hedgeIter++, prevPts++)
         {
-            seg_t* seg = *segIter;
-            vertex_t* vtx = seg->lineDef->L_v1;
+            HEdge* hedge = *hedgeIter;
+            vertex_t* vtx = hedge->lineDef->L_v1;
             vtx->V_pos[VX] = prevPts->pos[VX];
             vtx->V_pos[VY] = prevPts->pos[VY];
         }
 
-        segIter = po->segs;
-        for(i = 0; i < po->numSegs; ++i, segIter++)
+        hedgeIter = po->hedges;
+        for(i = 0; i < po->numHEdges; ++i, hedgeIter++)
         {
-            seg_t* seg = *segIter;
-            linedef_t* line = seg->lineDef;
+            HEdge* hedge = *hedgeIter;
+            linedef_t* line = hedge->lineDef;
 
             LineDef_UpdateAABox(line);
             LineDef_UpdateSlope(line);
             line->angle -= ANGLE_TO_BANG(angle);
 
-            // Seg angle must be kept in sync.
-            seg->angle = BANG_TO_ANGLE(line->angle);
+            // HEdge angle must be kept in sync.
+            hedge->angle = BANG_TO_ANGLE(line->angle);
         }
         Polyobj_UpdateAABox(po);
         po->angle -= angle;
@@ -440,7 +440,7 @@ int PTR_checkMobjBlocking(mobj_t* mo, void* data)
     return false; // Continue iteration.
 }
 
-static boolean checkMobjBlocking(seg_t* seg, polyobj_t* po)
+static boolean checkMobjBlocking(HEdge* hedge, polyobj_t* po)
 {
     gamemap_t* map = P_GetCurrentMap();
     ptrmobjblockingparams_t params;
@@ -449,7 +449,7 @@ static boolean checkMobjBlocking(seg_t* seg, polyobj_t* po)
     AABoxf aaBox;
 
     params.isBlocked = false;
-    params.lineDef = ld = seg->lineDef;
+    params.lineDef = ld = hedge->lineDef;
     params.polyobj = po;
 
     aaBox.minX = ld->aaBox.minX - DDMOBJ_RADIUS_MAX;
@@ -470,12 +470,12 @@ int Polyobj_LineDefIterator(polyobj_t* po, int (*callback) (struct linedef_s*, v
     int result = false; // Continue iteration.
     if(callback)
     {
-        seg_t** segIter = po->segs;
+        HEdge** hedgeIter = po->hedges;
         uint i;
-        for(i = 0; i < po->numSegs; ++i, segIter++)
+        for(i = 0; i < po->numHEdges; ++i, hedgeIter++)
         {
-            seg_t* seg = *segIter;
-            linedef_t* line = seg->lineDef;
+            HEdge* hedge = *hedgeIter;
+            linedef_t* line = hedge->lineDef;
 
             if(line->validCount == validCount) continue;
             line->validCount = validCount;
diff --git a/doomsday/engine/portable/src/p_seg.c b/doomsday/engine/portable/src/p_seg.c
index 1aaca046a3..da7c160d66 100644
--- a/doomsday/engine/portable/src/p_seg.c
+++ b/doomsday/engine/portable/src/p_seg.c
@@ -27,64 +27,64 @@
 #include "de_refresh.h"
 #include "de_play.h"
 
-int Seg_SetProperty(seg_t* seg, const setargs_t* args)
+int HEdge_SetProperty(HEdge* hedge, const setargs_t* args)
 {
     switch(args->prop)
     {
     case DMU_FLAGS:
-        DMU_SetValue(DMT_SEG_FLAGS, &seg->flags, args, 0);
+        DMU_SetValue(DMT_HEDGE_FLAGS, &hedge->flags, args, 0);
         break;
     default:
-        Con_Error("Seg_SetProperty: Property %s is not writable.\n", DMU_Str(args->prop));
+        Con_Error("HEdge_SetProperty: Property %s is not writable.\n", DMU_Str(args->prop));
     }
 
     return false; // Continue iteration.
 }
 
-int Seg_GetProperty(const seg_t* seg, setargs_t* args)
+int HEdge_GetProperty(const HEdge* hedge, setargs_t* args)
 {
     switch(args->prop)
     {
     case DMU_VERTEX0:
-        DMU_GetValue(DMT_SEG_V, &seg->SG_v1, args, 0);
+        DMU_GetValue(DMT_HEDGE_V, &hedge->HE_v1, args, 0);
         break;
     case DMU_VERTEX1:
-        DMU_GetValue(DMT_SEG_V, &seg->SG_v2, args, 0);
+        DMU_GetValue(DMT_HEDGE_V, &hedge->HE_v2, args, 0);
         break;
     case DMU_LENGTH:
-        DMU_GetValue(DMT_SEG_LENGTH, &seg->length, args, 0);
+        DMU_GetValue(DMT_HEDGE_LENGTH, &hedge->length, args, 0);
         break;
     case DMU_OFFSET:
-        DMU_GetValue(DMT_SEG_OFFSET, &seg->offset, args, 0);
+        DMU_GetValue(DMT_HEDGE_OFFSET, &hedge->offset, args, 0);
         break;
     case DMU_SIDEDEF:
-        DMU_GetValue(DMT_SEG_SIDEDEF, &SEG_SIDEDEF(seg), args, 0);
+        DMU_GetValue(DMT_HEDGE_SIDEDEF, &HEDGE_SIDEDEF(hedge), args, 0);
         break;
     case DMU_LINEDEF:
-        DMU_GetValue(DMT_SEG_LINEDEF, &seg->lineDef, args, 0);
+        DMU_GetValue(DMT_HEDGE_LINEDEF, &hedge->lineDef, args, 0);
         break;
     case DMU_FRONT_SECTOR: {
         sector_t* sec = NULL;
-        if(seg->SG_frontsector && seg->lineDef)
-            sec = seg->SG_frontsector;
-        DMU_GetValue(DMT_SEG_SEC, &sec, args, 0);
+        if(hedge->HE_frontsector && hedge->lineDef)
+            sec = hedge->HE_frontsector;
+        DMU_GetValue(DMT_HEDGE_SEC, &sec, args, 0);
         break;
       }
     case DMU_BACK_SECTOR: {
         sector_t* sec = NULL;
-        if(seg->SG_backsector && seg->lineDef)
-            sec = seg->SG_backsector;
-        DMU_GetValue(DMT_SEG_SEC, &seg->SG_backsector, args, 0);
+        if(hedge->HE_backsector && hedge->lineDef)
+            sec = hedge->HE_backsector;
+        DMU_GetValue(DMT_HEDGE_SEC, &hedge->HE_backsector, args, 0);
         break;
       }
     case DMU_FLAGS:
-        DMU_GetValue(DMT_SEG_FLAGS, &seg->flags, args, 0);
+        DMU_GetValue(DMT_HEDGE_FLAGS, &hedge->flags, args, 0);
         break;
     case DMU_ANGLE:
-        DMU_GetValue(DMT_SEG_ANGLE, &seg->angle, args, 0);
+        DMU_GetValue(DMT_HEDGE_ANGLE, &hedge->angle, args, 0);
         break;
     default:
-        Con_Error("Seg_GetProperty: No property %s.\n", DMU_Str(args->prop));
+        Con_Error("HEdge_GetProperty: No property %s.\n", DMU_Str(args->prop));
     }
 
     return false; // Continue iteration.
diff --git a/doomsday/engine/portable/src/p_sight.c b/doomsday/engine/portable/src/p_sight.c
index 4fe94ae478..b6286c2d87 100644
--- a/doomsday/engine/portable/src/p_sight.c
+++ b/doomsday/engine/portable/src/p_sight.c
@@ -111,10 +111,10 @@ static boolean crossLineDef(const linedef_t* li, byte side, losdata_t* los)
     boolean noBack;
 
     if(!interceptLineDef(li, los, &dl))
-        return true; // Ray does not intercept seg on the X/Y plane.
+        return true; // Ray does not intercept hedge on the X/Y plane.
 
     if(!li->L_side(side))
-        return true; // Seg is on the back side of a one-sided window.
+        return true; // HEdge is on the back side of a one-sided window.
 
     fsec = li->L_sector(side);
     bsec  = (li->L_backside? li->L_sector(side^1) : NULL);
@@ -130,7 +130,7 @@ static boolean crossLineDef(const linedef_t* li, byte side, losdata_t* los)
         if((los->flags & LS_PASSLEFT) &&
            P_PointOnLinedefSideXY(FIX2FLT(los->trace.pos[VX]),
                                 FIX2FLT(los->trace.pos[VY]), li))
-            return true; // Ray does not intercept seg from left to right.
+            return true; // Ray does not intercept hedge from left to right.
 
         if(!(los->flags & (LS_PASSOVER | LS_PASSUNDER)))
             return false; // Stop iteration.
@@ -204,15 +204,15 @@ static boolean crossSSec(uint ssecIdx, losdata_t* los)
     if(ssec->polyObj)
     {   // Check polyobj lines.
         polyobj_t* po = ssec->polyObj;
-        seg_t** segPtr = po->segs;
+        HEdge** segPtr = po->hedges;
         while(*segPtr)
         {
-            seg_t* seg = *segPtr;
-            if(seg->lineDef && seg->lineDef->validCount != validCount)
+            HEdge* hedge = *segPtr;
+            if(hedge->lineDef && hedge->lineDef->validCount != validCount)
             {
-                linedef_t* li = seg->lineDef;
+                linedef_t* li = hedge->lineDef;
                 li->validCount = validCount;
-                if(!crossLineDef(li, seg->side, los))
+                if(!crossLineDef(li, hedge->side, los))
                     return false; // Stop iteration.
             }
             segPtr++;
@@ -220,15 +220,15 @@ static boolean crossSSec(uint ssecIdx, losdata_t* los)
     }
 
     // Check lines.
-    { seg_t** segPtr = ssec->segs;
+    { HEdge** segPtr = ssec->hedges;
     while(*segPtr)
     {
-        const seg_t* seg = *segPtr;
-        if(seg->lineDef && seg->lineDef->validCount != validCount)
+        const HEdge* hedge = *segPtr;
+        if(hedge->lineDef && hedge->lineDef->validCount != validCount)
         {
-            linedef_t* li = seg->lineDef;
+            linedef_t* li = hedge->lineDef;
             li->validCount = validCount;
-            if(!crossLineDef(li, seg->side, los))
+            if(!crossLineDef(li, hedge->side, los))
                 return false;
         }
         segPtr++;
diff --git a/doomsday/engine/portable/src/p_subsector.c b/doomsday/engine/portable/src/p_subsector.c
index b61e95c723..04a412f249 100644
--- a/doomsday/engine/portable/src/p_subsector.c
+++ b/doomsday/engine/portable/src/p_subsector.c
@@ -46,10 +46,10 @@ int Subsector_GetProperty(const subsector_t* sub, setargs_t* args)
     case DMT_MOBJS:
         DMU_GetValue(DMT_SECTOR_MOBJLIST, &sub->sector->mobjList, args, 0);
         break;
-    case DMU_SEG_COUNT: {
+    case DMU_HEDGE_COUNT: {
         // FIXME:
-        //DMU_GetValue(DMT_SUBSECTOR_SEGCOUNT, &sub->segCount, args, 0);
-        int val = (int) sub->segCount;
+        //DMU_GetValue(DMT_SUBSECTOR_HEDGECOUNT, &sub->hedgeCount, args, 0);
+        int val = (int) sub->hedgeCount;
         DMU_GetValue(DDVT_INT, &val, args, 0);
         break;
       }
diff --git a/doomsday/engine/portable/src/r_fakeradio.c b/doomsday/engine/portable/src/r_fakeradio.c
index 36d952eb78..58177653f4 100644
--- a/doomsday/engine/portable/src/r_fakeradio.c
+++ b/doomsday/engine/portable/src/r_fakeradio.c
@@ -180,7 +180,7 @@ void R_UpdateVertexShadowOffsets(vertex_t *vtx)
 }
 
 /**
- * Link a seg to an arbitary subsector for the purposes of shadowing.
+ * Link a hedge to an arbitary subsector for the purposes of shadowing.
  */
 static void linkShadowLineDefToSSec(linedef_t *line, byte side,
                                     subsector_t *subsector)
diff --git a/doomsday/engine/portable/src/r_lumobjs.c b/doomsday/engine/portable/src/r_lumobjs.c
index c28d482c92..aa1992c7e6 100644
--- a/doomsday/engine/portable/src/r_lumobjs.c
+++ b/doomsday/engine/portable/src/r_lumobjs.c
@@ -1043,7 +1043,7 @@ BEGIN_PROF( PROF_LUMOBJ_INIT_ADD );
         }
     }
 
-    // If the segs of this subsector are affected by glowing planes we need
+    // If the hedges of this subsector are affected by glowing planes we need
     // to create dynlights and link them.
     if(useWallGlow)
     {
@@ -1163,17 +1163,17 @@ boolean LOIT_ClipLumObjBySight(void* data, void* context)
 
         // We need to figure out if any of the polyobj's segments lies
         // between the viewpoint and the lumobj.
-        for(i = 0; i < ssec->polyObj->numSegs; ++i)
+        for(i = 0; i < ssec->polyObj->numHEdges; ++i)
         {
-            seg_t* seg = ssec->polyObj->segs[i];
+            HEdge* hedge = ssec->polyObj->hedges[i];
 
-            // Ignore segs facing the wrong way.
-            if(seg->frameFlags & SEGINF_FACINGFRONT)
+            // Ignore hedges facing the wrong way.
+            if(hedge->frameFlags & HEDGEINF_FACINGFRONT)
             {
                 vec2_t source;
 
                 V2_Set(source, lum->pos[VX], lum->pos[VY]);
-                if(V2_Intercept2(source, eye, seg->SG_v1pos, seg->SG_v2pos, NULL, NULL, NULL))
+                if(V2_Intercept2(source, eye, hedge->HE_v1pos, hedge->HE_v2pos, NULL, NULL, NULL))
                 {
                     luminousClipped[lumIdx] = 1;
                     break;
diff --git a/doomsday/engine/portable/src/r_main.c b/doomsday/engine/portable/src/r_main.c
index 4fffb50b69..e9738f04be 100644
--- a/doomsday/engine/portable/src/r_main.c
+++ b/doomsday/engine/portable/src/r_main.c
@@ -594,10 +594,10 @@ void R_Update(void)
     for(i = 0; i < numPolyObjs; ++i)
     {
         polyobj_t* po = polyObjs[i];
-        seg_t** segPtr = po->segs;
+        HEdge** segPtr = po->hedges;
         while(*segPtr)
         {
-            sidedef_t* side = SEG_SIDEDEF(*segPtr);
+            sidedef_t* side = HEDGE_SIDEDEF(*segPtr);
             Surface_Update(&side->SW_middlesurface);
             segPtr++;
         }
diff --git a/doomsday/engine/portable/src/r_util.c b/doomsday/engine/portable/src/r_util.c
index 77b818259d..832b75ce37 100644
--- a/doomsday/engine/portable/src/r_util.c
+++ b/doomsday/engine/portable/src/r_util.c
@@ -361,10 +361,10 @@ boolean R_IsPointInSubsector(const float x, const float y,
     uint                i;
     fvertex_t*          vi, *vj;
 
-    for(i = 0; i < ssec->segCount; ++i)
+    for(i = 0; i < ssec->hedgeCount; ++i)
     {
-        vi = &ssec->segs[i]->SG_v1->v;
-        vj = &ssec->segs[(i + 1) % ssec->segCount]->SG_v1->v;
+        vi = &ssec->hedges[i]->HE_v1->v;
+        vj = &ssec->hedges[(i + 1) % ssec->hedgeCount]->HE_v1->v;
 
         if(((vi->pos[VY] - y) * (vj->pos[VX] - vi->pos[VX]) -
             (vi->pos[VX] - x) * (vj->pos[VY] - vi->pos[VY])) < 0)
diff --git a/doomsday/engine/portable/src/r_world.c b/doomsday/engine/portable/src/r_world.c
index dadf8ff907..1642127c2b 100644
--- a/doomsday/engine/portable/src/r_world.c
+++ b/doomsday/engine/portable/src/r_world.c
@@ -496,20 +496,20 @@ void R_MarkDependantSurfacesForDecorationUpdate(plane_t* pln)
         if(!li->L_backside)
         {
             if(pln->type != PLN_MID)
-                Surface_Update(&li->L_frontside->SW_surface(SEG_MIDDLE));
+                Surface_Update(&li->L_frontside->SW_surface(SS_MIDDLE));
         }
         else if(li->L_backsector != li->L_frontsector)
         {
             byte                side =
                 (li->L_frontsector == pln->sector? FRONT : BACK);
 
-            Surface_Update(&li->L_side(side)->SW_surface(SEG_BOTTOM));
-            Surface_Update(&li->L_side(side)->SW_surface(SEG_TOP));
+            Surface_Update(&li->L_side(side)->SW_surface(SS_BOTTOM));
+            Surface_Update(&li->L_side(side)->SW_surface(SS_TOP));
 
             if(pln->type == PLN_FLOOR)
-                Surface_Update(&li->L_side(side^1)->SW_surface(SEG_BOTTOM));
+                Surface_Update(&li->L_side(side^1)->SW_surface(SS_BOTTOM));
             else
-                Surface_Update(&li->L_side(side^1)->SW_surface(SEG_TOP));
+                Surface_Update(&li->L_side(side^1)->SW_surface(SS_TOP));
         }
 
         linep++;
@@ -1105,10 +1105,10 @@ void R_InitLinks(gamemap_t* map)
  * Create a list of vertices for the subsector which are suitable for
  * use as the points of single a trifan.
  *
- * We are assured by the node building process that subsector->segs has
+ * We are assured by the node building process that subsector->hedges has
  * been ordered by angle, clockwise starting from the smallest angle.
  * So, most of the time, the points can be created directly from the
- * seg vertexes.
+ * hedge vertexes.
  *
  * However, we do not want any overlapping tris so check the area of
  * each triangle is > 0, if not; try the next vertice in the list until
@@ -1123,7 +1123,7 @@ static void triangulateSubSector(subsector_t *ssec)
 
     // We need to find a good tri-fan base vertex, (one that doesn't
     // generate zero-area triangles).
-    if(ssec->segCount <= 3)
+    if(ssec->hedgeCount <= 3)
     {   // Always valid.
         found = true;
     }
@@ -1137,18 +1137,18 @@ static void triangulateSubSector(subsector_t *ssec)
         baseIDX = 0;
         do
         {
-            seg_t              *seg = ssec->segs[baseIDX];
+            HEdge              *hedge = ssec->hedges[baseIDX];
 
-            base = &seg->SG_v1->v;
+            base = &hedge->HE_v1->v;
             i = 0;
             do
             {
-                seg_t              *seg2 = ssec->segs[i];
+                HEdge              *seg2 = ssec->hedges[i];
 
                 if(!(baseIDX > 0 && (i == baseIDX || i == baseIDX - 1)))
                 {
-                    a = &seg2->SG_v1->v;
-                    b = &seg2->SG_v2->v;
+                    a = &seg2->HE_v1->v;
+                    b = &seg2->HE_v2->v;
 
                     if(TRIFAN_LIMIT >=
                        M_TriangleArea(base->pos, a->pos, b->pos))
@@ -1158,18 +1158,18 @@ static void triangulateSubSector(subsector_t *ssec)
                 }
 
                 i++;
-            } while(base && i < ssec->segCount);
+            } while(base && i < ssec->hedgeCount);
 
             if(!base)
                 baseIDX++;
-        } while(!base && baseIDX < ssec->segCount);
+        } while(!base && baseIDX < ssec->hedgeCount);
 
         if(base)
             found = true;
 #undef TRIFAN_LIMIT
     }
 
-    ssec->numVertices = ssec->segCount;
+    ssec->numVertices = ssec->hedgeCount;
     if(!found)
         ssec->numVertices += 2;
     ssec->vertices =
@@ -1180,19 +1180,19 @@ static void triangulateSubSector(subsector_t *ssec)
     n = 0;
     if(!found)
         ssec->vertices[n++] = &ssec->midPoint;
-    for(i = 0; i < ssec->segCount; ++i)
+    for(i = 0; i < ssec->hedgeCount; ++i)
     {
         uint                idx;
-        seg_t              *seg;
+        HEdge              *hedge;
 
         idx = baseIDX + i;
-        if(idx >= ssec->segCount)
-            idx = idx - ssec->segCount;
-        seg = ssec->segs[idx];
-        ssec->vertices[n++] = &seg->SG_v1->v;
+        if(idx >= ssec->hedgeCount)
+            idx = idx - ssec->hedgeCount;
+        hedge = ssec->hedges[idx];
+        ssec->vertices[n++] = &hedge->HE_v1->v;
     }
     if(!found)
-        ssec->vertices[n++] = &ssec->segs[0]->SG_v1->v;
+        ssec->vertices[n++] = &ssec->hedges[0]->HE_v1->v;
     ssec->vertices[n] = NULL; // terminate.
 
     if(!found)
@@ -1559,26 +1559,26 @@ boolean R_SectorContainsSkySurfaces(const sector_t* sec)
  * Non-animated materials are preferred.
  * Sky materials are ignored.
  */
-static material_t* chooseFixMaterial(sidedef_t* s, segsection_t section)
+static material_t* chooseFixMaterial(sidedef_t* s, sidedefsection_t section)
 {
     material_t* choice1 = NULL, *choice2 = NULL;
 
-    if(section == SEG_BOTTOM || section == SEG_TOP)
+    if(section == SS_BOTTOM || section == SS_TOP)
     {
         byte sid = (s->line->L_frontside == s? 0 : 1);
         sector_t* frontSec = s->line->L_sector(sid);
         sector_t* backSec = s->line->L_sector(sid^1);
         surface_t* suf;
 
-        if(backSec && ((section == SEG_BOTTOM && frontSec->SP_floorheight < backSec->SP_floorheight && frontSec->SP_ceilheight  > backSec->SP_floorheight) ||
-                       (section == SEG_TOP    && frontSec->SP_ceilheight  > backSec->SP_ceilheight  && frontSec->SP_floorheight < backSec->SP_ceilheight)))
+        if(backSec && ((section == SS_BOTTOM && frontSec->SP_floorheight < backSec->SP_floorheight && frontSec->SP_ceilheight  > backSec->SP_floorheight) ||
+                       (section == SS_TOP    && frontSec->SP_ceilheight  > backSec->SP_ceilheight  && frontSec->SP_floorheight < backSec->SP_ceilheight)))
         {
-            suf = &backSec->SP_plane(section == SEG_BOTTOM? PLN_FLOOR : PLN_CEILING)->surface;
+            suf = &backSec->SP_plane(section == SS_BOTTOM? PLN_FLOOR : PLN_CEILING)->surface;
             if(suf->material && !R_IsSkySurface(suf))
                 choice1 = suf->material;
         }
 
-        suf = &frontSec->SP_plane(section == SEG_BOTTOM? PLN_FLOOR : PLN_CEILING)->surface;
+        suf = &frontSec->SP_plane(section == SS_BOTTOM? PLN_FLOOR : PLN_CEILING)->surface;
         if(suf->material && !R_IsSkySurface(suf))
             choice2 = suf->material;
     }
@@ -1594,17 +1594,17 @@ static material_t* chooseFixMaterial(sidedef_t* s, segsection_t section)
     return NULL;
 }
 
-static void updateSidedefSection(sidedef_t* s, segsection_t section)
+static void updateSidedefSection(sidedef_t* s, sidedefsection_t section)
 {
     surface_t*          suf;
 
-    if(section == SEG_MIDDLE)
+    if(section == SS_MIDDLE)
         return; // Not applicable.
 
     suf = &s->sections[section];
     if(!suf->material /*&&
        !R_IsSkySurface(&s->sector->
-            SP_plane(section == SEG_BOTTOM? PLN_FLOOR : PLN_CEILING)->
+            SP_plane(section == SS_BOTTOM? PLN_FLOOR : PLN_CEILING)->
                 surface)*/)
     {
         Surface_SetMaterial(suf, chooseFixMaterial(s, section));
@@ -1640,15 +1640,15 @@ void R_UpdateLinedefsOfSector(sector_t* sec)
 
         // Check for missing lowers.
         if(frontSec->SP_floorheight < backSec->SP_floorheight)
-            updateSidedefSection(front, SEG_BOTTOM);
+            updateSidedefSection(front, SS_BOTTOM);
         else if(frontSec->SP_floorheight > backSec->SP_floorheight)
-            updateSidedefSection(back, SEG_BOTTOM);
+            updateSidedefSection(back, SS_BOTTOM);
 
         // Check for missing uppers.
         if(backSec->SP_ceilheight < frontSec->SP_ceilheight)
-            updateSidedefSection(front, SEG_TOP);
+            updateSidedefSection(front, SS_TOP);
         else if(backSec->SP_ceilheight > frontSec->SP_ceilheight)
-            updateSidedefSection(back, SEG_TOP);
+            updateSidedefSection(back, SS_TOP);
     }
 }
 
@@ -1692,15 +1692,15 @@ boolean R_UpdatePlane(plane_t* pln, boolean forceUpdate)
             do
             {
                 subsector_t* ssec = *ssecp;
-                seg_t** segp = ssec->segs;
+                HEdge** segp = ssec->hedges;
                 while(*segp)
                 {
-                    seg_t* seg = *segp;
-                    if(seg->lineDef)
+                    HEdge* hedge = *segp;
+                    if(hedge->lineDef)
                     {
                         uint i;
                         for(i = 0; i < 3; ++i)
-                            SB_SurfaceMoved(seg->bsuf[i]);
+                            SB_SurfaceMoved(hedge->bsuf[i]);
                     }
                     segp++;
                 }
diff --git a/doomsday/engine/portable/src/rend_bias.c b/doomsday/engine/portable/src/rend_bias.c
index 941592b1a0..3fa27b4850 100644
--- a/doomsday/engine/portable/src/rend_bias.c
+++ b/doomsday/engine/portable/src/rend_bias.c
@@ -360,8 +360,8 @@ void SB_InitForMap(const char* uniqueID)
     uint i;
 
     // First, determine the total number of vertexillum_ts we need.
-    for(i = 0; i < numSegs; ++i)
-        if(segs[i].lineDef)
+    for(i = 0; i < numHEdges; ++i)
+        if(hedges[i].lineDef)
             numVertIllums++;
 
     numVertIllums *= 3 * 4;
@@ -384,7 +384,7 @@ void SB_InitForMap(const char* uniqueID)
     for(i = 0; i < numPolyObjs; ++i)
     {
         polyobj_t* po = polyObjs[i];
-        numVertIllums += po->numSegs * 3 * 4;
+        numVertIllums += po->numHEdges * 3 * 4;
     }
 
     // Allocate and initialize the vertexillum_ts.
@@ -393,12 +393,12 @@ void SB_InitForMap(const char* uniqueID)
         SB_InitVertexIllum(&illums[i]);
 
     // Allocate bias surfaces and attach vertexillum_ts.
-    for(i = 0; i < numSegs; ++i)
+    for(i = 0; i < numHEdges; ++i)
     {
-        seg_t* seg = &segs[i];
+        HEdge* hedge = &hedges[i];
         int j;
 
-        if(!seg->lineDef)
+        if(!hedge->lineDef)
             continue;
 
         for(j = 0; j < 3; ++j)
@@ -409,7 +409,7 @@ void SB_InitForMap(const char* uniqueID)
             bsuf->illum = illums;
             illums += 4;
 
-            seg->bsuf[j] = bsuf;
+            hedge->bsuf[j] = bsuf;
         }
     }
 
@@ -444,9 +444,9 @@ void SB_InitForMap(const char* uniqueID)
         polyobj_t* po = polyObjs[i];
         uint j;
 
-        for(j = 0; j < po->numSegs; ++j)
+        for(j = 0; j < po->numHEdges; ++j)
         {
-            seg_t* seg = po->segs[j];
+            HEdge* hedge = po->hedges[j];
             int k;
 
             for(k = 0; k < 3; ++k)
@@ -457,7 +457,7 @@ void SB_InitForMap(const char* uniqueID)
                 bsuf->illum = illums;
                 illums += 4;
 
-                seg->bsuf[k] = bsuf;
+                hedge->bsuf[k] = bsuf;
             }
         }
     }
@@ -584,7 +584,7 @@ static void updateAffected(biassurface_t* bsuf, const fvertex_t* from,
         if(src->intensity <= 0)
             continue;
 
-        // Calculate minimum 2D distance to the seg.
+        // Calculate minimum 2D distance to the hedge.
         for(i = 0; i < 2; ++i)
         {
             if(!i)
@@ -744,7 +744,7 @@ static boolean SB_ChangeInAffected(biasaffection_t* affected,
 /**
  * Do initial processing that needs to be done before rendering a
  * frame.  Changed lights cause the tracker bits to the set for all
- * segs and planes.
+ * hedges and planes.
  */
 void SB_BeginFrame(void)
 {
@@ -924,9 +924,9 @@ static boolean SB_CheckColorOverride(biasaffection_t *affected)
  * @param numVertices   Number of vertices (in the array) to be lit.
  * @param normal        Surface normal.
  * @param sectorLightLevel Sector light level.
- * @param mapObject     Ptr to either a seg or subsector.
+ * @param mapObject     Ptr to either a hedge or subsector.
  * @param elmIdx        Used with subsectors to select a specific plane.
- * @param isSeg         @c true, if surface is to a seg ELSE a subsector.
+ * @param isSeg         @c true, if surface is to a hedge ELSE a subsector.
  */
 void SB_RendPoly(struct ColorRawf_s* rcolors, biassurface_t* bsuf,
                  const struct rvertex_s* rvertices,
@@ -965,9 +965,9 @@ void SB_RendPoly(struct ColorRawf_s* rcolors, biassurface_t* bsuf,
          */
         if(isSeg)
         {
-            seg_t*          seg = (seg_t*) mapObject;
+            HEdge*          hedge = (HEdge*) mapObject;
 
-            updateAffected(bsuf, &seg->SG_v1->v, &seg->SG_v2->v, normal);
+            updateAffected(bsuf, &hedge->HE_v1->v, &hedge->HE_v2->v, normal);
         }
         else
         {
diff --git a/doomsday/engine/portable/src/rend_clip.c b/doomsday/engine/portable/src/rend_clip.c
index 65d61501b7..b44db19910 100644
--- a/doomsday/engine/portable/src/rend_clip.c
+++ b/doomsday/engine/portable/src/rend_clip.c
@@ -1272,16 +1272,16 @@ clipnode_t *C_AngleClippedBy(binangle_t bang)
 int C_CheckSubsector(subsector_t *ssec)
 {
     uint        i;
-    seg_t     **ptr;
+    HEdge     **ptr;
 
-    if(!ssec || ssec->segCount < 3)
+    if(!ssec || ssec->hedgeCount < 3)
         return 0;
 
     if(devNoCulling)
         return 1;
 
     // Do we need to resize the angle list buffer?
-    if(ssec->segCount > anglistSize)
+    if(ssec->hedgeCount > anglistSize)
     {
         anglistSize *= 2;
         if(!anglistSize)
@@ -1291,11 +1291,11 @@ int C_CheckSubsector(subsector_t *ssec)
          Z_Realloc(anglist, sizeof(binangle_t) * anglistSize, PU_APPSTATIC);
     }
 
-    ptr = ssec->segs;
+    ptr = ssec->hedges;
     i = 0;
     while(*ptr) // Angles to all corners.
     {
-        vertex_t *vtx = (*ptr)->SG_v1;
+        vertex_t *vtx = (*ptr)->HE_v1;
 
         // Shift for more accuracy.
         anglist[i++] = bamsAtan2((int) ((vtx->V_pos[VY] - vz) * 100),
@@ -1304,7 +1304,7 @@ int C_CheckSubsector(subsector_t *ssec)
     }
 
     // Check each of the ranges defined by the edges.
-    for(i = 0; i < ssec->segCount - 1; ++i)
+    for(i = 0; i < ssec->hedgeCount - 1; ++i)
     {
         uint        end = i + 1;
         binangle_t  angLen;
diff --git a/doomsday/engine/portable/src/rend_decor.c b/doomsday/engine/portable/src/rend_decor.c
index 28d839db80..266d611e0d 100644
--- a/doomsday/engine/portable/src/rend_decor.c
+++ b/doomsday/engine/portable/src/rend_decor.c
@@ -72,7 +72,7 @@ typedef struct decorsource_s {
 
 // PRIVATE FUNCTION PROTOTYPES ---------------------------------------------
 
-static void updateSideSectionDecorations(sidedef_t* side, segsection_t section);
+static void updateSideSectionDecorations(sidedef_t* side, sidedefsection_t section);
 static void updatePlaneDecorations(plane_t* pln);
 
 // EXTERNAL DATA DECLARATIONS ----------------------------------------------
@@ -390,7 +390,7 @@ boolean R_ProjectSurfaceDecorations(surface_t* suf, void* context)
         case DMU_SIDEDEF:
             {
             sidedef_t* side = (sidedef_t*)suf->owner;
-            updateSideSectionDecorations(side, &side->SW_middlesurface == suf? SEG_MIDDLE : &side->SW_bottomsurface == suf? SEG_BOTTOM : SEG_TOP);
+            updateSideSectionDecorations(side, &side->SW_middlesurface == suf? SS_MIDDLE : &side->SW_bottomsurface == suf? SS_BOTTOM : SS_TOP);
             break;
             }
         case DMU_PLANE:
@@ -569,7 +569,7 @@ static void updatePlaneDecorations(plane_t* pln)
     updateSurfaceDecorations2(suf, offsetS, offsetT, v1, v2, sec, suf->material? true : false);
 }
 
-static void updateSideSectionDecorations(sidedef_t* side, segsection_t section)
+static void updateSideSectionDecorations(sidedef_t* side, sidedefsection_t section)
 {
     linedef_t*          line;
     surface_t*          suf;
@@ -580,10 +580,10 @@ static void updateSideSectionDecorations(sidedef_t* side, segsection_t section)
     const plane_t*      frontCeil, *frontFloor, *backCeil = NULL, *backFloor = NULL;
     float               bottom, top;
 
-    if(!side->segs || !side->segs[0])
+    if(!side->hedges || !side->hedges[0])
         return;
 
-    line = side->segs[0]->lineDef;
+    line = side->hedges[0]->lineDef;
     sid = (line->L_backside && line->L_backside == side)? 1 : 0;
     frontCeil  = line->L_sector(sid)->SP_plane(PLN_CEILING);
     frontFloor = line->L_sector(sid)->SP_plane(PLN_FLOOR);
@@ -596,7 +596,7 @@ static void updateSideSectionDecorations(sidedef_t* side, segsection_t section)
 
     switch(section)
     {
-    case SEG_MIDDLE:
+    case SS_MIDDLE:
         suf = &side->SW_middlesurface;
         if(suf->material)
         {
@@ -611,7 +611,7 @@ static void updateSideSectionDecorations(sidedef_t* side, segsection_t section)
             else
             {
                 float texOffset[2];
-                if(R_FindBottomTop(line, sid, SEG_MIDDLE, suf->visOffset[VX], suf->visOffset[VY],
+                if(R_FindBottomTop(line, sid, SS_MIDDLE, suf->visOffset[VX], suf->visOffset[VY],
                              frontFloor, frontCeil, backFloor, backCeil,
                              (line->flags & DDLF_DONTPEGBOTTOM)? true : false,
                              (line->flags & DDLF_DONTPEGTOP)? true : false,
@@ -628,7 +628,7 @@ static void updateSideSectionDecorations(sidedef_t* side, segsection_t section)
         }
         break;
 
-    case SEG_TOP:
+    case SS_TOP:
         suf = &side->SW_topsurface;
         if(suf->material)
             if(line->L_backside && backCeil->visHeight < frontCeil->visHeight &&
@@ -642,7 +642,7 @@ static void updateSideSectionDecorations(sidedef_t* side, segsection_t section)
             }
         break;
 
-    case SEG_BOTTOM:
+    case SS_BOTTOM:
         suf = &side->SW_bottomsurface;
         if(suf->material)
             if(line->L_backside && backFloor->visHeight > frontFloor->visHeight &&
diff --git a/doomsday/engine/portable/src/rend_fakeradio.c b/doomsday/engine/portable/src/rend_fakeradio.c
index 7a1237bdff..e11237c198 100644
--- a/doomsday/engine/portable/src/rend_fakeradio.c
+++ b/doomsday/engine/portable/src/rend_fakeradio.c
@@ -81,7 +81,7 @@ void Rend_RadioUpdateLinedef(linedef_t* line, boolean backSide)
     // Update disabled?
     if(!devFakeRadioUpdate) return;
 
-    // Have we yet determined the shadow properties to be used with segs
+    // Have we yet determined the shadow properties to be used with hedges
     // on this sidedef?
     s = line->sideDefs[backSide? BACK : FRONT];
     if(s->fakeRadioUpdateCount != frameCount)
@@ -210,7 +210,7 @@ static void scanNeighbor(boolean scanTop, const linedef_t* line, uint side,
         lengthDelta = 0;
         if(!stopScan)
         {
-            // This line will attribute to this seg's shadow edge.
+            // This line will attribute to this hedge's shadow edge.
             // Store identity for later use.
             edge->diff = diff;
             edge->line = iter;
@@ -232,7 +232,7 @@ static void scanNeighbor(boolean scanTop, const linedef_t* line, uint side,
             }
 
             // Does this line's length contribute to the alignment of the
-            // texture on the seg shadow edge being rendered?
+            // texture on the hedge shadow edge being rendered?
             if(scanTop)
             {
                 if(iter->L_backside &&
@@ -1202,7 +1202,7 @@ static void setRelativeHeights(const sector_t* front, const sector_t* back, bool
 static uint radioEdgeHackType(const linedef_t* line, const sector_t* front, const sector_t* back,
     int backside, boolean isCeiling, float fz, float bz)
 {
-    surface_t* surface = &line->L_side(backside)->sections[isCeiling? SEG_TOP:SEG_BOTTOM];
+    surface_t* surface = &line->L_side(backside)->sections[isCeiling? SS_TOP:SS_BOTTOM];
 
     if(fz < bz && !surface->material &&
        !(surface->inFlags & SUIF_FIX_MISSING_MATERIAL))
diff --git a/doomsday/engine/portable/src/rend_main.c b/doomsday/engine/portable/src/rend_main.c
index 6fa46a7f54..b77cc519c5 100644
--- a/doomsday/engine/portable/src/rend_main.c
+++ b/doomsday/engine/portable/src/rend_main.c
@@ -375,31 +375,31 @@ void Rend_PreparePlane(rvertex_t* rvertices, size_t numVertices,
     }
 }
 
-static void markSegSectionsPVisible(seg_t* seg)
+static void markSegSectionsPVisible(HEdge* hedge)
 {
     const plane_t* fceil, *bceil, *ffloor, *bfloor;
     sidedef_t* side;
     uint i;
 
-    if(!seg->lineDef || !seg->lineDef->L_side(seg->side)) return;
-    side = seg->lineDef->L_side(seg->side);
+    if(!hedge->lineDef || !hedge->lineDef->L_side(hedge->side)) return;
+    side = hedge->lineDef->L_side(hedge->side);
 
     for(i = 0; i < 3; ++i)
     {
         side->sections[i].inFlags |= SUIF_PVIS;
     }
 
-    if(!seg->lineDef->L_backside)
+    if(!hedge->lineDef->L_backside)
     {
         side->SW_topsurface   .inFlags &= ~SUIF_PVIS;
         side->SW_bottomsurface.inFlags &= ~SUIF_PVIS;
         return;
     }
 
-    fceil  = seg->lineDef->L_sector(seg->side  )->SP_plane(PLN_CEILING);
-    ffloor = seg->lineDef->L_sector(seg->side  )->SP_plane(PLN_FLOOR);
-    bceil  = seg->lineDef->L_sector(seg->side^1)->SP_plane(PLN_CEILING);
-    bfloor = seg->lineDef->L_sector(seg->side^1)->SP_plane(PLN_FLOOR);
+    fceil  = hedge->lineDef->L_sector(hedge->side  )->SP_plane(PLN_CEILING);
+    ffloor = hedge->lineDef->L_sector(hedge->side  )->SP_plane(PLN_FLOOR);
+    bceil  = hedge->lineDef->L_sector(hedge->side^1)->SP_plane(PLN_CEILING);
+    bfloor = hedge->lineDef->L_sector(hedge->side^1)->SP_plane(PLN_FLOOR);
 
     // Middle.
     if(!side->SW_middlematerial || !Material_IsDrawable(side->SW_middlematerial) || side->SW_middlergba[3] <= 0)
@@ -418,13 +418,13 @@ static void markSegSectionsPVisible(seg_t* seg)
         side->SW_bottomsurface.inFlags &= ~SUIF_PVIS;
 }
 
-static void Rend_MarkSegSectionsPVisible(seg_t* seg)
+static void Rend_MarkSegSectionsPVisible(HEdge* hedge)
 {
-    assert(seg);
+    assert(hedge);
     // danij: Do we really need to do this for both sides? Surely not.
-    markSegSectionsPVisible(seg);
-    if(seg->backSeg)
-        markSegSectionsPVisible(seg->backSeg);
+    markSegSectionsPVisible(hedge);
+    if(hedge->twin)
+        markSegSectionsPVisible(hedge->twin);
 }
 
 /**
@@ -548,41 +548,41 @@ static void doCalcSegDivisions(walldiv_t* div, const linedef_t* line,
     } while(!stopScan);
 }
 
-static void calcSegDivisions(walldiv_t* div, const seg_t* seg,
+static void calcSegDivisions(walldiv_t* div, const HEdge* hedge,
     const sector_t* frontSec, float bottomZ, float topZ, boolean doRight)
 {
     sidedef_t* side;
 
     div->num = 0;
 
-    // Polyobj segs are never split.
-    if(seg->flags & SEGF_POLYOBJ) return;
+    // Polyobj hedges are never split.
+    if(hedge->flags & HEDGEF_POLYOBJ) return;
 
-    // Only segs at sidedef ends can/should be split.
-    side = SEG_SIDEDEF(seg);
-    if(!((seg == side->segs[0] && !doRight) ||
-         (seg == side->segs[side->segCount -1] && doRight)))
+    // Only hedges at sidedef ends can/should be split.
+    side = HEDGE_SIDEDEF(hedge);
+    if(!((hedge == side->hedges[0] && !doRight) ||
+         (hedge == side->hedges[side->hedgeCount -1] && doRight)))
         return;
 
-    doCalcSegDivisions(div, seg->lineDef, seg->side, frontSec, bottomZ, topZ, doRight);
+    doCalcSegDivisions(div, hedge->lineDef, hedge->side, frontSec, bottomZ, topZ, doRight);
 }
 
 /**
  * Division will only happen if it must be done.
  */
-static void applyWallHeightDivision(walldiv_t* divs, const seg_t* seg,
+static void applyWallHeightDivision(walldiv_t* divs, const HEdge* hedge,
     const sector_t* frontsec, float low, float hi)
 {
     walldiv_t* div;
     uint i;
 
     // Mini-segs are never drawn.
-    if(!seg->lineDef) return;
+    if(!hedge->lineDef) return;
 
     for(i = 0; i < 2; ++i)
     {
         div = &divs[i];
-        calcSegDivisions(div, seg, frontsec, low, hi, i);
+        calcSegDivisions(div, hedge, frontsec, low, hi, i);
 
         // We need to sort the divisions for the renderer.
         if(div->num > 1)
@@ -608,11 +608,11 @@ for(k = 0; k < div->num; ++k)
 }
 
 static void selectSurfaceColors(const float** topColor,
-    const float** bottomColor, sidedef_t* side, segsection_t section)
+    const float** bottomColor, sidedef_t* side, sidedefsection_t section)
 {
     switch(section)
     {
-    case SEG_MIDDLE:
+    case SS_MIDDLE:
         if(side->flags & SDF_BLENDMIDTOTOP)
         {
             *topColor = side->SW_toprgba;
@@ -630,7 +630,7 @@ static void selectSurfaceColors(const float** topColor,
         }
         break;
 
-    case SEG_TOP:
+    case SS_TOP:
         if(side->flags & SDF_BLENDTOPTOMID)
         {
             *topColor = side->SW_toprgba;
@@ -643,7 +643,7 @@ static void selectSurfaceColors(const float** topColor,
         }
         break;
 
-    case SEG_BOTTOM:
+    case SS_BOTTOM:
         if(side->flags & SDF_BLENDBOTTOMTOMID)
         {
             *topColor = side->SW_middlergba;
@@ -1433,7 +1433,7 @@ static boolean renderWorldPoly(rvertex_t* rvertices, uint numVertices,
         !(p->alpha < 1 || !msA->isOpaque || p->blendMode > 0));
 }
 
-static boolean doRenderSeg(seg_t* seg,
+static boolean doRenderSeg(HEdge* hedge,
                            const fvertex_t* from, const fvertex_t* to,
                            float bottom, float top, const pvec3_t normal,
                            float alpha,
@@ -1456,7 +1456,7 @@ static boolean doRenderSeg(seg_t* seg,
                            boolean isTwosidedMiddle)
 {
     rendworldpoly_params_t params;
-    sidedef_t*          side = (seg->lineDef? SEG_SIDEDEF(seg) : NULL);
+    sidedef_t*          side = (hedge->lineDef? HEDGE_SIDEDEF(hedge) : NULL);
     rvertex_t*          rvertices;
 
     // Init the params.
@@ -1464,10 +1464,10 @@ static boolean doRenderSeg(seg_t* seg,
 
     params.flags = RPF_DEFAULT | (skyMask? RPF_SKYMASK : 0);
     params.isWall = true;
-    params.segLength = &seg->length;
+    params.segLength = &hedge->length;
     params.forceOpaque = (alpha < 0? true : false);
     params.alpha = (alpha < 0? 1 : alpha);
-    params.mapObject = seg;
+    params.mapObject = hedge;
     params.elmIdx = elmIdx;
     params.bsuf = bsuf;
     params.normal = normal;
@@ -1509,24 +1509,24 @@ static boolean doRenderSeg(seg_t* seg,
     // Top Right.
     V3_Set(rvertices[3].pos, to->pos[VX], to->pos[VY], top);
 
-    // Draw this seg.
+    // Draw this hedge.
     if(renderWorldPoly(rvertices, 4, divs, &params, msA, inter, msB))
     {   // Drawn poly was opaque.
-        // Render Fakeradio polys for this seg?
+        // Render Fakeradio polys for this hedge?
         if(!(params.flags & RPF_SKYMASK) && addFakeRadio)
         {
             rendsegradio_params_t radioParams;
             float ll;
 
-            radioParams.linedefLength = &seg->lineDef->length;
+            radioParams.linedefLength = &hedge->lineDef->length;
             radioParams.botCn = side->bottomCorners;
             radioParams.topCn = side->topCorners;
             radioParams.sideCn = side->sideCorners;
             radioParams.spans = side->spans;
-            radioParams.segOffset = &seg->offset;
-            radioParams.segLength = &seg->length;
-            radioParams.frontSec = seg->SG_frontsector;
-            radioParams.backSec = (!isTwosidedMiddle? seg->SG_backsector : NULL);
+            radioParams.segOffset = &hedge->offset;
+            radioParams.segLength = &hedge->length;
+            radioParams.frontSec = hedge->HE_frontsector;
+            radioParams.backSec = (!isTwosidedMiddle? hedge->HE_backsector : NULL);
 
             /**
              * \kludge Revert the vertex coords as they may have been changed
@@ -1564,7 +1564,7 @@ static boolean doRenderSeg(seg_t* seg,
         }
 
         R_FreeRendVertices(rvertices);
-        return true; // Clip with this solid seg.
+        return true; // Clip with this solid hedge.
     }
 
     R_FreeRendVertices(rvertices);
@@ -1738,8 +1738,8 @@ static void Rend_RenderPlane(subsector_t* ssec, planetype_t type, float height,
     }
 }
 
-static boolean rendSegSection(subsector_t* ssec, seg_t* seg,
-                              segsection_t section, surface_t* surface,
+static boolean rendSegSection(subsector_t* ssec, HEdge* hedge,
+                              sidedefsection_t section, surface_t* surface,
                               const fvertex_t* from, const fvertex_t* to,
                               float bottom, float top,
                               const float texOffset[2],
@@ -1752,9 +1752,9 @@ static boolean rendSegSection(subsector_t* ssec, seg_t* seg,
     if(!Surface_IsDrawable(surface)) return false;
     if(bottom >= top) return true;
 
-    alpha = (section == SEG_MIDDLE? surface->rgba[3] : 1.0f);
+    alpha = (section == SS_MIDDLE? surface->rgba[3] : 1.0f);
 
-    if(section == SEG_MIDDLE && softSurface)
+    if(section == SS_MIDDLE && softSurface)
     {
         mobj_t* mo = viewPlayer->shared.mo;
         const viewdata_t* viewData = R_ViewData(viewPlayer - ddPlayers);
@@ -1762,7 +1762,7 @@ static boolean rendSegSection(subsector_t* ssec, seg_t* seg,
         /**
          * Can the player walk through this surface?
          * If the player is close enough we should NOT add a
-         * solid seg otherwise they'd get HOM when they are
+         * solid hedge otherwise they'd get HOM when they are
          * directly on top of the line (eg passing through an
          * opaque waterfall).
          */
@@ -1771,7 +1771,7 @@ static boolean rendSegSection(subsector_t* ssec, seg_t* seg,
            viewData->current.pos[VZ] < top)
         {
             float delta[2], pos, result[2];
-            linedef_t* lineDef = seg->lineDef;
+            linedef_t* lineDef = hedge->lineDef;
 
             delta[0] = lineDef->dX;
             delta[1] = lineDef->dY;
@@ -1809,8 +1809,8 @@ static boolean rendSegSection(subsector_t* ssec, seg_t* seg,
         boolean             forceOpaque = false;
         material_t*         mat = NULL;
         int                 rpFlags = RPF_DEFAULT;
-        boolean             isTwoSided = (seg->lineDef &&
-            seg->lineDef->L_frontside && seg->lineDef->L_backside)? true:false;
+        boolean             isTwoSided = (hedge->lineDef &&
+            hedge->lineDef->L_frontside && hedge->lineDef->L_backside)? true:false;
         blendmode_t         blendMode = BM_NORMAL;
         boolean             addFakeRadio = false;
         const float*        color = NULL, *color2 = NULL;
@@ -1823,14 +1823,14 @@ static boolean rendSegSection(subsector_t* ssec, seg_t* seg,
         V3_Set(texBR, to->pos  [VX], to->pos  [VY], bottom);
 
         // Determine which Material to use.
-        if(devRendSkyMode && seg->SG_backsector &&
-           ((section == SEG_BOTTOM && R_IsSkySurface(&seg->SG_frontsector->SP_floorsurface) &&
-                                      R_IsSkySurface(&seg->SG_backsector->SP_floorsurface)) ||
-            (section == SEG_TOP    && R_IsSkySurface(&seg->SG_frontsector->SP_ceilsurface) &&
-                                      R_IsSkySurface(&seg->SG_backsector->SP_ceilsurface))))
+        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))))
         {
             // Geometry not normally rendered however we do so in dev sky mode.
-            mat = seg->SG_frontsector->SP_planematerial(section == SEG_TOP? PLN_CEILING : PLN_FLOOR);
+            mat = hedge->HE_frontsector->SP_planematerial(section == SS_TOP? PLN_CEILING : PLN_FLOOR);
         }
         else
         {
@@ -1881,7 +1881,7 @@ static boolean rendSegSection(subsector_t* ssec, seg_t* seg,
                 surfaceInFlags &= ~(SUIF_FIX_MISSING_MATERIAL);
             }
 
-            if(section != SEG_MIDDLE || (section == SEG_MIDDLE && !isTwoSided))
+            if(section != SS_MIDDLE || (section == SS_MIDDLE && !isTwoSided))
             {
                 forceOpaque = true;
                 blendMode = BM_NORMAL;
@@ -1905,8 +1905,8 @@ static boolean rendSegSection(subsector_t* ssec, seg_t* seg,
             // Dynamic Lights?
             if(addDLights && msA->glowing < 1 && !(!useDynlights && !useWallGlow))
             {
-                lightListIdx = LO_ProjectToSurface(((section == SEG_MIDDLE && isTwoSided)? PLF_SORT_LUMINOSITY_DESC : 0), ssec, 1,
-                    texTL, texBR, SEG_SIDEDEF(seg)->SW_middletangent, SEG_SIDEDEF(seg)->SW_middlebitangent, SEG_SIDEDEF(seg)->SW_middlenormal);
+                lightListIdx = LO_ProjectToSurface(((section == SS_MIDDLE && isTwoSided)? PLF_SORT_LUMINOSITY_DESC : 0), ssec, 1,
+                    texTL, texBR, HEDGE_SIDEDEF(hedge)->SW_middletangent, HEDGE_SIDEDEF(hedge)->SW_middlebitangent, HEDGE_SIDEDEF(hedge)->SW_middlenormal);
             }
 
             // Mobj shadows?
@@ -1914,33 +1914,33 @@ static boolean rendSegSection(subsector_t* ssec, seg_t* seg,
             {
                 // Glowing planes inversely diminish shadow strength.
                 shadowListIdx = R_ProjectShadowsToSurface(ssec, 1 - msA->glowing, texTL, texBR,
-                    SEG_SIDEDEF(seg)->SW_middletangent, SEG_SIDEDEF(seg)->SW_middlebitangent, SEG_SIDEDEF(seg)->SW_middlenormal);
+                    HEDGE_SIDEDEF(hedge)->SW_middletangent, HEDGE_SIDEDEF(hedge)->SW_middlebitangent, HEDGE_SIDEDEF(hedge)->SW_middlenormal);
             }
 
             addFakeRadio = ((addFakeRadio && msA->glowing == 0)? true : false);
 
-            selectSurfaceColors(&color, &color2, SEG_SIDEDEF(seg), section);
+            selectSurfaceColors(&color, &color2, HEDGE_SIDEDEF(hedge), section);
         }
 
         // Check for neighborhood division?
         divs[0].num = divs[1].num = 0;
-        if(!(section == SEG_MIDDLE && isTwoSided) &&
-           !(seg->lineDef->inFlags & LF_POLYOBJ))
+        if(!(section == SS_MIDDLE && isTwoSided) &&
+           !(hedge->lineDef->inFlags & LF_POLYOBJ))
         {
-            applyWallHeightDivision(divs, seg, frontsec, bottom, top);
+            applyWallHeightDivision(divs, hedge, frontsec, bottom, top);
         }
 
         {
         float deltaL, deltaR, diff;
 
-        LineDef_LightLevelDelta(seg->lineDef, seg->side, &deltaL, &deltaR);
+        LineDef_LightLevelDelta(hedge->lineDef, hedge->side, &deltaL, &deltaR);
 
-        // Linear interpolation of the linedef light deltas to the edges of the seg.
+        // Linear interpolation of the linedef light deltas to the edges of the hedge.
         diff = deltaR - deltaL;
-        deltaR = deltaL + ((seg->offset + seg->length) / seg->lineDef->length) * diff;
-        deltaL += (seg->offset / seg->lineDef->length) * diff;
+        deltaR = deltaL + ((hedge->offset + hedge->length) / hedge->lineDef->length) * diff;
+        deltaL += (hedge->offset / hedge->lineDef->length) * diff;
 
-        solidSeg = doRenderSeg(seg,
+        solidSeg = doRenderSeg(hedge,
                                from, to, bottom, top,
                                surface->normal, (forceOpaque? -1 : alpha),
                                &frontsec->lightLevel,
@@ -1952,9 +1952,9 @@ static boolean rendSegSection(subsector_t* ssec, seg_t* seg,
                                addFakeRadio,
                                texTL, texBR, texOffset, texScale, blendMode,
                                color, color2,
-                               seg->bsuf[section], (uint) section,
+                               hedge->bsuf[section], (uint) section,
                                msA, inter, msB,
-                               (section == SEG_MIDDLE && isTwoSided));
+                               (section == SS_MIDDLE && isTwoSided));
         }
     }
 
@@ -1962,9 +1962,9 @@ static boolean rendSegSection(subsector_t* ssec, seg_t* seg,
 }
 
 /**
- * Renders the given single-sided seg into the world.
+ * Renders the given single-sided hedge into the world.
  */
-static boolean Rend_RenderSeg(subsector_t* ssec, seg_t* seg)
+static boolean Rend_RenderSeg(subsector_t* ssec, HEdge* hedge)
 {
     boolean solidSeg = true;
     sidedef_t* side;
@@ -1974,12 +1974,12 @@ static boolean Rend_RenderSeg(subsector_t* ssec, seg_t* seg)
     sector_t* frontsec;
     int pid;
 
-    side = SEG_SIDEDEF(seg);
+    side = HEDGE_SIDEDEF(hedge);
     if(!side) return false; // A one-way window?
 
     frontsec = ssec->sector;
-    backSide = seg->side;
-    ldef = seg->lineDef;
+    backSide = hedge->side;
+    ldef = hedge->lineDef;
 
     pid = viewPlayer - ddPlayers;
     if(!ldef->mapped[pid])
@@ -2004,16 +2004,16 @@ static boolean Rend_RenderSeg(subsector_t* ssec, seg_t* seg)
         float texOffset[2];
         surface_t* surface = &side->SW_middlesurface;
 
-        texOffset[0] = surface->visOffset[0] + seg->offset;
+        texOffset[0] = surface->visOffset[0] + hedge->offset;
         texOffset[1] = surface->visOffset[1];
 
         if(ldef->flags & DDLF_DONTPEGBOTTOM)
             texOffset[1] += -(fceil - ffloor);
 
-        Rend_RadioUpdateLinedef(seg->lineDef, seg->side);
+        Rend_RadioUpdateLinedef(hedge->lineDef, hedge->side);
 
-        solidSeg = rendSegSection(ssec, seg, SEG_MIDDLE, &side->SW_middlesurface,
-                           &seg->SG_v1->v, &seg->SG_v2->v, ffloor, fceil,
+        solidSeg = rendSegSection(ssec, hedge, SS_MIDDLE, &side->SW_middlesurface,
+                           &hedge->HE_v1->v, &hedge->HE_v2->v, ffloor, fceil,
                            texOffset,
                            /*temp >*/ frontsec, /*< temp*/
                            false, true, true, side->flags);
@@ -2025,7 +2025,7 @@ static boolean Rend_RenderSeg(subsector_t* ssec, seg_t* seg)
     return solidSeg;
 }
 
-boolean R_FindBottomTop(linedef_t* lineDef, int side, segsection_t section,
+boolean R_FindBottomTop(linedef_t* lineDef, int side, sidedefsection_t section,
     float matOffsetX, float matOffsetY,
     const plane_t* ffloor, const plane_t* fceil,
     const plane_t* bfloor, const plane_t* bceil,
@@ -2035,7 +2035,7 @@ boolean R_FindBottomTop(linedef_t* lineDef, int side, segsection_t section,
 {
     switch(section)
     {
-    case SEG_TOP:
+    case SS_TOP:
         *top = fceil->visHeight;
         // Can't go over front ceiling, would induce polygon flaws.
         if(bceil->visHeight < ffloor->visHeight)
@@ -2055,7 +2055,7 @@ boolean R_FindBottomTop(linedef_t* lineDef, int side, segsection_t section,
         }
         break;
 
-    case SEG_BOTTOM: {
+    case SS_BOTTOM: {
         float t = bfloor->visHeight;
 
         *bottom = ffloor->visHeight;
@@ -2084,7 +2084,7 @@ boolean R_FindBottomTop(linedef_t* lineDef, int side, segsection_t section,
         }
         break;
       }
-    case SEG_MIDDLE: {
+    case SS_MIDDLE: {
         float ftop, fbottom, vR_ZBottom, vR_ZTop;
 
         if(isSelfRef)
@@ -2140,9 +2140,9 @@ boolean R_FindBottomTop(linedef_t* lineDef, int side, segsection_t section,
 }
 
 /**
- * Render wall sections for a Seg belonging to a two-sided LineDef.
+ * Render wall sections for a HEdge belonging to a two-sided LineDef.
  */
-static boolean Rend_RenderSegTwosided(subsector_t* ssec, seg_t* seg)
+static boolean Rend_RenderSegTwosided(subsector_t* ssec, HEdge* hedge)
 {
     int                 pid = viewPlayer - ddPlayers;
     float               bottom, top, texOffset[2];
@@ -2152,11 +2152,11 @@ static boolean Rend_RenderSegTwosided(subsector_t* ssec, seg_t* seg)
     linedef_t*          line;
     int                 solidSeg = false;
 
-    frontSide = SEG_SIDEDEF(seg);
-    backSide = SEG_SIDEDEF(seg->backSeg);
+    frontSide = HEDGE_SIDEDEF(hedge);
+    backSide = HEDGE_SIDEDEF(hedge->twin);
     frontSec = frontSide->sector;
     backSec = backSide->sector;
-    line = seg->lineDef;
+    line = hedge->lineDef;
 
     if(!line->mapped[pid])
     {
@@ -2172,7 +2172,7 @@ static boolean Rend_RenderSegTwosided(subsector_t* ssec, seg_t* seg)
     if(backSec == frontSec &&
        !frontSide->SW_topmaterial && !frontSide->SW_bottommaterial &&
        !frontSide->SW_middlematerial)
-       return false; // Ugh... an obvious wall seg hack. Best take no chances...
+       return false; // Ugh... an obvious wall hedge hack. Best take no chances...
 
     ffloor = ssec->sector->SP_plane(PLN_FLOOR);
     fceil  = ssec->sector->SP_plane(PLN_CEILING);
@@ -2182,7 +2182,7 @@ static boolean Rend_RenderSegTwosided(subsector_t* ssec, seg_t* seg)
     if((frontSide->SW_middleinflags & SUIF_PVIS) ||
        (frontSide->SW_topinflags & SUIF_PVIS) ||
        (frontSide->SW_bottominflags & SUIF_PVIS))
-        Rend_RadioUpdateLinedef(seg->lineDef, seg->side);
+        Rend_RadioUpdateLinedef(hedge->lineDef, hedge->side);
 
     /**
      * Create the wall sections.
@@ -2196,8 +2196,8 @@ static boolean Rend_RenderSegTwosided(subsector_t* ssec, seg_t* seg)
     {
         surface_t*          suf = &frontSide->SW_middlesurface;
 
-        if(R_FindBottomTop(seg->lineDef, seg->side, SEG_MIDDLE,
-               seg->offset + suf->visOffset[VX], suf->visOffset[VY],
+        if(R_FindBottomTop(hedge->lineDef, hedge->side, SS_MIDDLE,
+               hedge->offset + suf->visOffset[VX], suf->visOffset[VY],
                ffloor, fceil, bfloor, bceil,
                (line->flags & DDLF_DONTPEGBOTTOM)? true : false,
                (line->flags & DDLF_DONTPEGTOP)? true : false,
@@ -2205,8 +2205,8 @@ static boolean Rend_RenderSegTwosided(subsector_t* ssec, seg_t* seg)
                LINE_SELFREF(line)? true : false,
                &bottom, &top, texOffset))
         {
-            solidSeg = rendSegSection(ssec, seg, SEG_MIDDLE, suf,
-                                      &seg->SG_v1->v, &seg->SG_v2->v, bottom, top, texOffset,
+            solidSeg = rendSegSection(ssec, hedge, SS_MIDDLE, suf,
+                                      &hedge->HE_v1->v, &hedge->HE_v2->v, bottom, top, texOffset,
                                       frontSec,
                                       (((viewPlayer->shared.flags & (DDPF_NOCLIP|DDPF_CAMERA)) ||
                                         !(line->flags & DDLF_BLOCKING))? true : false),
@@ -2242,8 +2242,8 @@ static boolean Rend_RenderSegTwosided(subsector_t* ssec, seg_t* seg)
     {
         surface_t*      suf = &frontSide->SW_topsurface;
 
-        if(R_FindBottomTop(seg->lineDef, seg->side, SEG_TOP,
-               seg->offset + suf->visOffset[VX], suf->visOffset[VY],
+        if(R_FindBottomTop(hedge->lineDef, hedge->side, SS_TOP,
+               hedge->offset + suf->visOffset[VX], suf->visOffset[VY],
                ffloor, fceil, bfloor, bceil,
                (line->flags & DDLF_DONTPEGBOTTOM)? true : false,
                (line->flags & DDLF_DONTPEGTOP)? true : false,
@@ -2251,8 +2251,8 @@ static boolean Rend_RenderSegTwosided(subsector_t* ssec, seg_t* seg)
                LINE_SELFREF(line)? true : false,
                &bottom, &top, texOffset))
         {
-            rendSegSection(ssec, seg, SEG_TOP, suf,
-                           &seg->SG_v1->v, &seg->SG_v2->v, bottom, top, texOffset,
+            rendSegSection(ssec, hedge, SS_TOP, suf,
+                           &hedge->HE_v1->v, &hedge->HE_v2->v, bottom, top, texOffset,
                            frontSec, false, true, true, frontSide->flags);
         }
     }
@@ -2262,8 +2262,8 @@ static boolean Rend_RenderSegTwosided(subsector_t* ssec, seg_t* seg)
     {
         surface_t*          suf = &frontSide->SW_bottomsurface;
 
-        if(R_FindBottomTop(seg->lineDef, seg->side, SEG_BOTTOM,
-               seg->offset + suf->visOffset[VX], suf->visOffset[VY],
+        if(R_FindBottomTop(hedge->lineDef, hedge->side, SS_BOTTOM,
+               hedge->offset + suf->visOffset[VX], suf->visOffset[VY],
                ffloor, fceil, bfloor, bceil,
                (line->flags & DDLF_DONTPEGBOTTOM)? true : false,
                (line->flags & DDLF_DONTPEGTOP)? true : false,
@@ -2271,8 +2271,8 @@ static boolean Rend_RenderSegTwosided(subsector_t* ssec, seg_t* seg)
                LINE_SELFREF(line)? true : false,
                &bottom, &top, texOffset))
         {
-            rendSegSection(ssec, seg, SEG_BOTTOM, suf,
-                           &seg->SG_v1->v, &seg->SG_v2->v, bottom, top, texOffset,
+            rendSegSection(ssec, hedge, SS_BOTTOM, suf,
+                           &hedge->HE_v1->v, &hedge->HE_v2->v, bottom, top, texOffset,
                            frontSec, false, true, true, frontSide->flags);
         }
     }
@@ -2320,72 +2320,72 @@ static boolean Rend_RenderSegTwosided(subsector_t* ssec, seg_t* seg)
 
 static void Rend_MarkSegsFacingFront(subsector_t *sub)
 {
-    seg_t* seg, **segIt;
+    HEdge* hedge, **segIt;
     uint i;
 
-    for(segIt = sub->segs; *segIt; segIt++)
+    for(segIt = sub->hedges; *segIt; segIt++)
     {
-        seg = *segIt;
+        hedge = *segIt;
 
         // Occlusions can only happen where two sectors contact.
-        if(seg->lineDef)
+        if(hedge->lineDef)
         {
             // Which way should it be facing?
-            if(!(segFacingViewerDot(seg->SG_v1pos, seg->SG_v2pos) < 0))
-                seg->frameFlags |= SEGINF_FACINGFRONT;
+            if(!(segFacingViewerDot(hedge->HE_v1pos, hedge->HE_v2pos) < 0))
+                hedge->frameFlags |= HEDGEINF_FACINGFRONT;
             else
-                seg->frameFlags &= ~SEGINF_FACINGFRONT;
+                hedge->frameFlags &= ~HEDGEINF_FACINGFRONT;
 
-            Rend_MarkSegSectionsPVisible(seg);
+            Rend_MarkSegSectionsPVisible(hedge);
         }
     }
 
     if(sub->polyObj)
     {
-        for(i = 0; i < sub->polyObj->numSegs; ++i)
+        for(i = 0; i < sub->polyObj->numHEdges; ++i)
         {
-            seg = sub->polyObj->segs[i];
+            hedge = sub->polyObj->hedges[i];
 
             // Which way should it be facing?
-            if(!(segFacingViewerDot(seg->SG_v1pos, seg->SG_v2pos) < 0))
-                seg->frameFlags |= SEGINF_FACINGFRONT;
+            if(!(segFacingViewerDot(hedge->HE_v1pos, hedge->HE_v2pos) < 0))
+                hedge->frameFlags |= HEDGEINF_FACINGFRONT;
             else
-                seg->frameFlags &= ~SEGINF_FACINGFRONT;
+                hedge->frameFlags &= ~HEDGEINF_FACINGFRONT;
 
-            Rend_MarkSegSectionsPVisible(seg);
+            Rend_MarkSegSectionsPVisible(hedge);
         }
     }
 }
 
 static void occludeFrontFacingSegsInSubsector(const subsector_t* ssec)
 {
-    seg_t** segIt;
-    seg_t* seg;
+    HEdge** segIt;
+    HEdge* hedge;
     uint i;
 
-    for(segIt = ssec->segs; *segIt; segIt++)
+    for(segIt = ssec->hedges; *segIt; segIt++)
     {
-        seg = *segIt;
-        if(!seg->lineDef || !(seg->frameFlags & SEGINF_FACINGFRONT)) continue;
+        hedge = *segIt;
+        if(!hedge->lineDef || !(hedge->frameFlags & HEDGEINF_FACINGFRONT)) continue;
 
-        if(!C_CheckViewRelSeg(seg->SG_v1pos[VX], seg->SG_v1pos[VY],
-                              seg->SG_v2pos[VX], seg->SG_v2pos[VY]))
+        if(!C_CheckViewRelSeg(hedge->HE_v1pos[VX], hedge->HE_v1pos[VY],
+                              hedge->HE_v2pos[VX], hedge->HE_v2pos[VY]))
         {
-            seg->frameFlags &= ~SEGINF_FACINGFRONT;
+            hedge->frameFlags &= ~HEDGEINF_FACINGFRONT;
         }
     }
 
     if(!ssec->polyObj) return;
 
-    for(i = 0; i < ssec->polyObj->numSegs; ++i)
+    for(i = 0; i < ssec->polyObj->numHEdges; ++i)
     {
-        seg = ssec->polyObj->segs[i];
-        if(!(seg->frameFlags & SEGINF_FACINGFRONT)) continue;
+        hedge = ssec->polyObj->hedges[i];
+        if(!(hedge->frameFlags & HEDGEINF_FACINGFRONT)) continue;
 
-        if(!C_CheckViewRelSeg(seg->SG_v1pos[VX], seg->SG_v1pos[VY],
-                              seg->SG_v2pos[VX], seg->SG_v2pos[VY]))
+        if(!C_CheckViewRelSeg(hedge->HE_v1pos[VX], hedge->HE_v1pos[VY],
+                              hedge->HE_v2pos[VX], hedge->HE_v2pos[VY]))
         {
-            seg->frameFlags &= ~SEGINF_FACINGFRONT;
+            hedge->frameFlags &= ~HEDGEINF_FACINGFRONT;
         }
     }
 }
@@ -2421,26 +2421,26 @@ static __inline float skyFixCeilZ(const plane_t* frontCeil, const plane_t* backC
 }
 
 /**
- * Determine which sky fixes are necessary for the specified @a seg.
- * @param seg  Seg to be evaluated.
+ * Determine which sky fixes are necessary for the specified @a hedge.
+ * @param hedge  HEdge to be evaluated.
  * @return  @see skyCapFlags
  */
-static int segSkyFixes(seg_t* seg)
+static int segSkyFixes(HEdge* hedge)
 {
     int fixes = 0;
-    if(seg && seg->lineDef) // "minisegs" have no linedefs.
+    if(hedge && hedge->lineDef) // "minisegs" have no linedefs.
     {
-        const sector_t* frontSec = seg->SG_frontsector;
-        const sector_t* backSec  = seg->SG_backsector;
+        const sector_t* frontSec = hedge->HE_frontsector;
+        const sector_t* backSec  = hedge->HE_backsector;
 
-        if(!backSec || backSec != seg->SG_frontsector)
+        if(!backSec || backSec != hedge->HE_frontsector)
         {
             const boolean hasSkyFloor   = R_IsSkySurface(&frontSec->SP_floorsurface);
             const boolean hasSkyCeiling = R_IsSkySurface(&frontSec->SP_ceilsurface);
 
             if(hasSkyFloor || hasSkyCeiling)
             {
-                const boolean hasClosedBack = LineDef_BackClosed(seg->lineDef, seg->side, true/*ignore opacity*/);
+                const boolean hasClosedBack = LineDef_BackClosed(hedge->lineDef, hedge->side, true/*ignore opacity*/);
 
                 // Lower fix?
                 if(hasSkyFloor)
@@ -2478,15 +2478,15 @@ static int segSkyFixes(seg_t* seg)
 }
 
 /**
- * @param seg  Seg from which to determine sky fix coordinates.
+ * @param hedge  HEdge from which to determine sky fix coordinates.
  * @param skyCap  Either SKYCAP_LOWER or SKYCAP_UPPER (SKYCAP_UPPER has precendence).
  * @param bottom  Z map space coordinate for the bottom of the skyfix written here.
  * @param top  Z map space coordinate for the top of the skyfix written here.
  */
-static void skyFixZCoords(seg_t* seg, int skyCap, float* bottom, float* top)
+static void skyFixZCoords(HEdge* hedge, int skyCap, float* bottom, float* top)
 {
-    const sector_t* frontSec = seg->SG_frontsector;
-    const sector_t* backSec  = seg->SG_backsector;
+    const sector_t* frontSec = hedge->HE_frontsector;
+    const sector_t* backSec  = hedge->HE_backsector;
     const plane_t* ffloor = frontSec->SP_plane(PLN_FLOOR);
     const plane_t* fceil  = frontSec->SP_plane(PLN_CEILING);
     const plane_t* bceil  = backSec? backSec->SP_plane(PLN_CEILING) : NULL;
@@ -2513,17 +2513,17 @@ static void writeSkyFixGeometry(subsector_t* ssec, int skyCap, int rendPolyFlags
     float zBottom, zTop;
     int segSkyCapFlags;
     rvertex_t verts[4];
-    seg_t** segPtr;
+    HEdge** segPtr;
 
-    if(!ssec || !ssec->segCount || !ssec->sector) return;
+    if(!ssec || !ssec->hedgeCount || !ssec->sector) return;
     if(!(skyCap & SKYCAP_LOWER|SKYCAP_UPPER)) return;
 
-    for(segPtr = ssec->segs; *segPtr; segPtr++)
+    for(segPtr = ssec->hedges; *segPtr; segPtr++)
     {
-        seg_t* seg = *segPtr;
+        HEdge* hedge = *segPtr;
 
-        // Is a fix or two necessary for this seg?
-        segSkyCapFlags = segSkyFixes(seg);
+        // Is a fix or two necessary for this hedge?
+        segSkyCapFlags = segSkyFixes(hedge);
         if(!(segSkyCapFlags & (SKYCAP_LOWER|SKYCAP_UPPER))) continue;
 
         /**
@@ -2532,15 +2532,15 @@ static void writeSkyFixGeometry(subsector_t* ssec, int skyCap, int rendPolyFlags
          *   |  |
          *   0--2
          */
-        V2_Copy(verts[0].pos, seg->SG_v1pos);
-        V2_Copy(verts[1].pos, seg->SG_v1pos);
-        V2_Copy(verts[2].pos, seg->SG_v2pos);
-        V2_Copy(verts[3].pos, seg->SG_v2pos);
+        V2_Copy(verts[0].pos, hedge->HE_v1pos);
+        V2_Copy(verts[1].pos, hedge->HE_v1pos);
+        V2_Copy(verts[2].pos, hedge->HE_v2pos);
+        V2_Copy(verts[3].pos, hedge->HE_v2pos);
 
         // First, lower fix:
         if(skyCap & segSkyCapFlags & SKYCAP_LOWER)
         {
-            skyFixZCoords(seg, SKYCAP_LOWER, &zBottom, &zTop);
+            skyFixZCoords(hedge, SKYCAP_LOWER, &zBottom, &zTop);
             if(zBottom < zTop)
             {
                 verts[0].pos[VZ] = verts[2].pos[VZ] = zBottom;
@@ -2552,7 +2552,7 @@ static void writeSkyFixGeometry(subsector_t* ssec, int skyCap, int rendPolyFlags
         // Upper fix:
         if(skyCap & segSkyCapFlags & SKYCAP_UPPER)
         {
-            skyFixZCoords(seg, SKYCAP_UPPER, &zBottom, &zTop);
+            skyFixZCoords(hedge, SKYCAP_UPPER, &zBottom, &zTop);
             if(zBottom < zTop)
             {
                 verts[0].pos[VZ] = verts[2].pos[VZ] = zBottom;
@@ -2572,7 +2572,7 @@ static void rendSubsectorSky(subsector_t* ssec, int skyCap)
 {
     const int rendPolyFlags = RPF_DEFAULT | RPF_SKYMASK;
 
-    if(!ssec || !ssec->segCount || !ssec->sector) return;
+    if(!ssec || !ssec->hedgeCount || !ssec->sector) return;
 
     // Sky caps are only necessary in sectors with skymasked planes.
     if((skyCap & SKYCAP_LOWER) && !R_IsSkySurface(&ssec->sector->SP_floorsurface))
@@ -2608,7 +2608,7 @@ static void rendSubsectorSky(subsector_t* ssec, int skyCap)
     }
 }
 
-static boolean skymaskSegIsVisible(seg_t* seg, boolean clipBackFacing)
+static boolean skymaskSegIsVisible(HEdge* hedge, boolean clipBackFacing)
 {
     linedef_t* lineDef;
     sidedef_t* sideDef;
@@ -2616,18 +2616,18 @@ static boolean skymaskSegIsVisible(seg_t* seg, boolean clipBackFacing)
     sector_t* frontSec;
 
     // "minisegs" have no linedefs.
-    if(!seg->lineDef) return false;
-    lineDef = seg->lineDef;
+    if(!hedge->lineDef) return false;
+    lineDef = hedge->lineDef;
 
     // No SideDef on this side?
-    sideDef = SEG_SIDEDEF(seg);
+    sideDef = HEDGE_SIDEDEF(hedge);
     if(!sideDef) return false;
 
-    // Let's first check which way this seg is facing.
-    if(clipBackFacing && !(seg->frameFlags & SEGINF_FACINGFRONT)) return false;
+    // Let's first check which way this hedge is facing.
+    if(clipBackFacing && !(hedge->frameFlags & HEDGEINF_FACINGFRONT)) return false;
 
-    backSec  = seg->SG_backsector;
-    frontSec = seg->SG_frontsector;
+    backSec  = hedge->HE_backsector;
+    frontSec = hedge->HE_frontsector;
 
     // Avoid obvious hack (best take no chances...).
     return !(backSec == frontSec && !sideDef->SW_topmaterial && !sideDef->SW_bottommaterial &&
@@ -2649,15 +2649,15 @@ static void Rend_RenderSubsectorSky(subsector_t* ssec)
 /**
  * Creates new occlusion planes from the subsector's sides.
  * Before testing, occlude subsector's backfaces. After testing occlude
- * the remaining faces, i.e. the forward facing segs. This is done before
- * rendering segs, so solid segments cut out all unnecessary oranges.
+ * the remaining faces, i.e. the forward facing hedges. This is done before
+ * rendering hedges, so solid segments cut out all unnecessary oranges.
  */
 static void occludeSubsector(const subsector_t* ssec, boolean forwardFacing)
 {
     float fronth[2], backh[2];
     float* startv, *endv;
     sector_t* front = ssec->sector, *back;
-    seg_t* seg, **segIt;
+    HEdge* hedge, **segIt;
 
     if(devNoCulling || P_IsInVoid(viewPlayer))
         return;
@@ -2665,29 +2665,29 @@ static void occludeSubsector(const subsector_t* ssec, boolean forwardFacing)
     fronth[0] = front->SP_floorheight;
     fronth[1] = front->SP_ceilheight;
 
-    for(segIt = ssec->segs; *segIt; segIt++)
+    for(segIt = ssec->hedges; *segIt; segIt++)
     {
-        seg = *segIt;
+        hedge = *segIt;
 
         // Occlusions can only happen where two sectors contact.
-        if(seg->lineDef &&
-           seg->SG_backsector && !(seg->flags & SEGF_POLYOBJ) && // Polyobjects don't occlude.
-           (forwardFacing == ((seg->frameFlags & SEGINF_FACINGFRONT)? true : false)))
+        if(hedge->lineDef &&
+           hedge->HE_backsector && !(hedge->flags & HEDGEF_POLYOBJ) && // Polyobjects don't occlude.
+           (forwardFacing == ((hedge->frameFlags & HEDGEINF_FACINGFRONT)? true : false)))
         {
-            back = seg->SG_backsector;
+            back = hedge->HE_backsector;
             backh[0] = back->SP_floorheight;
             backh[1] = back->SP_ceilheight;
 
             // Choose start and end vertices so that it's facing forward.
             if(forwardFacing)
             {
-                startv = seg->SG_v1pos;
-                endv   = seg->SG_v2pos;
+                startv = hedge->HE_v1pos;
+                endv   = hedge->HE_v2pos;
             }
             else
             {
-                startv = seg->SG_v2pos;
-                endv   = seg->SG_v1pos;
+                startv = hedge->HE_v2pos;
+                endv   = hedge->HE_v1pos;
             }
 
             // Do not create an occlusion for sky floors.
@@ -2723,7 +2723,7 @@ static void Rend_RenderSubsector(uint ssecidx)
 {
     uint i;
     subsector_t* ssec = SUBSECTOR_PTR(ssecidx);
-    seg_t* seg, **segIt;
+    HEdge* hedge, **segIt;
     sector_t* sect;
     float sceil, sfloor;
 
@@ -2733,7 +2733,7 @@ static void Rend_RenderSubsector(uint ssecidx)
     sceil = sect->SP_ceilvisheight;
     sfloor = sect->SP_floorvisheight;
 
-    if(sceil - sfloor <= 0 || ssec->segCount < 3)
+    if(sceil - sfloor <= 0 || ssec->hedgeCount < 3)
     {
         // Skip this, it has no volume.
         // Neighbors handle adding the solid clipper segments.
@@ -2788,24 +2788,24 @@ static void Rend_RenderSubsector(uint ssecidx)
     Rend_RenderSubsectorSky(ssec);
 
     // Draw the walls.
-    for(segIt = ssec->segs; *segIt; segIt++)
+    for(segIt = ssec->hedges; *segIt; segIt++)
     {
-        seg = *segIt;
+        hedge = *segIt;
 
-        if(!(seg->flags & SEGF_POLYOBJ)  &&// Not handled here.
-           seg->lineDef && // "minisegs" have no linedefs.
-           (seg->frameFlags & SEGINF_FACINGFRONT))
+        if(!(hedge->flags & HEDGEF_POLYOBJ)  &&// Not handled here.
+           hedge->lineDef && // "minisegs" have no linedefs.
+           (hedge->frameFlags & HEDGEINF_FACINGFRONT))
         {
             boolean solid;
-            if(!seg->SG_backsector || !seg->SG_frontsector)
-                solid = Rend_RenderSeg(ssec, seg);
+            if(!hedge->HE_backsector || !hedge->HE_frontsector)
+                solid = Rend_RenderSeg(ssec, hedge);
             else
-                solid = Rend_RenderSegTwosided(ssec, seg);
+                solid = Rend_RenderSegTwosided(ssec, hedge);
 
             if(solid)
             {
-                C_AddViewRelSeg(seg->SG_v1pos[VX], seg->SG_v1pos[VY],
-                                seg->SG_v2pos[VX], seg->SG_v2pos[VY]);
+                C_AddViewRelSeg(hedge->HE_v1pos[VX], hedge->HE_v1pos[VY],
+                                hedge->HE_v2pos[VX], hedge->HE_v2pos[VY]);
             }
         }
     }
@@ -2813,17 +2813,17 @@ static void Rend_RenderSubsector(uint ssecidx)
     // Is there a polyobj on board?
     if(ssec->polyObj)
     {
-        for(i = 0; i < ssec->polyObj->numSegs; ++i)
+        for(i = 0; i < ssec->polyObj->numHEdges; ++i)
         {
-            seg = ssec->polyObj->segs[i];
-            // Let's first check which way this seg is facing.
-            if(seg->frameFlags & SEGINF_FACINGFRONT)
+            hedge = ssec->polyObj->hedges[i];
+            // Let's first check which way this hedge is facing.
+            if(hedge->frameFlags & HEDGEINF_FACINGFRONT)
             {
-                boolean solid = Rend_RenderSeg(ssec, seg);
+                boolean solid = Rend_RenderSeg(ssec, hedge);
                 if(solid)
                 {
-                    C_AddViewRelSeg(seg->SG_v1pos[VX], seg->SG_v1pos[VY],
-                                    seg->SG_v2pos[VX], seg->SG_v2pos[VY]);
+                    C_AddViewRelSeg(hedge->HE_v1pos[VX], hedge->HE_v1pos[VY],
+                                    hedge->HE_v2pos[VX], hedge->HE_v2pos[VY]);
                 }
             }
         }
@@ -2963,23 +2963,23 @@ void Rend_RenderSurfaceVectors(void)
 
     glDisable(GL_CULL_FACE);
 
-    for(i = 0; i < numSegs; ++i)
+    for(i = 0; i < numHEdges; ++i)
     {
-        seg_t* seg = &segs[i];
+        HEdge* hedge = &hedges[i];
         float x, y, bottom, top;
         sidedef_t* side;
         surface_t* suf;
         vec3_t origin;
 
-        if(!seg->lineDef || !seg->SG_frontsector ||
-           (seg->lineDef->inFlags & LF_POLYOBJ))
+        if(!hedge->lineDef || !hedge->HE_frontsector ||
+           (hedge->lineDef->inFlags & LF_POLYOBJ))
             continue;
 
-        side = SEG_SIDEDEF(seg);
-        x = seg->SG_v1pos[VX] + (seg->SG_v2pos[VX] - seg->SG_v1pos[VX]) / 2;
-        y = seg->SG_v1pos[VY] + (seg->SG_v2pos[VY] - seg->SG_v1pos[VY]) / 2;
+        side = HEDGE_SIDEDEF(hedge);
+        x = hedge->HE_v1pos[VX] + (hedge->HE_v2pos[VX] - hedge->HE_v1pos[VX]) / 2;
+        y = hedge->HE_v1pos[VY] + (hedge->HE_v2pos[VY] - hedge->HE_v1pos[VY]) / 2;
 
-        if(!seg->SG_backsector)
+        if(!hedge->HE_backsector)
         {
             bottom = side->sector->SP_floorvisheight;
             top = side->sector->SP_ceilvisheight;
@@ -2992,34 +2992,34 @@ void Rend_RenderSurfaceVectors(void)
         {
             if(side->SW_middlesurface.material)
             {
-                top = seg->SG_frontsector->SP_ceilvisheight;
-                bottom = seg->SG_frontsector->SP_floorvisheight;
+                top = hedge->HE_frontsector->SP_ceilvisheight;
+                bottom = hedge->HE_frontsector->SP_floorvisheight;
                 suf = &side->SW_middlesurface;
 
                 V3_Set(origin, x, y, bottom + (top - bottom) / 2);
                 drawSurfaceTangentSpaceVectors(suf, origin);
             }
 
-            if(seg->SG_backsector->SP_ceilvisheight <
-               seg->SG_frontsector->SP_ceilvisheight &&
-               !(R_IsSkySurface(&seg->SG_frontsector->SP_ceilsurface) &&
-                 R_IsSkySurface(&seg->SG_backsector->SP_ceilsurface)))
+            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)))
             {
-                bottom = seg->SG_backsector->SP_ceilvisheight;
-                top = seg->SG_frontsector->SP_ceilvisheight;
+                bottom = hedge->HE_backsector->SP_ceilvisheight;
+                top = hedge->HE_frontsector->SP_ceilvisheight;
                 suf = &side->SW_topsurface;
 
                 V3_Set(origin, x, y, bottom + (top - bottom) / 2);
                 drawSurfaceTangentSpaceVectors(suf, origin);
             }
 
-            if(seg->SG_backsector->SP_floorvisheight >
-               seg->SG_frontsector->SP_floorvisheight &&
-               !(R_IsSkySurface(&seg->SG_frontsector->SP_floorsurface) &&
-                 R_IsSkySurface(&seg->SG_backsector->SP_floorsurface)))
+            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)))
             {
-                bottom = seg->SG_frontsector->SP_floorvisheight;
-                top = seg->SG_backsector->SP_floorvisheight;
+                bottom = hedge->HE_frontsector->SP_floorvisheight;
+                top = hedge->HE_backsector->SP_floorvisheight;
                 suf = &side->SW_bottomsurface;
 
                 V3_Set(origin, x, y, bottom + (top - bottom) / 2);
@@ -3056,14 +3056,14 @@ void Rend_RenderSurfaceVectors(void)
         vec3_t origin;
         uint j;
 
-        for(j = 0; j < po->numSegs; ++j)
+        for(j = 0; j < po->numHEdges; ++j)
         {
-            seg_t* seg = po->segs[j];
-            linedef_t* lineDef = seg->lineDef;
+            HEdge* hedge = po->hedges[j];
+            linedef_t* lineDef = hedge->lineDef;
 
             V3_Set(origin, (lineDef->L_v2pos[VX]+lineDef->L_v1pos[VX])/2,
                            (lineDef->L_v2pos[VY]+lineDef->L_v1pos[VY])/2, zPos);
-            drawSurfaceTangentSpaceVectors(&SEG_SIDEDEF(seg)->SW_middlesurface, origin);
+            drawSurfaceTangentSpaceVectors(&HEDGE_SIDEDEF(hedge)->SW_middlesurface, origin);
         }
     }
 
@@ -3803,10 +3803,10 @@ static void Rend_RenderBoundingBoxes(void)
         Rend_DrawBBox(pos, width, length, height, 0, yellow, alpha, .08f, true);
 
         {uint j;
-        for(j = 0; j < po->numSegs; ++j)
+        for(j = 0; j < po->numHEdges; ++j)
         {
-            seg_t* seg = po->segs[j];
-            linedef_t* lineDef = seg->lineDef;
+            HEdge* hedge = po->hedges[j];
+            linedef_t* lineDef = hedge->lineDef;
             float width  = (lineDef->aaBox.maxX - lineDef->aaBox.minX)/2;
             float length = (lineDef->aaBox.maxY - lineDef->aaBox.minY)/2;
             float pos[3];
diff --git a/doomsday/engine/portable/src/s_environ.c b/doomsday/engine/portable/src/s_environ.c
index 4646d72953..f28c34388b 100644
--- a/doomsday/engine/portable/src/s_environ.c
+++ b/doomsday/engine/portable/src/s_environ.c
@@ -265,7 +265,7 @@ static boolean calcSSecReverb(subsector_t* ssec)
     material_env_class_t mclass;
     float total = 0;
     uint i, v;
-    seg_t** ptr;
+    HEdge** ptr;
 
     if(!ssec->sector)
     {
@@ -284,19 +284,19 @@ static boolean calcSSecReverb(subsector_t* ssec)
 
     // The other reverb properties can be found out by taking a look at the
     // materials of all surfaces in the subsector.
-    ptr = ssec->segs;
+    ptr = ssec->hedges;
     while(*ptr)
     {
-        seg_t* seg = *ptr;
-        if(seg->lineDef && SEG_SIDEDEF(seg) && SEG_SIDEDEF(seg)->SW_middlematerial)
+        HEdge* hedge = *ptr;
+        if(hedge->lineDef && HEDGE_SIDEDEF(hedge) && HEDGE_SIDEDEF(hedge)->SW_middlematerial)
         {
-            material_t* mat = SEG_SIDEDEF(seg)->SW_middlematerial;
+            material_t* mat = HEDGE_SIDEDEF(hedge)->SW_middlematerial;
 
             mclass = Material_EnvironmentClass(mat);
-            total += seg->length;
+            total += hedge->length;
             if(!(mclass >= 0 && mclass < NUM_MATERIAL_ENV_CLASSES))
                 mclass = MEC_WOOD; // Assume it's wood if unknown.
-            materials[mclass] += seg->length;
+            materials[mclass] += hedge->length;
         }
         ptr++;
     }
@@ -347,7 +347,7 @@ Con_Message("ssec %04i: vol:%3i sp:%3i dec:%3i dam:%3i\n",
 /**
  * Re-calculate the reverb properties of the given sector. Should be called
  * whenever any of the properties governing reverb properties have changed
- * (i.e. seg/plane texture or plane height changes).
+ * (i.e. hedge/plane texture or plane height changes).
  *
  * PRE: Subsector attributors must have been determined first.
  *
diff --git a/doomsday/plugins/common/include/p_mapsetup.h b/doomsday/plugins/common/include/p_mapsetup.h
index b47c086822..a23157f707 100644
--- a/doomsday/plugins/common/include/p_mapsetup.h
+++ b/doomsday/plugins/common/include/p_mapsetup.h
@@ -30,7 +30,7 @@
 #define LIBCOMMON_PLAYSETUP_H
 
 #define numvertexes (*(uint*) DD_GetVariable(DD_VERTEX_COUNT))
-#define numsegs     (*(uint*) DD_GetVariable(DD_SEG_COUNT))
+#define numsegs     (*(uint*) DD_GetVariable(DD_HEDGE_COUNT))
 #define numsectors  (*(uint*) DD_GetVariable(DD_SECTOR_COUNT))
 #define numsubsectors (*(uint*) DD_GetVariable(DD_SUBSECTOR_COUNT))
 #define numnodes    (*(uint*) DD_GetVariable(DD_NODE_COUNT))
diff --git a/doomsday/plugins/common/src/hu_automap.c b/doomsday/plugins/common/src/hu_automap.c
index 9dfbd74115..a326713706 100644
--- a/doomsday/plugins/common/src/hu_automap.c
+++ b/doomsday/plugins/common/src/hu_automap.c
@@ -579,11 +579,11 @@ static void rendLine2(uiwidget_t* obj, float x1, float y1, float x2, float y2,
     }
 }
 
-static int rendSeg(void* seg_, void* data)
+static int rendSeg(void* hedge_, void* data)
 {
-    assert(NULL != seg_ && NULL != data && ((uiwidget_t*)data)->type == GUI_AUTOMAP);
+    assert(NULL != hedge_ && NULL != data && ((uiwidget_t*)data)->type == GUI_AUTOMAP);
     {
-    seg_t* seg = (seg_t*) seg_;
+    HEdge* hedge = (HEdge*) hedge_;
     uiwidget_t* obj = (uiwidget_t*)data;
     guidata_automap_t* am = (guidata_automap_t*)obj->typedata;
     sector_t* frontSector, *backSector;
@@ -593,7 +593,7 @@ static int rendSeg(void* seg_, void* data)
     linedef_t* line;
     xline_t* xLine;
 
-    line = P_GetPtrp(seg, DMU_LINEDEF);
+    line = P_GetPtrp(hedge, DMU_LINEDEF);
     if(!line) return false;
 
     xLine = P_ToXLine(line);
@@ -677,7 +677,7 @@ static int rendSeg(void* seg_, void* data)
 
 static int rendSegsOfSubsector(subsector_t* ssec, void* context)
 {
-    return P_Iteratep(ssec, DMU_SEG, context, rendSeg);
+    return P_Iteratep(ssec, DMU_HEDGE, context, rendSeg);
 }
 
 /**
@@ -710,7 +710,7 @@ static void renderWalls(uiwidget_t* obj, int objType, boolean addToLists)
         // walls, not just those visible *now* (note rotation).
         for(i = 0; i < numsubsectors; ++i)
         {
-            P_Iteratep(P_ToPtr(DMU_SUBSECTOR, i), DMU_SEG, obj, rendSeg);
+            P_Iteratep(P_ToPtr(DMU_SUBSECTOR, i), DMU_HEDGE, obj, rendSeg);
         }
     }
 }
@@ -774,12 +774,12 @@ static void rendLinedef(linedef_t* line, float r, float g, float b, float a,
 }
 
 /**
- * Rather than draw the segs instead this will draw the linedef of which
- * the seg is a part.
+ * Rather than draw the hedges instead this will draw the linedef of which
+ * the hedge is a part.
  */
 int rendPolyobjSeg(void* segPtr, void* context)
 {
-    seg_t* seg = (seg_t*)segPtr;
+    HEdge* hedge = (HEdge*)segPtr;
     uiwidget_t* obj = (uiwidget_t*)context;
     guidata_automap_t* am = (guidata_automap_t*)obj->typedata;
     const float alpha = uiRendState->pageAlpha;
@@ -788,7 +788,7 @@ int rendPolyobjSeg(void* segPtr, void* context)
     linedef_t* line;
     xline_t* xLine;
 
-    if(!(line = P_GetPtrp(seg, DMU_LINEDEF)) || !(xLine = P_ToXLine(line))) return false;
+    if(!(line = P_GetPtrp(hedge, DMU_LINEDEF)) || !(xLine = P_ToXLine(line))) return false;
 
     // Already processed this frame?
     if(xLine->validCount == VALIDCOUNT) return false;
@@ -821,7 +821,7 @@ int rendPolyobjSeg(void* segPtr, void* context)
 int rendSegsOfPolyobj(polyobj_t* po, void* context)
 {
     int result = false; // Continue iteration.
-    seg_t** segPtr = po->segs;
+    HEdge** segPtr = po->hedges;
     while(*segPtr && !(result = rendPolyobjSeg(*segPtr, context)))
         segPtr++;
     return result;
diff --git a/doomsday/plugins/jhexen/src/po_man.c b/doomsday/plugins/jhexen/src/po_man.c
index 7b7a3091f2..d1a2942863 100644
--- a/doomsday/plugins/jhexen/src/po_man.c
+++ b/doomsday/plugins/jhexen/src/po_man.c
@@ -561,8 +561,8 @@ static int getPolyobjMirror(uint poly)
 
         if(po->tag == poly)
         {
-            seg_t*              seg = po->segs[0];
-            linedef_t*          linedef = P_GetPtrp(seg, DMU_LINEDEF);
+            HEdge*              hedge = po->hedges[0];
+            linedef_t*          linedef = P_GetPtrp(hedge, DMU_LINEDEF);
 
             return P_ToXLine(linedef)->arg2;
         }