Ticket #824: pretty_unit_rings_WIP_01mar12.patch

new file inaries/data/mods/public/shaders/overlay_selection.fp

@@ +1 @@
+!!ARBfp1.0
+TEMP base;
+TEMP mask;
+TEMP color;
+
+// Combine base texture and color, using mask texture
+TEX base, fragment.texcoord[0], texture[0], 2D;
+TEX mask, fragment.texcoord[0], texture[1], 2D;
+LRP color.rgb, mask, fragment.color, base;
+
+// Multiply RGB by LOS texture (alpha channel)
+TEMP los;
+TEX los, fragment.texcoord[1], texture[2], 2D;
+MUL result.color.rgb, color, los.a;
+
+// Use alpha from base texture, combined with the object color alpha.
+MUL result.color.a, fragment.color.a, base.a;
+
+END

new file inaries/data/mods/public/shaders/overlay_selection.vp

@@ +1 @@
+!!ARBvp1.0
+PARAM losTransform = program.local[0];
+ATTRIB position = vertex.position;
+
+DP4 result.position.x, state.matrix.mvp.row[0], position;
+DP4 result.position.y, state.matrix.mvp.row[1], position;
+DP4 result.position.z, state.matrix.mvp.row[2], position;
+DP4 result.position.w, state.matrix.mvp.row[3], position;
+
+MOV result.texcoord[0], vertex.texcoord[0];
+MAD result.texcoord[1], position.xzzz, losTransform.x, losTransform.y;
+
+MOV result.color, vertex.color;
+
+END

new file inaries/data/mods/public/shaders/overlay_selection.xml

@@ +1 @@
+<?xml version="1.0" encoding="utf-8"?>
+<program type="arb">
+
+    <vertex file="overlay_selection.vp">
+        <stream name="pos"/>
+        <stream name="uv0"/>
+        <stream name="color"/>
+        <uniform name="losTransform" loc="0" type="vec2"/>
+    </vertex>
+
+    <fragment file="overlay_selection.fp">
+        <uniform name="baseTex" loc="0" type="sampler2D"/>
+        <uniform name="maskTex" loc="1" type="sampler2D"/>
+        <uniform name="losTex" loc="2" type="sampler2D"/>
+    </fragment>
+
+</program>

binaries/data/mods/public/simulation/components/GuiInterface.js

@@ -375 +375 @@
 GuiInterface.prototype.SetSelectionHighlight = function(player, cmd)
 {
     var cmpPlayerMan = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager);
-
     var playerColours = {}; // cache of owner -> colour map
     
     for each (var ent in cmd.entities)
@@ -384 +383 @@
         if (!cmpSelectable)
             continue;
 
-        if (cmd.alpha == 0)
-        {
-            cmpSelectable.SetSelectionHighlight({"r":0, "g":0, "b":0, "a":0});
-            continue;
-        }
-
         // Find the entity's owner's colour:
-
         var owner = -1;
         var cmpOwnership = Engine.QueryInterface(ent, IID_Ownership);
         if (cmpOwnership)

binaries/data/mods/public/simulation/templates/special/territory_block.xml

@@ -23 +23 @@
   </Position>
   <Selectable>
     <EditorOnly disable=""/>
+    <Overlay>
+      <Texture>
+        <MainTexture>art/textures/selection/circle/64x64.png</MainTexture>
+        <MainTextureMask>art/textures/selection/circle/64x64_mask.png</MainTextureMask>
+      </Texture>
+    </Overlay>
   </Selectable>
   <TerritoryInfluence>
     <OverrideCost>64</OverrideCost>

binaries/data/mods/public/simulation/templates/special/territory_pull.xml

@@ -23 +23 @@
   </Position>
   <Selectable>
     <EditorOnly disable=""/>
+    <Overlay>
+      <Texture>
+        <MainTexture>art/textures/selection/circle/64x64.png</MainTexture>
+        <MainTextureMask>art/textures/selection/circle/64x64_mask.png</MainTextureMask>
+      </Texture>
+    </Overlay>
   </Selectable>
   <TerritoryInfluence>
     <OverrideCost>0</OverrideCost>

binaries/data/mods/public/simulation/templates/template_gaia_flora_bush_berry.xml

@@ -18 +18 @@
   </ResourceSupply>
   <Selectable>
     <EditorOnly disable=""/>
+    <Overlay>
+      <Texture>
+        <MainTexture>art/textures/selection/circle/64x64.png</MainTexture>
+        <MainTextureMask>art/textures/selection/circle/64x64_mask.png</MainTextureMask>
+      </Texture>
+    </Overlay>
   </Selectable>
   <Sound>
     <SoundGroups>

binaries/data/mods/public/simulation/templates/template_gaia_flora_tree.xml

@@ -17 +17 @@
   </ResourceSupply>
   <Selectable>
     <EditorOnly disable=""/>
+    <Overlay>
+      <Texture>
+        <MainTexture>art/textures/selection/circle/64x64.png</MainTexture>
+        <MainTextureMask>art/textures/selection/circle/64x64_mask.png</MainTextureMask>
+      </Texture>
+    </Overlay>
   </Selectable>
   <Sound>
     <SoundGroups>

binaries/data/mods/public/simulation/templates/template_gaia_geo_mineral.xml

@@ -17 +17 @@
   </ResourceSupply>
   <Selectable>
     <EditorOnly disable=""/>
+    <Overlay>
+      <Outline>
+        <LineTexture>art/textures/selection/outline_border.png</LineTexture>
+        <LineTextureMask>art/textures/selection/outline_border_mask.png</LineTextureMask>
+        <LineThickness>0.2</LineThickness>
+      </Outline>
+    </Overlay>
   </Selectable>
   <Sound>
     <SoundGroups>

binaries/data/mods/public/simulation/templates/template_gaia_geo_rock.xml

@@ -17 +17 @@
   </ResourceSupply>
   <Selectable>
     <EditorOnly disable=""/>
+    <Overlay>
+      <Texture>
+        <MainTexture>art/textures/selection/circle/64x64.png</MainTexture>
+        <MainTextureMask>art/textures/selection/circle/64x64_mask.png</MainTextureMask>
+      </Texture>
+    </Overlay>
   </Selectable>
   <Sound>
     <SoundGroups>

binaries/data/mods/public/simulation/templates/template_gaia_ruins.xml

@@ -24 +24 @@
   </ResourceSupply>
   <Selectable>
     <EditorOnly disable=""/>
+    <Overlay>
+      <Texture>
+        <MainTexture>art/textures/selection/circle/64x64.png</MainTexture>
+        <MainTextureMask>art/textures/selection/circle/64x64_mask.png</MainTextureMask>
+      </Texture>
+    </Overlay>
   </Selectable>
 </Entity>

binaries/data/mods/public/simulation/templates/template_gaia_treasure.xml

@@ -24 +24 @@
   </ResourceSupply>
   <Selectable>
     <EditorOnly disable=""/>
+    <Overlay>
+      <Texture>
+        <MainTexture>art/textures/selection/circle/64x64.png</MainTexture>
+        <MainTextureMask>art/textures/selection/circle/64x64_mask.png</MainTextureMask>
+      </Texture>
+    </Overlay>
   </Selectable>
 </Entity>

binaries/data/mods/public/simulation/templates/template_structure.xml

@@ -66 +66 @@
     <LineCostClass>default</LineCostClass>
     <LinePassabilityClass>default</LinePassabilityClass>
   </RallyPointRenderer>
+  <Selectable>
+    <Overlay>
+      <Outline>
+        <LineTexture>art/textures/selection/outline_border.png</LineTexture>
+        <LineTextureMask>art/textures/selection/outline_border_mask.png</LineTextureMask>
+        <LineThickness>0.4</LineThickness>
+      </Outline>
+    </Overlay>
+  </Selectable>
   <Sound>
     <SoundGroups>
       <select>interface/select/building/sel_universal.xml</select>

binaries/data/mods/public/simulation/templates/template_unit.xml

@@ -80 +80 @@
       <metal>20</metal>
     </Capacities>
   </ResourceGatherer>
+  <Selectable>
+    <Overlay>
+      <Texture>
+        <MainTexture>art/textures/selection/circle/64x64.png</MainTexture>
+        <MainTextureMask>art/textures/selection/circle/64x64_mask.png</MainTextureMask>
+      </Texture>
+    </Overlay>
+  </Selectable>
   <StatusBars>
     <BarWidth>2.0</BarWidth>
     <BarHeight>0.333</BarHeight>

source/graphics/ModelAbstract.h

@@ -89 +89 @@
     virtual void SetDirtyRec(int dirtyflags) = 0;
 
     /// Returns world space bounds of this object and all child objects.
-    virtual const CBoundingBoxAligned GetWorldBoundsRec() { return GetWorldBounds(); }
+    virtual const CBoundingBoxAligned GetWorldBoundsRec() { return GetWorldBounds(); } // default implementation
 
     /**
      * Returns the world-space selection box of this model. Used primarily for hittesting against against a selection ray. The 

source/graphics/Overlay.h

@@ -18 +18 @@
 #ifndef INCLUDED_GRAPHICS_OVERLAY
 #define INCLUDED_GRAPHICS_OVERLAY
 
+#include "precompiled.h"
+
+#include "lib/ogl.h"
 #include "graphics/RenderableObject.h"
 #include "graphics/Texture.h"
+#include "maths/Vector2D.h"
 #include "maths/Vector3D.h"
 #include "ps/Overlay.h" // CColor  (TODO: that file has nothing to do with overlays, it should be renamed)
+#include "simulation2/components/ICmpFootprint.h"
 
 class CTerrain;
 
@@ -37 +42 @@
     std::vector<float> m_Coords; // (x, y, z) vertex coordinate triples; shape is not automatically closed
     u8 m_Thickness; // pixels
 
-    /// Utility function; pushes three vertex coordinates at once onto the coordinates array
     void PushCoords(const float x, const float y, const float z) { m_Coords.push_back(x); m_Coords.push_back(y); m_Coords.push_back(z); }
-    /// Utility function; pushes a vertex location onto the coordinates array
     void PushCoords(const CVector3D& v) { PushCoords(v.X, v.Y, v.Z); }
 };
 
@@ -64 +67 @@
     };
 
     SOverlayTexturedLine()
-        : m_Terrain(NULL), m_Thickness(1.0f), m_Closed(false), m_AlwaysVisible(false), m_StartCapType(LINECAP_FLAT), m_EndCapType(LINECAP_FLAT)
-    {}
+        : m_SimContext(NULL), m_Thickness(1.0f), m_Closed(false), m_AlwaysVisible(false),
+          m_StartCapType(LINECAP_FLAT), m_EndCapType(LINECAP_FLAT)
+    { }
 
-    CTerrain* m_Terrain;
     CTexturePtr m_TextureBase;
     CTexturePtr m_TextureMask;
     CColor m_Color; ///< Color to apply to the line texture
@@ -79 +82 @@
     LineCapType m_StartCapType; ///< LineCapType to be used at the start of the line
     LineCapType m_EndCapType; ///< LineCapType to be used at the end of the line
 
+    const CSimContext* m_SimContext; /// Simulation context applicable for this overlay line; used to obtain terrain information
     shared_ptr<CRenderData> m_RenderData; ///< Cached renderer data (shared_ptr so that copies/deletes are automatic)
 
     /**
@@ -86 +90 @@
      * If the input string is unrecognized, a warning is issued and a default value is returned.
      */
     static LineCapType StrToLineCapType(const std::wstring& str);
+
+    void PushCoords(const float x, const float z) { m_Coords.push_back(x); m_Coords.push_back(z); }
+    void PushCoords(const CVector2D& v) { PushCoords(v.X, v.Y); }
+    void PushCoords(const std::vector<CVector2D>& points)
+    {
+        for (std::size_t i = 0; i < points.size(); ++i)
+            PushCoords(points[i]);
+    }
 };
 
 /**
@@ -99 +111 @@
     float m_X0, m_Y0, m_X1, m_Y1; // billboard corner coordinates, relative to base position
 };
 
+/**
+ * Rectangular single-quad terrain overlay, with world space coordinates.
+ */
+struct SOverlayQuad
+{
+    CTexturePtr m_Texture;
+    CTexturePtr m_TextureMask;
+    CVector3D m_Corners[4];
+    CColor m_Color;
+};
+
 // TODO: OverlayText
 
 #endif // INCLUDED_GRAPHICS_OVERLAY

source/graphics/RenderableObject.h

@@ -57 +57 @@
 
 public:
     // constructor
-    CRenderableObject() : m_RenderData(0), m_BoundsValid(false) {
+    CRenderableObject() : m_RenderData(0), m_BoundsValid(false)
+    {
         m_Transform.SetIdentity();
     }
     // destructor
     virtual ~CRenderableObject() { delete m_RenderData; }
 
     // set object transform
-    virtual void SetTransform(const CMatrix3D& transform) {
+    virtual void SetTransform(const CMatrix3D& transform)
+    {
         if (m_Transform == transform)
             return;
         // store transform, calculate inverse
@@ -82 +84 @@
 
     // mark some part of the renderdata as dirty, and requiring
     // an update on next render
-    void SetDirty(u32 dirtyflags) {
-        if (m_RenderData) m_RenderData->m_UpdateFlags|=dirtyflags;
+    void SetDirty(u32 dirtyflags)
+    {
+        if (m_RenderData)
+            m_RenderData->m_UpdateFlags |= dirtyflags;
     }
 
     /**
@@ -98 +102 @@
     virtual void CalcBounds() = 0;
 
     /// Returns the world-space axis-aligned bounds of this object.
-    const CBoundingBoxAligned& GetWorldBounds() {
+    const CBoundingBoxAligned& GetWorldBounds()
+    {
         RecalculateBoundsIfNecessary();
         return m_WorldBounds;
     }
@@ -111 +116 @@
     virtual void InvalidateBounds() { m_BoundsValid = false; }
 
     // Set the object renderdata and free previous renderdata, if any.
-    void SetRenderData(CRenderData* renderdata) {
+    void SetRenderData(CRenderData* renderdata)
+    {
         delete m_RenderData;
         m_RenderData = renderdata;
     }

source/maths/FixedVector2D.h

@@ -27 +27 @@
     fixed X, Y;
 
     CFixedVector2D() { }
-
     CFixedVector2D(fixed X, fixed Y) : X(X), Y(Y) { }
 
     /// Vector equality

source/maths/MathUtil.h

@@ -18 +18 @@
 #ifndef INCLUDED_MATHUTIL
 #define INCLUDED_MATHUTIL
 
+#include <cmath>
+
 #define DEGTORAD(a)                 ((a) * ((float)M_PI/180.0f))
 #define RADTODEG(a)                 ((a) * (180.0f/(float)M_PI))
 #define SQR(x)                      ((x) * (x))

source/maths/Vector2D.h

@@ -121 +121 @@
         Y /= mag;
     }
 
-    CVector2D Normalized()
+    CVector2D Normalized() const
     {
         float mag = Length();
         return CVector2D(X / mag, Y / mag);
@@ -130 +130 @@
     /**
      * Returns a version of this vector rotated counterclockwise by @p angle radians.
      */
-    CVector2D Rotated(float angle)
+    CVector2D Rotated(float angle) const
     {
         float c = cosf(angle);
         float s = sinf(angle);

source/renderer/OverlayRenderer.cpp

@@ -19 +19 @@
 
 #include "OverlayRenderer.h"
 
-#include "maths/MathUtil.h"
-#include "maths/Quaternion.h"
-#include "maths/Vector2D.h"
+#include "boost/unordered_map.hpp"
 #include "graphics/LOSTexture.h"
 #include "graphics/Overlay.h"
 #include "graphics/Terrain.h"
 #include "graphics/TextureManager.h"
 #include "lib/ogl.h"
+#include "maths/MathUtil.h"
+#include "maths/Quaternion.h"
 #include "ps/Game.h"
 #include "ps/Profile.h"
 #include "renderer/Renderer.h"
@@ -34 +34 @@
 #include "renderer/VertexBufferManager.h"
 #include "simulation2/Simulation2.h"
 #include "simulation2/components/ICmpWaterManager.h"
+#include "simulation2/system/SimContext.h"
+
+const float OverlayRenderer::OVERLAY_VOFFSET = 0.2f;
+
+struct QuadBatchKey
+{
+    QuadBatchKey (CTexturePtr texture, CTexturePtr textureMask) : m_Texture(texture), m_TextureMask(textureMask){ }
+
+    struct hash : std::unary_function<QuadBatchKey, size_t> {
+        size_t operator()(const QuadBatchKey& d) const;
+    };
+
+    struct eq : std::binary_function<QuadBatchKey, QuadBatchKey, bool> {
+        bool operator()(const QuadBatchKey& d1, const QuadBatchKey& d2) const;
+    };
+
+    CTexturePtr m_Texture;
+    CTexturePtr m_TextureMask;
+};
+
+class QuadBatchData : public CRenderData
+{
+public:
+    struct SVertex
+    {
+        SVertex(const CVector3D& pos, GLshort u, GLshort v, const CColor& color) : m_Position(pos), m_Color(color)
+        { m_UVs[0] = u; m_UVs[1] = v; }
+
+        CVector3D m_Position;
+        GLshort m_UVs[2];
+        CColor m_Color;
+    };
+    cassert(sizeof(SVertex) == 32);
+
+    QuadBatchData() : m_VB(NULL), m_VBIndices(NULL) { }
+    ~QuadBatchData()
+    {
+        // TODO: gets called by boost::unordered_map during PrepareForRendering, not desirable
+        if (m_VB)
+            g_VBMan.Release(m_VB);
+        if (m_VBIndices)
+            g_VBMan.Release(m_VBIndices);
+    }
+
+    std::vector<SOverlayQuad*> m_Quads;
+    CVertexBuffer::VBChunk* m_VB;
+    CVertexBuffer::VBChunk* m_VBIndices;
+};
 
 struct OverlayRendererInternals
 {
+    typedef boost::unordered_map<QuadBatchKey, QuadBatchData, QuadBatchKey::hash, QuadBatchKey::eq> QuadBatchMap;
+
     std::vector<SOverlayLine*> lines;
     std::vector<SOverlayTexturedLine*> texlines;
     std::vector<SOverlaySprite*> sprites;
+    std::vector<SOverlayQuad*> quads;
+
+    QuadBatchMap quadBatchData;
 };
 
 class CTexturedLineRData : public CRenderData
 {
 public:
-    CTexturedLineRData(SOverlayTexturedLine* line) :
-        m_Line(line), m_VB(NULL), m_VBIndices(NULL), m_Raise(.2f)
+    CTexturedLineRData(SOverlayTexturedLine* line) : m_Line(line), m_VB(NULL), m_VBIndices(NULL)
     { }
 
     ~CTexturedLineRData()
@@ -62 +114 @@
         SVertex(CVector3D pos, float u, float v) : m_Position(pos) { m_UVs[0] = u; m_UVs[1] = v; }
         CVector3D m_Position;
         GLfloat m_UVs[2];
-        float _padding[3]; // 5 floats up till now, so pad with another 3 floats to get a power of 2
+        float _padding[3]; // get a pow2 struct size
     };
     cassert(sizeof(SVertex) == 32);
 
@@ -91 +143 @@
     SOverlayTexturedLine* m_Line;
     CVertexBuffer::VBChunk* m_VB;
     CVertexBuffer::VBChunk* m_VBIndices;
-
-    float m_Raise; // small vertical offset of line from terrain to prevent visual glitches
 };
 
 OverlayRenderer::OverlayRenderer()
@@ -128 +178 @@
     m->sprites.push_back(overlay);
 }
 
+void OverlayRenderer::Submit(SOverlayQuad* overlay)
+{
+    m->quads.push_back(overlay);
+}
+
 void OverlayRenderer::EndFrame()
 {
     m->lines.clear();
     m->texlines.clear();
     m->sprites.clear();
+    m->quads.clear();
     // this should leave the capacity unchanged, which is okay since it
     // won't be very large or very variable
+    
+    // empty the batch rendering data structures, but keep their key mappings around for the next frames
+    for (OverlayRendererInternals::QuadBatchMap::iterator it = m->quadBatchData.begin(); it != m->quadBatchData.end(); it++)
+    {
+        QuadBatchData& batchRenderData = (it->second);
+
+        batchRenderData.m_Quads.clear();
+        if (batchRenderData.m_VB)
+        {
+            g_VBMan.Release(batchRenderData.m_VB);
+            batchRenderData.m_VB = NULL;
+        }
+        if (batchRenderData.m_VBIndices)
+        {
+            g_VBMan.Release(batchRenderData.m_VBIndices);
+            batchRenderData.m_VBIndices = NULL;
+        }
+    }
 }
 
 void OverlayRenderer::PrepareForRendering()
@@ -157 +231 @@
             // any of the parameters after first submitting the line.
         }
     }
+
+    // group quad overlays by their texture/mask combination for efficient rendering
+    for (size_t i = 0; i < m->quads.size(); ++i)
+    {
+        SOverlayQuad* const quad = m->quads[i];
+
+        QuadBatchKey textures(quad->m_Texture, quad->m_TextureMask);
+        QuadBatchData& batchRenderData = m->quadBatchData[textures]; // will create entry if it doesn't already exist
+
+        // add overlay to list of quads
+        batchRenderData.m_Quads.push_back(quad);
+    }
+
+    // Add vertices
+    for (OverlayRendererInternals::QuadBatchMap::iterator it = m->quadBatchData.begin(); it != m->quadBatchData.end(); ++it)
+    {
+        QuadBatchData& batchRenderData = (it->second);
+        if (batchRenderData.m_Quads.size() == 0)
+            continue;
+
+        const CVector3D vOffset(0, OVERLAY_VOFFSET, 0);
+
+        std::vector<u16> indices;
+        std::vector<QuadBatchData::SVertex> vertices;
+
+        for (size_t i = 0; i < batchRenderData.m_Quads.size(); i++)
+        {
+            const SOverlayQuad* quad = batchRenderData.m_Quads[i];
+            
+            size_t numVerticesBefore = vertices.size();
+            vertices.push_back(QuadBatchData::SVertex(quad->m_Corners[0] + vOffset, 0, 0, quad->m_Color));
+            vertices.push_back(QuadBatchData::SVertex(quad->m_Corners[1] + vOffset, 0, 1, quad->m_Color));
+            vertices.push_back(QuadBatchData::SVertex(quad->m_Corners[2] + vOffset, 1, 1, quad->m_Color));
+            vertices.push_back(QuadBatchData::SVertex(quad->m_Corners[3] + vOffset, 1, 0, quad->m_Color));
+
+            indices.push_back(numVerticesBefore);
+            indices.push_back(numVerticesBefore + 1);
+            indices.push_back(numVerticesBefore + 2);
+            indices.push_back(numVerticesBefore);
+            indices.push_back(numVerticesBefore + 2);
+            indices.push_back(numVerticesBefore + 3);
+        }
+
+        ENSURE(batchRenderData.m_VB == NULL);
+
+        batchRenderData.m_VB = g_VBMan.Allocate(sizeof(QuadBatchData::SVertex), vertices.size(), GL_DYNAMIC_DRAW, GL_ARRAY_BUFFER);
+        if (batchRenderData.m_VB) // allocation might fail
+        {
+            batchRenderData.m_VB->m_Owner->UpdateChunkVertices(batchRenderData.m_VB, &vertices[0]); // copy data into VBO
+
+            for (size_t k = 0; k < indices.size(); ++k)
+                indices[k] += batchRenderData.m_VB->m_Index;
+
+            batchRenderData.m_VBIndices = g_VBMan.Allocate(sizeof(u16), indices.size(), GL_DYNAMIC_DRAW, GL_ELEMENT_ARRAY_BUFFER);
+            if (batchRenderData.m_VBIndices)
+                batchRenderData.m_VBIndices->m_Owner->UpdateChunkVertices(batchRenderData.m_VBIndices, &indices[0]);
+        }
+    }
 }
 
 void OverlayRenderer::RenderOverlaysBeforeWater()
@@ -196 +328 @@
 {
     PROFILE3_GPU("overlays (after)");
 
+    RenderTexturedOverlayLines();
+    RenderQuadOverlays();
+}
+
+void OverlayRenderer::RenderTexturedOverlayLines()
+{
 #if CONFIG2_GLES
-#warning TODO: implement OverlayRenderer::RenderOverlaysAfterWater for GLES
+#warning TODO: implement OverlayRenderer::RenderTexturedOverlayLines for GLES
     return;
 #endif
+    if (m->texlines.empty())
+        return;
 
-    if (!m->texlines.empty())
-    {
-        glEnable(GL_TEXTURE_2D);
-        glEnable(GL_BLEND);
-        glDepthMask(0);
+    glEnable(GL_TEXTURE_2D);
+    glEnable(GL_BLEND);
+    glDepthMask(0);
 
-        const char* shaderName;
-        if (g_Renderer.GetRenderPath() == CRenderer::RP_SHADER)
-            shaderName = "overlayline";
-        else
-            shaderName = "fixed:overlayline";
+    const char* shaderName;
+    if (g_Renderer.GetRenderPath() == CRenderer::RP_SHADER)
+        shaderName = "overlayline";
+    else
+        shaderName = "fixed:overlayline";
 
-        std::map<CStr, CStr> defAlwaysVisible;
-        defAlwaysVisible.insert(std::make_pair(CStr("IGNORE_LOS"), CStr("1")));
+    std::map<CStr, CStr> defAlwaysVisible;
+    defAlwaysVisible.insert(std::make_pair(CStr("IGNORE_LOS"), CStr("1")));
 
-        CLOSTexture& los = g_Renderer.GetScene().GetLOSTexture();
+    CLOSTexture& los = g_Renderer.GetScene().GetLOSTexture();
 
-        CShaderManager& shaderManager = g_Renderer.GetShaderManager();
-        CShaderProgramPtr shaderTexLineNormal(shaderManager.LoadProgram(shaderName));
-        CShaderProgramPtr shaderTexLineAlwaysVisible(shaderManager.LoadProgram(shaderName, defAlwaysVisible));
+    CShaderManager& shaderManager = g_Renderer.GetShaderManager();
+    CShaderProgramPtr shaderTexLineNormal(shaderManager.LoadProgram(shaderName));
+    CShaderProgramPtr shaderTexLineAlwaysVisible(shaderManager.LoadProgram(shaderName, defAlwaysVisible));
 
-        // ----------------------------------------------------------------------------------------
+    // ----------------------------------------------------------------------------------------
 
-        shaderTexLineNormal->Bind();
-        shaderTexLineNormal->BindTexture("losTex", los.GetTexture());
-        shaderTexLineNormal->Uniform("losTransform", los.GetTextureMatrix()[0], los.GetTextureMatrix()[12], 0.f, 0.f);
+    shaderTexLineNormal->Bind();
+    shaderTexLineNormal->BindTexture("losTex", los.GetTexture());
+    shaderTexLineNormal->Uniform("losTransform", los.GetTextureMatrix()[0], los.GetTextureMatrix()[12], 0.f, 0.f);
 
-        // batch render only the non-always-visible overlay lines using the normal shader
-        RenderTexturedOverlayLines(shaderTexLineNormal, false);
+    // batch render only the non-always-visible overlay lines using the normal shader
+    RenderTexturedOverlayLines(shaderTexLineNormal, false);
 
-        shaderTexLineNormal->Unbind();
+    shaderTexLineNormal->Unbind();
 
-        // ----------------------------------------------------------------------------------------
+    // ----------------------------------------------------------------------------------------
 
-        shaderTexLineAlwaysVisible->Bind();
-        // TODO: losTex and losTransform are unused in the always visible shader, but I'm not sure if it's worthwhile messing 
-        // with it just to remove these calls
-        shaderTexLineAlwaysVisible->BindTexture("losTex", los.GetTexture());
-        shaderTexLineAlwaysVisible->Uniform("losTransform", los.GetTextureMatrix()[0], los.GetTextureMatrix()[12], 0.f, 0.f);
+    shaderTexLineAlwaysVisible->Bind();
+    // TODO: losTex and losTransform are unused in the always visible shader, but I'm not sure if it's worthwhile messing 
+    // with it just to remove these calls
+    shaderTexLineAlwaysVisible->BindTexture("losTex", los.GetTexture());
+    shaderTexLineAlwaysVisible->Uniform("losTransform", los.GetTextureMatrix()[0], los.GetTextureMatrix()[12], 0.f, 0.f);
 
-        // batch render only the always-visible overlay lines using the LoS-ignored shader
-        RenderTexturedOverlayLines(shaderTexLineAlwaysVisible, true);
+    // batch render only the always-visible overlay lines using the LoS-ignored shader
+    RenderTexturedOverlayLines(shaderTexLineAlwaysVisible, true);
 
-        shaderTexLineAlwaysVisible->Unbind();
+    shaderTexLineAlwaysVisible->Unbind();
 
-        // TODO: the shader should probably be responsible for unbinding its textures
-        g_Renderer.BindTexture(1, 0);
-        g_Renderer.BindTexture(0, 0);
+    // ----------------------------------------------------------------------------------------
 
-        CVertexBuffer::Unbind();
+    // TODO: the shader should probably be responsible for unbinding its textures
+    g_Renderer.BindTexture(1, 0);
+    g_Renderer.BindTexture(0, 0);
 
-        glDepthMask(1);
-        glDisable(GL_BLEND);
-    }
+    CVertexBuffer::Unbind();
+
+    glDepthMask(1);
+    glDisable(GL_BLEND);
 }
 
 void OverlayRenderer::RenderTexturedOverlayLines(CShaderProgramPtr shaderTexLine, bool alwaysVisible)
@@ -300 +439 @@
     }
 }
 
+void OverlayRenderer::RenderQuadOverlays()
+{
+    if (m->quadBatchData.empty())
+        return;
+
+    glEnable(GL_TEXTURE_2D);
+    glEnable(GL_BLEND);
+    glDepthMask(0);
+
+    const char* shaderName = "overlay_selection";
+    // TODO: create an FFP version of this shader
+
+    CLOSTexture& los = g_Renderer.GetScene().GetLOSTexture();
+
+    CShaderManager& shaderManager = g_Renderer.GetShaderManager();
+    CShaderProgramPtr shader(shaderManager.LoadProgram(shaderName));
+
+    shader->Bind();
+    shader->Uniform("losTransform", los.GetTextureMatrix()[0], los.GetTextureMatrix()[12], 0.f, 0.f);
+    shader->BindTexture("losTex", los.GetTexture());
+
+    // ----------------------------------------------------------------------------------------------------
+
+    for (OverlayRendererInternals::QuadBatchMap::iterator it = m->quadBatchData.begin(); it != m->quadBatchData.end(); it++)
+    {
+        QuadBatchData& batchRenderData = it->second;
+        ENSURE(batchRenderData.m_VB == NULL || batchRenderData.m_Quads.size() > 0); // if a VB was allocated, there must be at least one quad
+
+        if (!batchRenderData.m_VB)
+            continue;
+
+        const QuadBatchKey& maskPair = it->first;
+
+        shader->BindTexture("baseTex", maskPair.m_Texture->GetHandle());
+        shader->BindTexture("maskTex", maskPair.m_TextureMask->GetHandle());
+
+        int streamflags = shader->GetStreamFlags();
+
+        GLsizei stride = sizeof(QuadBatchData::SVertex);
+        QuadBatchData::SVertex* vertexBase = reinterpret_cast<QuadBatchData::SVertex*>(batchRenderData.m_VB->m_Owner->Bind());
+
+        if (streamflags & STREAM_POS)
+            shader->VertexPointer(3, GL_FLOAT, stride, &vertexBase->m_Position[0]);
+
+        if (streamflags & STREAM_UV0)
+            shader->TexCoordPointer(GL_TEXTURE0, 2, GL_SHORT, stride, &vertexBase->m_UVs[0]);
+
+        if (streamflags & STREAM_UV1)
+            shader->TexCoordPointer(GL_TEXTURE1, 2, GL_SHORT, stride, &vertexBase->m_UVs[0]);
+
+        if (streamflags & STREAM_COLOR)
+            shader->ColorPointer(4, GL_FLOAT, stride, &vertexBase->m_Color.r);
+
+        shader->AssertPointersBound();
+        
+        u8* indexBase = batchRenderData.m_VBIndices->m_Owner->Bind();
+        glDrawElements(GL_TRIANGLES, (GLsizei) batchRenderData.m_VBIndices->m_Count, GL_UNSIGNED_SHORT, indexBase + sizeof(u16) * batchRenderData.m_VBIndices->m_Index);
+
+        g_Renderer.GetStats().m_OverlayTris += batchRenderData.m_VB->m_Count/2;
+    }
+
+    // ----------------------------------------------------------------------------------------------------
+
+    shader->Unbind();
+
+    // TODO: the shader should probably be responsible for unbinding its textures
+    g_Renderer.BindTexture(1, 0);
+    g_Renderer.BindTexture(0, 0);
+
+    CVertexBuffer::Unbind();
+
+    glDepthMask(1);
+    glDisable(GL_BLEND);
+}
+
 void OverlayRenderer::RenderForegroundOverlays(const CCamera& viewCamera)
 {
     PROFILE3_GPU("overlays (fg)");
@@ -361 +575 @@
         m_VBIndices = NULL;
     }
 
-    CTerrain* terrain = m_Line->m_Terrain;
-    CmpPtr<ICmpWaterManager> cmpWaterManager(*g_Game->GetSimulation2(), SYSTEM_ENTITY);
+    if (!m_Line->m_SimContext)
+    {
+        debug_warn(L"[OverlayRenderer] No SimContext set for textured overlay line, cannot render (no terrain data)");
+        return;
+    }
+
+    const CTerrain& terrain = m_Line->m_SimContext->GetTerrain();
+    CmpPtr<ICmpWaterManager> cmpWaterManager(*m_Line->m_SimContext, SYSTEM_ENTITY);
 
     float v = 0.f;
     std::vector<SVertex> vertices;
@@ -398 +618 @@
     // 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);
+    p0.Y = terrain.GetExactGroundLevel(p0.X, p0.Z);
     if (p0.Y < w)
         p0.Y = w;
 
-    p1.Y = terrain->GetExactGroundLevel(p1.X, p1.Z);
+    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);
+    p2.Y = terrain.GetExactGroundLevel(p2.X, p2.Z);
     if (p2.Y < w)
     {
         p2.Y = w;
@@ -426 +646 @@
         if (p1floating)
             norm = CVector3D(0, 1, 0);
         else
-            norm = m_Line->m_Terrain->CalcExactNormal(p1.X, p1.Z);
+            norm = terrain.CalcExactNormal(p1.X, p1.Z);
 
         CVector3D b = ((p1 - p0).Normalized() + (p2 - p1).Normalized()).Cross(norm);
 
@@ -445 +665 @@
         // What the code below does is push the indices for a quad composed of two triangles in each iteration. The two triangles 
         // of each quad are indexed using the winding orders (BR, BL, TR) and (TR, BL, TR) (where BR is bottom-right of this
         // iteration's quad, TR top-right etc).
-        SVertex vertex1(p1 + b + norm*m_Raise, 0.f, v);
-        SVertex vertex2(p1 - b + norm*m_Raise, 1.f, v);
+        SVertex vertex1(p1 + b + norm*OverlayRenderer::OVERLAY_VOFFSET, 0.f, v);
+        SVertex vertex2(p1 - b + norm*OverlayRenderer::OVERLAY_VOFFSET, 1.f, v);
         vertices.push_back(vertex1);
         vertices.push_back(vertex2);
 
@@ -495 +715 @@
         else
             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);
+        p2.Y = terrain.GetExactGroundLevel(p2.X, p2.Z);
         if (p2.Y < w)
         {
             p2.Y = w;
@@ -538 +758 @@
 
         for (unsigned i = 0; i < capIndices.size(); i++)
             capIndices[i] += vertices.size();
+
         vertices.insert(vertices.end(), capVertices.begin(), capVertices.end());
         indices.insert(indices.end(), capIndices.begin(), capIndices.end());
 
@@ -558 +779 @@
 
         for (unsigned i = 0; i < capIndices.size(); i++)
             capIndices[i] += vertices.size();
+
         vertices.insert(vertices.end(), capVertices.begin(), capVertices.end());
         indices.insert(indices.end(), capIndices.begin(), capIndices.end());
     }
@@ -698 +920 @@
     }
 
 }
+
+size_t QuadBatchKey::hash::operator()(const QuadBatchKey& d) const
+{
+    size_t seed = 0;
+    boost::hash_combine(seed, d.m_Texture);
+    boost::hash_combine(seed, d.m_TextureMask);
+    return seed;
+}
+
+bool QuadBatchKey::eq::operator()(const QuadBatchKey& d1, const QuadBatchKey& d2) const
+{
+    return (d1.m_Texture == d2.m_Texture
+         && d1.m_TextureMask == d2.m_TextureMask);
+}
+ No newline at end of file

source/renderer/OverlayRenderer.h

@@ -23 +23 @@
 struct SOverlayLine;
 struct SOverlayTexturedLine;
 struct SOverlaySprite;
+struct SOverlayQuad;
 class CCamera;
 
 struct OverlayRendererInternals;
@@ -39 +40 @@
 
     /**
      * Add a line overlay for rendering in this frame.
+     * @param overlay Must be non-null.
      */
     void Submit(SOverlayLine* overlay);
 
     /**
      * Add a textured line overlay for rendering in this frame.
+     * @param overlay Must be non-null.
      */
     void Submit(SOverlayTexturedLine* overlay);
 
     /**
      * Add a sprite overlay for rendering in this frame.
+     * @param overlay Must be non-null.
      */
     void Submit(SOverlaySprite* overlay);
 
     /**
+     * Add a textured quad overlay for rendering in this frame.
+     * @param overlay Must be non-null.
+     */
+    void Submit(SOverlayQuad* overlay);
+
+    /**
+     * Add a selection ring overlay for rendering in this frame.
+     */
+    //void Submit(SOverlaySelectionOutline* selectionRing);
+
+    /**
      * Prepare internal data structures for rendering.
      * Must be called after all Submit calls for a frame, and before
      * any rendering calls.
@@ -85 +100 @@
      */
     void RenderForegroundOverlays(const CCamera& viewCamera);
 
+    /// Small vertical offset of overlays from terrain to prevent visual glitches
+    static const float OVERLAY_VOFFSET;
+
 private:
     
     /**
+     * Helper method; renders all overlay lines currently registered in the internals. Batch renders textured overlay lines
+     * according to their visibility status by delegating to RenderTexturedOverlayLines(CShaderProgramPtr, bool).
+     */
+    void RenderTexturedOverlayLines();
+
+    /**
      * Helper method; renders those overlay lines currently registered in the internals (i.e. in m->texlines) for which the
      * always visible flag equals @alwaysVisible. Used for batch rendering the overlay lines by their alwaysVisible status,
      * because this requires a separate shader to be used.
      */
     void RenderTexturedOverlayLines(CShaderProgramPtr shader, bool alwaysVisible);
 
+    /**
+     * Helper method; batch-renders all registered quad overlays according to their texture.
+     */
+    void RenderQuadOverlays();
+
 private:
     OverlayRendererInternals* m;
 };

source/renderer/Renderer.cpp

@@ -1729 +1729 @@
     m->overlayRenderer.Submit(overlay);
 }
 
+void CRenderer::Submit(SOverlayQuad* overlay)
+{
+    m->overlayRenderer.Submit(overlay);
+}
+
+/*void CRenderer::Submit(SOverlaySelectionOutline* overlay)
+{
+    m->overlayRenderer.Submit(overlay);
+}*/
+
 void CRenderer::Submit(CModelDecal* decal)
 {
     m->terrainRenderer->Submit(decal);

source/renderer/Renderer.h

@@ -325 +325 @@
     void Submit(SOverlayLine* overlay);
     void Submit(SOverlayTexturedLine* overlay);
     void Submit(SOverlaySprite* overlay);
+    void Submit(SOverlayQuad* overlay);
     void Submit(CModelDecal* decal);
     void Submit(CParticleEmitter* emitter);
     void SubmitNonRecursive(CModel* model);

source/renderer/Scene.h

@@ -39 +39 @@
 struct SOverlayLine;
 struct SOverlayTexturedLine;
 struct SOverlaySprite;
+struct SOverlayQuad;
 
 class SceneCollector;
 
@@ -104 +105 @@
     virtual void Submit(SOverlaySprite* overlay) = 0;
 
     /**
+     * Submit a textured quad overlay.
+     */
+    virtual void Submit(SOverlayQuad* overlay) = 0;
+
+    /**
      * Submit a terrain decal.
      */
     virtual void Submit(CModelDecal* decal) = 0;

source/renderer/VertexBuffer.cpp

@@ -33 +33 @@
 {
     size_t size = MAX_VB_SIZE_BYTES;
 
-    if (target == GL_ARRAY_BUFFER)
+    if (target == GL_ARRAY_BUFFER) // vertex data buffer
     {
         // We want to store 16-bit indices to any vertex in a buffer, so the
-        // buffer must never be bigger than vertexSize*64K bytes
+        // buffer must never be bigger than vertexSize*64K bytes since we can 
+        // address at most 64K of them with 16-bit indices
         size = std::min(size, vertexSize*65536);
     }
 
@@ -54 +55 @@
     }
 
     // store max/free vertex counts
-    m_MaxVertices=m_FreeVertices=size/vertexSize;
+    m_MaxVertices = m_FreeVertices = size/vertexSize;
     
     // create sole free chunk
-    VBChunk* chunk=new VBChunk;
-    chunk->m_Owner=this;
-    chunk->m_Count=m_FreeVertices;
-    chunk->m_Index=0;
+    VBChunk* chunk = new VBChunk;
+    chunk->m_Owner = this;
+    chunk->m_Count = m_FreeVertices;
+    chunk->m_Index = 0;
     m_FreeList.push_front(chunk);
 }
 
@@ -100 +101 @@
         return 0;
 
     // trawl free list looking for first free chunk with enough space
-    VBChunk* chunk=0;
+    VBChunk* chunk = 0;
     typedef std::list<VBChunk*>::iterator Iter;
-    for (Iter iter=m_FreeList.begin();iter!=m_FreeList.end();++iter) {
-        if (numVertices<=(*iter)->m_Count) {
-            chunk=*iter;
+    for (Iter iter = m_FreeList.begin(); iter != m_FreeList.end(); ++iter) {
+        if (numVertices <= (*iter)->m_Count) {
+            chunk = *iter;
             // remove this chunk from the free list
             m_FreeList.erase(iter);
             m_FreeVertices -= chunk->m_Count;
@@ -173 +174 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 // UpdateChunkVertices: update vertex data for given chunk
-void CVertexBuffer::UpdateChunkVertices(VBChunk* chunk,void* data)
+void CVertexBuffer::UpdateChunkVertices(VBChunk* chunk, void* data, unsigned int cnt /* = 0*/)
 {
     if (g_Renderer.m_Caps.m_VBO)
     {

source/renderer/VertexBuffer.h

@@ -30 +30 @@
 // absolute maximum (bytewise) size of each GL vertex buffer object
 #define MAX_VB_SIZE_BYTES       (512*1024)
 
-///////////////////////////////////////////////////////////////////////////////
-// CVertexBuffer: encapsulation of ARB_vertex_buffer_object, also supplying 
-// some additional functionality for sharing buffers between multiple objects
+/**
+ * CVertexBuffer: encapsulation of ARB_vertex_buffer_object, also supplying 
+ * some additional functionality for sharing buffers between multiple objects
+ */
 class CVertexBuffer
 {
 public:
-    // VBChunk: describes a portion of this vertex buffer
+
+    /// VBChunk: describes a portion of this vertex buffer
     struct VBChunk
     {
-        // owning buffer
+        /// Owning (parent) vertex buffer
         CVertexBuffer* m_Owner;
-        // start index of this chunk in owner
+        /// Start index of this chunk in owner
         size_t m_Index;
-        // number of vertices used by chunk
+        /// Number of vertices used by chunk
         size_t m_Count;
 
     private:
@@ -59 +61 @@
     CVertexBuffer(size_t vertexSize, GLenum usage, GLenum target);
     ~CVertexBuffer();
 
-    // bind to this buffer; return pointer to address required as parameter
-    // to glVertexPointer ( + etc) calls
+    /// Bind to this buffer; return pointer to address required as parameter
+    /// to glVertexPointer ( + etc) calls
     u8* Bind();
 
-    // get the address that Bind() will return, without actually binding
+    /// Get the address that Bind() will return, without actually binding
     u8* GetBindAddress();
 
-    // unbind any currently-bound buffer, so glVertexPointer etc calls will not attempt to use it
+    /// Unbind any currently-bound buffer, so glVertexPointer etc calls will not attempt to use it
     static void Unbind();
 
-    // update vertex data for given chunk
-    void UpdateChunkVertices(VBChunk* chunk, void* data);
+    /// Update vertex data for given chunk. Transfers the provided data to the actual OpenGL vertex buffer.
+    void UpdateChunkVertices(VBChunk* chunk, void* data, unsigned int cnt = 0);
 
     size_t GetVertexSize() const { return m_VertexSize; }
-
     size_t GetBytesReserved() const;
     size_t GetBytesAllocated() const;
 
+    /// Returns true if this vertex buffer is compatible with the specified vertex type and intended usage.
     bool CompatibleVertexType(size_t vertexSize, GLenum usage, GLenum target);
 
     void DumpStatus();
@@ -84 +86 @@
 protected:
     friend class CVertexBufferManager;      // allow allocate only via CVertexBufferManager
     
-    // try to allocate a buffer of given number of vertices (each of given size), 
-    // and with the given type - return null if no free chunks available
+    /// Try to allocate a buffer of given number of vertices (each of given size), 
+    /// and with the given type - return null if no free chunks available
     VBChunk* Allocate(size_t vertexSize, size_t numVertices, GLenum usage, GLenum target);
-    // return given chunk to this buffer
+    /// Return given chunk to this buffer
     void Release(VBChunk* chunk);
     
     
 private:    
-    // vertex size of this vertex buffer
+    /// Vertex size of this vertex buffer
     size_t m_VertexSize;
-    // number of vertices of above size in this buffer
+    /// Number of vertices of above size in this buffer
     size_t m_MaxVertices;
-    // list of free chunks in this buffer
+    /// List of free chunks in this buffer
     std::list<VBChunk*> m_FreeList;
-    // available free vertices - total of all free vertices in the free list
+    /// Available free vertices - total of all free vertices in the free list
     size_t m_FreeVertices;
-    // handle to the actual GL vertex buffer object
+    /// Handle to the actual GL vertex buffer object
     GLuint m_Handle;
-    // raw system memory for systems not supporting VBOs
+    /// Raw system memory for systems not supporting VBOs
     u8* m_SysMem;
-    // usage type of the buffer (GL_STATIC_DRAW etc)
+    /// Usage type of the buffer (GL_STATIC_DRAW etc)
     GLenum m_Usage;
-    // buffer target (GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER)
+    /// Buffer target (GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER)
     GLenum m_Target;
 };
 

source/renderer/VertexBufferManager.h

@@ -30 +30 @@
 class CVertexBufferManager
 {
 public:
-    // Explicit shutdown of the vertex buffer subsystem
-    void Shutdown();
     
     /**
      * Try to allocate a vertex buffer of the given size and type.
@@ -44 +42 @@
      */
     CVertexBuffer::VBChunk* Allocate(size_t vertexSize, size_t numVertices, GLenum usage, GLenum target);
 
-    // return given chunk to its owner
+    /// Returns the given @p chunk to its owning buffer
     void Release(CVertexBuffer::VBChunk* chunk);
 
-    // return list of all buffers
+    /// Returns a list of all buffers
     const std::list<CVertexBuffer*>& GetBufferList() const { return m_Buffers; }
 
     size_t GetBytesReserved();
     size_t GetBytesAllocated();
 
+    /// Returns the maximum possible size of a single vertex buffer
+    size_t GetMaxBufferSize() const { return MAX_VB_SIZE_BYTES; }
+
+    /// Explicit shutdown of the vertex buffer subsystem; releases all currently-allocated buffers.
+    void Shutdown();
+
 private:
-    // list of all known vertex buffers
+    /// List of all known vertex buffers
     std::list<CVertexBuffer*> m_Buffers;
 };
 

source/simulation2/components/CCmpRallyPointRenderer.cpp

@@ -600 +600 @@
             // construct solid textured overlay line along a subset of the full path points from startPointIdx to endPointIdx
             SOverlayTexturedLine overlayLine;
             overlayLine.m_Thickness = m_LineThickness;
-            overlayLine.m_Terrain = cmpTerrain->GetCTerrain();
+            overlayLine.m_SimContext = &GetSimContext();
             overlayLine.m_TextureBase = m_Texture;
             overlayLine.m_TextureMask = m_TextureMask;
             overlayLine.m_Color = m_LineColor;
@@ -624 +624 @@
         }
         else
         {
-            // construct dashed line from startPointIdx to endPointIdx, add textured overlay lines for it to the render list
+            // construct dashed line from startPointIdx to endPointIdx; add textured overlay lines for it to the render list
             std::vector<CVector2D> straightLine;
             straightLine.push_back(m_Path[segment.m_StartIndex]);
             straightLine.push_back(m_Path[segment.m_EndIndex]);
 
-            // We always want to have the dashed line end at either point with a full dash (i.e. not a cleared space), so that the dashed
-            // area is visually obvious. That implies that we want at least So, let's do some calculations to see what size we should make 
-            // the dashes and clears.
+            // We always want to the dashed line to end at either point with a full dash (i.e. not a cleared space), so that the dashed
+            // area is visually obvious. This requires some calculations to see what size we should make the dashes and clears for them
+            // to fit exactly.
 
             float maxDashSize = 3.f;
             float maxClearSize = 3.f;
@@ -642 +642 @@
 
             float distance = (m_Path[segment.m_StartIndex] - m_Path[segment.m_EndIndex]).Length(); // straight-line distance between the points
 
-            // see how many pairs (dash + clear) can fit into the distance unmodified. Then check the remaining distance; if it's not exactly
-            // a dash size's worth (and it likely won't be), then adjust the dash/clear sizes slightly so that it is.
+            // See how many pairs (dash + clear) of unmodified size can fit into the distance. Then check the remaining distance; if it's not exactly
+            // a dash size's worth (which it probably won't be), then adjust the dash/clear sizes slightly so that it is.
             int numFitUnmodified = floor(distance/(dashSize + clearSize));
             float remainderDistance = distance - (numFitUnmodified * (dashSize + clearSize));
 
@@ -672 +672 @@
                 SOverlayTexturedLine dashOverlay;
 
                 dashOverlay.m_Thickness = m_LineThickness;
-                dashOverlay.m_Terrain = cmpTerrain->GetCTerrain();
+                dashOverlay.m_SimContext = &GetSimContext();
                 dashOverlay.m_TextureBase = m_Texture;
                 dashOverlay.m_TextureMask = m_TextureMask;
                 dashOverlay.m_Color = m_LineDashColor;
@@ -757 +757 @@
     {
     case ICmpFootprint::SQUARE:
         {
-            // in this case, footprintSize0 and 1 respectively indicate the (unrotated) size along the X and Z axes
+            // in this case, footprintSize0 and 1 indicate the size along the X and Z axes, respectively.
 
             // the building's footprint could be rotated any which way, so let's get the rotation around the Y axis
             // and the rotated unit vectors in the X/Z plane of the shape's footprint
@@ -827 +827 @@
     player_id_t currentPlayer = GetSimContext().GetCurrentDisplayedPlayer();
     CLosQuerier losQuerier(cmpRangeMgr->GetLosQuerier(currentPlayer));
 
-    //for (std::vector<Waypoint>::iterator it = waypoints.begin(); it != waypoints.end();)
     for(std::vector<CVector2D>::iterator it = coords.begin(); it != coords.end();)
     {
         int i = (fixed::FromFloat(it->X) / (int)TERRAIN_TILE_SIZE).ToInt_RoundToNearest();

source/simulation2/components/CCmpSelectable.cpp

@@ -20 +20 @@
 #include "simulation2/system/Component.h"
 #include "ICmpSelectable.h"
 
-#include "ICmpPosition.h"
-#include "ICmpFootprint.h"
-#include "ICmpVisual.h"
-#include "simulation2/MessageTypes.h"
-#include "simulation2/helpers/Render.h"
-
 #include "graphics/Overlay.h"
+#include "graphics/Terrain.h"
+#include "graphics/TextureManager.h"
 #include "maths/MathUtil.h"
 #include "maths/Matrix3D.h"
 #include "maths/Vector3D.h"
+#include "maths/Vector2D.h"
+#include "ps/CLogger.h"
 #include "renderer/Scene.h"
+#include "renderer/Renderer.h"
+#include "simulation2/MessageTypes.h"
+#include "simulation2/components/ICmpPosition.h"
+#include "simulation2/components/ICmpFootprint.h"
+#include "simulation2/components/ICmpVisual.h"
+#include "simulation2/components/ICmpTerrain.h"
+#include "simulation2/components/ICmpOwnership.h"
+#include "simulation2/components/ICmpPlayer.h"
+#include "simulation2/components/ICmpPlayerManager.h"
+#include "simulation2/components/ICmpWaterManager.h"
+#include "simulation2/helpers/Render.h"
 
 class CCmpSelectable : public ICmpSelectable
 {
@@ -39 +48 @@
     {
         componentManager.SubscribeToMessageType(MT_Interpolate);
         componentManager.SubscribeToMessageType(MT_RenderSubmit);
+        // these next two are primarily for invalidating the static building outlines; not really applicable for unit 
+        // overlays since their positions and ownerships etc. are gathered every frame
+        componentManager.SubscribeToMessageType(MT_OwnershipChanged);
+        componentManager.SubscribeToMessageType(MT_PositionChanged);
         // TODO: it'd be nice if we didn't get these messages except in the rare
         // cases where we're actually drawing a selection highlight
     }
 
     DEFAULT_COMPONENT_ALLOCATOR(Selectable)
 
-    SOverlayLine m_Overlay;
-    SOverlayLine* m_DebugBoundingBoxOverlay;
-    SOverlayLine* m_DebugSelectionBoxOverlay;
-    bool m_EditorOnly;
-
     CCmpSelectable()
-        : m_DebugBoundingBoxOverlay(NULL), m_DebugSelectionBoxOverlay(NULL)
+        : m_DebugBoundingBoxOverlay(NULL), m_DebugSelectionBoxOverlay(NULL), 
+          m_AlphaTarget(0.f), m_BuildingOverlay(NULL), m_UnitOverlay(NULL)
     {
-        m_Overlay.m_Thickness = 2;
-        m_Overlay.m_Color = CColor(0, 0, 0, 0);
+        m_Color = CColor(0, 0, 0, m_AlphaTarget);
     }
 
-    ~CCmpSelectable(){
+    ~CCmpSelectable()
+    {
         delete m_DebugBoundingBoxOverlay;
         delete m_DebugSelectionBoxOverlay;
+        delete m_BuildingOverlay;
+        delete m_UnitOverlay;
     }
 
     static std::string GetSchema()
@@ -71 +82 @@
                 "<element name='EditorOnly' a:help='If this element is present, the entity is only selectable in Atlas'>"
                     "<empty/>"
                 "</element>"
-            "</optional>";
+            "</optional>"
+            "<element name='Overlay' a:help='Specifies the type of overlay to be displayed when this entity is selected'>"
+                "<choice>"
+                    "<element name='Texture' a:help='Displays a texture underneath the entity'>"
+                        "<element name='MainTexture'><text/></element>"
+                        "<element name='MainTextureMask'><text/></element>"
+                    "</element>"
+                    "<element name='Outline' a:help='Traces the outline of the entity with a line texture'>"
+                        "<element name='LineTexture'><text/></element>"
+                        "<element name='LineTextureMask'><text/></element>"
+                        "<element name='LineThickness'><ref name='positiveDecimal'/></element>"
+                    "</element>"
+                "</choice>"
+            "</element>";
     }
 
     virtual void Init(const CParamNode& paramNode)
     {
         m_EditorOnly = paramNode.GetChild("EditorOnly").IsOk();
-    }
 
-    virtual void Deinit()
-    {
+        const CParamNode& textureNode = paramNode.GetChild("Overlay").GetChild("Texture");
+        const CParamNode& outlineNode = paramNode.GetChild("Overlay").GetChild("Outline");
+
+        // TODO: we might be able to save some memory by de-duplicating these descriptors (particularly if actors
+        // also end up having Selectable components -- see CCmpTemplateManager::ConstructTemplateActor)
+
+        if (textureNode.IsOk())
+        {
+            // textured quad mode
+            m_OverlayDescriptor.m_Type = ICmpSelectable::DYNAMIC_QUAD;
+            m_OverlayDescriptor.m_QuadTexture = textureNode.GetChild("MainTexture").ToString();
+            m_OverlayDescriptor.m_QuadTextureMask = textureNode.GetChild("MainTextureMask").ToString();
+        }
+        else if (outlineNode.IsOk())
+        {
+            // outline mode
+            m_OverlayDescriptor.m_Type = ICmpSelectable::STATIC_OUTLINE;
+            m_OverlayDescriptor.m_LineTexture = outlineNode.GetChild("LineTexture").ToString();
+            m_OverlayDescriptor.m_LineTextureMask = outlineNode.GetChild("LineTextureMask").ToString();
+            m_OverlayDescriptor.m_LineThickness = outlineNode.GetChild("LineThickness").ToFixed().ToFloat();
+        }
     }
 
+    virtual void Deinit() { }
+
     virtual void Serialize(ISerializer& UNUSED(serialize))
     {
         // Nothing to do here (the overlay object is not worth saving, it'll get
@@ -95 +139 @@
         Init(paramNode);
     }
 
-    virtual void HandleMessage(const CMessage& msg, bool UNUSED(global))
+    virtual void HandleMessage(const CMessage& msg, bool UNUSED(global));
+
+    virtual void SetSelectionHighlight(CColor color)
     {
-        switch (msg.GetType())
-        {
-        case MT_Interpolate:
+        m_Color.r = color.r;
+        m_Color.g = color.g;
+        m_Color.b = color.b;
+        m_AlphaTarget = color.a; // set target for alpha fading
+    }
+
+    virtual bool IsEditorOnly()
+    {
+        return m_EditorOnly;
+    }
+
+    void RenderSubmit(SceneCollector& collector);
+
+    void UpdateStaticOverlay();
+    void UpdateDynamicOverlay(float frameOffset);
+
+    void InvalidateStaticOverlay();
+
+private:
+    SOverlayDescriptor m_OverlayDescriptor;
+    SOverlayTexturedLine* m_BuildingOverlay;
+    SOverlayQuad* m_UnitOverlay;
+
+    SOverlayLine* m_DebugBoundingBoxOverlay;
+    SOverlayLine* m_DebugSelectionBoxOverlay;
+
+    bool m_EditorOnly;
+    CColor m_Color; ///< Current selection overlay color (including alpha component for fading)
+    float m_AlphaTarget; // fade target
+};
+
+void CCmpSelectable::HandleMessage(const CMessage& msg, bool UNUSED(global))
+{
+    switch (msg.GetType())
+    {
+    case MT_Interpolate:
         {
-            if (m_Overlay.m_Color.a > 0)
+            // update dynamic overlay only when visible
+            if (m_Color.a > 0)
             {
-                float offset = static_cast<const CMessageInterpolate&> (msg).offset;
-                ConstructShape(offset);
+                const CMessageInterpolate& msgData = static_cast<const CMessageInterpolate&> (msg);
+                UpdateDynamicOverlay(msgData.offset);
             }
             break;
         }
-        case MT_RenderSubmit:
+    case MT_OwnershipChanged: 
         {
-            if (m_Overlay.m_Color.a > 0)
+            const CMessageOwnershipChanged& msgData = static_cast<const CMessageOwnershipChanged&> (msg);
+
+            // don't update color if there's no new owner (e.g. the unit died)
+            if (msgData.to == INVALID_PLAYER)
+                break;
+
+            // update the selection highlight color
+            // TODO: very similar to CCmpMinimap's MT_OwnershipChanged handler, consider factoring this out
+            CmpPtr<ICmpPlayerManager> cmpPlayerManager(GetSimContext(), SYSTEM_ENTITY);
+            if (!cmpPlayerManager)
+                break;
+
+            CmpPtr<ICmpPlayer> cmpPlayer(GetSimContext(), cmpPlayerManager->GetPlayerByID(msgData.to));
+            if (!cmpPlayer)
+                break;
+
+            CColor color = cmpPlayer->GetColour();
+            SetSelectionHighlight(CColor(color.r, color.g, color.b, m_AlphaTarget)); // keep current alpha target, change only RGB
+        }
+        // fall-through
+    case MT_PositionChanged:
+        {
+            InvalidateStaticOverlay();
+            break;
+        }
+    case MT_RenderSubmit:
+        {
+            // fade overlay alpha to target alpha
+            const float fadeSpeed = 0.3f; // ]0,1[, higher = faster
+
+            if (m_Color.a != m_AlphaTarget) // should be cheap enough to perform every frame for every selectable while also quickly eliminating many hidden overlays
             {
-                const CMessageRenderSubmit& msgData = static_cast<const CMessageRenderSubmit&> (msg);
-                RenderSubmit(msgData.collector);
+                float targetDiff = m_AlphaTarget - m_Color.a;
+                if (fabs(targetDiff) > 0.001f)
+                {
+                    m_Color.a += targetDiff * fadeSpeed; // apply a fraction of the remainder distance each frame
+                }
+                else
+                {
+                    // snap to the target value so we don't keep rendering because the alpha is like 0.000005 or sth when the
+                    // target alpha is set to 0 to hide the overlay
+                    m_Color.a = m_AlphaTarget;
+                }
             }
+
+            const CMessageRenderSubmit& msgData = static_cast<const CMessageRenderSubmit&> (msg);
+            RenderSubmit(msgData.collector);
+
             break;
         }
-        }
     }
+}
 
-    virtual bool IsEditorOnly()
+void CCmpSelectable::InvalidateStaticOverlay()
+{
+    SAFE_DELETE(m_BuildingOverlay);
+}
+
+void CCmpSelectable::UpdateStaticOverlay()
+{
+    if (m_BuildingOverlay || m_OverlayDescriptor.m_Type != STATIC_OUTLINE)
+        return;
+    
+    entity_id_t entityId = GetEntityId();
+    CmpPtr<ICmpPosition> cmpPosition(GetSimContext(), entityId);
+    CmpPtr<ICmpFootprint> cmpFootprint(GetSimContext(), entityId);
+    CmpPtr<ICmpOwnership> cmpOwnership(GetSimContext(), entityId);
+    if (!cmpFootprint || !cmpPosition)
+        return;
+
+    CmpPtr<ICmpTerrain> cmpTerrain(GetSimContext(), SYSTEM_ENTITY);
+    CmpPtr<ICmpPlayerManager> cmpPlayerManager(GetSimContext(), SYSTEM_ENTITY);
+    if (!cmpTerrain)
+        return; // should never happen
+
+    // grab position/footprint data
+    CFixedVector2D position = cmpPosition->GetPosition2D();
+    CFixedVector3D rotation = cmpPosition->GetRotation();
+
+    ICmpFootprint::EShape fpShape;
+    entity_pos_t fpSize0_fixed, fpSize1_fixed, fpHeight_fixed;
+    cmpFootprint->GetShape(fpShape, fpSize0_fixed, fpSize1_fixed, fpHeight_fixed);
+
+    CTextureProperties texturePropsBase(m_OverlayDescriptor.m_LineTexture); 
+    texturePropsBase.SetWrap(GL_CLAMP_TO_BORDER, GL_CLAMP_TO_EDGE); 
+    texturePropsBase.SetMaxAnisotropy(4.f);
+
+    CTextureProperties texturePropsMask(m_OverlayDescriptor.m_LineTextureMask);
+    texturePropsMask.SetWrap(GL_CLAMP_TO_BORDER, GL_CLAMP_TO_EDGE); 
+    texturePropsMask.SetMaxAnisotropy(4.f);
+
+    // -------------------------------------------------------------------------------------
+
+    m_BuildingOverlay = new SOverlayTexturedLine;
+    m_BuildingOverlay->m_AlwaysVisible = false;
+    m_BuildingOverlay->m_Closed = true;
+    m_BuildingOverlay->m_SimContext = &GetSimContext();
+    m_BuildingOverlay->m_Thickness = m_OverlayDescriptor.m_LineThickness;
+
+    if (g_Renderer.IsInitialised())
     {
-        return m_EditorOnly;
+        m_BuildingOverlay->m_TextureBase = g_Renderer.GetTextureManager().CreateTexture(texturePropsBase);
+        m_BuildingOverlay->m_TextureMask = g_Renderer.GetTextureManager().CreateTexture(texturePropsMask);
     }
-
-    virtual void SetSelectionHighlight(CColor color)
+    else
     {
-        m_Overlay.m_Color = color;
+        LOGWARNING(L"[CCmpSelectable] Cannot update static selection overlay; renderer not initialized");
+    }
+
+    CVector2D origin(position.X.ToFloat(), position.Y.ToFloat());
 
-        if (color.a == 0 && !m_Overlay.m_Coords.empty())
+    switch (fpShape)
+    {
+    case ICmpFootprint::SQUARE:
         {
-            // Delete the overlay data to save memory (we don't want hundreds of bytes
-            // times thousands of units when the selections are not being rendered any more)
-            std::vector<float> empty;
-            m_Overlay.m_Coords.swap(empty);
-            ENSURE(m_Overlay.m_Coords.capacity() == 0);
+            float s = sinf(-rotation.Y.ToFloat());
+            float c = cosf(-rotation.Y.ToFloat());
+            CVector2D unitX(c, s);
+            CVector2D unitZ(-s, c);
+
+            // add half the line thickness to the radius so that we get an 'outside' stroke of the footprint shape
+            const float halfSizeX = fpSize0_fixed.ToFloat()/2.f + m_BuildingOverlay->m_Thickness/2.f;
+            const float halfSizeZ = fpSize1_fixed.ToFloat()/2.f + m_BuildingOverlay->m_Thickness/2.f;
+
+            std::vector<CVector2D> points;
+            points.push_back(CVector2D(origin + unitX *  halfSizeX    + unitZ *(-halfSizeZ)));
+            points.push_back(CVector2D(origin + unitX *(-halfSizeX)   + unitZ *(-halfSizeZ)));
+            points.push_back(CVector2D(origin + unitX *(-halfSizeX)   + unitZ *  halfSizeZ));
+            points.push_back(CVector2D(origin + unitX *  halfSizeX    + unitZ *  halfSizeZ));
+
+            SimRender::SubdividePoints(points, TERRAIN_TILE_SIZE/3.f, m_BuildingOverlay->m_Closed);
+            m_BuildingOverlay->PushCoords(points);
         }
+        break;
+    case ICmpFootprint::CIRCLE:
+        {
+            const float radius = fpSize0_fixed.ToFloat() + m_BuildingOverlay->m_Thickness/3.f;
+            if (radius > 0) // prevent catastrophic failure
+            {
+                float stepAngle;
+                unsigned numSteps;
+                SimRender::AngularStepFromChordLen(TERRAIN_TILE_SIZE/3.f, radius, stepAngle, numSteps);
 
-        // TODO: it'd be nice to fade smoothly (but quickly) from transparent to solid
+                for (unsigned i = 0; i < numSteps; i++) // '<' is sufficient because the line is closed automatically
+                {
+                    float angle = i * stepAngle;
+                    float px = origin.X + radius * sinf(angle);
+                    float pz = origin.Y + radius * cosf(angle);
+
+                    m_BuildingOverlay->PushCoords(px, pz);
+                }
+            }
+        }
+        break;
     }
 
-    void ConstructShape(float frameOffset)
+    ENSURE(m_BuildingOverlay);
+}
+
+void CCmpSelectable::UpdateDynamicOverlay(float frameOffset)
+{
+    if (m_OverlayDescriptor.m_Type != DYNAMIC_QUAD)
+        return;
+
+    entity_id_t entityId = GetEntityId();
+    CmpPtr<ICmpPosition> cmpPosition(GetSimContext(), entityId);
+    CmpPtr<ICmpFootprint> cmpFootprint(GetSimContext(), entityId);
+    CmpPtr<ICmpOwnership> cmpOwnership(GetSimContext(), entityId);
+    if (!cmpFootprint || !cmpPosition || !cmpPosition->IsInWorld())
+        return;
+
+    float rotY;
+    CVector2D position;
+    cmpPosition->GetInterpolatedPosition2D(frameOffset, position.X, position.Y, rotY);
+
+    CmpPtr<ICmpWaterManager> cmpWaterManager(GetSimContext(), SYSTEM_ENTITY);
+    CmpPtr<ICmpTerrain> cmpTerrain(GetSimContext(), SYSTEM_ENTITY);
+    ENSURE(cmpWaterManager && cmpTerrain);
+
+    CTerrain* terrain = cmpTerrain->GetCTerrain();
+    ENSURE(terrain);
+
+    // ---------------------------------------------------------------------------------
+
+    CTextureProperties texturePropsBase(m_OverlayDescriptor.m_QuadTexture); 
+    texturePropsBase.SetWrap(GL_CLAMP_TO_BORDER, GL_CLAMP_TO_EDGE); 
+    texturePropsBase.SetMaxAnisotropy(4.f);
+
+    CTextureProperties texturePropsMask(m_OverlayDescriptor.m_QuadTextureMask);
+    texturePropsMask.SetWrap(GL_CLAMP_TO_BORDER, GL_CLAMP_TO_EDGE); 
+    texturePropsMask.SetMaxAnisotropy(4.f);
+
+    ICmpFootprint::EShape fpShape;
+    entity_pos_t fpSize0_fixed, fpSize1_fixed, fpHeight_fixed;
+    cmpFootprint->GetShape(fpShape, fpSize0_fixed, fpSize1_fixed, fpHeight_fixed);
+
+    // ---------------------------------------------------------------------------------
+
+    if (!m_UnitOverlay)
+        m_UnitOverlay = new SOverlayQuad;
+
+    m_UnitOverlay->m_Texture = g_Renderer.GetTextureManager().CreateTexture(texturePropsBase);
+    m_UnitOverlay->m_TextureMask = g_Renderer.GetTextureManager().CreateTexture(texturePropsMask);
+    m_UnitOverlay->m_Color = m_Color;
+
+    // TODO: some code duplication here :< would be nice to factor out getting the corner points of an entity based on its footprint
+    // sizes (and regardless of whether it's a circle or a square)
+
+    float s = sinf(-rotY);
+    float c = cosf(-rotY);
+    CVector2D unitX(c, s);
+    CVector2D unitZ(-s, c);
+
+    float halfSizeX = fpSize0_fixed.ToFloat();
+    float halfSizeZ = fpSize1_fixed.ToFloat();
+    if (fpShape == ICmpFootprint::SQUARE)
     {
-        CmpPtr<ICmpPosition> cmpPosition(GetSimContext(), GetEntityId());
-        if (!cmpPosition)
-            return;
+        halfSizeX /= 2.0f;
+        halfSizeZ /= 2.0f;
+    }
 
-        if (!cmpPosition->IsInWorld())
-            return;
+    std::vector<CVector2D> points;
+    points.push_back(CVector2D(position + unitX *(-halfSizeX)   + unitZ *  halfSizeZ));  // top left
+    points.push_back(CVector2D(position + unitX *(-halfSizeX)   + unitZ *(-halfSizeZ))); // bottom left
+    points.push_back(CVector2D(position + unitX *  halfSizeX    + unitZ *(-halfSizeZ))); // bottom right
+    points.push_back(CVector2D(position + unitX *  halfSizeX    + unitZ *  halfSizeZ));  // top right
 
-        float x, z, rotY;
-        cmpPosition->GetInterpolatedPosition2D(frameOffset, x, z, rotY);
+    for (int i=0; i < 4; i++)
+    {
+        float quadY = std::max(
+            terrain->GetExactGroundLevel(points[i].X, points[i].Y),
+            cmpWaterManager->GetExactWaterLevel(points[i].X, points[i].Y)
+        );
 
-        CmpPtr<ICmpFootprint> cmpFootprint(GetSimContext(), GetEntityId());
-        if (!cmpFootprint)
-        {
-            // Default (this probably shouldn't happen) - just render an arbitrary-sized circle
-            SimRender::ConstructCircleOnGround(GetSimContext(), x, z, 2.f, m_Overlay, cmpPosition->IsFloating());
-        }
-        else
+        m_UnitOverlay->m_Corners[i] = CVector3D(points[i].X, quadY, points[i].Y);
+    }
+}
+
+void CCmpSelectable::RenderSubmit(SceneCollector& collector)
+{
+    // don't render selection overlay if it's not gonna be visible
+    if (m_Color.a > 0)
+    {
+        switch (m_OverlayDescriptor.m_Type)
         {
-            ICmpFootprint::EShape shape;
-            entity_pos_t size0, size1, height;
-            cmpFootprint->GetShape(shape, size0, size1, height);
-
-            if (shape == ICmpFootprint::SQUARE)
-                SimRender::ConstructSquareOnGround(GetSimContext(), x, z, size0.ToFloat(), size1.ToFloat(), rotY, m_Overlay, cmpPosition->IsFloating());
-            else
-                SimRender::ConstructCircleOnGround(GetSimContext(), x, z, size0.ToFloat(), m_Overlay, cmpPosition->IsFloating());
+            case STATIC_OUTLINE:
+                {
+                    UpdateStaticOverlay();
+                    m_BuildingOverlay->m_Color = m_Color; // done separately so alpha changes don't require a full update call
+                    collector.Submit(m_BuildingOverlay);
+                }
+                break;
+            case DYNAMIC_QUAD:
+                {
+                    if (m_UnitOverlay)
+                        collector.Submit(m_UnitOverlay);
+                }
+                break;
+            default:
+                break;
         }
     }
 
-    void RenderSubmit(SceneCollector& collector)
+    // render bounding box debug overlays 
+    if (m_AlphaTarget > 0) // so the debug overlay responds immediately to deselection without delay from fading out
     {
-        // (This is only called if a > 0)
-        collector.Submit(&m_Overlay);
-
         if (ICmpSelectable::ms_EnableDebugOverlays)
         {
             // allocate debug overlays on-demand
@@ -205 +484 @@
             if (m_DebugSelectionBoxOverlay) SAFE_DELETE(m_DebugSelectionBoxOverlay);
         }
     }
-};
+}
 
 REGISTER_COMPONENT_TYPE(Selectable)

source/simulation2/components/CCmpTemplateManager.cpp

@@ -371 +371 @@
 
     // Initialise the actor's name and make it an Atlas selectable entity.
     std::string name = utf8_from_wstring(CParamNode::EscapeXMLString(wstring_from_utf8(actorName)));
-    std::string xml = "<Entity><VisualActor><Actor>" + name + "</Actor></VisualActor><Selectable><EditorOnly/></Selectable></Entity>";
+    std::string xml = "<Entity>"
+                          "<VisualActor><Actor>" + name + "</Actor></VisualActor>"
+                          "<Selectable>"
+                              "<EditorOnly/>"
+                              "<Overlay><Texture><MainTexture>art/textures/selection/actor.png</MainTexture><MainTextureMask>art/textures/selection/actor_mask.png</MainTextureMask></Texture></Overlay>"
+                          "</Selectable>"
+                      "</Entity>";
+
     CParamNode::LoadXMLString(out, xml.c_str());
 }
 

source/simulation2/components/CCmpTerritoryManager.cpp

@@ -618 +618 @@
     texturePropsMask.SetMaxAnisotropy(2.f);
     CTexturePtr textureMask = g_Renderer.GetTextureManager().CreateTexture(texturePropsMask);
 
-    CmpPtr<ICmpTerrain> cmpTerrain(GetSimContext(), SYSTEM_ENTITY);
-    if (!cmpTerrain)
-        return;
-    CTerrain* terrain = cmpTerrain->GetCTerrain();
-
     CmpPtr<ICmpPlayerManager> cmpPlayerManager(GetSimContext(), SYSTEM_ENTITY);
     if (!cmpPlayerManager)
         return;
@@ -640 +635 @@
         m_BoundaryLines.push_back(SBoundaryLine());
         m_BoundaryLines.back().connected = boundaries[i].connected;
         m_BoundaryLines.back().color = color;
-        m_BoundaryLines.back().overlay.m_Terrain = terrain;
+        m_BoundaryLines.back().overlay.m_SimContext = &GetSimContext();
         m_BoundaryLines.back().overlay.m_TextureBase = textureBase;
         m_BoundaryLines.back().overlay.m_TextureMask = textureMask;
         m_BoundaryLines.back().overlay.m_Color = color;
@@ -648 +643 @@
         m_BoundaryLines.back().overlay.m_Closed = true;
 
         SimRender::SmoothPointsAverage(boundaries[i].points, m_BoundaryLines.back().overlay.m_Closed);
-
         SimRender::InterpolatePointsRNS(boundaries[i].points, m_BoundaryLines.back().overlay.m_Closed, m_BorderSeparation);
 
         std::vector<float>& points = m_BoundaryLines.back().overlay.m_Coords;

source/simulation2/components/ICmpSelectable.h

@@ -25 +25 @@
 class ICmpSelectable : public IComponent
 {
 public:
+    /// Batch rendering data ID; used by the selection highlight renderer to efficiently render selection highlights
+    typedef std::size_t renderdata_id;
+
+    enum EOverlayType {
+        /// A single textured quad overlay, intended for entities that move around much, like units (e.g. foot soldiers, etc).
+        DYNAMIC_QUAD,
+        /// A more complex textured line overlay, composed of several textured line segments. Intended for entities that do not
+        /// move often, such as buildings (structures).
+        STATIC_OUTLINE,
+    };
+
+    struct SOverlayDescriptor
+    {
+        EOverlayType m_Type;
+        std::wstring m_QuadTexture;
+        std::wstring m_QuadTextureMask;
+        std::wstring m_LineTexture;
+        std::wstring m_LineTextureMask;
+        float m_LineThickness;
+        std::wstring m_CornerTexture;
+        std::wstring m_CornerTextureMask;
+
+        SOverlayDescriptor() : m_LineThickness(0) {}
+
+        struct hash : std::unary_function<SOverlayDescriptor, renderdata_id>
+        {
+            renderdata_id operator()(SOverlayDescriptor const& d) const;
+        };
+
+        bool operator==(const SOverlayDescriptor& other) const;
+    };
+
     /**
      * Returns true if the entity is only selectable in Atlas editor, e.g. a decorative visual actor.
      */

source/simulation2/helpers/Geometry.cpp

@@ -45 +45 @@
     );
 }
 
+float Geometry::ChordToCentralAngle(const float chordLength, const float radius)
+{
+    ENSURE(radius > 0);
+    return acosf(1.f - SQR(chordLength)/(2.f*SQR(radius))); // cfr. law of cosines
+}
+
 fixed Geometry::DistanceToSquare(CFixedVector2D point, CFixedVector2D u, CFixedVector2D v, CFixedVector2D halfSize)
 {
     /*

source/simulation2/helpers/Geometry.h

@@ -24 +24 @@
  */
 
 #include "maths/Fixed.h"
+#include "maths/MathUtil.h"
 
 class CFixedVector2D;
 
@@ -53 +54 @@
 fixed DistanceToSquare(CFixedVector2D point, CFixedVector2D u, CFixedVector2D v, CFixedVector2D halfSize);
 
 /**
+ * Given a circle of radius @p radius, and a chord of length @p chordLength on this circle, computes the central angle formed by 
+ * connecting the chord's endpoints to the center of the circle.
+ * 
+ * @param radius Radius of the circle; must be strictly positive.
+ */
+float ChordToCentralAngle(const float chordLength, const float radius);
+
+/**
  * Find point closest to the given point on the edge of the given square or rectangle.
  *
  * @note Currently assumes the @p u and @p v vectors are perpendicular.

source/simulation2/helpers/Render.cpp

@@ -19 +19 @@
 
 #include "Render.h"
 
-#include "simulation2/Simulation2.h"
-#include "simulation2/components/ICmpTerrain.h"
-#include "simulation2/components/ICmpWaterManager.h"
 #include "graphics/Overlay.h"
 #include "graphics/Terrain.h"
 #include "maths/BoundingBoxAligned.h"
 #include "maths/BoundingBoxOriented.h"
 #include "maths/MathUtil.h"
+#include "maths/Quaternion.h"
 #include "maths/Vector2D.h"
 #include "ps/Profile.h"
-#include "maths/Quaternion.h"
+#include "simulation2/Simulation2.h"
+#include "simulation2/components/ICmpTerrain.h"
+#include "simulation2/components/ICmpWaterManager.h"
+#include "simulation2/helpers/Geometry.h"
 
 void SimRender::ConstructLineOnGround(const CSimContext& context, const std::vector<float>& xz,
         SOverlayLine& overlay, bool floating, float heightOffset)
@@ -343 +344 @@
     return p + CVector2D(dp.Y*-offset, dp.X*offset);
 }
 
-void SimRender::InterpolatePointsRNS(std::vector<CVector2D>& points, bool closed, float offset, int segmentSamples)
+void SimRender::InterpolatePointsRNS(std::vector<CVector2D>& points, bool closed, float offset, int segmentSamples /* = 4 */)
 {
     PROFILE("InterpolatePointsRNS");
     ENSURE(segmentSamples > 0);
@@ -381 +382 @@
 
     for (size_t i = 0; i < imax; ++i)
     {
-
         // Get the relevant points for this spline segment; each step interpolates the segment between p1 and p2; p0 and p3 are the points
         // before p1 and after p2, respectively; they're needed to compute tangents and whatnot.
         CVector2D p0; // normally points[(i-1+n)%n], but it's a bit more complicated due to open/closed paths -- see below
@@ -521 +521 @@
     }
 
 }
+
+void SimRender::AngularStepFromChordLen(const float maxChordLength, const float radius, float& out_stepAngle, unsigned& out_numSteps)
+{
+    float maxAngle = Geometry::ChordToCentralAngle(maxChordLength, radius);
+    out_numSteps = ceilf(float(2*M_PI)/maxAngle);
+    out_stepAngle = float(2*M_PI)/out_numSteps;
+}
+
+// TODO: this serves a similar purpose to SplitLine above, but is more general. Also, SplitLine seems to be implemented more
+// efficiently, might be nice to take some cues from it
+void SimRender::SubdividePoints(std::vector<CVector2D>& points, float maxSegmentLength, bool closed)
+{
+    size_t numControlPoints = points.size();
+    if (numControlPoints < 2)
+        return;
+
+    ENSURE(maxSegmentLength > 0);
+
+    size_t endIndex = numControlPoints;
+    if (!closed && numControlPoints > 2)
+        endIndex--;
+
+    std::vector<CVector2D> newPoints;
+
+    for (size_t i = 0; i < endIndex; i++)
+    {
+        const CVector2D& curPoint = points[i];
+        const CVector2D& nextPoint = points[(i+1) % numControlPoints];
+        const CVector2D line(nextPoint - curPoint);
+        CVector2D lineDirection = line.Normalized();
+
+        // include control point i + a list of intermediate points between i and i + 1 (excluding i+1 itself)
+        newPoints.push_back(curPoint);
+
+        // calculate how many intermediate points are needed so that each segment is of length <= maxSegmentLength
+        float lineLength = line.Length();
+        size_t numSegments = (size_t) ceilf(lineLength / maxSegmentLength);
+        float segmentLength = lineLength / numSegments;
+
+        for (size_t s = 1; s < numSegments; ++s) // start at one, we already included curPoint
+        {
+            newPoints.push_back(curPoint + lineDirection * (s * segmentLength));
+        }
+    }
+
+    points.swap(newPoints);
+}
+ No newline at end of file

source/simulation2/helpers/Render.h

@@ -76 +76 @@
  * @param[in,out] overlay Updated overlay line representing this circle.
  * @param[in] floating If true, the circle conforms to water as well.
  * @param[in] heightOffset Height above terrain to offset the circle.
+ * @param heightOffset The vertical offset to apply to points, to raise the line off the terrain a bit.
  */
 void ConstructCircleOnGround(const CSimContext& context, float x, float z, float radius,
         SOverlayLine& overlay,
@@ -96 +97 @@
         bool floating, float heightOffset = 0.25f);
 
 /**
- * Constructs a solid outline of an arbitrarily-aligned box.
+ * Constructs a solid outline of an arbitrarily-aligned bounding @p box.
  *
  * @param[in] box
  * @param[in,out] overlayLine Updated overlay line representing the oriented box.
@@ -104 +105 @@
 void ConstructBoxOutline(const CBoundingBoxOriented& box, SOverlayLine& overlayLine);
 
 /**
- * Constructs a solid outline of an axis-aligned bounding box.
+ * Constructs a solid outline of an axis-aligned bounding @p box.
  *
  * @param[in] bound
  * @param[in,out] overlayLine Updated overlay line representing the AABB.
  */
-void ConstructBoxOutline(const CBoundingBoxAligned& bound, SOverlayLine& overlayLine);
+void ConstructBoxOutline(const CBoundingBoxAligned& box, SOverlayLine& overlayLine);
 
 /**
  * Constructs a simple gimbal outline with the given radius and center.
@@ -124 +125 @@
 
 /**
  * Constructs 3D axis marker overlay lines for the given coordinate system.
- * The overlay lines are colored RGB for the XYZ axes, respectively.
+ * The XYZ axes are colored RGB, respectively.
  *
  * @param[in] coordSystem Specifies the coordinate system.
  * @param[out] outX,outY,outZ Constructed overlay lines for each axes.
@@ -162 +163 @@
  * @param[in] dashLength Length of a single dash. Must be strictly positive.
  * @param[in] blankLength Length of a single blank between dashes. Must be strictly positive.
  */
-void ConstructDashedLine(const std::vector<CVector2D>& linePoints, SDashedLine& dashedLineOut, const float dashLength, const float blankLength);
+void ConstructDashedLine(const std::vector<CVector2D>& linePoints, SDashedLine& dashedLineOut,
+        const float dashLength, const float blankLength);
+
+/**
+ * Computes angular step parameters @p out_stepAngle and @p out_numSteps, given a @p maxChordLength on a circle of radius @p radius.
+ * The resulting values satisfy @p out_numSteps * @p out_stepAngle = 2*PI.
+ * 
+ * This function is used to find the angular step parameters when drawing a circle outline approximated by several connected chords;
+ * it returns the step angle and number of steps such that the length of each resulting chord is less than or equal to @p maxChordLength.
+ * By stating that each chord cannot be longer than a particular length, a certain level of visual smoothness of the resulting circle
+ * outline can be guaranteed independently of the radius of the outline.
+ * 
+ * @param radius Radius of the circle. Must be strictly positive.
+ * @param maxChordLength Desired maximum length of individual chords. Must be strictly positive.
+ */
+void AngularStepFromChordLen(const float maxChordLength, const float radius, float& out_stepAngle, unsigned& out_numSteps);
+
+/**
+ * Subdivides a list of @p points into segments of maximum length @p maxSegmentLength that are of equal size between every two
+ * control points. The resulting subdivided list of points is written back to @p points.
+ * 
+ * @param points The list of intermediate points to subdivide.
+ * @param maxSegmentLength The maximum length of a single segment after subdivision. Must be strictly positive.
+ * @param closed Should the provided list of points be treated as a closed shape? If true, the resulting list of points will include
+ *        extra subdivided points between the last and the first point.
+ */
+void SubdividePoints(std::vector<CVector2D>& points, float maxSegmentLength, bool closed);
 
 } // namespace
 

source/simulation2/tests/test_CmpTemplateManager.h

@@ -78 +78 @@
         const CParamNode* actor = tempMan->LoadTemplate(ent2, "actor|example1", -1);
         TS_ASSERT(actor != NULL);
         TS_ASSERT_WSTR_EQUALS(actor->ToXML(),
-                L"<Selectable><EditorOnly></EditorOnly></Selectable><VisualActor><Actor>example1</Actor><SilhouetteDisplay>false</SilhouetteDisplay><SilhouetteOccluder>false</SilhouetteOccluder></VisualActor>");
+                L"<Selectable><EditorOnly></EditorOnly><Overlay><Texture><MainTexture>art/textures/selection/actor.png</MainTexture><MainTextureMask>art/textures/selection/actor_mask.png</MainTextureMask></Texture></Overlay></Selectable>"
+                L"<VisualActor><Actor>example1</Actor><SilhouetteDisplay>false</SilhouetteDisplay><SilhouetteOccluder>false</SilhouetteOccluder></VisualActor>");
 
         const CParamNode* preview = tempMan->LoadTemplate(ent2, "preview|unit", -1);
         TS_ASSERT(preview != NULL);

new file source/tools/selectiontexgen/selectiontexgen.py

@@ +1 @@
+"""Generates basic square and circle selection overlay textures by parsing all the entity XML files and reading
+their Footprint components."""
+
+# This script uses PyCairo for plotting, since PIL (Python Imaging Library) is absolutely horrible. On Linux,
+# this should be merely a matter of installing a package (e.g. 'python-cairo' for Debian/Ubuntu), but on Windows
+# it's kind of tricky and requires some Google-fu. Fortunately, I have saved the working instructions below:
+# 
+# Grab a Win32 binary from http://ftp.gnome.org/pub/GNOME/binaries/win32/pycairo/1.8/ and install PyCairo using 
+# the installer. The installer extracts the necessary files into Lib\site-packages\cairo within the folder where 
+# Python is installed. There are some extra DLLs which are required to make Cairo work, so we have to get these 
+# as well.
+# 
+# Head to http://ftp.gnome.org/pub/gnome/binaries/win32/dependencies/ and get the binary versions of Cairo 
+# (cairo_1.8.10-3_win32.zip at the time of writing), Fontconfig (fontconfig_2.8.0-2_win32.zip), Freetype 
+# (freetype_2.4.4-1_win32.zip), Expat (expat_2.0.1-1_win32.zip), libpng (libpng_1.4.3-1_win32.zip) and zlib 
+# (zlib_1.2.5-2_win32.zip). Version numbers may vary, so be adaptive! Each ZIP file will contain a bin subfolder 
+# with a DLL file in it. Put the following DLLs in Lib\site-packages\cairo within your Python installation:
+#
+#    freetype6.dll (from freetype_2.4.4-1_win32.zip)
+#    libcairo-2.dll (from cairo_1.8.10-3_win32.zip)
+#    libexpat-1.dll (from expat_2.0.1-1_win32.zip)
+#    libfontconfig-1.dll (from fontconfig_2.8.0-2_win32.zip)
+#    libpng14-14.dll (from libpng_1.4.3-1_win32.zip)
+#    zlib1.dll (from zlib_1.2.5-2_win32.zip).
+#
+# Should be all set now.
+
+import optparse
+import sys, os
+import math
+import operator
+import cairo                    # Requires PyCairo (see notes above)
+from os.path import *
+from xml.dom import minidom
+
+def geqPow2(x):
+    """Returns the smallest power of two that's equal to or greater than x"""
+    return int(2**math.ceil(math.log(x, 2)))
+
+def generateSelectionTexture(shape, textureW, textureH, outputDir):
+    
+    outputBasename = "%dx%d" % (textureW, textureH)
+    
+    # size of the image canvas containing the texture (may be larger to ensure power-of-two dimensions)
+    canvasW = geqPow2(textureW)
+    canvasH = geqPow2(textureH)
+    
+    # draw texture
+    texture = cairo.ImageSurface(cairo.FORMAT_ARGB32, canvasW, canvasH)
+    textureMask = cairo.ImageSurface(cairo.FORMAT_RGB24, canvasW, canvasH)
+    
+    ctxTexture = cairo.Context(texture)
+    ctxTextureMask = cairo.Context(textureMask)
+    
+    # fill entire image with transparent pixels
+    ctxTexture.set_source_rgba(1.0, 1.0, 1.0, 0.0)      # transparent
+    ctxTexture.rectangle(0, 0, textureW, textureH)          
+    ctxTexture.fill()                                   # fill current path
+    
+    ctxTextureMask.set_source_rgb(0.0, 0.0, 0.0)        # black
+    ctxTextureMask.rectangle(0, 0, canvasW, canvasH)    # (!)
+    ctxTextureMask.fill()
+    
+    pasteX = (canvasW - textureW)//2                    # integer division, floored result
+    pasteY = (canvasH - textureH)//2                    # integer division, floored result
+    ctxTexture.translate(pasteX, pasteY)                # translate all drawing so that the result is centered
+    ctxTextureMask.translate(pasteX, pasteY)
+    
+    if shape == "square":
+        
+        rectW = textureW
+        rectH = textureH
+        
+        # draw texture (4px white outline, then overlay a 2px black outline)
+        ctxTexture.rectangle(2, 2, rectW-4, rectH-4)
+        ctxTexture.set_line_width(4)
+        ctxTexture.set_source_rgba(1.0, 1.0, 1.0, 1.0)  # white
+        ctxTexture.stroke_preserve()                    # stroke and maintain path
+        ctxTexture.set_line_width(2)
+        ctxTexture.set_source_rgba(0.0, 0.0, 0.0, 1.0)  # black
+        ctxTexture.stroke()                             # stroke and clear path
+        
+        # draw mask (2px white)
+        ctxTextureMask.rectangle(2, 2, rectW-4, rectH-4)
+        ctxTextureMask.set_line_width(2)
+        ctxTextureMask.set_source_rgb(1.0, 1.0, 1.0)
+        ctxTextureMask.stroke()
+        
+    elif shape == "circle":
+        
+        centerX = textureW//2
+        centerY = textureH//2
+        radius = textureW//2 - 2 # allow for 2px on either side so the 4px-wide white stroke can fit
+        
+        # draw texture
+        ctxTexture.arc(centerX, centerY, radius, 0, 2*math.pi)
+        ctxTexture.set_line_width(4)
+        ctxTexture.set_source_rgba(1.0, 1.0, 1.0, 1.0)  # white
+        ctxTexture.stroke_preserve()                    # stroke and maintain path
+        ctxTexture.set_line_width(2)
+        ctxTexture.set_source_rgba(0.0, 0.0, 0.0, 1.0)  # black
+        ctxTexture.stroke()
+        
+        # draw mask
+        ctxTextureMask.arc(centerX, centerY, radius, 0, 2*math.pi)
+        ctxTextureMask.set_line_width(2)
+        ctxTextureMask.set_source_rgb(1.0, 1.0, 1.0)
+        ctxTextureMask.stroke()
+    
+    finalOutputDir = outputDir + "/" + shape
+    if not isdir(finalOutputDir):
+        os.makedirs(finalOutputDir)
+    
+    print "Generating " + os.path.normcase(finalOutputDir + "/" + outputBasename + ".png")
+    
+    texture.write_to_png(finalOutputDir + "/" + outputBasename + ".png")
+    textureMask.write_to_png(finalOutputDir + "/" + outputBasename + "_mask.png")
+
+
+def generateSelectionTextures(xmlTemplateDir, outputDir, snapSizes = False):
+    
+    # recursively list XML files
+    xmlFiles = []
+    
+    for dir, subdirs, basenames in os.walk(xmlTemplateDir):
+        for basename in basenames:
+            filename = join(dir, basename)
+            if filename[-4:] == ".xml":
+                xmlFiles.append(filename)
+    
+    textureTypesRaw = set()     # set of (type, w, h) tuples (so we can eliminate duplicates)
+    
+    # parse the XML files, and look for <Footprint> nodes that are a child of <Entity> and
+    # that do not have the disable attribute defined
+    for xmlFile in xmlFiles:
+        xmlDoc = minidom.parse(xmlFile)
+        rootNode = xmlDoc.childNodes[0]
+        
+        # we're only interested in entity templates
+        if not rootNode.nodeName == "Entity":
+            continue
+        
+        # check if this entity has a footprint definition
+        rootChildNodes = [n for n in rootNode.childNodes if n.localName is not None] # remove whitespace text nodes
+        footprintNodes = filter(lambda x: x.localName == "Footprint", rootChildNodes)
+        if not len(footprintNodes) == 1:
+            continue
+        
+        footprintNode = footprintNodes[0]
+        if footprintNode.hasAttribute("disable"):
+            continue
+        
+        # parse the footprint declaration
+        # Footprints can either have either one of these children:
+        # <Circle radius="xx.x" />
+        # <Square width="xx.x" depth="xx.x"/>
+        # There's also a <Height> node, but we don't care about it here.
+        
+        squareNodes = footprintNode.getElementsByTagName("Square")
+        circleNodes = footprintNode.getElementsByTagName("Circle")
+        
+        numSquareNodes = len(squareNodes)
+        numCircleNodes = len(circleNodes)
+        
+        if not (numSquareNodes + numCircleNodes == 1):
+            print "Invalid Footprint definition: insufficient or too many Square and/or Circle definitions in %s" % xmlFile
+        
+        texShape = None
+        texW = None     # in world-space units
+        texH = None     # in world-space units
+        
+        if numSquareNodes == 1:
+            texShape = "square"
+            texW = float(squareNodes[0].getAttribute("width"))
+            texH = float(squareNodes[0].getAttribute("depth"))
+        
+        elif numCircleNodes == 1:
+            texShape = "circle"
+            texW = float(circleNodes[0].getAttribute("radius"))
+            texH = texW
+        
+        textureTypesRaw.add((texShape, texW, texH))
+    
+    # endfor xmlFiles
+    
+    print "Found:     %d footprints (%d square, %d circle)" % (
+        len(textureTypesRaw),
+        len([x for x in textureTypesRaw if x[0] == "square"]),
+        len([x for x in textureTypesRaw if x[0] == "circle"])
+    )
+    
+    textureTypes = set()
+    
+    for type, w, h in textureTypesRaw:
+        if snapSizes:
+            # "snap" texture sizes to close-enough neighbours that will still look good enough so we can get away with fewer 
+            # actual textures than there are unique footprint outlines 
+            w = 1*math.ceil(w/1)    # round up to the nearest world-space unit
+            h = 1*math.ceil(h/1)    # round up to the nearest world-space unit
+            
+        textureTypes.add((type, w, h))
+    
+    if snapSizes:
+        print "Reduced: %d footprints (%d square, %d circle)" % (
+            len(textureTypes),
+            len([x for x in textureTypes if x[0] == "square"]),
+            len([x for x in textureTypes if x[0] == "circle"])
+        )
+    
+    # create list from texture types set (so we can sort and have prettier output)
+    textureTypes = sorted(list(textureTypes), key=operator.itemgetter(0,1,2))       # sort by the first tuple element, then by the second, then the third
+    
+    # ------------------------------------------------------------------------------------
+    # compute the size of the actual texture we want to generate (in px)
+    
+    scale = 8       # world-space-units-to-pixels scale
+    for type, w, h in textureTypes:
+        
+        # if we have a circle, update the w and h so that they're the full width and height of the texture 
+        # and not just the radius
+        if type == "circle":
+            assert w == h
+            w *= 2
+            h *= 2
+        
+        w = int(math.ceil(w*scale))
+        h = int(math.ceil(h*scale))
+        
+        # apply a minimum size for really small textures (otherwise you get really ugly textures ingame)
+        w = max(24, w)
+        h = max(24, h)
+        
+        generateSelectionTexture(type, w, h, outputDir)
+
+
+if __name__ == "__main__":
+    
+    parser = optparse.OptionParser(usage="Usage: %prog [filenames]")
+    
+    parser.add_option("--template-dir",  type="str",  default=None,  help="Path to simulation template XML definition folder. Will be searched recursively for templates containing Footprint definitions. If not specified and this script is run from its directory, it will be automatically determined.")
+    parser.add_option("--output-dir",    type="str",  default=".",   help="Output directory. Will be created if it does not already exist.")
+    
+    (options, args) = parser.parse_args()
+    
+    templateDir = options.template_dir
+    if templateDir is None:
+        
+        scriptDir = dirname(abspath(__file__))
+        
+        # 'autodetect' location if run from its own dir
+        if normcase(scriptDir).replace('\\', '/').endswith("source/tools/selectiontexgen"):
+            templateDir = "../../../binaries/data/mods/public/simulation/templates"
+        else:
+            print "No template dir specified; use the --template-dir command line argument."
+            sys.exit()
+    
+    # check if the template dir exists
+    templateDir = abspath(templateDir)
+    if not isdir(templateDir):
+        print "No such template directory: %s" % templateDir
+        sys.exit()
+    
+    # check if the output dir exists, create it if needed
+    outputDir = abspath(options.output_dir)
+    print outputDir
+    if not isdir(outputDir):
+        print "Creating output directory: %s" % outputDir
+        os.makedirs(outputDir)
+    
+    print "Template directory:\t%s" % templateDir
+    print "Output directory:  \t%s" % outputDir
+    print "------------------------------------------------"
+    
+    generateSelectionTextures(templateDir, outputDir)
+ No newline at end of file