Ticket #524: rallypoints_wip_11sep11.patch

binaries/data/mods/public/art/actors/props/special/common/waypoint_flag.xml

@@ -11 +11 @@
     <variant name="waypoint_hellenes">
       <texture>props/banner_greek.png</texture>
     </variant>
+    <variant name="waypoint_persians">
+      <texture>props/banner_persian.png</texture>
+    </variant>
+    <variant name="waypoint_celts">
+      <texture>props/banner_celt.png</texture>
+    </variant>
+    <variant name="waypoint_carthaginians">
+      <texture>props/banner_carthage.png</texture>
+    </variant>
+    <variant name="waypoint_iberians">
+      <texture>props/banner_iberians.png</texture>
+    </variant>
+    <variant name="waypoint_romans">
+      <texture>props/banner_romans.png</texture>
+    </variant>
   </group>
 </actor>

binaries/data/mods/public/gui/session/input.js

@@ -1108 +1108 @@
             case "unload-all":
                 unloadAll(entity);
                 break;
+            case "focus-rally":
+                // make the camera move to the building's rally point
+                
+                // grab the rally point position (if any)
+                var entState = Engine.GuiInterfaceCall("GetEntityState", entity);
+                if (entState.rallyPoint)
+                {
+                    // the rally point isn't necessarily set
+                    if (entState.rallyPoint.position)
+                    {
+                        Engine.CameraMoveTo(entState.rallyPoint.position.x, entState.rallyPoint.position.y);
+                    }
+                    else
+                    {
+                        // no rally point set, jump to the building itself instead (since units will now spawn right next to the
+                        // building)
+                        if (entState.position)
+                            Engine.CameraMoveTo(entState.position.x, entState.position.z);
+                    }
+                }
+                
+                break;
             default:
                 break;
             }

binaries/data/mods/public/gui/session/unit_commands.js

@@ -236 +236 @@
                 break;
 
             case COMMAND:
-                if (item == "unload-all")
+                // here, "item" is an object with properties .name (command name), .tooltip and .icon (relative to session/icons/single)
+                if (item.name == "unload-all")
                 {
                     var count = unitEntState.garrisonHolder.entities.length;
                     getGUIObjectByName("unit"+guiName+"Count["+i+"]").caption = (count > 0 ? count : "");
@@ -246 +247 @@
                     getGUIObjectByName("unit"+guiName+"Count["+i+"]").caption = "";
                 }
 
-                tooltip = toTitleCase(item);
+                tooltip = (item.tooltip ? item.tooltip : toTitleCase(item.name)); // use item.tooltip if available, otherwise default to title-cased command name
                 break;
 
             default:
@@ -300 +301 @@
         {
             //icon.cell_id = i;
             //icon.cell_id = getCommandCellId(item);
-            icon.sprite = "stretched:session/icons/single/" + getCommandImage(item);
+            icon.sprite = "stretched:session/icons/single/" + item.icon;
 
         }
         else if (template.icon)
@@ -384 +385 @@
         var commands = getEntityCommandsList(entState);
         if (commands.length)
             setupUnitPanel("Command", usedPanels, entState, commands,
-                function (item) { performCommand(entState.id, item); } );
+                function (item) { performCommand(entState.id, item.name); } );
 
         if (entState.garrisonHolder)
         {

binaries/data/mods/public/gui/session/utility_functions.js

@@ -188 +188 @@
     }
 }
 
-function getCommandImage(commandName)
-{
-    switch (commandName)
-    {
-    case "delete":
-        return "kill_small.png";
-    case "unload-all":
-        return "garrison-out.png";
-    case "garrison":
-        return "garrison.png";
-    case "repair":
-        return "repair.png";
-    default:
-        return "";
-    }
-}
-
 function getEntityFormationsList(entState)
 {
     var civ = g_Players[entState.player].civ;
@@ -233 +216 @@
 {
     var commands = [];
     if (entState.garrisonHolder)
-        commands.push("unload-all");
+    {
+        commands.push({
+            "name": "unload-all",
+            "tooltip": "Unload All",
+            "icon": "garrison-out.png"
+        });
+    }
+    
+    commands.push({
+        "name": "delete",
+        "tooltip": "Delete",
+        "icon": "kill_small.png"
+    });
+    
     if (isUnit(entState))
-        commands.push("garrison");
+    {
+        commands.push({
+            "name": "garrison",
+            "tooltip": "Garrison",
+            "icon": "garrison.png"
+        });
+    }
+    
     if (entState.buildEntities)
-        commands.push("repair");
-    commands.push("delete");
+    {
+        commands.push({
+            "name": "repair",
+            "tooltip": "Repair",
+            "icon": "repair.png"
+        });
+    }
+    
+    if(entState.rallyPoint)
+    {
+        commands.push({
+            "name": "focus-rally",
+            "tooltip": "Focus on Rally Point",
+            "icon": "focus-rally.png"
+        });
+    }
+    
     return commands;
 }
 

binaries/data/mods/public/shaders/overlayline.fp

@@ -3 +3 @@
 TEMP base;
 TEMP mask;
 TEMP color;
-TEMP los;
+
 
 // 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, objectColor, base;
 
-// Multiply by LOS texture
-TEX los, fragment.texcoord[1], texture[2], 2D;
-MUL result.color.rgb, color, los.a;
+#ifdef IGNORE_LOS
+  MOV result.color.rgb, color;
+#else
+  // Multiply RGB by LOS texture (alpha channel)
+  TEMP los;
+  TEX los, fragment.texcoord[1], texture[2], 2D;
+  MUL result.color.rgb, color, los.a;
+#endif
 
-// Use alpha from base texture
+// use alpha from base texture, combined with the object color alpha
+// the latter is usually 1, so this basically comes down to base.a
 MUL result.color.a, objectColor.a, base.a;
 
+
 END

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

@@ -183 +183 @@
 {
     var cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
     var cmpRallyPoint = Engine.QueryInterface(this.entity, IID_RallyPoint);
-    if (cmpRallyPoint)
+    if (cmpRallyPoint && cmpRallyPoint.IsSet())
     {
         var rallyPos = cmpRallyPoint.GetPosition();
         if (rallyPos)
@@ -192 +192 @@
                 "type": "walk",
                 "entities": entities,
                 "x": rallyPos.x,
-                "z": rallyPos.z,
+                "z": rallyPos.y,
                 "queued": false
             });
         }

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

@@ -222 +222 @@
     if (cmpRallyPoint)
     {
         ret.rallyPoint = { };
+        if (cmpRallyPoint.IsSet()) // can't return a rally point position if none is set ...
+            ret.rallyPoint.position = cmpRallyPoint.GetPosition();
     }
 
     var cmpGarrisonHolder = Engine.QueryInterface(ent, IID_GarrisonHolder);
@@ -379 +381 @@
  */
 GuiInterface.prototype.DisplayRallyPoint = function(player, cmd)
 {
-    // If there are rally points already displayed, destroy them
-    for each (var ent in this.rallyPoints)
+    // If there are some rally points already displayed, first hide them
+    for each (var ent in this.entsRallyPointsDisplayed)
     {
-        // Hide it first (the destruction won't be instantaneous)
-        var cmpPosition = Engine.QueryInterface(ent, IID_Position);
-        cmpPosition.MoveOutOfWorld();
+        var cmpRallyPoint = Engine.QueryInterface(ent, IID_RallyPoint);
+        if (!cmpRallyPoint)
+            continue;
 
-        Engine.DestroyEntity(ent);
+        cmpRallyPoint.SetDisplayed(false);
     }
 
-    this.rallyPoints = [];
-
-    var positions = [];
-    // DisplayRallyPoints is called passing a list of entities for which
-    // rally points must be displayed
+    // Show the rally points for the passed entities
     for each (var ent in cmd.entities)
     {
         var cmpRallyPoint = Engine.QueryInterface(ent, IID_RallyPoint);
@@ -405 +403 @@
         if (!cmpOwnership || cmpOwnership.GetOwner() != player)
             continue;
 
-        // If the command was passed an explicit position, use that and
-        // override the real rally point position; otherwise use the real position
-        var pos;
+        // If the command was passed an explicit position, first set it
         if (cmd.x && cmd.z)
-            pos = {"x": cmd.x, "z": cmd.z};
-        else
-            pos = cmpRallyPoint.GetPosition();
+            cmpRallyPoint.SetPosition({x: cmd.x, y:cmd.z}); // SetPosition takes a CFixedVector2D which has X/Y components, not X/Z
 
-        if (pos)
-        {
-            // TODO: it'd probably be nice if we could draw some kind of line
-            // between the building and pos, to make the marker easy to find even
-            // if it's a long way from the building
+        cmpRallyPoint.SetDisplayed(true);
 
-            positions.push(pos);
-        }
     }
 
-    // Add rally point entity for each building
-    for each (var pos in positions)
-    {
-        var rallyPoint = Engine.AddLocalEntity("actor|props/special/common/waypoint_flag.xml");
-        var cmpPosition = Engine.QueryInterface(rallyPoint, IID_Position);
-        cmpPosition.JumpTo(pos.x, pos.z);
-        this.rallyPoints.push(rallyPoint);
-    }   
+    // Remember which entities have their rally points displayed so we can hide them again
+    this.entsRallyPointsDisplayed = cmd.entities;
+    
 };
 
 /**

deleted file binaries/data/mods/public/simulation/components/RallyPoint.js

@@ -1 @@
-function RallyPoint() {}
-
-RallyPoint.prototype.Schema =
-    "<a:component/><empty/>";
-
-RallyPoint.prototype.Init = function()
-{
-    this.pos = undefined;
-};
-
-RallyPoint.prototype.SetPosition = function(x, z)
-{
-    this.pos = {
-        "x": x,
-        "z": z
-    }
-};
-
-RallyPoint.prototype.Unset = function()
-{
-    this.pos = undefined;
-};
-
-RallyPoint.prototype.GetPosition = function()
-{
-    return this.pos;
-};
-
-Engine.RegisterComponentType(IID_RallyPoint, "RallyPoint", RallyPoint);

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

@@ -281 +281 @@
     if (spawnedEnts.length > 0)
     {
         // If a rally point is set, walk towards it (in formation)
-        if (cmpRallyPoint)
+        if (cmpRallyPoint && cmpRallyPoint.IsSet())
         {
             var rallyPos = cmpRallyPoint.GetPosition();
             if (rallyPos)
@@ -290 +290 @@
                     "type": "walk",
                     "entities": spawnedEnts,
                     "x": rallyPos.x,
-                    "z": rallyPos.z,
+                    "z": rallyPos.y,
                     "queued": false
                 });
             }

deleted file binaries/data/mods/public/simulation/components/interfaces/RallyPoint.js

@@ -1 @@
-Engine.RegisterInterface("RallyPoint");

binaries/data/mods/public/simulation/helpers/Commands.js

@@ -229 +229 @@
         {
             var cmpRallyPoint = Engine.QueryInterface(ent, IID_RallyPoint);
             if (cmpRallyPoint)
-                cmpRallyPoint.SetPosition(cmd.x, cmd.z);
+                cmpRallyPoint.SetPosition({x:cmd.x, y:cmd.z}); // SetPosition takes a CFixedVector2D which has X/Y components instead of X/Z
         }
         break;
 

new file inaries/data/mods/public/simulation/templates/special/rallypoint.xml

@@ +1 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Entity parent="special/actor">
+  <VisualActor>
+    <Actor>props/special/common/waypoint_flag.xml</Actor>
+  </VisualActor>
+  <Vision>
+    <AlwaysVisible>true</AlwaysVisible>
+  </Vision>
+</Entity>

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

@@ -53 +53 @@
     <DisableBlockPathfinding>false</DisableBlockPathfinding>
   </Obstruction>
   <OverlayRenderer/>
-  <RallyPoint/>
+  <RallyPoint>
+    <MarkerTemplate>special/rallypoint</MarkerTemplate>
+    <LineThickness>0.2</LineThickness>
+    <LineColour r="35" g="86" b="188"></LineColour>
+    <LineDashColour r="158" g="11" b="15"></LineDashColour>
+    <LineStartCap>square</LineStartCap>
+    <LineEndCap>round</LineEndCap>
+  </RallyPoint>
   <Sound>
     <SoundGroups>
       <select>interface/select/building/sel_universal.xml</select>

new file source/graphics/Overlay.cpp

@@ +1 @@
+/* Copyright (C) 2011 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 0 A.D. is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "precompiled.h"
+
+#include "Overlay.h"
+
+bool SOverlayTexturedLine::StrToLineCap(const std::wstring& str, SOverlayTexturedLine::LineCap& out)
+{
+    if (str == L"flat")
+    {
+        out = LINECAP_FLAT;
+        return true;
+    }
+    else if (str == L"round")
+    {
+        out = LINECAP_ROUND;
+        return true;
+    }
+    else if (str == L"sharp")
+    {
+        out = LINECAP_SHARP;
+        return true;
+    }
+    else if (str == L"square")
+    {
+        out = LINECAP_SQUARE;
+        return true;
+    }
+    else
+        return false;
+}

source/graphics/Overlay.h

@@ -44 +44 @@
  */
 struct SOverlayTexturedLine
 {
-    SOverlayTexturedLine() : m_Terrain(NULL), m_Thickness(1.0f) { }
+
+    enum LineCap
+    {
+        LINECAP_FLAT, ///< no line ending; abrupt stop of the line (aka. butt ending)
+
+        /**
+         * Semi-circular line ending. The texture is mapped by curving the left vertical edge around the semi-circle's rim. That is,
+         * the center point has UV coordinates (0.5;0.5), and the rim vertices all have U coordinate 0 and a V coordinate that ranges
+         * from 0 to 1 as the rim is traversed.
+         */
+        LINECAP_ROUND,
+        LINECAP_SHARP, ///< sharp point ending
+        LINECAP_SQUARE, ///< square end that extends half the line width beyond the line end
+    };
+
+    SOverlayTexturedLine()
+        : m_Terrain(NULL), m_Thickness(1.0f), m_Closed(false), m_AlwaysVisible(false), m_StartCap(LINECAP_FLAT), m_EndCap(LINECAP_FLAT)
+    {}
 
     CTerrain* m_Terrain;
     CTexturePtr m_TextureBase;
     CTexturePtr m_TextureMask;
-    CColor m_Color;
-    std::vector<float> m_Coords; // (x, z) vertex coordinate pairs; y is computed automatically; shape is automatically closed
-    float m_Thickness; // world-space units
+    CColor m_Color; // color to apply to the line texture
+    std::vector<float> m_Coords; // (x, z) vertex coordinate pairs; y is computed automatically
+    float m_Thickness; // half-width of the line, in world-space units
+
+    bool m_Closed; // should this line be treated as a closed loop? (if set, the end cap settings are ignored)
+    bool m_AlwaysVisible; // should this line be rendered even under the SoD?
+    LineCap m_StartCap; // LineEndCap to be used at the start of the line
+    LineCap m_EndCap; // LineEndCap to be used at the end of the line
 
     shared_ptr<CRenderData> m_RenderData; // cached renderer data (shared_ptr so that copies/deletes are automatic)
+
+    /**
+     * Interprets @p str as a LineCap value, and writes the matching value to @p out, if any. Returns true if a value was written to @p out,
+     * false otherwise.
+     */
+    static bool StrToLineCap(const std::wstring& str, LineCap& out);
+
 };
 
 /**

source/graphics/ShaderManager.cpp

@@ -76 +76 @@
 {
     if (strncmp(name, "fixed:", 6) == 0)
     {
-        program = CShaderProgramPtr(CShaderProgram::ConstructFFP(name+6));
+        program = CShaderProgramPtr(CShaderProgram::ConstructFFP(name+6, baseDefines));
         if (!program)
             return false;
         program->Reload();

source/graphics/ShaderProgram.h

@@ -71 +71 @@
     /**
      * Construct an instance of a pre-defined fixed-function pipeline setup.
      */
-    static CShaderProgram* ConstructFFP(const std::string& id);
+    static CShaderProgram* ConstructFFP(const std::string& id, const std::map<CStr, CStr>& defines);
 
     typedef const char* attrib_id_t;
     typedef const char* texture_id_t;

source/graphics/ShaderProgramFFP.cpp

@@ -100 +100 @@
         ID_objectColor
     };
 
+    std::map<CStr, CStr> m_Defines;
+
+    bool IsIgnoreLos()
+    {
+        std::map<CStr, CStr>::const_iterator define = m_Defines.find(CStr("IGNORE_LOS"));
+        return (define != m_Defines.end() && define->second == CStr("1"));
+    }
+
 public:
-    CShaderProgramFFP_OverlayLine() :
-        CShaderProgramFFP(STREAM_POS | STREAM_UV0 | STREAM_UV1)
+    CShaderProgramFFP_OverlayLine(const std::map<CStr, CStr>& defines) :
+        CShaderProgramFFP(STREAM_POS | STREAM_UV0 | STREAM_UV1),
+        m_Defines(defines)
     {
         m_UniformIndexes["losTransform"] = ID_losTransform;
         m_UniformIndexes["objectColor"] = ID_objectColor;
@@ -145 +154 @@
         // RGB channels:
         //   Unit 0: Load base texture
         //   Unit 1: Load mask texture; interpolate with objectColor & base
-        //   Unit 2: Load LOS texture; multiply
+        //   Unit 2: (Load LOS texture; multiply) if not #IGNORE_LOS, pass through otherwise
         // Alpha channel:
         //   Unit 0: Load base texture
         //   Unit 1: Multiply by objectColor
@@ -163 +172 @@
         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_TEXTURE);
         glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA);
 
+        // -----------------------------------------------------------------------------
+
         pglActiveTextureARB(GL_TEXTURE1);
         glEnable(GL_TEXTURE_2D);
-
         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
         // Uniform() sets GL_TEXTURE_ENV_COLOR
 
+        // load mask texture; interpolate with objectColor and base; GL_INTERPOLATE takes 3 arguments:
+        // a0 * a2 + a1 * (1 - a2)
         glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_INTERPOLATE);
         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_CONSTANT);
         glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
@@ -183 +195 @@
         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_ARB, GL_PREVIOUS);
         glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_ARB, GL_SRC_ALPHA);
 
+        // -----------------------------------------------------------------------------
+
         pglActiveTextureARB(GL_TEXTURE2);
         glEnable(GL_TEXTURE_2D);
-
         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
 
+        bool ignoreLos = IsIgnoreLos();
+        if (ignoreLos)
+        {
+            // RGB pass through
+            glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE);
+            glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS);
+            glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
+        }
+        else
+        {
+            // multiply RGB with LoS texture alpha channel
         glEnable(GL_TEXTURE_GEN_S);
         glEnable(GL_TEXTURE_GEN_T);
         glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
@@ -199 +223 @@
         glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_TEXTURE);
         glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_ALPHA);
+        }
 
+        // alpha pass through
         glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE);
         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_PREVIOUS);
         glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA);
+        
     }
 
     virtual void Unbind()
@@ -210 +237 @@
         pglActiveTextureARB(GL_TEXTURE2);
         glDisable(GL_TEXTURE_2D);
 
+        // technically these aren't enabled if ignore_los is true, but the previous behaviour before ignore_los was added
+        // was to always disable it, so not doing the if-check for ignore_los here shouldn't break anything
         glDisable(GL_TEXTURE_GEN_S);
         glDisable(GL_TEXTURE_GEN_T);
 
@@ -221 +250 @@
     }
 };
 
-/*static*/ CShaderProgram* CShaderProgram::ConstructFFP(const std::string& id)
+/*static*/ CShaderProgram* CShaderProgram::ConstructFFP(const std::string& id, const std::map<CStr, CStr>& defines)
 {
     if (id == "overlayline")
-        return new CShaderProgramFFP_OverlayLine();
+        return new CShaderProgramFFP_OverlayLine(defines);
 
     LOGERROR(L"CShaderProgram::ConstructFFP: Invalid id '%hs'", id.c_str());
     return NULL;

source/gui/scripting/ScriptFunctions.cpp

@@ -34 +34 @@
 #include "ps/CConsole.h"
 #include "ps/Errors.h"
 #include "ps/Game.h"
+#include "ps/World.h"
 #include "ps/Hotkey.h"
 #include "ps/Overlay.h"
 #include "ps/ProfileViewer.h"
@@ -346 +347 @@
         g_Game->GetView()->CameraFollow(entityid, true);
 }
 
+/// Move camera to a 2D location
+void CameraMoveTo(void* UNUSED(cbdata), entity_pos_t x, entity_pos_t z)
+{
+    // this must not fail
+    if(!(g_Game && g_Game->GetWorld() && g_Game->GetView() && g_Game->GetWorld()->GetTerrain()))
+        return;
+
+    CTerrain* terrain = g_Game->GetWorld()->GetTerrain();
+
+    CVector3D target;
+    target.X = x.ToFloat();
+    target.Z = z.ToFloat();
+    target.Y = terrain->GetExactGroundLevel(target.X, target.Z);
+
+    // move the camera in minimap mode since this is an "instant" camera movement similar to what 
+    // you would get for clicking the minimap (also prevents height glitches)
+    g_Game->GetView()->MoveCameraTarget(target, true);
+}
+
 entity_id_t GetFollowedEntity(void* UNUSED(cbdata))
 {
     if (g_Game && g_Game->GetView())
@@ -499 +519 @@
     scriptInterface.RegisterFunction<CScriptVal, &GetMapSettings>("GetMapSettings");
     scriptInterface.RegisterFunction<void, entity_id_t, &CameraFollow>("CameraFollow");
     scriptInterface.RegisterFunction<void, entity_id_t, &CameraFollowFPS>("CameraFollowFPS");
+    scriptInterface.RegisterFunction<void, entity_pos_t, entity_pos_t, &CameraMoveTo>("CameraMoveTo");
     scriptInterface.RegisterFunction<entity_id_t, &GetFollowedEntity>("GetFollowedEntity");
     scriptInterface.RegisterFunction<bool, std::string, &HotkeyIsPressed_>("HotkeyIsPressed");
     scriptInterface.RegisterFunction<void, std::wstring, &DisplayErrorDialog>("DisplayErrorDialog");

source/maths/Vector2D.h

@@ -127 +127 @@
         return CVector2D(X / mag, Y / mag);
     }
 
+    /**
+     * Returns a version of this vector rotated counterclockwise by @p angle radians.
+     */
+    CVector2D Rotated(float angle)
+    {
+        float c = cosf(angle);
+        float s = sinf(angle);
+        return CVector2D(
+            c*X - s*Y,
+            s*X + c*Y
+        );
+    }
+
+    /**
+     * Rotates this vector counterclockwise by @p angle radians.
+     */
+    void Rotate(float angle)
+    {
+        float c = cosf(angle);
+        float s = sinf(angle);
+        float newX = c*X - s*Y;
+        float newY = s*X + c*Y;
+        X = newX;
+        Y = newY;
+    }
+
 public:
     float X, Y;
 };

source/renderer/OverlayRenderer.cpp

@@ -1 @@
-/* Copyright (C) 2010 Wildfire Games.
+/* Copyright (C) 2011 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -19 +19 @@
 
 #include "OverlayRenderer.h"
 
+#include "maths/MathUtil.h"
 #include "graphics/LOSTexture.h"
 #include "graphics/Overlay.h"
-#include "graphics/ShaderManager.h"
 #include "graphics/Terrain.h"
 #include "graphics/TextureManager.h"
 #include "lib/ogl.h"
+#include "maths/Vector2D.h"
+#include "maths/Quaternion.h"
 #include "ps/Game.h"
 #include "ps/Profile.h"
 #include "renderer/Renderer.h"
@@ -44 +46 @@
 {
 public:
     CTexturedLineRData(SOverlayTexturedLine* line) :
-        m_Line(line), m_VB(NULL), m_VBIndices(NULL)
+        m_Line(line),
+        m_VB(NULL),
+        m_VBIndices(NULL),
+        m_LineIndexCount(0),
+        m_StartCapIndexCount(0),
+        m_StartCapIndexOffset(0),
+        m_EndCapIndexCount(0),
+        m_EndCapIndexOffset(0),
+        m_Raise(.2f)
     {
     }
 
@@ -58 +68 @@
 
     struct SVertex
     {
-        SVertex(CVector3D pos, short u, short v) : m_Position(pos) { m_UVs[0] = u; m_UVs[1] = v; }
+        SVertex(CVector3D pos, float u, float v) : m_Position(pos) { m_UVs[0] = u; m_UVs[1] = v; }
         CVector3D m_Position;
-        GLshort m_UVs[2];
+        GLfloat m_UVs[2];
+        float _padding[3]; // 5 floats up till now, so pad with another 3 floats to get a power of 2
     };
-    cassert(sizeof(SVertex) == 16);
+    cassert(sizeof(SVertex) == 32);
 
     void Update();
 
+    /**
+     * Creates a line cap of the specified type @p endCapType at the end of the segment going in direction @p normal, and write the vertices and indices
+     * to @p verticesOut and @p indicesOut, respectively. The drawing mode to use for the resulting vertices/indices array (quad strip,
+     * triangle strip, ...) is written to @p drawModeOut.
+     *
+     * @param corner1 One of the two butt-end corner points of the line to which the cap should be attached.
+     * @param corner2 One of the two butt-end corner points of the line to which the cap should be attached.
+     * @param normal Normal vector indicating the direction of the segment to which the cap should be attached.
+     * @param endCapType The type of end cap to produce.
+     * @param verticesOut Output vector of vertices to draw using @p drawModeOut. These will be entered into a vertex buffer and handed to the
+     *                    renderer along with the indices array.
+     * @param indicesOut Output vector of vertex indices to draw using @p drawModeOut. These will be entered into a vertex index buffer and
+     *                   handed to the rendered along with the vertex array.
+     */
+    void CreateLineCap(const CVector3D& corner1, const CVector3D& corner2, const CVector3D& normal, SOverlayTexturedLine::LineCap endCapType,
+                       std::vector<SVertex>& verticesOut, std::vector<u16>& indicesOut);
+
+    /// Small utility function; grabs the centroid of the positions of two vertices
+    inline CVector3D Centroid(const SVertex& v1, const SVertex& v2)
+    {
+        return (v1.m_Position + v2.m_Position) * 0.5;
+    }
+
     SOverlayTexturedLine* m_Line;
 
     CVertexBuffer::VBChunk* m_VB;
     CVertexBuffer::VBChunk* m_VBIndices;
+    unsigned int m_LineIndexCount;
+    unsigned int m_StartCapIndexOffset; // offset of start cap indices in the VB; valid iff > 0
+    unsigned int m_StartCapIndexCount; // number of start cap indices in the VB; valid iff > 0
+    unsigned int m_EndCapIndexOffset; // offset of end cap indices in the VB; valid iff > 0
+    unsigned int m_EndCapIndexCount; // number of end cap indices in the VB; valid iff > 0
+
+    float m_Raise; // small vertical offset of line from terrain to prevent visual glitches
+
 };
 
 OverlayRenderer::OverlayRenderer()
@@ -164 +206 @@
     glDisable(GL_BLEND);
 }
 
-void OverlayRenderer::RenderOverlaysAfterWater()
+void OverlayRenderer::RenderTexturedOverlayLines(const std::vector<size_t>& indices, CShaderProgramPtr shaderTexLine)
 {
-    PROFILE("render overlays (after water)");
-
-    if (!m->texlines.empty())
-    {
-        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";
-
-        CShaderManager& shaderManager = g_Renderer.GetShaderManager();
-        CShaderProgramPtr shaderTexLine(shaderManager.LoadProgram(shaderName, std::map<CStr, CStr>()));
-
-        shaderTexLine->Bind();
-
         int streamflags = shaderTexLine->GetStreamFlags();
 
         if (streamflags & STREAM_POS)
@@ -202 +225 @@
             glEnableClientState(GL_TEXTURE_COORD_ARRAY);
         }
 
-        CLOSTexture& los = g_Renderer.GetScene().GetLOSTexture();
-        shaderTexLine->BindTexture("losTex", los.GetTexture());
-        shaderTexLine->Uniform("losTransform", los.GetTextureMatrix()[0], los.GetTextureMatrix()[12], 0.f, 0.f);
-
-        for (size_t i = 0; i < m->texlines.size(); ++i)
+    //for (size_t i = 0; i < m->texlines.size(); ++i)
+    for (std::vector<size_t>::const_iterator idxIt = indices.begin(); idxIt != indices.end(); idxIt++)
         {
-            SOverlayTexturedLine* line = m->texlines[i];
+        SOverlayTexturedLine* line = m->texlines[(*idxIt)];
             if (!line->m_RenderData)
                 continue;
 
@@ -218 +238 @@
 
             CTexturedLineRData* rdata = static_cast<CTexturedLineRData*>(line->m_RenderData.get());
 
+        // -- render main line quad strip ----------------------
+
             GLsizei stride = sizeof(CTexturedLineRData::SVertex);
-            CTexturedLineRData::SVertex* base = reinterpret_cast<CTexturedLineRData::SVertex*>(rdata->m_VB->m_Owner->Bind());
+        CTexturedLineRData::SVertex* vertexBase = reinterpret_cast<CTexturedLineRData::SVertex*>(rdata->m_VB->m_Owner->Bind());
 
             if (streamflags & STREAM_POS)
-                glVertexPointer(3, GL_FLOAT, stride, &base->m_Position[0]);
+            glVertexPointer(3, GL_FLOAT, stride, &vertexBase->m_Position[0]);
 
             if (streamflags & STREAM_UV0)
             {
                 pglClientActiveTextureARB(GL_TEXTURE0);
-                glTexCoordPointer(2, GL_SHORT, stride, &base->m_UVs[0]);
+            glTexCoordPointer(2, GL_FLOAT, stride, &vertexBase->m_UVs[0]);
             }
 
             if (streamflags & STREAM_UV1)
             {
                 pglClientActiveTextureARB(GL_TEXTURE1);
-                glTexCoordPointer(2, GL_SHORT, stride, &base->m_UVs[0]);
+            glTexCoordPointer(2, GL_FLOAT, stride, &vertexBase->m_UVs[0]);
             }
 
+
             u8* indexBase = rdata->m_VBIndices->m_Owner->Bind();
-            glDrawElements(GL_QUAD_STRIP, rdata->m_VBIndices->m_Count, GL_UNSIGNED_SHORT, indexBase + sizeof(u16)*rdata->m_VBIndices->m_Index);
+        glDrawElements(GL_QUAD_STRIP, rdata->m_LineIndexCount, GL_UNSIGNED_SHORT, indexBase + sizeof(u16)*rdata->m_VBIndices->m_Index);
+
+        g_Renderer.GetStats().m_OverlayTris += rdata->m_LineIndexCount - 2;
 
-            g_Renderer.GetStats().m_OverlayTris += rdata->m_VBIndices->m_Count - 2;
+        // -- render start cap (if any) ------------------------
+
+        if (rdata->m_StartCapIndexCount > 0)
+        {
+            glDrawElements(GL_TRIANGLES, rdata->m_StartCapIndexCount, GL_UNSIGNED_SHORT, indexBase + sizeof(u16)*(rdata->m_VBIndices->m_Index + rdata->m_StartCapIndexOffset));
+            g_Renderer.GetStats().m_OverlayTris += rdata->m_StartCapIndexCount/3;
         }
 
-        shaderTexLine->Unbind();
+        // -- render end cap (if any) --------------------------
+
+        if (rdata->m_EndCapIndexCount > 0)
+        {
+            glDrawElements(GL_TRIANGLES, rdata->m_EndCapIndexCount, GL_UNSIGNED_SHORT, indexBase + sizeof(u16)*(rdata->m_VBIndices->m_Index + rdata->m_EndCapIndexOffset));
+            g_Renderer.GetStats().m_OverlayTris += rdata->m_EndCapIndexCount/3;
+        }
+
+    }
+
+}
+
+void OverlayRenderer::RenderOverlaysAfterWater()
+{
+    PROFILE("render overlays (after water)");
+
+    if (!m->texlines.empty())
+    {
+        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";
+
+        std::map<CStr, CStr> defAlwaysVisible;
+        defAlwaysVisible.insert(std::make_pair(CStr("IGNORE_LOS"), CStr("1")));
+
+        CLOSTexture& los = g_Renderer.GetScene().GetLOSTexture();
+
+        CShaderManager& shaderManager = g_Renderer.GetShaderManager();
+        CShaderProgramPtr shaderTexLineNormal(shaderManager.LoadProgram(shaderName, std::map<CStr, CStr>()));
+        CShaderProgramPtr shaderTexLineAlwaysVisible(shaderManager.LoadProgram(shaderName, defAlwaysVisible));
+
+        // ----------------------------------------------------------------------------------------
+        // group the overlay lines by whether they need to be always visible
+        std::vector<size_t> alwaysVisibleTexLineIndices;
+        std::vector<size_t> normalTexLineIndices;
+
+        for (size_t i = 0; i < m->texlines.size(); i++)
+        {
+            if (m->texlines[i]->m_AlwaysVisible)
+                alwaysVisibleTexLineIndices.push_back(i);
+            else
+                normalTexLineIndices.push_back(i);
+        }
+
+        // render go go
+        shaderTexLineNormal->Bind();
+        shaderTexLineNormal->BindTexture("losTex", los.GetTexture());
+        shaderTexLineNormal->Uniform("losTransform", los.GetTextureMatrix()[0], los.GetTextureMatrix()[12], 0.f, 0.f);
+
+        RenderTexturedOverlayLines(normalTexLineIndices, shaderTexLineNormal);
+
+        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);
+
+        RenderTexturedOverlayLines(alwaysVisibleTexLineIndices, shaderTexLineAlwaysVisible);
+
+        shaderTexLineAlwaysVisible->Unbind();
 
         // TODO: the shader should probably be responsible for unbinding its textures
         g_Renderer.BindTexture(1, 0);
@@ -293 +392 @@
         };
 
         glVertexPointer(3, GL_FLOAT, sizeof(float)*3, &pos[0].X);
-
         glDrawArrays(GL_QUADS, 0, (GLsizei)4);
     }
 
@@ -324 +422 @@
     std::vector<SVertex> vertices;
     std::vector<u16> indices;
 
-    short v = 0;
+    float v = 0.f;
 
-    size_t n = m_Line->m_Coords.size() / 2;
-    ENSURE(n >= 1);
+    size_t n = m_Line->m_Coords.size() / 2; // number of line points
+    bool closed = m_Line->m_Closed;
 
-    CTerrain* terrain = m_Line->m_Terrain;
+    if (closed)
+        ENSURE(n >= 1); // granted, it's kind of hard to draw a closed loop through 1 point, but this is the minimum to avoid errors
+    else
+        ENSURE(n >= 2);
 
-    // TODO: this assumes paths are closed loops; probably should extend this to
-    // handle non-closed paths too
+    CTerrain* terrain = m_Line->m_Terrain;
 
     // In each iteration, p1 is the position of vertex i, p0 is i-1, p2 is i+1.
     // To avoid slightly expensive terrain computations we cycle these around and
     // recompute p2 at the end of each iteration.
-    CVector3D p0 = CVector3D(m_Line->m_Coords[(n-1)*2], 0, m_Line->m_Coords[(n-1)*2+1]);
-    CVector3D p1 = CVector3D(m_Line->m_Coords[0], 0, m_Line->m_Coords[1]);
-    CVector3D p2 = CVector3D(m_Line->m_Coords[(1 % n)*2], 0, m_Line->m_Coords[(1 % n)*2+1]);
+
+    CVector3D p0;
+    CVector3D p1(m_Line->m_Coords[0], 0, m_Line->m_Coords[1]);
+    CVector3D p2(m_Line->m_Coords[(1 % n)*2], 0, m_Line->m_Coords[(1 % n)*2+1]);
+
+    if (closed)
+        // grab the ending point so as to close the loop
+        p0 = CVector3D(m_Line->m_Coords[(n-1)*2], 0, m_Line->m_Coords[(n-1)*2+1]);
+    else
+        // we don't want to loop around and use the direction towards the other end of the line, so create an artificial p0 that 
+        // extends the p2 -> p1 direction, and use that point instead
+        p0 = p1 + (p1 - p2);
+
     bool p1floating = false;
     bool p2floating = false;
 
@@ -371 +481 @@
     {
         // For vertex i, compute bisector of lines (i-1)..(i) and (i)..(i+1)
         // perpendicular to terrain normal
+        // Push vertices in GL_QUAD_STRIP order
 
         // Normal is vertical if on water, else computed from terrain
         CVector3D norm;
@@ -386 +497 @@
         if (fabs(l) > 0.000001f) // avoid unlikely divide-by-zero
             b *= m_Line->m_Thickness / l;
 
-        // Raise off the terrain a little bit
-        const float raised = 0.2f;
-
-        vertices.push_back(SVertex(p1 + b + norm*raised, 0, v));
+        vertices.push_back(SVertex(p1 + b + norm*m_Raise, 0.f, v));
         indices.push_back(vertices.size() - 1);
 
-        vertices.push_back(SVertex(p1 - b + norm*raised, 1, v));
+        vertices.push_back(SVertex(p1 - b + norm*m_Raise, 1.f, v));
         indices.push_back(vertices.size() - 1);
 
         // Alternate V coordinate for debugging
@@ -402 +510 @@
         p0 = p1;
         p1 = p2;
         p1floating = p2floating;
+
+        // if in closed mode, wrap around the coordinate array for p2 -- otherwise, extend linearly
+        if (!closed && i == n-2)
+            // next iteration is the last point of the line, so create an artificial p2 that extends the p0 -> p1 direction
+            p2 = p1 + (p1 - p0);
+        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);
         if (p2.Y < w)
         {
@@ -413 +528 @@
             p2floating = false;
     }
 
+    
+    if (closed)
+    {
     // Close the path
     indices.push_back(0);
     indices.push_back(1);
+    }
+
+    m_LineIndexCount = indices.size();
+
+    if (!closed)
+    {
+        // -------------------------------------------------------------------
+        // create start cap
+
+        std::vector<u16> startCapIndices;
+        std::vector<SVertex> startCapVertices;
+
+        CreateLineCap(
+            vertices[1].m_Position, // the order of these vertices is actually important here, swapping them produces caps at the wrong side
+            vertices[0].m_Position,
+            (Centroid(vertices[1], vertices[0]) - Centroid(vertices[3], vertices[2])).Normalized(),
+            m_Line->m_StartCap,
+            startCapVertices,
+            startCapIndices
+        );
+
+        if (!startCapVertices.empty() && !startCapIndices.empty())
+        {
+            ENSURE(startCapIndices.size() % 3 == 0); // GL_TRIANGLES indices, so must be multiple of 3
+
+            m_StartCapIndexOffset = indices.size(); // start cap indices start where the line indices end
+            m_StartCapIndexCount = startCapIndices.size();
+
+            // adjust the indices to take the existing line vertices into account (right now they're relative to their own vertices array)
+            for (size_t k = 0; k < m_StartCapIndexCount; ++k)
+                startCapIndices[k] += vertices.size();
+
+            indices.insert(indices.end(), startCapIndices.begin(), startCapIndices.end()); // append start cap indices to VBO data
+            vertices.insert(vertices.end(), startCapVertices.begin(), startCapVertices.end()); // append start cap vertices to VBO data
+        }
+
+        // -------------------------------------------------------------------
+        // create end cap
+
+        std::vector<u16> endcapIndices;
+        std::vector<SVertex> endcapVertices;
+
+        CreateLineCap(
+            vertices[2*n-2].m_Position, // second-to-last line vertex
+            vertices[2*n-1].m_Position, // last line vertex
+            (Centroid(vertices[2*n-2], vertices[2*n-1]) - Centroid(vertices[2*n-4], vertices[2*n-3])).Normalized(),
+            m_Line->m_EndCap,
+            endcapVertices,
+            endcapIndices
+        );
+
+        if (!endcapVertices.empty() && !endcapIndices.empty())
+        {
+            ENSURE(endcapIndices.size() % 3 == 0); // GL_TRIANGLES indices, so must be multiple of 3
+
+            m_EndCapIndexOffset = indices.size(); // end cap indices start where the line + start indices end
+            m_EndCapIndexCount = endcapIndices.size();
+
+            // adjust the indices to take the existing line + start vertices into account (right now they're relative to their own vertices array)
+            for (size_t k = 0; k < m_EndCapIndexCount; ++k)
+                endcapIndices[k] += vertices.size();
+
+            indices.insert(indices.end(), endcapIndices.begin(), endcapIndices.end()); // append end cap indices to VBO data
+            vertices.insert(vertices.end(), endcapVertices.begin(), endcapVertices.end()); // append end cap vertices to VBO data
+        }
+
+    }
 
     m_VB = g_VBMan.Allocate(sizeof(SVertex), vertices.size(), GL_STATIC_DRAW, GL_ARRAY_BUFFER);
-    m_VB->m_Owner->UpdateChunkVertices(m_VB, &vertices[0]);
+    m_VB->m_Owner->UpdateChunkVertices(m_VB, &vertices[0]); // copy data into VBO
 
     // Update the indices to include the base offset of the vertex data
     for (size_t k = 0; k < indices.size(); ++k)
         indices[k] += m_VB->m_Index;
 
     m_VBIndices = g_VBMan.Allocate(sizeof(u16), indices.size(), GL_STATIC_DRAW, GL_ELEMENT_ARRAY_BUFFER);
-    m_VBIndices->m_Owner->UpdateChunkVertices(m_VBIndices, &indices[0]);
+    m_VBIndices->m_Owner->UpdateChunkVertices(m_VBIndices, &indices[0]); // copy data into VBO
+}
+
+void CTexturedLineRData::CreateLineCap(const CVector3D& corner1, const CVector3D& corner2, const CVector3D& normal, SOverlayTexturedLine::LineCap endCapType,
+                                       std::vector<SVertex>& verticesOut, std::vector<u16>& indicesOut)
+{
+
+    if (endCapType == SOverlayTexturedLine::LINECAP_FLAT)
+        return; // no action needed, this is the default
+
+    CTerrain* terrain = m_Line->m_Terrain;
+    CmpPtr<ICmpWaterManager> cmpWaterManager(*g_Game->GetSimulation2(), SYSTEM_ENTITY);
+
+    // when not in closed mode, we've created artificial points for the start- and endpoints that extend the line in the
+    // direction of the first and the last segment, respectively. Thus, we know both the start and endpoints have perpendicular
+    // butt endings, i.e. the end corner vertices on either side of the line extend perpendicularly from the segment direction.
+    // That is to say, we will have something like
+    //                                                 .
+    //  this:                     and not like this:  /|
+    //         ____.                                 / |
+    //             |                                /  .
+    //             |                                  /
+    //         ____.                                 /
+    //
+
+    int roundCapPoints = 8; // = how many points to sample along the semicircle for rounded caps (including corner points)
+    float texCenterU = 0.5f; // U coordinate of butt end centroid
+    float texCenterV = 0.5f; // V coordinate of butt end centroid
+
+    float radius = m_Line->m_Thickness;
+    CVector3D centerPoint = (corner1 + corner2) * 0.5f; // middle between last two vertices (i.e. "butt" corner points)
+
+    switch (endCapType)
+    {
+
+    case SOverlayTexturedLine::LINECAP_SHARP:
+        {
+            roundCapPoints = 3; // creates only one point directly ahead
+            radius *= 1.2f; // make it a bit sharper (note that we don't use this for the butt corner points so it should be ok)
+            texCenterU = 0.485f; // slight visual correction to make the texture edges match up better (they're slightly too thin with only 3 points and a U coord of 0.5f)
+        }
+    case SOverlayTexturedLine::LINECAP_ROUND:
+        {
+            
+            // Draw a rounded line cap in the 3D plane of the line specified by the two corner points and the normal vector of the 
+            // line's direction. The terrain normal at the centroid between the two corner points is perpendicular to this plane.
+            // The way this works is by taking a vector from the corner points' centroid to one of the corner points (which is then of
+            // radius length), and rotate it around the terrain normal vector in that centroid. This will rotate the vector in the line's
+            // plane, producing the desired rounded cap.
+
+            // To please OpenGL's winding order thing, this angle needs to be negated depending on whether we start rotating from the 
+            // (center -> corner1) or (center -> corner2) vector. For the (center -> corner2) vector, apparently we need to use the 
+            // negated angle. There's probable some reason for it you can look up, but trial and error is a much more effective way of 
+            // finding out.
+            float stepAngle = -(float)(M_PI/(roundCapPoints-1));
+
+            // first push the vertices, then figure out the GL_TRIANGLES indices
+            verticesOut.push_back(SVertex(centerPoint, texCenterU, texCenterV));
+            verticesOut.push_back(SVertex(corner2, 0.f, 0.f));
+
+            // usually corner2 - centerPoint suffices for baseVector below since it is of radius length, but we want to support custom 
+            // radii to support tuning the sharp caps (see above)
+            CVector3D baseVector = (corner2 - centerPoint).Normalized() * radius;
+            CVector3D centerPointNormalVector = terrain->CalcExactNormal(centerPoint.X, centerPoint.Z); // always normalized
+
+            for (int i = 1; i < roundCapPoints - 1; ++i)
+            {
+                // set up a quaternion rotation of the centerPoint -> corner vector by i*stepAngle 
+                // radians around the terrain normal at centerPoint
+                CQuaternion quatRotation;
+                quatRotation.FromAxisAngle(centerPointNormalVector, i * stepAngle);
+                // at this point, quatRotation is always normalized because centerPointNormalVector is normalized. Note that we don't need
+                // to scale the rotated baseVector to the radius, as baseVector was already of radius length and rotation maintains vector length.
+                CVector3D worldPos3D = centerPoint + quatRotation.Rotate(baseVector);
+
+                // let v range from 0 to 1 as we move along the semi-circle, keep u fixed at 0 (i.e. curve the left vertical edge of the texture
+                // around the edge of the semicircle)
+                float u = 0.f;
+                float v = clamp((i/(float)(roundCapPoints-1)), 0.f, 1.f);
+                verticesOut.push_back(SVertex(worldPos3D, u, v)); // pos, u, v
+            }
+
+            // connect back to the other butt corner point to complete the semicircle
+            verticesOut.push_back(SVertex(corner1, 0.f, 1.f));
+
+            // now push indices for GL_TRIANGLES; vertices[0] is the center, vertices[1] is the first corner point, then a bunch of 
+            // radial samples, and then at the end we have the other corner point again. So:
+            for (int i=1; i < roundCapPoints; ++i)
+            {
+                indicesOut.push_back(0); // center point
+                indicesOut.push_back(i);
+                indicesOut.push_back(i+1);
+            }
+
+        }
+        break;
+
+    case SOverlayTexturedLine::LINECAP_SQUARE:
+        {
+            // extend the (corner1 -> corner2) vector along the direction normal and draw a triangle fan with 3 triangles (although actually
+            // drawn as GL_TRIANGLES)
+            // NOTE: the order in which the vertices are pushed out determines the visibility, as they
+            // are rendered only one-sided; the wrong order of vertices will only make the cap visible from the bottom.
+            
+            verticesOut.push_back(SVertex(centerPoint, texCenterU, texCenterV)); // push center point
+            verticesOut.push_back(SVertex(corner2, 0.f, 0.f)); // push butt corner point 2
+            verticesOut.push_back(SVertex(corner2 + (normal * (m_Line->m_Thickness)), 0.f, 0.33333f)); // extend butt corner point 2 along the normal vector
+            verticesOut.push_back(SVertex(corner1 + (normal * (m_Line->m_Thickness)), 0.f, 0.66666f)); // extend butt corner point 1 along the normal vector
+            verticesOut.push_back(SVertex(corner1, 0.f, 1.0f)); // push butt corner point 1
+
+            for (int i=1; i < 4; ++i)
+            {
+                indicesOut.push_back(0); // center point
+                indicesOut.push_back(i);
+                indicesOut.push_back(i+1);
+            }
+
+        }
+        break;
+
+    default:
+        break;
+
+    }
+
 }

source/renderer/OverlayRenderer.h

@@ -1 @@
-/* Copyright (C) 2010 Wildfire Games.
+/* Copyright (C) 2011 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -18 +18 @@
 #ifndef INCLUDED_OVERLAYRENDERER
 #define INCLUDED_OVERLAYRENDERER
 
+#include "graphics/ShaderManager.h"
+
 struct SOverlayLine;
 struct SOverlayTexturedLine;
 struct SOverlaySprite;
@@ -84 +86 @@
     void RenderForegroundOverlays(const CCamera& viewCamera);
 
 private:
+    
+    /**
+     * Helper method; renders the overlay lines currently registered in the internals (i.e. in m->texlines) in the order 
+     * specified by @p indices. Used for splitting the textured overlay lines by their visibility status, and then batch
+     * rendering them with the right shader by passing the correct indices to this method.
+     */
+    void RenderTexturedOverlayLines(const std::vector<size_t>& indices, CShaderProgramPtr shader);
+
+private:
     OverlayRendererInternals* m;
 };
 

source/renderer/RenderModifiers.h

@@ -1 @@
-/* Copyright (C) 2009 Wildfire Games.
+/* Copyright (C) 2011 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -137 +137 @@
 /**
  * Class RenderModifierRenderer: Interface to a model renderer that can render
  * its models via a RenderModifier that sets up fragment stages.
+ * TODO: this appears to be currently unused, should be considered for deletion
  */
 class RenderModifierRenderer : public ModelRenderer
 {

source/simulation2/TypeList.h

@@ -114 +114 @@
 INTERFACE(ProjectileManager)
 COMPONENT(ProjectileManager)
 
+INTERFACE(RallyPoint)
+COMPONENT(RallyPoint)
+
 INTERFACE(RangeManager)
 COMPONENT(RangeManager)
 

new file source/simulation2/components/CCmpRallyPoint.cpp

@@ +1 @@
+/* Copyright (C) 2011 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 0 A.D. is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "precompiled.h"
+
+#include "simulation2/system/Component.h"
+#include "ICmpRallyPoint.h"
+
+#include "simulation2/MessageTypes.h"
+#include "simulation2/helpers/Render.h"
+#include "simulation2/helpers/Geometry.h"
+
+#include "simulation2/components/ICmpPosition.h"
+#include "simulation2/components/ICmpPathFinder.h"
+#include "simulation2/components/ICmpFootprint.h"
+#include "simulation2/components/ICmpRangeManager.h"
+#include "simulation2/components/ICmpPlayer.h"
+#include "simulation2/components/ICmpOwnership.h"
+#include "simulation2/components/ICmpTerrain.h"
+#include "simulation2/components/ICmpPlayerManager.h"
+#include "simulation2/components/ICmpPlayer.h"
+#include "simulation2/components/ICmpObstructionManager.h"
+
+#include "ps/CLogger.h"
+#include "graphics/Overlay.h"
+#include "graphics/TextureManager.h"
+#include "renderer/Renderer.h"
+
+struct SVisibilitySegment
+{
+    bool m_Visible;
+    size_t m_StartIndex;
+    size_t m_EndIndex; // inclusive
+
+    SVisibilitySegment(bool visible, size_t startIndex, size_t endIndex) 
+        : m_Visible(visible), m_StartIndex(startIndex), m_EndIndex(endIndex)
+    {}
+
+    bool operator==(const SVisibilitySegment& other) const
+    {
+        return (m_Visible == other.m_Visible && m_StartIndex == other.m_StartIndex && m_EndIndex == other.m_EndIndex);
+    }
+
+    bool operator!=(const SVisibilitySegment& other) const
+    {
+        return !(*this == other);
+    }
+
+    bool IsSinglePoint()
+    {
+        return (m_StartIndex == m_EndIndex);
+    }
+};
+
+class CCmpRallyPoint : public ICmpRallyPoint
+{
+    // import some types for less verbosity
+    typedef ICmpPathfinder::Waypoint Waypoint;
+    typedef ICmpPathfinder::Path Path;
+    typedef ICmpPathfinder::Goal Goal;
+    typedef ICmpRangeManager::CLosQuerier CLosQuerier;
+    typedef SOverlayTexturedLine::LineCap LineCap;
+
+public:
+    static void ClassInit(CComponentManager& componentManager)
+    {
+        componentManager.SubscribeToMessageType(MT_RenderSubmit);
+        componentManager.SubscribeToMessageType(MT_OwnershipChanged);
+        componentManager.SubscribeToMessageType(MT_TurnStart);
+        // TODO: should probably also listen to movement messages
+    }
+
+    DEFAULT_COMPONENT_ALLOCATOR(RallyPoint)
+
+protected:
+
+    /// Actual position of the rally point (in fixed-point world coordinates for stability)
+    CFixedVector2D m_RallyPoint;
+    /// Full path to the rally point as returned by the pathfinder, with some post-processing applied to reduce zig/zagging.
+    std::vector<CVector2D> m_FullPath;
+    std::deque<SVisibilitySegment> m_VisibilitySegments;
+
+    bool m_Displayed; ///< Should we render the rally point and its path line? (set from JS when e.g. the unit is selected/deselected)
+    bool m_SmoothPath; ///< Smooth the path before rendering?
+
+    entity_id_t m_MarkerEntity; ///< Entity ID of the rally point marker. Allocated when first displayed.
+    std::wstring m_MarkerTemplate;  ///< Template name of the rally point marker.
+
+    /// Marker connector line settings (loaded from XML)
+    float m_LineThickness;
+    CColor m_LineColor;
+    CColor m_LineDashColor;
+    LineCap m_LineStartCap;
+    LineCap m_LineEndCap;
+    std::wstring m_LineTexturePath;
+    std::wstring m_LineTextureMaskPath;
+
+    CTexturePtr m_Texture;
+    CTexturePtr m_TextureMask;
+
+    ///< Textured overlay lines for the marker line. There can be multiple because we need to do dashes inside the SoD.
+    std::vector<SOverlayTexturedLine> m_TexturedOverlayLines;
+
+    /// Draw little overlay circles to indicate where the exact path points are?
+    bool m_EnableDebugNodeOverlay;
+    std::vector<SOverlayLine> m_DebugNodeOverlays;
+
+public:
+
+    CCmpRallyPoint()
+    {
+        m_Displayed = false;
+        m_SmoothPath = true;
+        m_MarkerEntity = INVALID_ENTITY;
+        m_EnableDebugNodeOverlay = false;
+    }
+
+    ~CCmpRallyPoint(){}
+
+    static std::string GetSchema()
+    {
+        return
+            "<a:component />"
+            "<a:help>Displays a rally point where created units will gather when spawned.</a:help>"
+            "<a:example>"
+                "<MarkerTemplate>special/rallypoint</MarkerTemplate>"
+                "<LineThickness>0.75</LineThickness>"
+                "<LineStartCap>round</LineStartCap>"
+                "<LineEndCap>square</LineEndCap>"
+                "<LineColour r='20' g='128' b='240'></LineColour>"
+            "</a:example>"
+            "<element name='MarkerTemplate' a:help='Template name for the rally point marker entity (typically a waypoint flag actor).'>"
+                "<text/>"
+            "</element>"
+            "<optional>"
+                "<element name='LineColour'>"
+                    "<attribute name='r'>"
+                        "<data type='integer'><param name='minInclusive'>0</param><param name='maxInclusive'>255</param></data>"
+                    "</attribute>"
+                    "<attribute name='g'>"
+                        "<data type='integer'><param name='minInclusive'>0</param><param name='maxInclusive'>255</param></data>"
+                    "</attribute>"
+                    "<attribute name='b'>"
+                        "<data type='integer'><param name='minInclusive'>0</param><param name='maxInclusive'>255</param></data>"
+                    "</attribute>"
+                "</element>"
+            "</optional>"
+            "<optional>"
+                "<element name='LineStartCap'>"
+                    "<choice>"
+                        "<value a:help='Abrupt line ending; line endings are not closed.'>flat</value>"
+                        "<value a:help='Semi-circular line end cap.'>round</value>"
+                        "<value a:help='Sharp, pointy line end cap.'>sharp</value>"
+                        "<value a:help='Square line end cap.'>square</value>"
+                    "</choice>"
+                "</element>"
+            "</optional>"
+            "<optional>"
+                "<element name='LineEndCap'>"
+                    "<choice>"
+                    "<value a:help='Abrupt line ending; line endings are not closed.'>flat</value>"
+                    "<value a:help='Semi-circular line end cap.'>round</value>"
+                    "<value a:help='Sharp, pointy line end cap.'>sharp</value>"
+                    "<value a:help='Square line end cap.'>square</value>"
+                    "</choice>"
+                "</element>"
+            "</optional>"
+            "<optional>"
+                "<element name='LineThickness' a:help='Thickness of the marker line connecting the entity to the rally point marker.'>"
+                    "<data type='decimal'/>"
+                "</element>"
+            "</optional>"
+            "<optional>"
+                "<element name='LineDashColour'>"
+                    "<attribute name='r'>"
+                        "<data type='integer'><param name='minInclusive'>0</param><param name='maxInclusive'>255</param></data>"
+                    "</attribute>"
+                    "<attribute name='g'>"
+                        "<data type='integer'><param name='minInclusive'>0</param><param name='maxInclusive'>255</param></data>"
+                    "</attribute>"
+                    "<attribute name='b'>"
+                        "<data type='integer'><param name='minInclusive'>0</param><param name='maxInclusive'>255</param></data>"
+                    "</attribute>"
+                "</element>"
+            "</optional>";
+    }
+
+    virtual void Init(const CParamNode& paramNode);
+
+    virtual void Deinit()
+    {
+    }
+
+    virtual void Serialize(ISerializer& UNUSED(serialize))
+    {
+        // TODO should probably serialize the rally point location here
+    }
+
+    virtual void Deserialize(const CParamNode& paramNode, IDeserializer& UNUSED(deserialize))
+    {
+        Init(paramNode);
+    }
+
+    virtual void HandleMessage(const CMessage& msg, bool UNUSED(global))
+    {
+        switch (msg.GetType())
+        {
+        case MT_RenderSubmit:
+        {
+            if(m_Displayed && IsSet())
+            {
+                const CMessageRenderSubmit& msgData = static_cast<const CMessageRenderSubmit&> (msg);
+                RenderSubmit(msgData.collector);
+            }
+            break;
+        }
+        case MT_OwnershipChanged:
+        {
+            CreateMarker();
+            RepositionMarker(); // the new marker doesn't have a position yet, so let's make sure to update it
+        }
+        case MT_TurnStart:
+        {
+            UpdateOverlayLines(); // check for changes to the SoD and update the overlay lines accordingly
+        }
+        }
+    }
+
+    virtual CFixedVector2D GetPosition()
+    {
+        return m_RallyPoint;
+    }
+
+    virtual void SetPosition(CFixedVector2D pos)
+    {
+        bool posChanged = (pos.X != m_RallyPoint.X || pos.Y != m_RallyPoint.Y);
+        m_RallyPoint = pos;
+
+        if(posChanged)
+        {
+            RecomputeRallyPointPath();
+            RepositionMarker();
+        }
+    }
+
+    virtual void Unset()
+    {
+        SetPosition(CFixedVector2D()); // reset to zero
+    }
+
+    bool IsSet()
+    {
+        return !m_RallyPoint.IsZero();
+    }
+
+    virtual void SetDisplayed(bool displayed)
+    {
+        bool displayChanged = (m_Displayed != displayed);
+        m_Displayed = displayed;
+
+        if(displayChanged)
+        {
+            RepositionMarker(); // move the marker out of oblivion and back into the real world, or vice-versa
+            UpdateOverlayLines(); // check for changes to the SoD and update the overlay lines accordingly
+        }
+    }
+
+private:
+
+    /**
+     * (Re)creates the rally point marker entity. Called upon initialization and whenever the ownership of this entity changes, as the marker
+     * depends on the owner's civilization. If a marker entity already exists, it will be destroyed first.
+     */
+    void CreateMarker();
+
+    /**
+     * Repositions the rally point marker; moves it outside of the world (ie. hides it), or positions it at the rally point. Executed
+     * whenever either the position of the rally point changes (including whether it is set or not), or the display flag changes.
+     *
+     * TODO: this is executed from JS-executed methods, which must not fail under any circumstances. We'd probably have to change this to
+     * detect the changes in the rendering code rather than execute them directly here.
+     **/
+    void RepositionMarker();
+
+    /**
+     * Recomputes the full path from this entity to the rally point, and does all the necessary post-processing to make it prettier.
+     * Called whenever the rally point position changes.
+     */
+    void RecomputeRallyPointPath();
+
+    /**
+     * Sets up the overlay lines for rendering according to the current full path and visibility segments. Does all the necessary splitting 
+     * of the line into solid and dashed pieces (for the SoD). Should be called whenever the SoD has changed. If no full path is currently 
+     * set, this method does nothing.
+     */
+    void ConstructOverlayLines();
+
+    /**
+     * Checks for changes to the SoD to the previously saved state, and reconstructs the overlay lines to match if necessary. Does nothing
+     * if the rally point line is not currently set to be displayed, so that we don't waste compute cycles trying to update rally point
+     * overlays for every building all the time if they're not even gonna be visible anyway.
+     */
+    void UpdateOverlayLines();
+
+    /**
+     * Removes waypoints from m_rallyPointPath that are obstructed by the originating building's footprint, and links up the rally point path
+     * nicely to the edge of the building's footprint. Only needed if the pathfinder can possibly return obstructed tile waypoints, i.e. when
+     * pathfinding is started from an obstructed tile.
+     */
+    void FixFootprintWaypoints(std::vector<CVector2D>& coords, CmpPtr<ICmpPosition> cmpPosition, CmpPtr<ICmpFootprint> cmpFootprint);
+
+    /**
+     * Removes waypoints that are inside the shroud of darkness, i.e. where the player shouldn't be able to get any information about the
+     * positions of various buildings and whatnot from the rally point path.
+     */
+    void FixInvisibleWaypoints(std::vector<CVector2D>& coords);
+
+    /**
+     * Simplifies the path by removing waypoints that lie between two points that are visible from one another. This is primarily intended to
+     * reduce some unnecessary curviness of the path; the pathfinder returns a mathematically (near-)optimal path, which will happily curve
+     * and bend to reduce costs. Visually, it doesn't make sense for a rally point path to curve and bend when it could just as well have gone
+     * in a straight line, so that's why we have this.
+     *
+     * @p coords array of path coordinates to simplify
+     * @p maxSegmentLinks if non-zero, indicates the maximum amount of consecutive node-to-node links that can be eliminated to form a single 
+     *                    link. If this value is set to e.g. 1, then no reductions will be performed. A value of 3 means that at most 3 
+     *                    consecutive node links will be joined into a single link.
+     */
+    void ReduceSegmentsByVisibility(std::vector<CVector2D>& coords, unsigned maxSegmentLinks = 0);
+
+    /**
+     * Returns a list of indices of waypoints in the current path (m_FullPath) where the LOS visibility changes, ordered from building to rally 
+     * point. Used to construct the overlay line segments and track changes to the shroud of darkness.
+     */
+    void GetVisibilitySegments(std::deque<SVisibilitySegment>& out);
+
+    /**
+     * Helper function to GetVisibilitySegments, factored out for testing. Merges single-point segments with its neighbouring segments.
+     * You should not have to call this method directly.
+     */
+    static void MergeVisibilitySegments(std::deque<SVisibilitySegment>& segments);
+
+    void RenderSubmit(SceneCollector& collector);
+
+};
+
+REGISTER_COMPONENT_TYPE(RallyPoint)
+
+void CCmpRallyPoint::Init(const CParamNode& paramNode)
+{
+    // set some defaults
+    m_LineThickness = .3f;
+    m_LineStartCap = SOverlayTexturedLine::LINECAP_FLAT;
+    m_LineEndCap = SOverlayTexturedLine::LINECAP_FLAT;
+    m_LineTexturePath = std::wstring(L"art/textures/misc/rallypoint_line.png");
+    m_LineTextureMaskPath = std::wstring(L"art/textures/misc/rallypoint_line_mask.png");
+    // implicit constructor defaults for m_LineColor and m_MarkerTemplate
+
+    // ---------------------------------------------------------------------------------------------
+    // load some XML configuration data
+
+    if (paramNode.GetChild("MarkerTemplate").IsOk())
+        m_MarkerTemplate = paramNode.GetChild("MarkerTemplate").ToString();
+
+    if (paramNode.GetChild("LineThickness").IsOk())
+        m_LineThickness = paramNode.GetChild("LineThickness").ToFixed().ToFloat();
+
+    const CParamNode& lineColor = paramNode.GetChild("LineColour");
+    if (lineColor.IsOk() && lineColor.GetChild("@r").IsOk() && lineColor.GetChild("@g").IsOk() && lineColor.GetChild("@b").IsOk())
+    {
+        m_LineColor = CColor(
+            lineColor.GetChild("@r").ToInt()/255.f,
+            lineColor.GetChild("@g").ToInt()/255.f,
+            lineColor.GetChild("@b").ToInt()/255.f,
+            1.f
+        );
+    }
+
+    const CParamNode& lineDashColor = paramNode.GetChild("LineDashColour");
+    if (lineDashColor.IsOk() && lineDashColor.GetChild("@r").IsOk() && lineDashColor.GetChild("@g").IsOk() && lineDashColor.GetChild("@b").IsOk())
+    {
+        m_LineDashColor = CColor(
+            lineDashColor.GetChild("@r").ToInt()/255.f,
+            lineDashColor.GetChild("@g").ToInt()/255.f,
+            lineDashColor.GetChild("@b").ToInt()/255.f,
+            1.f
+        );
+    }
+    else
+    {
+        m_LineDashColor = m_LineColor; // if not specified, use the same colour as the regular line segments
+    }
+
+    if (paramNode.GetChild("LineTexture").IsOk())
+        m_LineTexturePath = paramNode.GetChild("LineTexture").ToString();
+
+    if (paramNode.GetChild("LineMaskTexture").IsOk())
+        m_LineTextureMaskPath = paramNode.GetChild("LineMaskTexture").ToString();
+
+    if (paramNode.GetChild("LineStartCap").IsOk())
+    {
+        const std::wstring& xmlLineStartCap = paramNode.GetChild("LineStartCap").ToString();
+        if (!SOverlayTexturedLine::StrToLineCap(xmlLineStartCap, m_LineStartCap))
+            LOGERROR(L"Unrecognized LineStartCap value \"%ls\"", xmlLineStartCap); // this shouldn't happen by virtue of the XML validation
+    }
+
+    if (paramNode.GetChild("LineEndCap").IsOk())
+    {
+        const std::wstring& xmlLineEndCap = paramNode.GetChild("LineEndCap").ToString();
+        if (!SOverlayTexturedLine::StrToLineCap(xmlLineEndCap, m_LineEndCap))
+            LOGERROR(L"Unrecognized LineEndCap value \"%ls\"", xmlLineEndCap); // this shouldn't happen by virtue of the XML validation
+    }
+
+    // ---------------------------------------------------------------------------------------------
+    // load some textures
+
+    CTextureProperties texturePropsBase(m_LineTexturePath);
+    texturePropsBase.SetWrap(GL_CLAMP_TO_BORDER, GL_CLAMP_TO_EDGE);
+    texturePropsBase.SetMaxAnisotropy(8.f);
+    m_Texture = g_Renderer.GetTextureManager().CreateTexture(texturePropsBase);
+
+    CTextureProperties texturePropsMask(m_LineTextureMaskPath);
+    texturePropsMask.SetWrap(GL_CLAMP_TO_BORDER, GL_CLAMP_TO_EDGE);
+    texturePropsMask.SetMaxAnisotropy(8.f);
+    m_TextureMask = g_Renderer.GetTextureManager().CreateTexture(texturePropsMask);
+
+    // ---------------------------------------------------------------------------------------------
+
+    CreateMarker(); // TODO: evaluate how much load this puts on the entity IDs, if it's too high then we can do this on-demand)
+
+}
+
+void CCmpRallyPoint::CreateMarker()
+{
+
+    CComponentManager& componentMgr = GetSimContext().GetComponentManager();
+
+    // if a marker entity already exists, kill it first
+    if (m_MarkerEntity != INVALID_ENTITY)
+    {
+        CmpPtr<ICmpPosition> markerCmpPosition(GetSimContext(), m_MarkerEntity);
+        if (!markerCmpPosition.null())
+            markerCmpPosition->MoveOutOfWorld();
+
+        componentMgr.DestroyComponentsSoon(m_MarkerEntity); // queue entity for destruction
+        m_MarkerEntity = INVALID_ENTITY; // make sure any code below doesn't try to access the soon-to-be-destroyed entity anymore
+    }
+
+    // allocate a new entity for the marker
+    if (!m_MarkerTemplate.empty())
+    {
+        m_MarkerEntity = componentMgr.AllocateNewLocalEntity();
+        if (m_MarkerEntity != INVALID_ENTITY)
+            m_MarkerEntity = componentMgr.AddEntity(m_MarkerTemplate, m_MarkerEntity);
+    }
+    
+    CmpPtr<ICmpOwnership> cmpOwnership(GetSimContext(), GetEntityId());
+    if (!cmpOwnership.null())
+    {
+        player_id_t ownerId = cmpOwnership->GetOwner();
+        if (ownerId != INVALID_PLAYER)
+        {
+            CmpPtr<ICmpPlayerManager> cmpPlayerManager(GetSimContext(), SYSTEM_ENTITY);
+            ENSURE(!cmpPlayerManager.null());
+
+            CmpPtr<ICmpPlayer> cmpPlayer(GetSimContext(), cmpPlayerManager->GetPlayerByID(ownerId));
+            if (!cmpPlayer.null())
+            {
+                // TODO: in the future, when variants are working properly for actors, we should set the variant corresponding to the
+                // owning player's civilization here.
+            }
+        }
+    }
+
+}
+
+void CCmpRallyPoint::RepositionMarker()
+{
+    if (m_MarkerEntity == INVALID_ENTITY)
+        return; // there is no valid marker entity, no use trying to position it
+
+    CmpPtr<ICmpPosition> markerCmpPosition(GetSimContext(), m_MarkerEntity);
+    if (!markerCmpPosition.null())
+    {
+        if(m_Displayed && IsSet())
+        {
+            markerCmpPosition->JumpTo(m_RallyPoint.X, m_RallyPoint.Y);
+        }
+        else
+        {
+            markerCmpPosition->MoveOutOfWorld(); // hide it
+        }
+    }
+}
+
+void CCmpRallyPoint::RecomputeRallyPointPath()
+{
+    
+    m_FullPath.clear();
+    m_VisibilitySegments.clear();
+
+    if (!IsSet())
+        return; // no use computing a path if the rally point isn't set
+
+    CmpPtr<ICmpPosition> cmpPosition(GetSimContext(), GetEntityId());
+    if (cmpPosition.null() || !cmpPosition->IsInWorld())
+        return; // no point going on if this entity doesn't have a position or is outside of the world
+
+    CmpPtr<ICmpFootprint> cmpFootprint(GetSimContext(), GetEntityId());
+    CmpPtr<ICmpPathfinder> cmpPathFinder(GetSimContext(), SYSTEM_ENTITY);
+    //CmpPtr<ICmpTerrain> cmpTerrain(GetSimContext(), SYSTEM_ENTITY);
+
+
+    // -------------------------------------------------------------------------------------------------
+
+    entity_pos_t pathStartX = cmpPosition->GetPosition2D().X;
+    entity_pos_t pathStartY = cmpPosition->GetPosition2D().Y;
+
+    // Find a long path to the goal point -- this uses the tile-based pathfinder, which will return a
+    // list of waypoints (i.e. a Path) from the building to the goal, where each waypoint is centered
+    // at a tile. We'll have to do some post-processing on the path to get it smooth.
+    Path path;
+    std::vector<Waypoint>& waypoints = path.m_Waypoints;
+
+    Goal goal = { Goal::POINT, m_RallyPoint.X, m_RallyPoint.Y };
+    cmpPathFinder->ComputePath(
+        pathStartX,
+        pathStartY,
+        goal,
+        cmpPathFinder->GetPassabilityClass("default"),
+        cmpPathFinder->GetCostClass("default"),
+        path
+    );
+
+    if (path.m_Waypoints.size() < 2)
+        return; // not likely to happen, but can't hurt to check
+
+    // from here on, we choose to represent the waypoints as CVector2D floats to avoid to have to convert back and forth
+    // between fixed-point Waypoint/CFixedVector2D and various other float-based formats used by interpolation and whatnot.
+    // Since we'll only be further using these points for rendering purposes, using floats should be fine.
+
+    // make sure to add the actual goal point as the last point (the long pathfinder only finds paths to
+    // the tile closest to the goal, so we need to complete the last bit from the closest tile to the rally
+    // point itself)
+    // NOTE: the points are returned in reverse order (from the goal to the start point), so we need to
+    // actually insert it at the front of the coordinate list. Hence, we'll do this first before appending the rest of the
+    // fixed waypoints as CVector2Ds.
+
+    Waypoint& lastWaypoint = waypoints.back();
+    if (lastWaypoint.x != goal.x || lastWaypoint.z != goal.z)
+        m_FullPath.push_back(CVector2D(goal.x.ToFloat(), goal.z.ToFloat()));
+
+    // add the rest of the waypoints
+    for (size_t i = 0; i < waypoints.size(); ++i)
+        m_FullPath.push_back(CVector2D(waypoints[i].x.ToFloat(), waypoints[i].z.ToFloat()));
+
+    // -------------------------------------------------------------------------------------------
+    // postprocessing
+
+    // linearize the path;
+    // pass through the waypoints , averaging each waypoint with its next one except the last one. Because the path
+    // goes from the marker to this entity and we want to keep the point at the marker's exact position, loop backwards through the
+    // waypoints so that the marker waypoint is maintained.
+    // TODO: see if we can do this at the same time as the waypoint -> coord conversion above
+    for(size_t i = m_FullPath.size() - 1; i > 0; --i)
+        m_FullPath[i] = (m_FullPath[i] + m_FullPath[i-1]) / 2.0f;
+
+    // if there's a footprint, remove any points returned by the pathfinder that may be on obstructed footprint tiles
+    if (!cmpFootprint.null())
+        FixFootprintWaypoints(m_FullPath, cmpPosition, cmpFootprint);
+
+    // eliminate some consecutive waypoints that are visible from eachother.
+    ReduceSegmentsByVisibility(m_FullPath, 6); // reduce across a maximum distance of approx. 6 tiles (prevents segments that are too long to properly stick to the terrain)
+
+    //// <DEBUG> ///////////////////////////////////////////////
+    if (m_EnableDebugNodeOverlay)
+        m_DebugNodeOverlays.clear();
+
+    if (m_EnableDebugNodeOverlay && m_SmoothPath)
+    {
+        // create separate control point overlays so we can differentiate when using smoothing (offset them a little higher from the
+        // terrain so we can still see them after the interpolated points are added)
+        for (size_t j = 0; j < m_FullPath.size(); ++j)
+        {
+            SOverlayLine overlayLine;
+            overlayLine.m_Color = CColor(1.0f, 0.0f, 0.0f, 1.0f);
+            overlayLine.m_Thickness = 2;
+            SimRender::ConstructSquareOnGround(GetSimContext(), m_FullPath[j].X, m_FullPath[j].Y, 0.2f, 0.2f, 1.0f, overlayLine, true);
+            m_DebugNodeOverlays.push_back(overlayLine);
+        }
+    }
+    //// </DEBUG> //////////////////////////////////////////////
+
+    if (m_SmoothPath)
+        // the number of points to interpolate goes together with the maximum amount of node links allowed to be joined together by 
+        // the visibility reduction. The more node links that can be joined together, the more interpolated points you need to generate 
+        // to be able to deal with local terrain height changes
+        SimRender::InterpolatePointsRNS(m_FullPath, false, 0, 8); // no offset, keep line at its exact path
+
+    // -------------------------------------------------------------------------------------------
+    
+    // find which point is the last visible point before going into the SoD, so we have a point to compare to on the next turn
+    GetVisibilitySegments(m_VisibilitySegments);
+
+    // build overlay lines for the new path
+    ConstructOverlayLines();
+
+}
+
+void CCmpRallyPoint::ConstructOverlayLines()
+{
+    
+    // we need to create a new SOverlayTexturedLine every time we want to change the coordinates after having passed it to the renderer,
+    // because it does some fancy vertex buffering thing and caches them internally instead of recomputing them on every pass (which is
+    // only sensible)
+
+    m_TexturedOverlayLines.clear();
+
+    if (m_FullPath.size() < 2)
+        return;
+
+    CmpPtr<ICmpTerrain> cmpTerrain(GetSimContext(), SYSTEM_ENTITY);
+    SOverlayTexturedLine::LineCap dashesLineCap = SOverlayTexturedLine::LINECAP_ROUND; // line caps to use for the dashed segments (and any other segment's edges that border it)
+
+    for (std::deque<SVisibilitySegment>::const_iterator it = m_VisibilitySegments.begin(); it != m_VisibilitySegments.end(); ++it)
+    {
+        const SVisibilitySegment& segment = (*it);
+
+        if (segment.m_Visible)
+        {
+            // does this segment border on the building or rally point flag on either side?
+            bool bordersBuilding = (segment.m_EndIndex == m_FullPath.size() - 1);
+            bool bordersFlag = (segment.m_StartIndex == 0);
+
+            // 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_TextureBase = m_Texture;
+            overlayLine.m_TextureMask = m_TextureMask;
+            overlayLine.m_Color = m_LineColor;
+            overlayLine.m_Closed = false;
+            // we should take care to only use m_LineXCap for the actual end points at the building and the rally point; any intermediate
+            // end points (i.e., that border a dashed segment) should have the dashed cap
+            // the path line is actually in reverse order as well, so let's swap out the start and end caps
+            overlayLine.m_StartCap = (bordersFlag ? m_LineEndCap : dashesLineCap);
+            overlayLine.m_EndCap = (bordersBuilding ? m_LineStartCap : dashesLineCap);
+            overlayLine.m_AlwaysVisible = true;
+
+            // push overlay line coordinates
+            ENSURE(segment.m_EndIndex > segment.m_StartIndex);
+            for (size_t j = segment.m_StartIndex; j <= segment.m_EndIndex; ++j) // end index is inclusive here
+            {
+                overlayLine.m_Coords.push_back(m_FullPath[j].X);
+                overlayLine.m_Coords.push_back(m_FullPath[j].Y);
+            }
+
+            m_TexturedOverlayLines.push_back(overlayLine);
+        }
+        else
+        {
+            // 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_FullPath[segment.m_StartIndex]);
+            straightLine.push_back(m_FullPath[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.
+
+            float maxDashSize = 3.f;
+            float maxClearSize = 3.f;
+            
+            float dashSize = maxDashSize;
+            float clearSize = maxClearSize;
+            float pairDashRatio = (dashSize / (dashSize + clearSize)); // ratio of the dash's length to a (dash + clear) pair's length
+
+            float distance = (m_FullPath[segment.m_StartIndex] - m_FullPath[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.
+            int numFitUnmodified = floor(distance/(dashSize + clearSize));
+            float remainderDistance = distance - (numFitUnmodified * (dashSize + clearSize));
+
+            // Now we want to make remainderDistance equal exactly one dash size (i.e. maxDashSize) by scaling dashSize and clearSize slightly. 
+            // We have (remainderDistance - maxDashSize) of space to distribute over numFitUnmodified instances of (dashSize + clearSize) to make
+            // it fit, so each (dashSize + clearSize) pair needs to adjust its length by (remainderDistance - maxDashSize)/numFitUnmodified 
+            // (which will be positive or negative accordingly). This number can then be distributed further proportionally among the dash's 
+            // length and the clear's length.
+
+            // we always want to have at least one dash/clear pair (i.e., "|===|   |===|"); also, we need to avoid division by zero below.
+            numFitUnmodified = std::max(1, numFitUnmodified);
+
+            float pairwiseLengthDifference = (remainderDistance - maxDashSize)/numFitUnmodified; // can be either positive or negative
+            dashSize += pairDashRatio * pairwiseLengthDifference;
+            clearSize += (1 - pairDashRatio) * pairwiseLengthDifference;
+
+            // ------------------------------------------------------------------------------------------------
+
+            SDashedLine dashedLine;
+            SimRender::ConstructDashedLine(straightLine, dashedLine, dashSize, clearSize);
+
+            // build overlay lines for dashes
+            size_t numDashes = dashedLine.m_StartIndices.size();
+            for (size_t i=0; i < numDashes; i++)
+            {
+                SOverlayTexturedLine dashOverlay;
+
+                dashOverlay.m_Thickness = m_LineThickness;
+                dashOverlay.m_Terrain = cmpTerrain->GetCTerrain();
+                dashOverlay.m_TextureBase = m_Texture;
+                dashOverlay.m_TextureMask = m_TextureMask;
+                dashOverlay.m_Color = m_LineDashColor;
+                dashOverlay.m_Closed = false;
+                dashOverlay.m_StartCap = dashesLineCap;
+                dashOverlay.m_EndCap = dashesLineCap;
+                dashOverlay.m_AlwaysVisible = true;
+                // TODO: maybe adjust the elevation of the dashes to be a little lower, so that it slides underneath the actual path
+
+                size_t dashStartIndex = dashedLine.m_StartIndices[i];
+                size_t dashEndIndex = dashedLine.GetEndIndex(i);
+                ENSURE(dashEndIndex > dashStartIndex);
+
+                for (size_t n = dashStartIndex; n < dashEndIndex; n++)
+                {
+                    dashOverlay.m_Coords.push_back(dashedLine.m_Points[n].X);
+                    dashOverlay.m_Coords.push_back(dashedLine.m_Points[n].Y);
+                }
+
+                m_TexturedOverlayLines.push_back(dashOverlay);
+            }
+            
+        }
+    }
+
+    //// <DEBUG> //////////////////////////////////////////////
+    if (m_EnableDebugNodeOverlay)
+    {
+        for (size_t j = 0; j < m_FullPath.size(); ++j)
+        {
+            SOverlayLine overlayLine;
+            overlayLine.m_Color = CColor(1.0f, 1.0f, 1.0f, 1.0f);
+            overlayLine.m_Thickness = 1;
+            SimRender::ConstructCircleOnGround(GetSimContext(), m_FullPath[j].X, m_FullPath[j].Y, 0.075f, overlayLine, true);
+            m_DebugNodeOverlays.push_back(overlayLine);
+        }
+    }
+    //// </DEBUG> //////////////////////////////////////////////
+}
+
+void CCmpRallyPoint::UpdateOverlayLines()
+{
+    // we should really only do this if the rally point is currently being displayed and set inside the world, otherwise it's a massive 
+    // waste of time to calculate all this stuff every turn if there's nothing to show for it anyway
+
+    if (!m_Displayed || !IsSet())
+        return;
+
+    // see if there have been any changes to the SoD by grabbing the visibility edge points and comparing them to the previous ones
+    std::deque<SVisibilitySegment> newVisibilitySegments;
+    GetVisibilitySegments(newVisibilitySegments);
+
+    // compare the two indices vectors; as soon as an element is different (and provided the full path hasn't changed), then the SoD 
+    // has changed and we should recreate the overlay lines
+    bool same = (m_VisibilitySegments == newVisibilitySegments);
+    if (!same)
+    {
+        // the visibility segments have changed, so we want to reconstruct the overlay lines to match. Note that the path itself doesn't
+        // change, only the overlay lines we construct from them.
+        m_VisibilitySegments = newVisibilitySegments; // save the new visibility segments to compare against next time
+        ConstructOverlayLines();
+    }
+
+}
+
+void CCmpRallyPoint::FixFootprintWaypoints(std::vector<CVector2D>& coords, CmpPtr<ICmpPosition> cmpPosition, CmpPtr<ICmpFootprint> cmpFootprint)
+{
+    ENSURE(!cmpPosition.null());
+    ENSURE(!cmpFootprint.null());
+
+    // -----------------------------------------------------------------------------------------------------
+    // TODO: nasty fixed/float conversions everywhere
+
+    // grab the shape and dimensions of the footprint
+    entity_pos_t footprintSize0, footprintSize1, footprintHeight;
+    ICmpFootprint::EShape footprintShape;
+    cmpFootprint->GetShape(footprintShape, footprintSize0, footprintSize1, footprintHeight);
+
+    // grab the center of the footprint
+    CFixedVector2D center = cmpPosition->GetPosition2D();
+
+    // -----------------------------------------------------------------------------------------------------
+
+    switch (footprintShape)
+    {
+    case ICmpFootprint::SQUARE:
+        {
+            // in this case, footprintSize0 and 1 respectively indicate the (unrotated) size along the X and Z axes
+
+            // 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
+            // (the Footprint itself holds only the outline, the Position holds the orientation)
+
+            fixed s, c; // sine and cosine of the Y axis rotation angle (aka the yaw)
+            fixed a = cmpPosition->GetRotation().Y;
+            sincos_approx(a, s, c);
+            CFixedVector2D u(c, -s); // unit vector along the rotated X axis
+            CFixedVector2D v(s, c); // unit vector along the rotated Z axis
+            CFixedVector2D halfSize(footprintSize0/2, footprintSize1/2);
+
+            // starting from the start position, check if any points are within the footprint of the building
+            // (this is possible if the pathfinder was started from a point located within the footprint)
+            for(int i = (int)(coords.size() - 1); i >= 0; i--)
+            {
+                const CVector2D& wp = coords[i];
+                if (Geometry::PointIsInSquare(CFixedVector2D(fixed::FromFloat(wp.X), fixed::FromFloat(wp.Y)) - center, u, v, halfSize))
+                {
+                    coords.erase(coords.begin() + i);
+                }
+                else
+                {
+                    break; // point no longer inside footprint, from this point on neither will any of the following be
+                }
+            }
+
+            // add a point right on the edge of the footprint (nearest to the last waypoint) so that it links up nicely with the rest of the path
+            CFixedVector2D lastWaypoint(fixed::FromFloat(coords.back().X), fixed::FromFloat(coords.back().Y));
+            CFixedVector2D footprintEdgePoint = Geometry::NearestPointOnSquare(lastWaypoint - center, u, v, halfSize); // relative to the shape origin (center)
+            CVector2D footprintEdge((center.X + footprintEdgePoint.X).ToFloat(), (center.Y + footprintEdgePoint.Y).ToFloat());
+            coords.push_back(footprintEdge);
+
+        }
+        break;
+    case ICmpFootprint::CIRCLE:
+        {
+            // in this case, both footprintSize0 and 1 indicate the circle's radius
+
+            for(int i = (int)(coords.size() - 1); i >= 0; i--)
+            {
+                const CVector2D& wp = coords[i];
+                fixed pointDistance = (CFixedVector2D(fixed::FromFloat(wp.X), fixed::FromFloat(wp.Y)) - center).Length();
+                if (pointDistance <= footprintSize0)
+                {
+                    coords.erase(coords.begin() + i);
+                }
+                else
+                {
+                    break; // point no longer inside footprint, from this point on neither will any of the following be
+                }
+            }
+
+            // add a point right on the edge of the footprint so that it links up nicely with the rest of the path
+            CFixedVector2D radiusEdgePoint(fixed::FromFloat(coords.back().X), fixed::FromFloat(coords.back().Y));
+            radiusEdgePoint.Normalize(footprintSize1);
+            CVector2D footprintEdge((center.X + radiusEdgePoint.X).ToFloat(), (center.Y + radiusEdgePoint.Y).ToFloat());
+            coords.push_back(footprintEdge);
+
+        }
+        break;
+    }
+
+}
+
+void CCmpRallyPoint::FixInvisibleWaypoints(std::vector<CVector2D>& coords)
+{
+    CmpPtr<ICmpRangeManager> cmpRangeMgr(GetSimContext(), SYSTEM_ENTITY);
+
+    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)CELL_SIZE).ToInt_RoundToNearest();
+        int j = (fixed::FromFloat(it->Y) / (int)CELL_SIZE).ToInt_RoundToNearest();
+
+        bool explored = losQuerier.IsExplored(i, j);
+        if (!explored)
+        {
+            it = coords.erase(it);
+        }
+        else
+        {
+            it++;
+        }
+    }
+
+}
+
+void CCmpRallyPoint::ReduceSegmentsByVisibility(std::vector<CVector2D>& coords, unsigned maxSegmentLinks)
+{
+
+    CmpPtr<ICmpPathfinder> cmpPathFinder(GetSimContext(), SYSTEM_ENTITY);
+    CmpPtr<ICmpTerrain> cmpTerrain(GetSimContext(), SYSTEM_ENTITY);
+
+    if (coords.size() < 3)
+        return;
+
+    // the basic idea is this: starting from a base node, keep checking each individual point along the path to see if there's a visible
+    // line between it and the base point. If so, keep going, otherwise, make the last visible point the new base node and start the same
+    // process from there on until the entire line is checked. The output is the array of base nodes.
+
+    std::vector<CVector2D> newCoords;
+    StationaryObstructionFilter obstructionFilter; // TODO: is this the right one to use?
+    entity_pos_t lineRadius = fixed::FromFloat(m_LineThickness);
+    ICmpPathfinder::pass_class_t passabilityClass = cmpPathFinder->GetPassabilityClass("default");
+
+    newCoords.push_back(coords[0]); // save the first base node
+
+    size_t baseNodeIdx = 0;
+    size_t curNodeIdx = 1;
+
+// kind of ugly, but prevents code duplication below
+#define UPDATE_BASENODE_XYZ() STMT(baseNodeX = fixed::FromFloat(coords[baseNodeIdx].X);\
+                                   baseNodeZ = fixed::FromFloat(coords[baseNodeIdx].Y);\
+                                   baseNodeY = cmpTerrain->GetExactGroundLevel(coords[baseNodeIdx].X, coords[baseNodeIdx].Y);)
+    
+    float baseNodeY;
+    entity_pos_t baseNodeX;
+    entity_pos_t baseNodeZ;
+
+    UPDATE_BASENODE_XYZ(); // set initial base node coords
+
+    while (curNodeIdx < coords.size())
+    {
+        ENSURE(curNodeIdx > baseNodeIdx); // this needs to be true at all times, otherwise we're checking visibility between a point and itself
+
+        entity_pos_t curNodeX = fixed::FromFloat(coords[curNodeIdx].X);
+        entity_pos_t curNodeZ = fixed::FromFloat(coords[curNodeIdx].Y);
+        float curNodeY = cmpTerrain->GetExactGroundLevel(coords[curNodeIdx].X, coords[curNodeIdx].Y);
+
+        // find out whether curNode is visible from baseNode (careful; this is in 2D only; terrain height differences are ignored!)
+        bool curNodeVisible = cmpPathFinder->CheckMovement(obstructionFilter, baseNodeX, baseNodeZ, curNodeX, curNodeZ, lineRadius, passabilityClass);
+
+        // since height differences are ignored by CheckMovement, let's call two points visible from one another only if they're at roughly the same terrain elevation
+        curNodeVisible = curNodeVisible && fabsf(curNodeY - baseNodeY) < 3.f; // TODO: this could probably use some tuning
+        if (maxSegmentLinks > 0)
+            curNodeVisible = curNodeVisible && ((curNodeIdx - baseNodeIdx) <= maxSegmentLinks); // max. amount of node-to-node links to be eliminated (unsigned subtraction is valid because curNodeIdx is always > baseNodeIdx)
+
+        if (!curNodeVisible)
+        {
+            // current node is not visible from the base node, so the previous one was the last visible point from baseNode and should
+            // hence become the new base node for further iterations.
+
+            // if curNodeIdx is adjacent to the current baseNode (which is possible due to steep height differences, e.g. hills), then
+            // we should take care not to stay stuck at the current base node
+            if (curNodeIdx > baseNodeIdx + 1)
+            {
+                baseNodeIdx = curNodeIdx - 1;
+            }
+            else
+            {
+                // curNodeIdx == baseNodeIdx + 1
+                baseNodeIdx = curNodeIdx;
+                curNodeIdx++; // move the next candidate node one forward so that we don't test a point against itself in the next iteration
+            }
+
+            newCoords.push_back(coords[baseNodeIdx]); // add new base node to output list
+
+            UPDATE_BASENODE_XYZ();
+
+        }
+
+        curNodeIdx++;
+
+    }
+
+#undef UPDATE_BASENODE_XYZ
+
+    // we always need to add the last point back to the array; if e.g. all the points up to the last one are all visible from the current
+    // base node, then the loop above just ends and no endpoint is ever added to the list.
+    ENSURE(curNodeIdx == coords.size());
+    newCoords.push_back(coords[coords.size() - 1]);
+
+    coords.swap(newCoords);
+
+}
+
+void CCmpRallyPoint::GetVisibilitySegments(std::deque<SVisibilitySegment>& out)
+{
+    
+    out.clear();
+
+    if (m_FullPath.size() < 2)
+        return;
+
+    CmpPtr<ICmpRangeManager> cmpRangeMgr(GetSimContext(), SYSTEM_ENTITY);
+
+    player_id_t currentPlayer = GetSimContext().GetCurrentDisplayedPlayer();
+    CLosQuerier losQuerier(cmpRangeMgr->GetLosQuerier(currentPlayer));
+
+    // go through the path node list, comparing each node's visibility with the previous one. If it changes, end the current segment and start
+    // a new one at the next point.
+
+    bool lastVisible = losQuerier.IsExplored(
+        (fixed::FromFloat(m_FullPath[0].X) / (int) CELL_SIZE).ToInt_RoundToNearest(),
+        (fixed::FromFloat(m_FullPath[0].Y) / (int) CELL_SIZE).ToInt_RoundToNearest()
+    );
+    size_t curSegmentStartIndex = 0; // starting node index of the current segment
+
+    for (size_t k = 1; k < m_FullPath.size(); ++k)
+    {
+        // grab tile indices for this coord
+        int i = (fixed::FromFloat(m_FullPath[k].X) / (int)CELL_SIZE).ToInt_RoundToNearest();
+        int j = (fixed::FromFloat(m_FullPath[k].Y) / (int)CELL_SIZE).ToInt_RoundToNearest();
+
+        bool nodeVisible = losQuerier.IsExplored(i, j);
+        if (nodeVisible != lastVisible)
+        {
+            // visibility changed; write out the segment that was just completed and get ready for the new one
+            out.push_back(SVisibilitySegment(lastVisible, curSegmentStartIndex, k - 1));
+
+            //curSegmentStartIndex = k; // new segment starts here
+            curSegmentStartIndex = k - 1;
+            lastVisible = nodeVisible;
+        }
+
+    }
+
+    // terminate the last segment
+    out.push_back(SVisibilitySegment(lastVisible, curSegmentStartIndex, m_FullPath.size() - 1));
+
+    // ---------------------------------------------------------------------------------------------------
+    MergeVisibilitySegments(out);
+
+}
+
+void CCmpRallyPoint::MergeVisibilitySegments(std::deque<SVisibilitySegment>& segments)
+{
+    // scan for single-point segments; if they are inbetween two other segments, delete it and merge the surrounding segments;
+    // if they're at either end of the path, include them in their bordering segment (but only if those bordering segments aren't 
+    // themselves single-point segments, because then we would want those to get absorbed by its surrounding ones first).
+
+    // first scan for absorptions of single-point surrounded segments (i.e. excluding edge segments)
+    size_t numSegments = segments.size();
+
+    // YE BE WARNED: HERE BE FOR LOOP TRICKERY
+    for (size_t i = 1; i < numSegments - 1;)
+    {
+        SVisibilitySegment& segment = segments[i];
+        if (segment.IsSinglePoint())
+        {
+            ENSURE(segments[i-1].m_Visible == segments[i+1].m_Visible); // since the segments' visibility alternates, the surrounding ones should have the same visibility
+            segments[i-1].m_EndIndex = segments[i+1].m_EndIndex; // make previous segment span all the way across to the next
+            segments.erase(segments.begin() + i); // erase this segment ...
+            segments.erase(segments.begin() + i); // and the next (we removed [i], so [i+1] is now at position [i])
+            numSegments -= 2; // we removed 2 segments, so update the loop condition
+            // in the next iteration, i should still point to the segment right after the one that got expanded, which is now
+            // at position i; so don't increment i here
+        }
+        else
+        {
+            ++i;
+        }
+    }
+
+    ENSURE(numSegments == segments.size());
+
+    // check to see if the first segment needs to be merged with its neighbour
+    if (segments.size() >= 2 && segments[0].IsSinglePoint())
+    {
+        int firstSegmentStartIndex = segments.front().m_StartIndex;
+        ENSURE(firstSegmentStartIndex == 0);
+        ENSURE(!segments[1].IsSinglePoint()); // at this point, the second segment should never be a single-point segment
+        
+        segments.erase(segments.begin());
+        segments.front().m_StartIndex = firstSegmentStartIndex;
+
+    }
+
+    // check to see if the last segment needs to be merged with its neighbour
+    if (segments.size() >= 2 && segments[segments.size()-1].IsSinglePoint())
+    {
+        int lastSegmentEndIndex = segments.back().m_EndIndex;
+        ENSURE(!segments[segments.size()-2].IsSinglePoint()); // at this point, the second-to-last segment should never be a single-point segment
+
+        segments.erase(segments.end());
+        segments.back().m_EndIndex = lastSegmentEndIndex;
+    }
+
+    // --------------------------------------------------------------------------------------------------------
+    // at this point, every segment should have at least 2 points
+    for (size_t i = 0; i < segments.size(); ++i)
+    {
+        ENSURE(!segments[i].IsSinglePoint());
+        ENSURE(segments[i].m_EndIndex > segments[i].m_StartIndex);
+    }
+
+}
+
+void CCmpRallyPoint::RenderSubmit(SceneCollector& collector)
+{
+    // we only get here if the rally point is set and should be displayed
+    for (size_t i = 0; i < m_TexturedOverlayLines.size(); ++i)
+    {
+        if (!m_TexturedOverlayLines[i].m_Coords.empty())
+            collector.Submit(&m_TexturedOverlayLines[i]);
+    }
+
+    if (m_EnableDebugNodeOverlay && !m_DebugNodeOverlays.empty())
+    {
+        for (size_t i = 0; i < m_DebugNodeOverlays.size(); i++)
+            collector.Submit(&m_DebugNodeOverlays[i]);
+    }
+}

source/simulation2/components/CCmpTerritoryManager.cpp

@@ -103 +103 @@
 
     TerritoryOverlay* m_DebugOverlay;
 
+    bool m_EnableLineDebugOverlays; ///< Enable node debugging overlays for boundary lines?
+    std::vector<SOverlayLine> m_DebugBoundaryLineNodes;
+
     virtual void Init(const CParamNode& UNUSED(paramNode))
     {
         m_Territories = NULL;
@@ -110 +113 @@
 //      m_DebugOverlay = new TerritoryOverlay(*this);
         m_BoundaryLinesDirty = true;
         m_TriggerEvent = true;
-
+        m_EnableLineDebugOverlays = false;
         m_DirtyID = 1;
 
         m_AnimTime = 0.0;
@@ -742 +745 @@
     PROFILE("update boundary lines");
 
     m_BoundaryLines.clear();
+    m_DebugBoundaryLineNodes.clear();
 
     if (!CRenderer::IsInitialised())
         return;
@@ -780 +784 @@
         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_TextureBase = textureBase;
         m_BoundaryLines.back().overlay.m_TextureMask = textureMask;
         m_BoundaryLines.back().overlay.m_Color = color;
         m_BoundaryLines.back().overlay.m_Thickness = m_BorderThickness;
+        m_BoundaryLines.back().overlay.m_Closed = true;
 
-        SimRender::SmoothPointsAverage(boundaries[i].points, true);
+        SimRender::SmoothPointsAverage(boundaries[i].points, m_BoundaryLines.back().overlay.m_Closed);
 
-        SimRender::InterpolatePointsRNS(boundaries[i].points, true, m_BorderSeparation);
+        SimRender::InterpolatePointsRNS(boundaries[i].points, m_BoundaryLines.back().overlay.m_Closed, m_BorderSeparation);
 
         std::vector<float>& points = m_BoundaryLines.back().overlay.m_Coords;
         for (size_t j = 0; j < boundaries[i].points.size(); ++j)
         {
             points.push_back(boundaries[i].points[j].X);
             points.push_back(boundaries[i].points[j].Y);
+
+            if (m_EnableLineDebugOverlays)
+            {
+                SOverlayLine overlayNode;
+                if (j > boundaries[i].points.size() - 1 - 7)
+                    overlayNode.m_Color = CColor(1.f, 0.f, 0.f, 1.f);
+                else if (j < 7)
+                    overlayNode.m_Color = CColor(0.f, 1.f, 0.f, 1.f);
+                else
+                    overlayNode.m_Color = CColor(1.0f, 1.0f, 1.0f, 1.0f);
+
+                overlayNode.m_Thickness = 1;
+                SimRender::ConstructCircleOnGround(GetSimContext(), boundaries[i].points[j].X, boundaries[i].points[j].Y, 0.1f, overlayNode, true);
+                m_DebugBoundaryLineNodes.push_back(overlayNode);
+            }
         }
+
     }
 }
 
@@ -825 +845 @@
 {
     for (size_t i = 0; i < m_BoundaryLines.size(); ++i)
         collector.Submit(&m_BoundaryLines[i].overlay);
+    
+    for( size_t i = 0; i < m_DebugBoundaryLineNodes.size(); ++i)
+        collector.Submit(&m_DebugBoundaryLineNodes[i]);
+
 }
 
 player_id_t CCmpTerritoryManager::GetOwner(entity_pos_t x, entity_pos_t z)

new file source/simulation2/components/ICmpRallyPoint.cpp

@@ +1 @@
+/* Copyright (C) 2011 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 0 A.D. is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "precompiled.h"
+
+#include "ICmpRallyPoint.h"
+#include "simulation2/system/InterfaceScripted.h"
+
+BEGIN_INTERFACE_WRAPPER(RallyPoint)
+DEFINE_INTERFACE_METHOD_0("GetPosition", CFixedVector2D, ICmpRallyPoint, GetPosition)
+DEFINE_INTERFACE_METHOD_1("SetPosition", void, ICmpRallyPoint, SetPosition, CFixedVector2D)
+DEFINE_INTERFACE_METHOD_0("IsSet", bool, ICmpRallyPoint, IsSet)
+DEFINE_INTERFACE_METHOD_0("Unset", void, ICmpRallyPoint, Unset)
+DEFINE_INTERFACE_METHOD_1("SetDisplayed", void, ICmpRallyPoint, SetDisplayed, bool)
+//DEFINE_INTERFACE_METHOD_0("GetMarkerEntityId", entity_id_t, ICmpRallyPoint, GetMarkerEntityId)
+END_INTERFACE_WRAPPER(RallyPoint)

new file source/simulation2/components/ICmpRallyPoint.h

@@ +1 @@
+/* Copyright (C) 2011 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 0 A.D. is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef INCLUDED_ICMPRALLYPOINT
+#define INCLUDED_ICMPRALLYPOINT
+
+#include "simulation2/system/Interface.h"
+#include "simulation2/helpers/Position.h"
+
+#include "maths/FixedVector2D.h"
+
+/**
+ * Rally Point.
+ * Holds the position of a unit's rally point, and renders it to screen.
+ */
+class ICmpRallyPoint : public IComponent
+{
+public:
+
+    virtual CFixedVector2D GetPosition() = 0; ///< Returns the position of the rally point
+    virtual void SetPosition(CFixedVector2D pos) = 0; ///< Set the position of the rally point
+    virtual void SetDisplayed(bool displayed) = 0; ///< Set whether the rally point marker and line should be displayed
+    virtual void Unset() = 0; ///< Unsets the current rally point position
+    virtual bool IsSet() = 0; ///< Is the rally point position currently set?
+
+    DECLARE_INTERFACE_TYPE(RallyPoint)
+};
+
+#endif // INCLUDED_ICMPRALLYPOINT

source/simulation2/helpers/Geometry.h

@@ -1 @@
-/* Copyright (C) 2010 Wildfire Games.
+/* Copyright (C) 2011 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -30 +30 @@
 namespace Geometry
 {
 
+/**
+ * Returns true if @p point is inside the square with rotated X axis unit vector @p u and rotated Z axis unit vector @p v,
+ * and half dimensions specified by @p halfSizes. Currently assumes the @p u and @p v vectors are perpendicular. Can also
+ * be used for rectangles.
+ *
+ * @param point point vector of the point that is to be tested relative to the origin (center) of the shape.
+ * @param u rotated X axis unit vector relative to the absolute XZ plane. Indicates the orientation of the rectangle. If not rotated,
+ *          this value is the absolute X axis unit vector (1,0). If rotated by angle theta, this should be (cos theta, -sin theta), as
+ *          the absolute Z axis points down in the unit circle.
+ * @param v rotated Z axis unit vector relative to the absolute XZ plane. Indicates the orientation of the rectangle. If not rotated,
+ *          this value is the absolute Z axis unit vector (0,1). If rotated by angle theta, this should be (sin theta, cos theta), as
+ *          the absolute Z axis points down in the unit circle.
+ * @param halfSizes Holds half the dimensions of the shape along the u and v vectors, respectively.
+ */
 bool PointIsInSquare(CFixedVector2D point, CFixedVector2D u, CFixedVector2D v, CFixedVector2D halfSize);
 
 CFixedVector2D GetHalfBoundingBox(CFixedVector2D u, CFixedVector2D v, CFixedVector2D halfSize);
 
 fixed DistanceToSquare(CFixedVector2D point, CFixedVector2D u, CFixedVector2D v, CFixedVector2D halfSize);
 
+/**
+ * Returns the point that is closest to @p point on the edge of the square specified by orientation unit vectors @p u and @p v and half
+ * dimensions @p halfSize, relative to the center of the square. Currently assumes the @p u and @p v vectors are perpendicular.
+ * Can also be used for rectangles.
+ *
+ * @param point point vector of the point we want to get the nearest edge point for, relative to the origin (center) of the shape.
+ * @param u rotated X axis unit vector, relative to the absolute XZ plane. Indicates the orientation of the shape. If not rotated,
+ *          this value is the absolute X axis unit vector (1,0). If rotated by angle theta, this should be (cos theta, -sin theta).
+ * @param v rotated Z axis unit vector, relative to the absolute XZ plane. Indicates the orientation of the shape. If not rotated,
+ *          this value is the absolute Z axis unit vector (0,1). If rotated by angle theta, this should be (sin theta, cos theta).
+ * @param halfSizes Holds half the dimensions of the shape along the u and v vectors, respectively.
+ */
 CFixedVector2D NearestPointOnSquare(CFixedVector2D point, CFixedVector2D u, CFixedVector2D v, CFixedVector2D halfSize);
 
 bool TestRaySquare(CFixedVector2D a, CFixedVector2D b, CFixedVector2D u, CFixedVector2D v, CFixedVector2D halfSize);

source/simulation2/helpers/Render.cpp

@@ -1 @@
-/* Copyright (C) 2010 Wildfire Games.
+/* Copyright (C) 2011 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -201 +201 @@
     return p + CVector2D(dp.Y*-offset, dp.X*offset);
 }
 
-void SimRender::InterpolatePointsRNS(std::vector<CVector2D>& points, bool closed, float offset)
+void SimRender::InterpolatePointsRNS(std::vector<CVector2D>& points, bool closed, float offset, int segmentSamples)
 {
     PROFILE("InterpolatePointsRNS");
+    ENSURE(segmentSamples > 0);
 
     std::vector<CVector2D> newPoints;
+    const float fSegmentSamples = (float) segmentSamples;
 
     // (This does some redundant computations for adjacent vertices,
     // but it's fairly fast (<1ms typically) so we don't worry about it yet)
@@ -215 +217 @@
     // curve with fewer points
 
     size_t n = points.size();
+
+    if (closed)
+    {
     if (n < 1)
-        return; // can't do anything unless we have two points
+            return; // we need at least a single point to not crash
+    }
+    else
+    {
+        if (n < 2)
+            return; // in non-closed mode, we need at least n=2 to not crash
+    }
 
-    size_t imax = closed ? n : n-1; // TODO: we probably need to do a bit more to handle non-closed paths
+    size_t imax = closed ? n : n-1;
+    newPoints.reserve(imax*segmentSamples);
 
-    newPoints.reserve(imax*4);
+    // these are primarily used inside the loop, but for open paths we need them outside the loop once to compute the last point
+    CVector2D a0;
+    CVector2D a1;
+    CVector2D a2;
+    CVector2D a3;
 
     for (size_t i = 0; i < imax; ++i)
     {
-        // Get the relevant points for this spline segment
-        CVector2D p0 = points[(i-1+n)%n];
+
+        // 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
         CVector2D p1 = points[i];
         CVector2D p2 = points[(i+1)%n];
-        CVector2D p3 = points[(i+2)%n];
+        CVector2D p3; // normally points[(i+2)%n], but it's a bit more complicated due to open/closed paths -- see below
+
+        if (!closed && (i == 0))
+            // p0's point index is out of bounds, and we can't wrap around because we're in non-closed mode -- create an artificial point
+            // that extends p1 -> p0 (i.e. the first segment's direction)
+            p0 = points[0] + (points[0] - points[1]);
+        else
+            // standard wrap-around case
+            p0 = points[(i-1+n)%n]; // careful; don't use (i-1)%n here, as the result is machine-dependent for negative operands (e.g. if i==0, the result could be either -1 or n-1)
+
+
+        if (!closed && (i == n-2))
+            // p3's point index is out of bounds; create an artificial point that extends p_(n-2) -> p_(n-1) (i.e. the last segment's direction)
+            // (note that p2's index should not be out of bounds, because in non-closed mode imax is reduced by 1)
+            p3 = points[n-1] + (points[n-1] - points[n-2]);
+        else
+            // standard wrap-around case
+            p3 = points[(i+2)%n];
+
 
         // Do the RNS computation (based on GPG4 "Nonuniform Splines")
         float l1 = (p2 - p1).Length(); // length of spline segment (i)..(i+1)
@@ -239 +275 @@
         CVector2D v2 = (s1 + s2).Normalized() * l1; // spline velocity at i+1
 
         // Compute standard cubic spline parameters
-        CVector2D a0 = p1*2 + p2*-2 + v1 + v2;
-        CVector2D a1 = p1*-3 + p2*3 + v1*-2 + v2*-1;
-        CVector2D a2 = v1;
-        CVector2D a3 = p1;
+        a0 = p1*2 + p2*-2 + v1 + v2;
+        a1 = p1*-3 + p2*3 + v1*-2 + v2*-1;
+        a2 = v1;
+        a3 = p1;
+
+        // Interpolate at regular points across the interval
+        for (int sample = 0; sample < segmentSamples; sample++)
+            newPoints.push_back(EvaluateSpline(sample/fSegmentSamples, a0, a1, a2, a3, offset));
 
-        // Interpolate at various points
-        newPoints.push_back(EvaluateSpline(0.f, a0, a1, a2, a3, offset));
-        newPoints.push_back(EvaluateSpline(1.f/4.f, a0, a1, a2, a3, offset));
-        newPoints.push_back(EvaluateSpline(2.f/4.f, a0, a1, a2, a3, offset));
-        newPoints.push_back(EvaluateSpline(3.f/4.f, a0, a1, a2, a3, offset));
     }
 
+    if (!closed)
+        // if the path is open, we should take care to include the last control point
+        // NOTE: we can't just do push_back(points[n-1]) here because that ignores the offset
+        newPoints.push_back(EvaluateSpline(1.f, a0, a1, a2, a3, offset));
+
     points.swap(newPoints);
 }
+
+void SimRender::ConstructDashedLine(const std::vector<CVector2D>& keyPoints, SDashedLine& dashedLineOut, const float dashLength, const float blankLength)
+{
+    // sanity checks
+    if (dashLength <= 0)
+        return;
+
+    if (blankLength <= 0)
+        return;
+
+    if (keyPoints.size() < 2)
+        return;
+
+    dashedLineOut.m_Points.clear();
+    dashedLineOut.m_StartIndices.clear();
+
+    // walk the line, counting the total length so far at each node point. When the length exceeds dashLength, cut the last segment at the
+    // required length and continue for blankLength along the line to start a new dash segment.
+
+    // TODO: we should probably extend this function to also allow for closed lines. I was thinking of slightly scaling the dash/blank length
+    // so that it fits the length of the curve, but that requires knowing the length of the curve upfront which is sort of expensive to compute
+    // (O(n) and lots of square roots).
+
+    bool buildingDash = true; // true if we're building a dash, false if a blank
+    float curDashLength = 0; // builds up the current dash/blank's length as we walk through the line nodes
+    CVector2D dashLastPoint = keyPoints[0]; // last point of the current dash/blank being built.
+
+    // register the first starting node of the first dash
+    dashedLineOut.m_Points.push_back(keyPoints[0]);
+    dashedLineOut.m_StartIndices.push_back(0);
+
+    // index of the next key point on the path. Must always point to a node that is further along the path than dashLastPoint, so we can
+    // properly take a direction vector along the path.
+    size_t i = 0;
+
+    while(i < keyPoints.size() - 1)
+    {
+        // get length of this segment
+        CVector2D segmentVector = keyPoints[i + 1] - dashLastPoint; // vector from our current point along the path to nextNode
+        float segmentLength = segmentVector.Length();
+
+        float targetLength = (buildingDash ? dashLength : blankLength);
+        if (curDashLength + segmentLength > targetLength)
+        {
+            // segment is longer than the dash length we still have to go, so we'll need to cut it; create a cut point along the segment
+            // line that is of just the required length to complete the dash, then make it the base point for the next dash/blank.
+            float cutLength = targetLength - curDashLength;
+            CVector2D cutPoint = dashLastPoint + (segmentVector.Normalized() * cutLength);
+
+            // start a new dash or blank in the next iteration
+            curDashLength = 0;
+            buildingDash = !buildingDash; // flip from dash to blank and vice-versa
+            dashLastPoint = cutPoint;
+
+            // don't increment i, we haven't fully traversed this segment yet so we still need to use the same point to take the
+            // direction vector with in the next iteration
+
+            // this cut point is either the end of the current dash or the beginning of a new dash; either way, we're gonna need it
+            // in the points array.
+            dashedLineOut.m_Points.push_back(cutPoint);
+
+            if (buildingDash)
+            {
+                // if we're gonna be building a new dash, then cutPoint is now the base point of that new dash, so let's register its
+                // index as a start index of a dash.
+                dashedLineOut.m_StartIndices.push_back(dashedLineOut.m_Points.size() - 1);
+            }
+
+        }
+        else
+        {
+            // the segment from lastDashPoint to keyPoints[i+1] doesn't suffice to complete the dash, so we need to add keyPoints[i+1]
+            // to this dash's points and continue from there
+
+            if (buildingDash)
+                // still building the dash, add it to the output (we don't need to store the blanks)
+                dashedLineOut.m_Points.push_back(keyPoints[i+1]);
+
+            curDashLength += segmentLength;
+            dashLastPoint = keyPoints[i+1];
+            i++;
+
+        }
+
+    }
+
+}

source/simulation2/helpers/Render.h

@@ -23 +23 @@
  * Helper functions related to rendering
  */
 
+#include "maths/Vector2D.h"
+
 class CSimContext;
-class CVector2D;
 struct SOverlayLine;
 
+
+
+struct SDashedLine
+{
+    std::vector<CVector2D> m_Points; ///< Packed array of consecutive dashes' points. Use m_StartIndices to navigate it.
+
+    /**
+     * Start indices in m_Points of each dash. Dash n starts at point m_StartIndices[n] and ends at the point with index 
+     * m_StartIndices[n+1] - 1, or at the end of the m_Points vector. Use the GetEndIndex(n) convenience method to abstract away the
+     * difference and get the (exclusive) end index of dash n.
+     */
+    std::vector<size_t> m_StartIndices;
+
+    /// Returns the (exclusive) end point index (i.e. index within m_Points) of dash n.
+    size_t GetEndIndex(size_t i)
+    {
+        // for the last dash, there is no next starting index, so we need to use the end index of the m_Points array instead
+        return (i < m_StartIndices.size() - 1 ? m_StartIndices[i+1] : m_Points.size());
+    }
+};
+
 namespace SimRender
 {
 
@@ -68 +90 @@
  * the direction of the curve.
  * If @p closed then the points are treated as a closed path (the last is connected
  * to the first).
+ * @param segmentSamples Amount of intermediate points to sample between every two control points.
+ */
+void InterpolatePointsRNS(std::vector<CVector2D>& points, bool closed, float offset, int segmentSamples = 4);
+
+/**
+ * Creates a dashed line from the line specified by @points so that each dash is of length
+ * @p dashLength, and each blank inbetween is of length @p blankLength. The dashed line returned as a list of smaller lines
+ * in @p dashedLineOut.
+ *
+ * @param dashLength Length of a single dash. Must be strictly positive.
+ * @param blankLength Length of a single blank between dashes. Must be strictly positive.
  */
-void InterpolatePointsRNS(std::vector<CVector2D>& points, bool closed, float offset);
+void ConstructDashedLine(const std::vector<CVector2D>& linePoints, SDashedLine& dashedLineOut, const float dashLength, const float blankLength);
 
 } // namespace