Changeset 9929 for ps

Timestamp:

07/30/11 02:56:45 (13 years ago)

Author:

philip

Message:

# New territory border rendering.
Add textured line overlay rendering.
Change terrain height calculations to be triangulation-dependent for improved accuracy.
Add triangulation-dependent terrain normal function.
Support separate S/T wrap modes for textures.
Rename CVector2D_Maths since it no longer conflicts with simulation CVector2D.
Coalesce freed chunks in vertex buffers, to avoid excessive fragmentation.
Add some things to help debug vertex buffer allocation a little.

Location:

ps/trunk

Files:

• binaries/data/mods/_test.sim/simulation/data/territorymanager.xml (added)
• binaries/data/mods/public/art/textures/misc (added)
• binaries/data/mods/public/art/textures/misc/territory_border.png (added)
• binaries/data/mods/public/art/textures/misc/territory_border_mask.png (added)
• binaries/data/mods/public/art/textures/misc/textures.xml (added)
• binaries/data/mods/public/shaders/overlayline.fp (added)
• binaries/data/mods/public/shaders/overlayline.vp (added)
• binaries/data/mods/public/shaders/overlayline.xml (added)
• binaries/data/mods/public/shaders/terrain_base.xml (modified) (2 diffs)
• binaries/data/mods/public/shaders/terrain_blend.xml (modified) (2 diffs)
• binaries/data/mods/public/shaders/terrain_common.fp (modified) (1 diff)
• binaries/data/mods/public/shaders/terrain_common.vp (modified) (2 diffs)
• binaries/data/mods/public/shaders/terrain_decal.xml (modified) (2 diffs)
• binaries/data/mods/public/simulation/data/pathfinder.xml (modified) (1 diff)
• binaries/data/mods/public/simulation/data/territorymanager.xml (added)
• source/graphics/Overlay.h (modified) (3 diffs)
• source/graphics/Terrain.cpp (modified) (3 diffs)
• source/graphics/Terrain.h (modified) (1 diff)
• source/graphics/TextureManager.cpp (modified) (3 diffs)
• source/graphics/TextureManager.h (modified) (3 diffs)
• source/lib/res/graphics/ogl_tex.cpp (modified) (5 diffs)
• source/lib/res/graphics/ogl_tex.h (modified) (1 diff)
• source/maths/Noise.cpp (modified) (2 diffs)
• source/maths/Noise.h (modified) (1 diff)
• source/maths/Vector2D.h (modified) (2 diffs)
• source/renderer/OverlayRenderer.cpp (modified) (6 diffs)
• source/renderer/OverlayRenderer.h (modified) (3 diffs)
• source/renderer/Renderer.cpp (modified) (7 diffs)
• source/renderer/Renderer.h (modified) (2 diffs)
• source/renderer/Scene.h (modified) (2 diffs)
• source/renderer/VertexBuffer.cpp (modified) (6 diffs)
• source/renderer/VertexBuffer.h (modified) (2 diffs)
• source/renderer/VertexBufferManager.cpp (modified) (3 diffs)
• source/renderer/VertexBufferManager.h (modified) (1 diff)
• source/simulation2/components/CCmpTerritoryManager.cpp (modified) (12 diffs)
• source/simulation2/helpers/Render.cpp (modified) (7 diffs)
• source/simulation2/helpers/Render.h (modified) (3 diffs)

ps/trunk/binaries/data/mods/public/shaders/terrain_base.xml

@@ -6 +6 @@
         <uniform name="losTransform" loc="1" type="vec2"/>
         <uniform name="shadowTransform" loc="2" type="mat4"/>
-        <uniform name="territoryTransform" loc="6" type="vec2"/>
     </vertex>
 
@@ -13 +12 @@
         <uniform name="shadowTex" loc="2" type="sampler2DShadow"/>
         <uniform name="losTex" loc="3" type="sampler2D"/>
-        <uniform name="territoryTex" loc="4" type="sampler2D"/>
 
         <uniform name="ambient" loc="0" type="vec3"/>

ps/trunk/binaries/data/mods/public/shaders/terrain_blend.xml

@@ -8 +8 @@
         <uniform name="losTransform" loc="1" type="vec2"/>
         <uniform name="shadowTransform" loc="2" type="mat4"/>
-        <uniform name="territoryTransform" loc="6" type="vec2"/>
     </vertex>
 
@@ -16 +15 @@
         <uniform name="shadowTex" loc="2" type="sampler2DShadow"/>
         <uniform name="losTex" loc="3" type="sampler2D"/>
-        <uniform name="territoryTex" loc="4" type="sampler2D"/>
 
         <uniform name="ambient" loc="0" type="vec3"/>

ps/trunk/binaries/data/mods/public/shaders/terrain_common.fp

@@ -82 +82 @@
 #endif
 
-// Blend with the territory boundary texture
-TEX tex, fragment.texcoord[4], texture[4], 2D;
-LRP color.rgb, tex.a, tex, color;
-
 // Multiply everything by the LOS texture
 TEX tex.a, fragment.texcoord[3], texture[3], 2D;

ps/trunk/binaries/data/mods/public/shaders/terrain_common.vp

@@ -3 +3 @@
 PARAM losTransform = program.local[1];
 PARAM shadowTransform[4] = { program.local[2..5] };
-PARAM territoryTransform = program.local[6];
 
 TEMP lighting;
@@ -40 +39 @@
 
 MAD result.texcoord[3], position.xzzz, losTransform.x, losTransform.y;
-MAD result.texcoord[4], position.xzzz, territoryTransform.x, territoryTransform.y;
 
 END

ps/trunk/binaries/data/mods/public/shaders/terrain_decal.xml

@@ -8 +8 @@
         <uniform name="losTransform" loc="1" type="vec2"/>
         <uniform name="shadowTransform" loc="2" type="mat4"/>
-        <uniform name="territoryTransform" loc="6" type="vec2"/>
     </vertex>
 
@@ -15 +14 @@
         <uniform name="shadowTex" loc="2" type="sampler2DShadow"/>
         <uniform name="losTex" loc="3" type="sampler2D"/>
-        <uniform name="territoryTex" loc="4" type="sampler2D"/>
 
         <uniform name="ambient" loc="0" type="vec3"/>

ps/trunk/binaries/data/mods/public/simulation/data/pathfinder.xml

@@ -8 +8 @@
 
     <!-- Unit pathfinding classes: -->
+    <unrestricted/>
     <default>
       <MaxWaterDepth>2</MaxWaterDepth>

ps/trunk/source/graphics/Overlay.h

@@ -1 @@
-/* Copyright (C) 2010 Wildfire Games.
+/* Copyright (C) 2011 Wildfire Games.
  * This file is part of 0 A.D.
  *
@@ -19 +19 @@
 #define INCLUDED_GRAPHICS_OVERLAY
 
+#include "graphics/RenderableObject.h"
 #include "graphics/Texture.h"
 #include "maths/Vector3D.h"
 #include "ps/Overlay.h" // CColor  (TODO: that file has nothing to do with overlays, it should be renamed)
+
+class CTerrain;
 
 /**
@@ -34 +37 @@
     std::vector<float> m_Coords; // (x, y, z) vertex coordinate triples; shape is not automatically closed
     u8 m_Thickness; // pixels
+};
+
+/**
+ * Textured line overlay, with world-space coordinates, rendered in the world
+ * onto the terrain. Designed for territory borders.
+ */
+struct SOverlayTexturedLine
+{
+    SOverlayTexturedLine() : m_Terrain(NULL), m_Thickness(1.0f) { }
+
+    CTerrain* m_Terrain;
+    CTexturePtr m_TextureBase;
+    CTexturePtr m_TextureMask;
+    CColor m_Color;
+    std::vector<float> m_Coords; // (x, z) vertex coordinate pairs; y is computed automatically; shape is automatically closed
+    float m_Thickness; // world-space units
+
+    shared_ptr<CRenderData> m_RenderData; // cached renderer data (shared_ptr so that copies/deletes are automatic)
 };
 

ps/trunk/source/graphics/Terrain.cpp

@@ -224 +224 @@
 }
 
+CVector3D CTerrain::CalcExactNormal(float x, float z) const
+{
+    // Clamp to size-2 so we can use the tiles (xi,zi)-(xi+1,zi+1)
+    const ssize_t xi = clamp((ssize_t)floor(x/CELL_SIZE), (ssize_t)0, m_MapSize-2);
+    const ssize_t zi = clamp((ssize_t)floor(z/CELL_SIZE), (ssize_t)0, m_MapSize-2);
+
+    const float xf = clamp(x/CELL_SIZE-xi, 0.0f, 1.0f);
+    const float zf = clamp(z/CELL_SIZE-zi, 0.0f, 1.0f);
+
+    float h00 = m_Heightmap[zi*m_MapSize + xi];
+    float h01 = m_Heightmap[(zi+1)*m_MapSize + xi];
+    float h10 = m_Heightmap[zi*m_MapSize + (xi+1)];
+    float h11 = m_Heightmap[(zi+1)*m_MapSize + (xi+1)];
+
+    // Determine which terrain triangle this point is on,
+    // then compute the normal of that triangle's plane
+
+    if (GetTriangulationDir(xi, zi))
+    {
+        if (xf + zf <= 1.f)
+        {
+            // Lower-left triangle (don't use h11)
+            return -CVector3D(CELL_SIZE, (h10-h00)*HEIGHT_SCALE, 0).Cross(CVector3D(0, (h01-h00)*HEIGHT_SCALE, CELL_SIZE)).Normalized();
+        }
+        else
+        {
+            // Upper-right triangle (don't use h00)
+            return -CVector3D(CELL_SIZE, (h11-h01)*HEIGHT_SCALE, 0).Cross(CVector3D(0, (h11-h10)*HEIGHT_SCALE, CELL_SIZE)).Normalized();
+        }
+    }
+    else
+    {
+        if (xf <= zf)
+        {
+            // Upper-left triangle (don't use h10)
+            return -CVector3D(CELL_SIZE, (h11-h01)*HEIGHT_SCALE, 0).Cross(CVector3D(0, (h01-h00)*HEIGHT_SCALE, CELL_SIZE)).Normalized();
+        }
+        else
+        {
+            // Lower-right triangle (don't use h01)
+            return -CVector3D(CELL_SIZE, (h10-h00)*HEIGHT_SCALE, 0).Cross(CVector3D(0, (h11-h10)*HEIGHT_SCALE, CELL_SIZE)).Normalized();
+        }
+    }
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // GetPatch: return the patch at (i,j) in patch space, or null if the patch is
@@ -299 +344 @@
     float h10 = m_Heightmap[zi*m_MapSize + (xi+1)];
     float h11 = m_Heightmap[(zi+1)*m_MapSize + (xi+1)];
-    // Linearly interpolate
-    return (HEIGHT_SCALE * (
-        (1 - zf) * ((1 - xf) * h00 + xf * h10)
-           + zf  * ((1 - xf) * h01 + xf * h11)));
+
+    // Determine which terrain triangle this point is on,
+    // then compute the linearly-interpolated height on that triangle's plane
+
+    if (GetTriangulationDir(xi, zi))
+    {
+        if (xf + zf <= 1.f)
+        {
+            // Lower-left triangle (don't use h11)
+            return HEIGHT_SCALE * (h00 + (h10-h00)*xf + (h01-h00)*zf);
+        }
+        else
+        {
+            // Upper-right triangle (don't use h00)
+            return HEIGHT_SCALE * (h11 + (h01-h11)*(1-xf) + (h10-h11)*(1-zf));
+        }
+    }
+    else
+    {
+        if (xf <= zf)
+        {
+            // Upper-left triangle (don't use h10)
+            return HEIGHT_SCALE * (h00 + (h11-h01)*xf + (h01-h00)*zf);
+        }
+        else
+        {
+            // Lower-right triangle (don't use h01)
+            return HEIGHT_SCALE * (h00 + (h10-h00)*xf + (h11-h10)*zf);
+        }
+    }
 }
 
@@ -329 +400 @@
     return ((one - zf).Multiply(xf1 * h00 + xf0 * h10)
                   + zf.Multiply(xf1 * h01 + xf0 * h11)) / (int)(HEIGHT_UNITS_PER_METRE / 2);
+
+    // TODO: This should probably be more like GetExactGroundLevel()
+    // in handling triangulation properly
 }
 

ps/trunk/source/graphics/Terrain.h

@@ -127 +127 @@
     void CalcNormalFixed(ssize_t i, ssize_t j, CFixedVector3D& normal) const;
 
+    CVector3D CalcExactNormal(float x, float z) const;
+
     // flatten out an area of terrain (specified in world space coords); return
     // the average height of the flattened area

ps/trunk/source/graphics/TextureManager.cpp

@@ -45 +45 @@
         boost::hash_combine(seed, a.m_Path);
         boost::hash_combine(seed, a.m_Filter);
-        boost::hash_combine(seed, a.m_Wrap);
+        boost::hash_combine(seed, a.m_WrapS);
+        boost::hash_combine(seed, a.m_WrapT);
         boost::hash_combine(seed, a.m_Aniso);
         return seed;
@@ -62 +63 @@
     {
         return a.m_Path == b.m_Path && a.m_Filter == b.m_Filter
-            && a.m_Wrap == b.m_Wrap && a.m_Aniso == b.m_Aniso;
+            && a.m_WrapS == b.m_WrapS && a.m_WrapT == b.m_WrapT
+            && a.m_Aniso == b.m_Aniso;
     }
     bool operator()(CTexturePtr const& a, CTexturePtr const& b) const
@@ -187 +189 @@
 
         // Set GL upload properties
-        (void)ogl_tex_set_wrap(h, texture->m_Properties.m_Wrap);
+        (void)ogl_tex_set_wrap(h, texture->m_Properties.m_WrapS, texture->m_Properties.m_WrapT);
         (void)ogl_tex_set_anisotropy(h, texture->m_Properties.m_Aniso);
 

ps/trunk/source/graphics/TextureManager.h

@@ -130 +130 @@
      */
     explicit CTextureProperties(const VfsPath& path) :
-        m_Path(path), m_Filter(GL_LINEAR_MIPMAP_LINEAR), m_Wrap(GL_REPEAT), m_Aniso(1.0f)
+        m_Path(path), m_Filter(GL_LINEAR_MIPMAP_LINEAR),
+        m_WrapS(GL_REPEAT), m_WrapT(GL_REPEAT), m_Aniso(1.0f)
     {
     }
@@ -142 +143 @@
      * Set wrapping mode (typically GL_REPEAT, GL_CLAMP_TO_EDGE, etc).
      */
-    void SetWrap(GLint wrap) { m_Wrap = wrap; }
+    void SetWrap(GLint wrap) { m_WrapS = wrap; m_WrapT = wrap; }
+
+    /**
+     * Set wrapping mode (typically GL_REPEAT, GL_CLAMP_TO_EDGE, etc),
+     * separately for S and T.
+     */
+    void SetWrap(GLint wrap_s, GLint wrap_t) { m_WrapS = wrap_s; m_WrapT = wrap_t; }
 
     /**
@@ -169 +176 @@
     VfsPath m_Path;
     GLint m_Filter;
-    GLint m_Wrap;
+    GLint m_WrapS;
+    GLint m_WrapT;
     float m_Aniso;
 };

ps/trunk/source/lib/res/graphics/ogl_tex.cpp

@@ -276 +276 @@
     GLint filter;
     // .. wrap mode
-    //    note: to simplify things, we assume that apps will never want to
-    //          set S/T modes independently. it that becomes necessary,
-    //          it's easy to add.
-    GLint wrap;
+    GLint wrap_s;
+    GLint wrap_t;
     // .. anisotropy
     //    note: ignored unless EXT_texture_filter_anisotropic is supported.
@@ -290 +288 @@
 {
     ots->filter = default_filter;
-    ots->wrap = GL_REPEAT;
+    ots->wrap_s = GL_REPEAT;
+    ots->wrap_t = GL_REPEAT;
     ots->anisotropy = 1.0f;
 }
@@ -306 +305 @@
 
     // wrap
-    const GLint wrap = ots->wrap;
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrap);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrap);
+    const GLint wrap_s = ots->wrap_s;
+    const GLint wrap_t = ots->wrap_t;
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrap_s);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrap_t);
     // .. only CLAMP and REPEAT are guaranteed to be available.
     //    if we're using one of the others, we squelch the error that
     //    may have resulted if this GL implementation is old.
-    if(wrap != GL_CLAMP && wrap != GL_REPEAT)
+    if((wrap_s != GL_CLAMP && wrap_s != GL_REPEAT) || (wrap_t != GL_CLAMP && wrap_t != GL_REPEAT))
         ogl_SquelchError(GL_INVALID_ENUM);
 
@@ -482 +482 @@
     if(!filter_valid(ot->state.filter))
         WARN_RETURN(ERR::_14);
-    if(!wrap_valid(ot->state.wrap))
+    if(!wrap_valid(ot->state.wrap_s))
         WARN_RETURN(ERR::_15);
+    if(!wrap_valid(ot->state.wrap_t))
+        WARN_RETURN(ERR::_16);
 
     // misc
     if(!q_flags_valid(ot->q_flags))
-        WARN_RETURN(ERR::_16);
+        WARN_RETURN(ERR::_17);
     if(ot->tmu >= 128)  // unexpected that there will ever be this many
-        WARN_RETURN(ERR::_17);
+        WARN_RETURN(ERR::_18);
     if(ot->flags > OT_ALL_FLAGS)
-        WARN_RETURN(ERR::_18);
+        WARN_RETURN(ERR::_19);
     // .. note: don't check ot->fmt and ot->int_fmt - they aren't set
     //    until during ogl_tex_upload.
@@ -621 +623 @@
 // override default wrap mode (GL_REPEAT) for this texture.
 // must be called before uploading (raises a warning if called afterwards).
-// wrap is as defined by OpenGL and applies to both S and T coordinates
-// (rationale: see OglTexState).
-Status ogl_tex_set_wrap(Handle ht, GLint wrap)
+// wrap is as defined by OpenGL.
+Status ogl_tex_set_wrap(Handle ht, GLint wrap_s, GLint wrap_t)
 {
     H_DEREF(ht, OglTex, ot);
 
-    if(!wrap_valid(wrap))
+    if(!wrap_valid(wrap_s))
         WARN_RETURN(ERR::INVALID_PARAM);
 
-    if(ot->state.wrap != wrap)
+    if(!wrap_valid(wrap_t))
+        WARN_RETURN(ERR::INVALID_PARAM);
+
+    if(ot->state.wrap_s != wrap_s || ot->state.wrap_t != wrap_t)
     {
         warn_if_uploaded(ht, ot);
-        ot->state.wrap = wrap;
+        ot->state.wrap_s = wrap_s;
+        ot->state.wrap_t = wrap_t;
     }
     return INFO::OK;

ps/trunk/source/lib/res/graphics/ogl_tex.h

@@ -290 +290 @@
 *
 * @param ht Texture handle
-* @param wrap OpenGL wrap mode (for both S and T coordinates)
-*        (rationale: see {@link OglTexState})
+* @param wrap_s OpenGL wrap mode for S coordinates
+* @param wrap_t OpenGL wrap mode for T coordinates
 * @return Status
 *
 * Must be called before uploading (raises a warning if called afterwards).
 */
-extern Status ogl_tex_set_wrap(Handle ht, GLint wrap);
+extern Status ogl_tex_set_wrap(Handle ht, GLint wrap_s, GLint wrap_t);
 
 /**

ps/trunk/source/maths/Noise.cpp

@@ -49 +49 @@
 {
     freq = f;
-    grads = new CVector2D_Maths*[freq];
+    grads = new CVector2D*[freq];
     for(int i=0; i<freq; i++) 
     {
-        grads[i] = new CVector2D_Maths[freq];
+        grads[i] = new CVector2D[freq];
         for(int j=0; j<freq; j++) 
         {
             float a = randFloat() * 2 * (float)M_PI;
-            grads[i][j] = CVector2D_Maths(cos(a), sin(a));
+            grads[i][j] = CVector2D(cos(a), sin(a));
         }
     }
@@ -87 +87 @@
     int iy1 = (iy+1) % freq;
     
-    float s = grads[ix][iy].Dot(CVector2D_Maths(fx, fy));
-    float t = grads[ix1][iy].Dot(CVector2D_Maths(fx-1, fy));
-    float u = grads[ix][iy1].Dot(CVector2D_Maths(fx, fy-1));
-    float v = grads[ix1][iy1].Dot(CVector2D_Maths(fx-1, fy-1));
+    float s = grads[ix][iy].Dot(CVector2D(fx, fy));
+    float t = grads[ix1][iy].Dot(CVector2D(fx-1, fy));
+    float u = grads[ix][iy1].Dot(CVector2D(fx, fy-1));
+    float v = grads[ix1][iy1].Dot(CVector2D(fx-1, fy-1));
     
     float ex = easeCurve(fx);

ps/trunk/source/maths/Noise.h

@@ -37 +37 @@
 
     /// freq*freq random gradient vectors in the unit cube
-    CVector2D_Maths** grads;
+    CVector2D** grads;
 public:
     Noise2D(int freq);

ps/trunk/source/maths/Vector2D.h

@@ -1 @@
-/* Copyright (C) 2009 Wildfire Games.
+/* Copyright (C) 2011 Wildfire Games.
  * This file is part of 0 A.D.
  *
@@ -28 +28 @@
 
 ///////////////////////////////////////////////////////////////////////////////
-// CVector2D_Maths:
-class CVector2D_Maths
+// CVector2D:
+class CVector2D
 {
 public:
-    CVector2D_Maths() {}
-    CVector2D_Maths(float x,float y) { X=x; Y=y; }
-    CVector2D_Maths(const CVector2D_Maths& p) { X=p.X; Y=p.Y; }
+    CVector2D() {}
+    CVector2D(float x, float y) : X(x), Y(y) {}
 
-    operator float*() {
+    operator float*()
+    {
         return &X;
     }
 
-    operator const float*() const {
+    operator const float*() const
+    {
         return &X;
     }
 
-    CVector2D_Maths operator-() const {
-        return CVector2D_Maths(-X, -Y);
+    CVector2D operator-() const
+    {
+        return CVector2D(-X, -Y);
     }
 
-    CVector2D_Maths operator+(const CVector2D_Maths& t) const {
-        return CVector2D_Maths(X+t.X, Y+t.Y);
+    CVector2D operator+(const CVector2D& t) const
+    {
+        return CVector2D(X + t.X, Y + t.Y);
     }
 
-    CVector2D_Maths operator-(const CVector2D_Maths& t) const {
-        return CVector2D_Maths(X-t.X, Y-t.Y);
+    CVector2D operator-(const CVector2D& t) const
+    {
+        return CVector2D(X - t.X, Y - t.Y);
     }
 
-    CVector2D_Maths operator*(float f) const {
-        return CVector2D_Maths(X*f, Y*f);
+    CVector2D operator*(float f) const
+    {
+        return CVector2D(X * f, Y * f);
     }
 
-    CVector2D_Maths operator/(float f) const {
-        float inv=1.0f/f;
-        return CVector2D_Maths(X*inv, Y*inv);
+    CVector2D operator/(float f) const
+    {
+        float inv = 1.0f / f;
+        return CVector2D(X * inv, Y * inv);
     }
 
-    CVector2D_Maths& operator+=(const CVector2D_Maths& t) {
-        X+=t.X; Y+=t.Y;
-        return *this;
+    CVector2D& operator+=(const CVector2D& t)
+    {
+        X += t.X;
+        Y += t.Y;
+        return *this;
     }
 
-    CVector2D_Maths& operator-=(const CVector2D_Maths& t) {
-        X-=t.X; Y-=t.Y;
-        return *this;
+    CVector2D& operator-=(const CVector2D& t)
+    {
+        X -= t.X;
+        Y -= t.Y;
+        return *this;
     }
 
-    CVector2D_Maths& operator*=(float f) {
-        X*=f; Y*=f;
-        return *this;
+    CVector2D& operator*=(float f)
+    {
+        X *= f;
+        Y *= f;
+        return *this;
     }
 
-    CVector2D_Maths& operator/=(float f) {
-        float invf=1.0f/f;
-        X*=invf; Y*=invf;
-        return *this;
+    CVector2D& operator/=(float f)
+    {
+        float invf = 1.0f / f;
+        X *= invf;
+        Y *= invf;
+        return *this;
     }
 
-    float Dot(const CVector2D_Maths& a) const {
-        return X*a.X + Y*a.Y;
+    float Dot(const CVector2D& a) const
+    {
+        return X * a.X + Y * a.Y;
     }
 
-    float LengthSquared() const {
-        return Dot(*this);
+    float LengthSquared() const
+    {
+        return Dot(*this);
     }
 
-    float Length() const {
-        return (float) sqrt(LengthSquared());
+    float Length() const
+    {
+        return (float)sqrt(LengthSquared());
     }
 
-    void Normalize() {
-        float mag=Length();
-        X/=mag; Y/=mag;
+    void Normalize()
+    {
+        float mag = Length();
+        X /= mag;
+        Y /= mag;
+    }
+
+    CVector2D Normalized()
+    {
+        float mag = Length();
+        return CVector2D(X / mag, Y / mag);
     }
 

ps/trunk/source/renderer/OverlayRenderer.cpp

@@ -20 +20 @@
 #include "OverlayRenderer.h"
 
+#include "graphics/LOSTexture.h"
 #include "graphics/Overlay.h"
+#include "graphics/ShaderManager.h"
+#include "graphics/Terrain.h"
 #include "graphics/TextureManager.h"
 #include "lib/ogl.h"
+#include "ps/Game.h"
+#include "ps/Profile.h"
 #include "renderer/Renderer.h"
+#include "renderer/VertexBuffer.h"
+#include "renderer/VertexBufferManager.h"
+#include "simulation2/Simulation2.h"
+#include "simulation2/components/ICmpWaterManager.h"
 
 struct OverlayRendererInternals
 {
     std::vector<SOverlayLine*> lines;
+    std::vector<SOverlayTexturedLine*> texlines;
     std::vector<SOverlaySprite*> sprites;
 };
 
+class CTexturedLineRData : public CRenderData
+{
+public:
+    CTexturedLineRData(SOverlayTexturedLine* line) :
+        m_Line(line), m_VB(NULL), m_VBIndices(NULL)
+    {
+    }
+
+    ~CTexturedLineRData()
+    {
+        if (m_VB)
+            g_VBMan.Release(m_VB);
+        if (m_VBIndices)
+            g_VBMan.Release(m_VBIndices);
+    }
+
+    struct SVertex
+    {
+        SVertex(CVector3D pos, short u, short v) : m_Position(pos) { m_UVs[0] = u; m_UVs[1] = v; }
+        CVector3D m_Position;
+        GLshort m_UVs[2];
+    };
+    cassert(sizeof(SVertex) == 16);
+
+    void Update();
+
+    SOverlayTexturedLine* m_Line;
+
+    CVertexBuffer::VBChunk* m_VB;
+    CVertexBuffer::VBChunk* m_VBIndices;
+};
+
 OverlayRenderer::OverlayRenderer()
 {
@@ -41 +83 @@
 }
 
-void OverlayRenderer::Submit(SOverlayLine* overlay)
-{
-    m->lines.push_back(overlay);
+void OverlayRenderer::Submit(SOverlayLine* line)
+{
+    ENSURE(line->m_Coords.size() % 3 == 0);
+
+    m->lines.push_back(line);
+}
+
+void OverlayRenderer::Submit(SOverlayTexturedLine* line)
+{
+    // Simplify the rest of the code by guaranteeing non-empty lines
+    if (line->m_Coords.empty())
+        return;
+
+    ENSURE(line->m_Coords.size() % 2 == 0);
+
+    m->texlines.push_back(line);
 }
 
@@ -54 +109 @@
 {
     m->lines.clear();
+    m->texlines.clear();
     m->sprites.clear();
     // this should leave the capacity unchanged, which is okay since it
@@ -61 +117 @@
 void OverlayRenderer::PrepareForRendering()
 {
+    PROFILE("prepare overlays");
+
     // This is where we should do something like sort the overlays by
     // colour/sprite/etc for more efficient rendering
-}
-
-void OverlayRenderer::RenderOverlays()
-{
+
+    for (size_t i = 0; i < m->texlines.size(); ++i)
+    {
+        SOverlayTexturedLine* line = m->texlines[i];
+        if (!line->m_RenderData)
+        {
+            line->m_RenderData = shared_ptr<CRenderData>(new CTexturedLineRData(line));
+            static_cast<CTexturedLineRData*>(line->m_RenderData.get())->Update();
+            // We assume the overlay line will get replaced by the caller
+            // if terrain changes, so we don't need to detect that here and
+            // call Update again. Also we assume the caller won't change
+            // any of the parameters after first submitting the line.
+        }
+    }
+}
+
+void OverlayRenderer::RenderOverlaysBeforeWater()
+{
+    PROFILE("render overlays (before water)");
+
     glDisable(GL_TEXTURE_2D);
     glEnable(GL_BLEND);
@@ -91 +165 @@
 }
 
+void OverlayRenderer::RenderOverlaysAfterWater()
+{
+    PROFILE("render overlays (after water)");
+
+    // Only supported in shader modes
+    // (TODO: should support in non-shader too)
+    if (g_Renderer.GetRenderPath() != CRenderer::RP_SHADER)
+        return;
+
+    if (!m->texlines.empty())
+    {
+        glEnable(GL_TEXTURE_2D);
+        glEnable(GL_BLEND);
+        glDepthMask(0);
+
+        glEnableClientState(GL_VERTEX_ARRAY);
+        glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+
+        CShaderManager& shaderManager = g_Renderer.GetShaderManager();
+        CShaderProgramPtr shaderTexLine(shaderManager.LoadProgram("overlayline", std::map<CStr, CStr>()));
+
+        shaderTexLine->Bind();
+
+        CLOSTexture& los = g_Renderer.GetScene().GetLOSTexture();
+        shaderTexLine->BindTexture("losTex", los.GetTexture());
+        shaderTexLine->Uniform("losTransform", los.GetTextureMatrix()[0], los.GetTextureMatrix()[12], 0.f, 0.f);
+
+        for (size_t i = 0; i < m->texlines.size(); ++i)
+        {
+            SOverlayTexturedLine* line = m->texlines[i];
+            if (!line->m_RenderData)
+                continue;
+
+            shaderTexLine->BindTexture("baseTex", line->m_TextureBase->GetHandle());
+            shaderTexLine->BindTexture("maskTex", line->m_TextureMask->GetHandle());
+            shaderTexLine->Uniform("objectColor", line->m_Color);
+
+            CTexturedLineRData* rdata = static_cast<CTexturedLineRData*>(line->m_RenderData.get());
+
+            GLsizei stride = sizeof(CTexturedLineRData::SVertex);
+            CTexturedLineRData::SVertex* base = reinterpret_cast<CTexturedLineRData::SVertex*>(rdata->m_VB->m_Owner->Bind());
+
+            glVertexPointer(3, GL_FLOAT, stride, &base->m_Position[0]);
+            glTexCoordPointer(2, GL_SHORT, stride, &base->m_UVs[0]);
+
+            u8* indexBase = rdata->m_VBIndices->m_Owner->Bind();
+            glDrawElements(GL_QUAD_STRIP, rdata->m_VBIndices->m_Count, GL_UNSIGNED_SHORT, indexBase + sizeof(u16)*rdata->m_VBIndices->m_Index);
+
+            g_Renderer.GetStats().m_OverlayTris += rdata->m_VBIndices->m_Count - 2;
+        }
+
+        shaderTexLine->Unbind();
+
+        // TODO: the shader should probably be responsible for unbinding its textures
+        g_Renderer.BindTexture(1, 0);
+        g_Renderer.BindTexture(0, 0);
+
+        CVertexBuffer::Unbind();
+        glDisableClientState(GL_VERTEX_ARRAY);
+        glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+
+        glDepthMask(1);
+        glDisable(GL_BLEND);
+    }
+}
+
 void OverlayRenderer::RenderForegroundOverlays(const CCamera& viewCamera)
 {
+    PROFILE("render overlays (fg)");
+
     glEnable(GL_TEXTURE_2D);
     glEnable(GL_BLEND);
@@ -133 +275 @@
     glDisable(GL_TEXTURE_2D);
 }
+
+void CTexturedLineRData::Update()
+{
+    if (m_VB)
+    {
+        g_VBMan.Release(m_VB);
+        m_VB = NULL;
+    }
+
+    if (m_VBIndices)
+    {
+        g_VBMan.Release(m_VBIndices);
+        m_VBIndices = NULL;
+    }
+
+    CmpPtr<ICmpWaterManager> cmpWaterManager(*g_Game->GetSimulation2(), SYSTEM_ENTITY);
+
+    std::vector<SVertex> vertices;
+    std::vector<u16> indices;
+
+    short v = 0;
+
+    size_t n = m_Line->m_Coords.size() / 2;
+    ENSURE(n >= 1);
+
+    CTerrain* terrain = m_Line->m_Terrain;
+
+    // TODO: this assumes paths are closed loops; probably should extend this to
+    // handle non-closed paths too
+
+    // In each iteration, p1 is the position of vertex i, p0 is i-1, p2 is i+1.
+    // To avoid slightly expensive terrain computations we cycle these around and
+    // recompute p2 at the end of each iteration.
+    CVector3D p0 = CVector3D(m_Line->m_Coords[(n-1)*2], 0, m_Line->m_Coords[(n-1)*2+1]);
+    CVector3D p1 = CVector3D(m_Line->m_Coords[0], 0, m_Line->m_Coords[1]);
+    CVector3D p2 = CVector3D(m_Line->m_Coords[(1 % n)*2], 0, m_Line->m_Coords[(1 % n)*2+1]);
+    bool p1floating = false;
+    bool p2floating = false;
+
+    // Compute terrain heights, clamped to the water height (and remember whether
+    // each point was floating on water, for normal computation later)
+
+    // TODO: if we ever support more than one water level per map, recompute this per point
+    float w = cmpWaterManager->GetExactWaterLevel(p0.X, p0.Z);
+
+    p0.Y = terrain->GetExactGroundLevel(p0.X, p0.Z);
+    if (p0.Y < w)
+        p0.Y = w;
+
+    p1.Y = terrain->GetExactGroundLevel(p1.X, p1.Z);
+    if (p1.Y < w)
+    {
+        p1.Y = w;
+        p1floating = true;
+    }
+
+    p2.Y = terrain->GetExactGroundLevel(p2.X, p2.Z);
+    if (p2.Y < w)
+    {
+        p2.Y = w;
+        p2floating = true;
+    }
+
+    for (size_t i = 0; i < n; ++i)
+    {
+        // For vertex i, compute bisector of lines (i-1)..(i) and (i)..(i+1)
+        // perpendicular to terrain normal
+
+        // Normal is vertical if on water, else computed from terrain
+        CVector3D norm;
+        if (p1floating)
+            norm = CVector3D(0, 1, 0);
+        else
+            norm = m_Line->m_Terrain->CalcExactNormal(p1.X, p1.Z);
+
+        CVector3D b = ((p1 - p0).Normalized() + (p2 - p1).Normalized()).Cross(norm);
+
+        // Adjust bisector length to match the line thickness, along the line's width
+        float l = b.Dot((p2 - p1).Normalized().Cross(norm));
+        if (fabs(l) > 0.000001f) // avoid unlikely divide-by-zero
+            b *= m_Line->m_Thickness / l;
+
+        // Raise off the terrain a little bit
+        const float raised = 0.2f;
+
+        vertices.push_back(SVertex(p1 + b + norm*raised, 0, v));
+        indices.push_back(vertices.size() - 1);
+
+        vertices.push_back(SVertex(p1 - b + norm*raised, 1, v));
+        indices.push_back(vertices.size() - 1);
+
+        // Alternate V coordinate for debugging
+        v = 1 - v;
+
+        // Cycle the p's and compute the new p2
+        p0 = p1;
+        p1 = p2;
+        p1floating = p2floating;
+        p2 = CVector3D(m_Line->m_Coords[((i+2) % n)*2], 0, m_Line->m_Coords[((i+2) % n)*2+1]);
+        p2.Y = terrain->GetExactGroundLevel(p2.X, p2.Z);
+        if (p2.Y < w)
+        {
+            p2.Y = w;
+            p2floating = true;
+        }
+        else
+            p2floating = false;
+    }
+
+    // Close the path
+    indices.push_back(0);
+    indices.push_back(1);
+
+    m_VB = g_VBMan.Allocate(sizeof(SVertex), vertices.size(), GL_STATIC_DRAW, GL_ARRAY_BUFFER);
+    m_VB->m_Owner->UpdateChunkVertices(m_VB, &vertices[0]);
+
+    // Update the indices to include the base offset of the vertex data
+    for (size_t k = 0; k < indices.size(); ++k)
+        indices[k] += m_VB->m_Index;
+
+    m_VBIndices = g_VBMan.Allocate(sizeof(u16), indices.size(), GL_STATIC_DRAW, GL_ELEMENT_ARRAY_BUFFER);
+    m_VBIndices->m_Owner->UpdateChunkVertices(m_VBIndices, &indices[0]);
+}

ps/trunk/source/renderer/OverlayRenderer.h

@@ -20 +20 @@
 
 struct SOverlayLine;
+struct SOverlayTexturedLine;
 struct SOverlaySprite;
 class CCamera;
@@ -41 +42 @@
 
     /**
+     * Add a textured line overlay for rendering in this frame.
+     */
+    void Submit(SOverlayTexturedLine* overlay);
+
+    /**
      * Add a sprite overlay for rendering in this frame.
      */
@@ -59 +65 @@
     /**
      * Render all the submitted overlays that are embedded in the world
-     * (i.e. rendered behind other objects, underwater, etc).
+     * (i.e. rendered behind other objects in the normal 3D way)
+     * and should be drawn before water (i.e. may be visible under the water)
      */
-    void RenderOverlays();
+    void RenderOverlaysBeforeWater();
+
+    /**
+     * Render all the submitted overlays that are embedded in the world
+     * (i.e. rendered behind other objects in the normal 3D way)
+     * and should be drawn after water (i.e. may be visible on top of the water)
+     */
+    void RenderOverlaysAfterWater();
 
     /**

ps/trunk/source/renderer/Renderer.cpp

@@ -107 +107 @@
         Row_WaterTris,
         Row_ModelTris,
+        Row_OverlayTris,
         Row_BlendSplats,
         Row_Particles,
@@ -174 +175 @@
             return "# model tris";
         sprintf_s(buf, sizeof(buf), "%lu", (unsigned long)Stats.m_ModelTris);
+        return buf;
+
+    case Row_OverlayTris:
+        if (col == 0)
+            return "# overlay tris";
+        sprintf_s(buf, sizeof(buf), "%lu", (unsigned long)Stats.m_OverlayTris);
         return buf;
 
@@ -1574 +1581 @@
     ogl_WarnIfError();
 
-    // render other debug-related overlays before water (so they can be displayed when underwater)
-    PROFILE_START("render overlays");
-    m->overlayRenderer.RenderOverlays();
-    PROFILE_END("render overlays");
+    // render other debug-related overlays before water (so they can be seen when underwater)
+    m->overlayRenderer.RenderOverlaysBeforeWater();
     ogl_WarnIfError();
 
@@ -1604 +1609 @@
     }
 
+    // render some other overlays after water (so they can be displayed on top of water)
+    m->overlayRenderer.RenderOverlaysAfterWater();
+    ogl_WarnIfError();
+
     // particles are transparent so render after water
     RenderParticles();
@@ -1623 +1632 @@
 
     // render overlays that should appear on top of all other objects
-    PROFILE_START("render fg overlays");
     m->overlayRenderer.RenderForegroundOverlays(m_ViewCamera);
-    PROFILE_END("render fg overlays");
     ogl_WarnIfError();
 }
@@ -1719 +1726 @@
 
 void CRenderer::Submit(SOverlayLine* overlay)
+{
+    m->overlayRenderer.Submit(overlay);
+}
+
+void CRenderer::Submit(SOverlayTexturedLine* overlay)
 {
     m->overlayRenderer.Submit(overlay);
@@ -1933 +1945 @@
     m_hCompositeAlphaMap = ogl_tex_wrap(&t, g_VFS, key);
     (void)ogl_tex_set_filter(m_hCompositeAlphaMap, GL_LINEAR);
-    (void)ogl_tex_set_wrap  (m_hCompositeAlphaMap, GL_CLAMP_TO_EDGE);
+    (void)ogl_tex_set_wrap  (m_hCompositeAlphaMap, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE);
     int ret = ogl_tex_upload(m_hCompositeAlphaMap, 0, 0, GL_INTENSITY);
 

ps/trunk/source/renderer/Renderer.h

@@ -117 +117 @@
         // number of (non-transparent) model triangles drawn
         size_t m_ModelTris;
+        // number of overlay triangles drawn
+        size_t m_OverlayTris;
         // number of splat passes for alphamapping
         size_t m_BlendSplats;
@@ -335 +337 @@
     void Submit(CPatch* patch);
     void Submit(SOverlayLine* overlay);
+    void Submit(SOverlayTexturedLine* overlay);
     void Submit(SOverlaySprite* overlay);
     void Submit(CModelDecal* decal);

ps/trunk/source/renderer/Scene.h

@@ -38 +38 @@
 class CTerritoryTexture;
 struct SOverlayLine;
+struct SOverlayTexturedLine;
 struct SOverlaySprite;
 
@@ -94 +95 @@
 
     /**
+     * Submit a textured line overlay.
+     */
+    virtual void Submit(SOverlayTexturedLine* overlay) = 0;
+
+    /**
      * Submit a sprite overlay.
      */

ps/trunk/source/renderer/VertexBuffer.cpp

@@ -29 +29 @@
 #include "ps/CLogger.h"
 
-///////////////////////////////////////////////////////////////////////////////
-// CVertexBuffer constructor 
 CVertexBuffer::CVertexBuffer(size_t vertexSize, GLenum usage, GLenum target)
     : m_VertexSize(vertexSize), m_Handle(0), m_SysMem(0), m_Usage(usage), m_Target(target)
@@ -67 +65 @@
 }
 
-///////////////////////////////////////////////////////////////////////////////
-// CVertexBuffer destructor
 CVertexBuffer::~CVertexBuffer()
 {
@@ -74 +70 @@
         pglDeleteBuffersARB(1, &m_Handle);
 
-    if (m_SysMem)
-        delete[] m_SysMem;
-
-    // janwas 2004-06-14: release freelist
+    delete[] m_SysMem;
+
     typedef std::list<VBChunk*>::iterator Iter;
     for (Iter iter = m_FreeList.begin(); iter != m_FreeList.end(); ++iter)
         delete *iter;
+}
+
+
+bool CVertexBuffer::CompatibleVertexType(size_t vertexSize, GLenum usage, GLenum target)
+{
+    if (usage != m_Usage || target != m_Target || vertexSize != m_VertexSize)
+        return false;
+
+    return true;
 }
 
@@ -90 +93 @@
 {
     // check this is the right kind of buffer
-    if (usage != m_Usage || target != m_Target || vertexSize != m_VertexSize)
+    if (!CompatibleVertexType(vertexSize, usage, target))
         return 0;
 
@@ -139 +142 @@
 void CVertexBuffer::Release(VBChunk* chunk)
 {
-    // add to free list
-    // TODO, RC - need to merge available chunks where possible to avoid 
-    // excessive fragmentation of vertex buffer space
+    // Update total free count before potentially modifying this chunk's count
+    m_FreeVertices += chunk->m_Count;
+
+    typedef std::list<VBChunk*>::iterator Iter;
+
+    // Coalesce with any free-list items that are adjacent to this chunk;
+    // merge the found chunk with the new one, and remove the old one
+    // from the list, and repeat until no more are found
+    bool coalesced;
+    do
+    {
+        coalesced = false;
+        for (Iter iter = m_FreeList.begin(); iter != m_FreeList.end(); ++iter)
+        {
+            if ((*iter)->m_Index == chunk->m_Index + chunk->m_Count
+             || (*iter)->m_Index + (*iter)->m_Count == chunk->m_Index)
+            {
+                chunk->m_Index = std::min(chunk->m_Index, (*iter)->m_Index);
+                chunk->m_Count += (*iter)->m_Count;
+                m_FreeList.erase(iter);
+                coalesced = true;
+                break;
+            }
+        }
+    }
+    while (coalesced);
+
     m_FreeList.push_front(chunk);
-    m_FreeVertices += chunk->m_Count;
 }
 
@@ -206 +232 @@
     return (m_MaxVertices - m_FreeVertices) * m_VertexSize;
 }
+
+void CVertexBuffer::DumpStatus()
+{
+    debug_printf(L"freeverts = %d\n", m_FreeVertices);
+
+    size_t maxSize = 0;
+    typedef std::list<VBChunk*>::iterator Iter;
+    for (Iter iter = m_FreeList.begin(); iter != m_FreeList.end(); ++iter)
+    {
+        debug_printf(L"free chunk %p: size=%d\n", *iter, (*iter)->m_Count);
+        maxSize = std::max((*iter)->m_Count, maxSize);
+    }
+    debug_printf(L"max size = %d\n", maxSize);
+}

ps/trunk/source/renderer/VertexBuffer.h

@@ -46 +46 @@
         // number of vertices used by chunk
         size_t m_Count;
+
+    private:
+        // Only CVertexBuffer can construct/delete these
+        // (Other people should use g_VBMan.Allocate, g_VBMan.Release)
+        friend class CVertexBuffer;
+        VBChunk() {}
+        ~VBChunk() {}
     };
 
@@ -70 +77 @@
     size_t GetBytesReserved() const;
     size_t GetBytesAllocated() const;
+
+    bool CompatibleVertexType(size_t vertexSize, GLenum usage, GLenum target);
+
+    void DumpStatus();
 
 protected:

ps/trunk/source/renderer/VertexBufferManager.cpp

@@ -27 +27 @@
 #include "ps/CLogger.h"
 
+#define DUMP_VB_STATS 0 // for debugging
+
 CVertexBufferManager g_VBMan;
-
-// janwas 2004-06-14: added dtor
-
-CVertexBufferManager::~CVertexBufferManager()
-{
-}
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -62 +58 @@
     // TODO, RC - run some sanity checks on allocation request
 
+    typedef std::list<CVertexBuffer*>::iterator Iter;
+
+#if DUMP_VB_STATS
+    debug_printf(L"\n============================\n# allocate vsize=%d nverts=%d\n\n", vertexSize, numVertices);
+    for (Iter iter = m_Buffers.begin(); iter != m_Buffers.end(); ++iter) {
+        CVertexBuffer* buffer = *iter;
+        if (buffer->CompatibleVertexType(vertexSize, usage, target))
+        {
+            debug_printf(L"%p\n", buffer);
+            buffer->DumpStatus();
+        }
+    }
+#endif
+
     // iterate through all existing buffers testing for one that'll 
     // satisfy the allocation
-    typedef std::list<CVertexBuffer*>::iterator Iter;
     for (Iter iter = m_Buffers.begin(); iter != m_Buffers.end(); ++iter) {
         CVertexBuffer* buffer = *iter;
@@ -90 +99 @@
 {
     ENSURE(chunk);
+#if DUMP_VB_STATS
+    debug_printf(L"\n============================\n# release %p nverts=%d\n\n", chunk, chunk->m_Count);
+#endif
     chunk->m_Owner->Release(chunk);
 }

ps/trunk/source/renderer/VertexBufferManager.h

@@ -31 +31 @@
 {
 public:
-    CVertexBufferManager() {}
-    ~CVertexBufferManager();
-
     // Explicit shutdown of the vertex buffer subsystem
     void Shutdown();

ps/trunk/source/simulation2/components/CCmpTerritoryManager.cpp

@@ -21 +21 @@
 #include "ICmpTerritoryManager.h"
 
+#include "graphics/Overlay.h"
 #include "graphics/Terrain.h"
+#include "graphics/TextureManager.h"
 #include "maths/MathUtil.h"
+#include "maths/Vector2D.h"
 #include "ps/Overlay.h"
+#include "renderer/Renderer.h"
+#include "renderer/Scene.h"
 #include "renderer/TerrainOverlay.h"
 #include "simulation2/MessageTypes.h"
@@ -30 +35 @@
 #include "simulation2/components/ICmpOwnership.h"
 #include "simulation2/components/ICmpPathfinder.h"
+#include "simulation2/components/ICmpPlayer.h"
+#include "simulation2/components/ICmpPlayerManager.h"
 #include "simulation2/components/ICmpPosition.h"
 #include "simulation2/components/ICmpSettlement.h"
@@ -37 +44 @@
 #include "simulation2/helpers/Grid.h"
 #include "simulation2/helpers/PriorityQueue.h"
+#include "simulation2/helpers/Render.h"
 
 class CCmpTerritoryManager;
@@ -59 +67 @@
         componentManager.SubscribeGloballyToMessageType(MT_PositionChanged);
         componentManager.SubscribeToMessageType(MT_TerrainChanged);
+        componentManager.SubscribeToMessageType(MT_RenderSubmit);
     }
 
@@ -67 +76 @@
         return "<a:component type='system'/><empty/>";
     }
+
+    u8 m_ImpassableCost;
+    float m_BorderThickness;
+    float m_BorderSeparation;
 
     Grid<u8>* m_Territories;
     TerritoryOverlay* m_DebugOverlay;
+    std::vector<SOverlayTexturedLine> m_BoundaryLines;
+    bool m_BoundaryLinesDirty;
 
     virtual void Init(const CParamNode& UNUSED(paramNode))
@@ -76 +91 @@
         m_DebugOverlay = NULL;
 //      m_DebugOverlay = new TerritoryOverlay(*this);
+        m_BoundaryLinesDirty = true;
 
         m_DirtyID = 1;
+
+        CParamNode externalParamNode;
+        CParamNode::LoadXML(externalParamNode, L"simulation/data/territorymanager.xml");
+
+        m_ImpassableCost = externalParamNode.GetChild("TerritoryManager").GetChild("ImpassableCost").ToInt();
+        m_BorderThickness = externalParamNode.GetChild("TerritoryManager").GetChild("BorderThickness").ToFixed().ToFloat();
+        m_BorderSeparation = externalParamNode.GetChild("TerritoryManager").GetChild("BorderSeparation").ToFixed().ToFloat();
     }
 
@@ -117 +140 @@
             break;
         }
+        case MT_RenderSubmit:
+        {
+            const CMessageRenderSubmit& msgData = static_cast<const CMessageRenderSubmit&> (msg);
+            RenderSubmit(msgData.collector);
+            break;
+        }
         }
     }
@@ -149 +178 @@
         SAFE_DELETE(m_Territories);
         ++m_DirtyID;
+        m_BoundaryLinesDirty = true;
     }
 
@@ -170 +200 @@
      */
     void RasteriseInfluences(CComponentManager::InterfaceList& infls, Grid<u8>& grid);
+
+    struct TerritoryBoundary
+    {
+        player_id_t owner;
+        std::vector<CVector2D> points;
+    };
+
+    std::vector<TerritoryBoundary> ComputeBoundaries();
+
+    void UpdateBoundaryLines();
+
+    void RenderSubmit(SceneCollector& collector);
 };
 
@@ -253 +295 @@
 
     CmpPtr<ICmpPathfinder> cmpPathfinder(GetSimContext(), SYSTEM_ENTITY);
-    ICmpPathfinder::pass_class_t passClass = cmpPathfinder->GetPassabilityClass("default");
+    ICmpPathfinder::pass_class_t passClassUnrestricted = cmpPathfinder->GetPassabilityClass("unrestricted");
+    ICmpPathfinder::pass_class_t passClassDefault = cmpPathfinder->GetPassabilityClass("default");
     const Grid<u16>& passGrid = cmpPathfinder->GetPassabilityGrid();
     for (u32 j = 0; j < tilesH; ++j)
@@ -259 +302 @@
         for (u32 i = 0; i < tilesW; ++i)
         {
+            u8 g = passGrid.get(i, j);
             u8 cost;
-            if (passGrid.get(i, j) & passClass)
-                cost = 4; // TODO: should come from some XML file
+            if (g & passClassUnrestricted)
+                cost = 255; // off the world; use maximum cost
+            else if (g & passClassDefault)
+                cost = m_ImpassableCost;
             else
                 cost = 1;
@@ -426 +472 @@
 }
 
+std::vector<CCmpTerritoryManager::TerritoryBoundary> CCmpTerritoryManager::ComputeBoundaries()
+{
+    PROFILE("ComputeBoundaries");
+
+    std::vector<CCmpTerritoryManager::TerritoryBoundary> boundaries;
+
+    CalculateTerritories();
+
+    // Copy the territories grid so we can mess with it
+    Grid<u8> grid (*m_Territories);
+
+    // Some constants for the border walk
+    CVector2D edgeOffsets[] = {
+        CVector2D(0.5f, 0.0f),
+        CVector2D(1.0f, 0.5f),
+        CVector2D(0.5f, 1.0f),
+        CVector2D(0.0f, 0.5f)
+    };
+
+    // Try to find an assigned tile
+    for (int j = 0; j < grid.m_H; ++j)
+    {
+        for (int i = 0; i < grid.m_W; ++i)
+        {
+            u8 owner = grid.get(i, j);
+            if (owner)
+            {
+                // Found the first tile (which must be the lowest j value of any non-zero tile);
+                // start at the bottom edge of it and chase anticlockwise around the border until
+                // we reach the starting point again
+
+                boundaries.push_back(TerritoryBoundary());
+                boundaries.back().owner = owner;
+                std::vector<CVector2D>& points = boundaries.back().points;
+
+                int dir = 0; // 0 == bottom edge of tile, 1 == right, 2 == top, 3 == left
+
+                int cdir = dir;
+                int ci = i, cj = j;
+
+                while (true)
+                {
+                    points.push_back((CVector2D(ci, cj) + edgeOffsets[cdir]) * CELL_SIZE);
+
+                    // Given that we're on an edge on a continuous boundary and aiming anticlockwise,
+                    // we can either carry on straight or turn left or turn right, so examine each
+                    // of the three possible cases (depending on initial direction):
+                    switch (cdir)
+                    {
+                    case 0:
+                        if (ci < grid.m_W-1 && cj > 0 && grid.get(ci+1, cj-1) == owner)
+                        {
+                            ++ci;
+                            --cj;
+                            cdir = 3;
+                        }
+                        else if (ci < grid.m_W-1 && grid.get(ci+1, cj) == owner)
+                            ++ci;
+                        else
+                            cdir = 1;
+                        break;
+                    case 1:
+                        if (ci < grid.m_W-1 && cj < grid.m_H-1 && grid.get(ci+1, cj+1) == owner)
+                        {
+                            ++ci;
+                            ++cj;
+                            cdir = 0;
+                        }
+                        else if (cj < grid.m_H-1 && grid.get(ci, cj+1) == owner)
+                            ++cj;
+                        else
+                            cdir = 2;
+                        break;
+                    case 2:
+                        if (ci > 0 && cj < grid.m_H-1 && grid.get(ci-1, cj+1) == owner)
+                        {
+                            --ci;
+                            ++cj;
+                            cdir = 1;
+                        }
+                        else if (ci > 0 && grid.get(ci-1, cj) == owner)
+                            --ci;
+                        else
+                            cdir = 3;
+                        break;
+                    case 3:
+                        if (ci > 0 && cj > 0 && grid.get(ci-1, cj-1) == owner)
+                        {
+                            --ci;
+                            --cj;
+                            cdir = 2;
+                        }
+                        else if (cj > 0 && grid.get(ci, cj-1) == owner)
+                            --cj;
+                        else
+                            cdir = 0;
+                        break;
+                    }
+
+                    // Stop when we've reached the starting point again
+                    if (ci == i && cj == j && cdir == dir)
+                        break;
+                }
+
+                // Zero out this whole territory with a simple flood fill, so we don't
+                // process it a second time
+                std::vector<std::pair<int, int> > tileStack;
+
+#define ZERO_AND_PUSH(i, j) STMT(grid.set(i, j, 0); tileStack.push_back(std::make_pair(i, j)); )
+
+                ZERO_AND_PUSH(i, j);
+                while (!tileStack.empty())
+                {
+                    int ti = tileStack.back().first;
+                    int tj = tileStack.back().second;
+                    tileStack.pop_back();
+
+                    if (ti > 0 && grid.get(ti-1, tj) == owner)
+                        ZERO_AND_PUSH(ti-1, tj);
+                    if (ti < grid.m_W-1 && grid.get(ti+1, tj) == owner)
+                        ZERO_AND_PUSH(ti+1, tj);
+                    if (tj > 0 && grid.get(ti, tj-1) == owner)
+                        ZERO_AND_PUSH(ti, tj-1);
+                    if (tj < grid.m_H-1 && grid.get(ti, tj+1) == owner)
+                        ZERO_AND_PUSH(ti, tj+1);
+
+                    if (ti > 0 && tj > 0 && grid.get(ti-1, tj-1) == owner)
+                        ZERO_AND_PUSH(ti-1, tj-1);
+                    if (ti > 0 && tj < grid.m_H-1 && grid.get(ti-1, tj+1) == owner)
+                        ZERO_AND_PUSH(ti-1, tj+1);
+                    if (ti < grid.m_W-1 && tj > 0 && grid.get(ti+1, tj-1) == owner)
+                        ZERO_AND_PUSH(ti+1, tj-1);
+                    if (ti < grid.m_W-1 && tj < grid.m_H-1 && grid.get(ti+1, tj+1) == owner)
+                        ZERO_AND_PUSH(ti+1, tj+1);
+                }
+
+#undef ZERO_AND_PUSH
+            }
+        }
+    }
+
+    return boundaries;
+}
+
+void CCmpTerritoryManager::UpdateBoundaryLines()
+{
+    PROFILE("update boundary lines");
+
+    m_BoundaryLines.clear();
+
+    std::vector<CCmpTerritoryManager::TerritoryBoundary> boundaries = ComputeBoundaries();
+
+    CTextureProperties texturePropsBase("art/textures/misc/territory_border.png");
+    texturePropsBase.SetWrap(GL_CLAMP_TO_BORDER, GL_CLAMP_TO_EDGE);
+    texturePropsBase.SetMaxAnisotropy(2.f);
+    CTexturePtr textureBase = g_Renderer.GetTextureManager().CreateTexture(texturePropsBase);
+
+    CTextureProperties texturePropsMask("art/textures/misc/territory_border_mask.png");
+    texturePropsMask.SetWrap(GL_CLAMP_TO_BORDER, GL_CLAMP_TO_EDGE);
+    texturePropsMask.SetMaxAnisotropy(2.f);
+    CTexturePtr textureMask = g_Renderer.GetTextureManager().CreateTexture(texturePropsMask);
+
+    CmpPtr<ICmpTerrain> cmpTerrain(GetSimContext(), SYSTEM_ENTITY);
+    if (cmpTerrain.null())
+        return;
+    CTerrain* terrain = cmpTerrain->GetCTerrain();
+
+    CmpPtr<ICmpPlayerManager> cmpPlayerManager(GetSimContext(), SYSTEM_ENTITY);
+    if (cmpPlayerManager.null())
+        return;
+
+    for (size_t i = 0; i < boundaries.size(); ++i)
+    {
+        if (boundaries[i].points.empty())
+            continue;
+
+        CColor color(1, 0, 1, 1);
+        CmpPtr<ICmpPlayer> cmpPlayer(GetSimContext(), cmpPlayerManager->GetPlayerByID(boundaries[i].owner));
+        if (!cmpPlayer.null())
+            color = cmpPlayer->GetColour();
+
+        m_BoundaryLines.push_back(SOverlayTexturedLine());
+        m_BoundaryLines.back().m_Terrain = terrain;
+        m_BoundaryLines.back().m_TextureBase = textureBase;
+        m_BoundaryLines.back().m_TextureMask = textureMask;
+        m_BoundaryLines.back().m_Color = color;
+        m_BoundaryLines.back().m_Thickness = m_BorderThickness;
+
+        SimRender::SmoothPointsAverage(boundaries[i].points, true);
+
+        SimRender::InterpolatePointsRNS(boundaries[i].points, true, m_BorderSeparation);
+
+        std::vector<float>& points = m_BoundaryLines.back().m_Coords;
+        for (size_t j = 0; j < boundaries[i].points.size(); ++j)
+        {
+            points.push_back(boundaries[i].points[j].X);
+            points.push_back(boundaries[i].points[j].Y);
+        }
+    }
+}
+
+void CCmpTerritoryManager::RenderSubmit(SceneCollector& collector)
+{
+    if (m_BoundaryLinesDirty)
+    {
+        UpdateBoundaryLines();
+        m_BoundaryLinesDirty = false;
+    }
+
+    for (size_t i = 0; i < m_BoundaryLines.size(); ++i)
+        collector.Submit(&m_BoundaryLines[i]);
+}
+
 
 void TerritoryOverlay::StartRender()

ps/trunk/source/simulation2/helpers/Render.cpp

@@ -26 +26 @@
 #include "graphics/Terrain.h"
 #include "maths/MathUtil.h"
-
-static const float RENDER_HEIGHT_DELTA = 0.25f; // distance above terrain
-
-void SimRender::ConstructLineOnGround(const CSimContext& context, std::vector<float> xz,
-        SOverlayLine& overlay, bool floating)
-{
+#include "maths/Vector2D.h"
+#include "ps/Profile.h"
+
+void SimRender::ConstructLineOnGround(const CSimContext& context, const std::vector<float>& xz,
+        SOverlayLine& overlay, bool floating, float heightOffset)
+{
+    PROFILE("ConstructLineOnGround");
+
     overlay.m_Coords.clear();
 
@@ -55 +57 @@
         float px = xz[i];
         float pz = xz[i+1];
-        float py = std::max(water, cmpTerrain->GetExactGroundLevel(px, pz)) + RENDER_HEIGHT_DELTA;
+        float py = std::max(water, cmpTerrain->GetExactGroundLevel(px, pz)) + heightOffset;
         overlay.m_Coords.push_back(px);
         overlay.m_Coords.push_back(py);
@@ -63 +65 @@
 
 void SimRender::ConstructCircleOnGround(const CSimContext& context, float x, float z, float radius,
-        SOverlayLine& overlay, bool floating)
+        SOverlayLine& overlay, bool floating, float heightOffset)
 {
     overlay.m_Coords.clear();
@@ -89 +91 @@
         float px = x + radius * sin(a);
         float pz = z + radius * cos(a);
-        float py = std::max(water, cmpTerrain->GetExactGroundLevel(px, pz)) + RENDER_HEIGHT_DELTA;
+        float py = std::max(water, cmpTerrain->GetExactGroundLevel(px, pz)) + heightOffset;
         overlay.m_Coords.push_back(px);
         overlay.m_Coords.push_back(py);
@@ -114 +116 @@
 
 void SimRender::ConstructSquareOnGround(const CSimContext& context, float x, float z, float w, float h, float a,
-        SOverlayLine& overlay, bool floating)
+        SOverlayLine& overlay, bool floating, float heightOffset)
 {
     overlay.m_Coords.clear();
@@ -151 +153 @@
         float px = coords[i].first;
         float pz = coords[i].second;
-        float py = std::max(water, cmpTerrain->GetExactGroundLevel(px, pz)) + RENDER_HEIGHT_DELTA;
+        float py = std::max(water, cmpTerrain->GetExactGroundLevel(px, pz)) + heightOffset;
         overlay.m_Coords.push_back(px);
         overlay.m_Coords.push_back(py);
@@ -157 +159 @@
     }
 }
+
+void SimRender::SmoothPointsAverage(std::vector<CVector2D>& points, bool closed)
+{
+    PROFILE("SmoothPointsAverage");
+
+    size_t n = points.size();
+    if (n < 2)
+        return; // avoid out-of-bounds array accesses, and leave the points unchanged
+
+    std::vector<CVector2D> newPoints;
+    newPoints.resize(points.size());
+
+    // Handle the end points appropriately
+    if (closed)
+    {
+        newPoints[0] = (points[n-1] + points[0] + points[1]) / 3.f;
+        newPoints[n-1] = (points[n-2] + points[n-1] + points[0]) / 3.f;
+    }
+    else
+    {
+        newPoints[0] = points[0];
+        newPoints[n-1] = points[n-1];
+    }
+
+    // Average all the intermediate points
+    for (size_t i = 1; i < n-1; ++i)
+        newPoints[i] = (points[i-1] + points[i] + points[i+1]) / 3.f;
+
+    points.swap(newPoints);
+}
+
+static CVector2D EvaluateSpline(float t, CVector2D a0, CVector2D a1, CVector2D a2, CVector2D a3, float offset)
+{
+    // Compute position on spline
+    CVector2D p = a0*(t*t*t) + a1*(t*t) + a2*t + a3;
+
+    // Compute unit-vector direction of spline
+    CVector2D dp = (a0*(3*t*t) + a1*(2*t) + a2).Normalized();
+
+    // Offset position perpendicularly
+    return p + CVector2D(dp.Y*-offset, dp.X*offset);
+}
+
+void SimRender::InterpolatePointsRNS(std::vector<CVector2D>& points, bool closed, float offset)
+{
+    PROFILE("InterpolatePointsRNS");
+
+    std::vector<CVector2D> newPoints;
+
+    // (This does some redundant computations for adjacent vertices,
+    // but it's fairly fast (<1ms typically) so we don't worry about it yet)
+
+    // TODO: Instead of doing a fixed number of line segments between each
+    // control point, it should probably be somewhat adaptive to get a nicer
+    // curve with fewer points
+
+    size_t n = points.size();
+    if (n < 1)
+        return; // can't do anything unless we have two points
+
+    size_t imax = closed ? n : n-1; // TODO: we probably need to do a bit more to handle non-closed paths
+
+    newPoints.reserve(imax*4);
+
+    for (size_t i = 0; i < imax; ++i)
+    {
+        // Get the relevant points for this spline segment
+        CVector2D p0 = points[(i-1+n)%n];
+        CVector2D p1 = points[i];
+        CVector2D p2 = points[(i+1)%n];
+        CVector2D p3 = points[(i+2)%n];
+
+        // Do the RNS computation (based on GPG4 "Nonuniform Splines")
+        float l1 = (p2 - p1).Length(); // length of spline segment (i)..(i+1)
+        CVector2D s0 = (p1 - p0).Normalized(); // unit vector of spline segment (i-1)..(i)
+        CVector2D s1 = (p2 - p1).Normalized(); // unit vector of spline segment (i)..(i+1)
+        CVector2D s2 = (p3 - p2).Normalized(); // unit vector of spline segment (i+1)..(i+2)
+        CVector2D v1 = (s0 + s1).Normalized() * l1; // spline velocity at i
+        CVector2D v2 = (s1 + s2).Normalized() * l1; // spline velocity at i+1
+
+        // Compute standard cubic spline parameters
+        CVector2D a0 = p1*2 + p2*-2 + v1 + v2;
+        CVector2D a1 = p1*-3 + p2*3 + v1*-2 + v2*-1;
+        CVector2D a2 = v1;
+        CVector2D a3 = p1;
+
+        // Interpolate at various points
+        newPoints.push_back(EvaluateSpline(0.f, a0, a1, a2, a3, offset));
+        newPoints.push_back(EvaluateSpline(1.f/4.f, a0, a1, a2, a3, offset));
+        newPoints.push_back(EvaluateSpline(2.f/4.f, a0, a1, a2, a3, offset));
+        newPoints.push_back(EvaluateSpline(3.f/4.f, a0, a1, a2, a3, offset));
+    }
+
+    points.swap(newPoints);
+}

ps/trunk/source/simulation2/helpers/Render.h

@@ -25 +25 @@
 
 class CSimContext;
+class CVector2D;
 struct SOverlayLine;
 
@@ -34 +35 @@
  * flattened on the terrain (or on the water if @p floating).
  */
-void ConstructLineOnGround(const CSimContext& context, std::vector<float> xz, SOverlayLine& overlay, bool floating);
+void ConstructLineOnGround(const CSimContext& context, const std::vector<float>& xz,
+        SOverlayLine& overlay,
+        bool floating, float heightOffset = 0.25f);
 
 /**
  * Updates @p overlay so that it represents the given circle, flattened on the terrain.
  */
-void ConstructCircleOnGround(const CSimContext& context, float x, float z, float radius, SOverlayLine& overlay, bool floating);
+void ConstructCircleOnGround(const CSimContext& context, float x, float z, float radius,
+        SOverlayLine& overlay,
+        bool floating, float heightOffset = 0.25f);
 
 /**
@@ -45 +50 @@
  * @p x and @p z are position of center, @p w and @p h are size of rectangle, @p a is clockwise angle.
  */
-void ConstructSquareOnGround(const CSimContext& context, float x, float z, float w, float h, float a, SOverlayLine& overlay, bool floating);
+void ConstructSquareOnGround(const CSimContext& context, float x, float z, float w, float h, float a,
+        SOverlayLine& overlay,
+        bool floating, float heightOffset = 0.25f);
+
+/**
+ * Updates @p points so each point is averaged with its neighbours, resulting in
+ * a somewhat smoother curve, assuming the points are roughly equally spaced.
+ * If @p closed then the points are treated as a closed path (the last is connected
+ * to the first).
+ */
+void SmoothPointsAverage(std::vector<CVector2D>& points, bool closed);
+
+/**
+ * Updates @p points to include intermediate points interpolating between the original
+ * control points, using a rounded nonuniform spline.
+ * The points are also shifted by @p offset in a direction 90 degrees clockwise from
+ * the direction of the curve.
+ * If @p closed then the points are treated as a closed path (the last is connected
+ * to the first).
+ */
+void InterpolatePointsRNS(std::vector<CVector2D>& points, bool closed, float offset);
 
 } // namespace