Ticket #2264: terrainflattening.3.patch

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

@@ +1 @@
+function TerrainModifier() {};
+
+/*
+ * A component to calculate the height of different vertices for a height changing entity
+ */
+TerrainModifier.prototype.Schema =
+    "<element name='Type'>" +
+        "<choice>" +
+            "<value>flatten</value>" +
+            "<value>slopeWall</value>" +
+        "</choice>" +
+    "</element>";
+
+TerrainModifier.prototype.GetType = function()
+{
+    return this.template.Type;
+};
+
+/**
+ * All queried vertices will be in a relative square around this entity, 
+ * with as size the value from this method.
+ */
+TerrainModifier.prototype.GetBBox = function()
+{
+    if (!this.footprint)
+    {
+        var cmpFootprint = Engine.QueryInterface(this.entity, IID_Footprint);
+        this.footprint = cmpFootprint.GetShape();
+    }
+    if (this.footprint.type == "square")
+        var max = Math.max(this.footprint.width, this.footprint.depth) + 6;
+    else
+        var max = this.footprint.radius * 2 + 6;
+    if (this.GetType() == "flatten")
+        return max
+    return Math.max(max, 100);
+    
+};
+
+/**
+ * Calculate the new height for the relative point
+ * the oldHeight for that point, and the default entity height are given to save CPU time
+ *
+ * Note that the entity height will change when vertices near the centre 
+ * are modified in height
+ */
+TerrainModifier.prototype.GetNewHeight = function(point, oldHeight, entHeight)
+{
+    var r = {"height": oldHeight, "weight":0};
+    switch (this.GetType())
+    {
+    case "flatten":
+        var w = 0;
+        var fp = this.footprint;
+        // get the max distance from the footprint
+        if (fp.type == "square")
+            w = Math.max(Math.abs(point.x) - fp.width/2, Math.abs(point.y) - fp.depth/2);
+        else
+            w = Math.sqrt(Math.pow(point.x,2) + Math.pow(point.y,2)) - fp.radius;
+
+        // convert to a weight, where w == 1 is inside the footprint, 
+        // and w == 0 is far away from the footprint
+        // TODO: turn '6' into a variable, it's the cutoff from which point nothing is changed 
+        w = Math.max(Math.min(1 - w/6, 1), 0); 
+        r = {"height": (1 - w)*oldHeight + w*entHeight, "weight": w};
+        break;
+
+    case "slopeWall":
+        if (point.y <= 6 )
+        {
+            if (point.y > -4 && Math.abs(point.x) < 4)
+                r = {"height": oldHeight, weight: 1};
+            break;
+        }
+        var l = 50;
+        var newHeight = this.footprint.height*(Math.atan(-7*point.y/l + 3.5) + 1.4)/2.6;
+        if (Math.abs(point.x) > this.footprint.width/2 + 4)
+        {
+            var mult = 1/(Math.abs(point.x) - this.footprint.width/2 - 3);
+            newHeight *= mult;
+            var weight = mult/10;
+            newHeight += oldHeight
+        }
+        else
+        {
+            var weight = (l-Math.abs(point.y))/l;
+            newHeight += (entHeight*(l - point.y) + oldHeight*point.y)/l;
+        }
+        r = {"height": newHeight, "weight": weight};
+        break;
+    default:
+        warn("unknown terrain modifier type");
+        break;
+    }
+    return {"x": r.height, "y": r.weight}
+};
+
+TerrainModifier.prototype.OnPositionChanged = function(msg)
+{
+    var cmpTerrain = Engine.QueryInterface(SYSTEM_ENTITY, IID_Terrain);
+    cmpTerrain.MakeVisualTerrainDirty();
+};
+
+TerrainModifier.prototype.OnDestroy = function(msg)
+{
+    this.GetBBox = function(){ return 0;};
+    var cmpTerrain = Engine.QueryInterface(SYSTEM_ENTITY, IID_Terrain);
+    cmpTerrain.MakeVisualTerrainDirty();
+};
+
+Engine.RegisterComponentType(IID_TerrainModifier, "TerrainModifier", TerrainModifier);
+

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

@@ -96 +96 @@
     <BarHeight>0.6</BarHeight>
     <HeightOffset>12.0</HeightOffset>
   </StatusBars>
+  <TerrainModifier>
+    <Type>
+      flatten
+    </Type>
+  </TerrainModifier>
   <TerritoryDecay>
     <HealthDecayRate>5</HealthDecayRate>
   </TerritoryDecay>

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

@@ -10 +10 @@
     <SpawnEntityOnDeath>rubble/rubble_stone_wall_long</SpawnEntityOnDeath>
   </Health>
   <Identity>
-    <Classes datatype="tokens">LongWall</Classes>
-    <Tooltip>Long wall segments can be converted to gates.</Tooltip>
-  </Identity>
-</Entity>
+    <Classes datatype="tokens">LongWall</Classes>
+    <Tooltip>Long wall segments can be converted to gates.</Tooltip>
+  </Identity>
+  <TerrainModifier>
+    <Type>
+      slopeWall
+    </Type>
+  </TerrainModifier>
+</Entity>

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

@@ -85 +85 @@
   <StatusBars>
     <HeightOffset>20.0</HeightOffset>
   </StatusBars>
+  <TerrainModifier disable=""/>
   <TerritoryInfluence>
     <Root>false</Root>
     <Radius>20</Radius>

source/simulation2/TypeList.h

@@ -148 +148 @@
 INTERFACE(Terrain)
 COMPONENT(Terrain)
 
+INTERFACE(TerrainModifier)
+COMPONENT(TerrainModifierScripted)
+
 INTERFACE(TerritoryInfluence)
 COMPONENT(TerritoryInfluence)
 

source/simulation2/components/CCmpTerrain.cpp

@@ -20 +20 @@
 #include "simulation2/system/Component.h"
 #include "ICmpTerrain.h"
 
+#include "ICmpTerrainModifier.h"
 #include "ICmpObstructionManager.h"
 #include "ICmpRangeManager.h"
+#include "ICmpPosition.h"
 #include "simulation2/MessageTypes.h"
+#include "simulation2/helpers/Geometry.h"
 
 #include "graphics/Terrain.h"
 #include "renderer/Renderer.h"
 #include "renderer/WaterManager.h"
+#include "graphics/Patch.h"
+#include "maths/MathUtil.h"
 #include "maths/Vector3D.h"
 
 class CCmpTerrain : public ICmpTerrain
@@ -40 +45 @@
 
     CTerrain* m_Terrain; // not null
 
+    std::vector<u16> m_SimHeightmap;
+    ssize_t m_MapSizePatches;
+
+
     static std::string GetSchema()
     {
         return "<a:component type='system'/><empty/>";
@@ -48 +57 @@
     virtual void Init(const CParamNode& UNUSED(paramNode))
     {
         m_Terrain = &GetSimContext().GetTerrain();
+        m_MapSizePatches = 0;
     }
 
     virtual void Deinit()
@@ -68 +78 @@
         return m_Terrain->GetVerticesPerSide() != 0;
     }
 
+
+    virtual u16* GetSimHeightMap()
+    {
+        return &m_SimHeightmap[0];
+    }
+
+    virtual void MakeVisualTerrainDirty()
+    {
+        if (m_Terrain->GetPatchesPerSide() != m_MapSizePatches)
+            m_Terrain->Resize(m_MapSizePatches);
+
+        if (m_MapSizePatches)
+            RecalculateVisualHeightmap();
+    }
+
     virtual CFixedVector3D CalcNormal(entity_pos_t x, entity_pos_t z)
     {
         CFixedVector3D normal;
@@ -83 +108 @@
     virtual entity_pos_t GetGroundLevel(entity_pos_t x, entity_pos_t z)
     {
         // TODO: this can crash if the terrain heightmap isn't initialised yet
-
         return m_Terrain->GetExactGroundLevelFixed(x, z);
     }
 
@@ -94 +118 @@
 
     virtual u16 GetTilesPerSide()
     {
-        ssize_t tiles = m_Terrain->GetTilesPerSide();
+        ssize_t tiles = m_MapSizePatches * PATCH_SIZE;
         ENSURE(1 <= tiles && tiles <= 65535);
         return (u16)tiles;
     }
@@ -101 +125 @@
 
     virtual u16 GetVerticesPerSide()
     {
-        ssize_t vertices = m_Terrain->GetVerticesPerSide();
-        ENSURE(1 <= vertices && vertices <= 65535);
+        ssize_t vertices = m_MapSizePatches * PATCH_SIZE + 1;
+        ENSURE(1 < vertices && vertices <= 65535);
         return (u16)vertices;
     }
 
@@ -111 +135 @@
         return m_Terrain;
     }
 
+    struct IterateHeightmapAverage
+    {
+        u16* heightmap;
+        int pitch;
+
+        // weighted sum of the wanted heights
+        float* sumHeightmap;
+        // sum of the weights
+        float* sumWeightmap;
+
+        void operator()(int i, int j, float weight, float newHeight)
+        {
+            if (weight > 0)
+            {
+                sumHeightmap[i+j*pitch] += weight * newHeight;
+                sumWeightmap[i+j*pitch] += weight;
+                int h = (int) (HEIGHT_UNITS_PER_METRE*sumHeightmap[i+j*pitch]/sumWeightmap[i+j*pitch]);
+                heightmap[i + j*pitch] = Clamp(h, 0, 65535);
+            }
+        }
+    };
+
+    template<typename T>
+    void IterateHeightmap(T& callback, CFixedVector2D pos, fixed angle, entity_id_t ent)
+    {
+        CmpPtr<ICmpTerrainModifier> CCmpTerrainModifier(GetSimContext(), ent);
+        // get the bbox, multiply by sqrt(2)/2 (rounded up) to get half the size and take
+        // account of possible rotations
+        fixed BBoxSize = CCmpTerrainModifier->GetBBox()/2;
+        fixed maxBBoxSize = BBoxSize.Multiply(fixed::FromFloat(1.42f));
+        int numVerts = m_MapSizePatches*PATCH_SIZE + 1;
+
+        int i0 = ((pos.X - maxBBoxSize) / TERRAIN_TILE_SIZE).ToInt_RoundToNegInfinity();
+        int i1 = ((pos.X + maxBBoxSize) / TERRAIN_TILE_SIZE).ToInt_RoundToInfinity();
+        int j0 = ((pos.Y - maxBBoxSize) / TERRAIN_TILE_SIZE).ToInt_RoundToNegInfinity();
+        int j1 = ((pos.Y + maxBBoxSize) / TERRAIN_TILE_SIZE).ToInt_RoundToInfinity();
+        i0 = Clamp(i0, 0, numVerts);
+        i1 = Clamp(i1, 0, numVerts);
+        j0 = Clamp(j0, 0, numVerts);
+        j1 = Clamp(j1, 0, numVerts);
+
+        float entHeight = m_Terrain->GetExactGroundLevel(pos.X.ToFloat(), pos.Y.ToFloat());
+        for (int j = j0; j <= j1; ++j)
+        {
+            for (int i = i0; i <= i1; ++i)
+            {
+                CFixedVector2D pt = CFixedVector2D(fixed::FromInt(i*TERRAIN_TILE_SIZE), fixed::FromInt(j*TERRAIN_TILE_SIZE)) - CFixedVector2D(pos.X, pos.Y);
+                pt = pt.Rotate(-angle);
+                if (pt.X.Absolute() > BBoxSize || pt.Y.Absolute() > BBoxSize)
+                    continue;
+                float oldHeight = m_Terrain->GetVertexGroundLevel(i, j);
+                float newHeight, weight;
+                CCmpTerrainModifier->GetNewHeight(pt, oldHeight, entHeight, newHeight, weight);
+                callback(i, j, weight, newHeight);
+            }
+        }
+    }
+
+    void RecalculateVisualHeightmap()
+    {
+        u16* heightmap = m_Terrain->GetHeightMap();
+        int pitch = m_MapSizePatches * PATCH_SIZE + 1;
+        std::vector<u16> tempHeightmap(pitch*pitch);
+        memcpy(&tempHeightmap[0], &m_SimHeightmap[0], pitch * pitch * sizeof(u16));
+        memcpy(heightmap, &m_SimHeightmap[0], (m_MapSizePatches * PATCH_SIZE + 1) * (m_MapSizePatches * PATCH_SIZE + 1 )* sizeof(u16));
+
+        IterateHeightmapAverage callback;
+        callback.heightmap = &tempHeightmap[0];
+        callback.pitch = pitch;
+        std::vector<float> sumHeightmap(pitch * pitch, 0.0f);
+        callback.sumHeightmap = &sumHeightmap[0];
+        std::vector<float> sumWeightmap(pitch * pitch, 0.0f);
+        callback.sumWeightmap = &sumWeightmap[0];
+
+        CComponentManager::InterfaceList ents = GetSimContext().GetComponentManager().GetEntitiesWithInterface(IID_TerrainModifier);
+        for (CComponentManager::InterfaceList::const_iterator it = ents.begin(); it != ents.end(); ++it)
+        {
+            CmpPtr<ICmpPosition> cmpPosition(GetSimContext(), it->first);
+            if (cmpPosition)
+            {
+                CFixedVector2D pos = cmpPosition->GetPosition2D();
+                fixed angle = cmpPosition->GetRotation().Y;
+
+                IterateHeightmap(callback, pos, angle, it->first);
+            }
+        }
+
+        memcpy(heightmap, &tempHeightmap[0], pitch * pitch * sizeof(u16));
+        m_Terrain->MakeDirty(RENDERDATA_UPDATE_VERTICES);
+    }
+
     virtual void ReloadTerrain()
     {
         // TODO: should refactor this code to be nicer
+        m_MapSizePatches = m_Terrain->GetPatchesPerSide();
+        size_t size = (m_MapSizePatches * PATCH_SIZE + 1)*(m_MapSizePatches * PATCH_SIZE + 1);
+        m_SimHeightmap.resize(size);
+        if (m_Terrain->GetHeightMap())
+            memcpy(&m_SimHeightmap[0], m_Terrain->GetHeightMap(), size*sizeof(u16));
+        else
+            memset(&m_SimHeightmap[0], 0, size*sizeof(u16));
 
         u16 tiles = GetTilesPerSide();
         u16 vertices = GetVerticesPerSide();
@@ -138 +260 @@
         if (CRenderer::IsInitialised())
             g_Renderer.GetWaterManager()->SetMapSize(vertices);
 
+        MakeVisualTerrainDirty();
+
         MakeDirty(0, 0, tiles+1, tiles+1);
     }
 

source/simulation2/components/ICmpTerrain.cpp

@@ -24 +24 @@
 BEGIN_INTERFACE_WRAPPER(Terrain)
 DEFINE_INTERFACE_METHOD_2("GetGroundLevel", entity_pos_t, ICmpTerrain, GetGroundLevel, entity_pos_t, entity_pos_t)
 DEFINE_INTERFACE_METHOD_2("CalcNormal", CFixedVector3D, ICmpTerrain, CalcNormal, entity_pos_t, entity_pos_t)
+DEFINE_INTERFACE_METHOD_0("MakeVisualTerrainDirty", void, ICmpTerrain, MakeVisualTerrainDirty)
 END_INTERFACE_WRAPPER(Terrain)

source/simulation2/components/ICmpTerrain.h

@@ -32 +32 @@
 public:
     virtual bool IsLoaded() = 0;
 
+    virtual u16* GetSimHeightMap() = 0;
+
+    virtual void MakeVisualTerrainDirty() = 0;
+
     virtual CFixedVector3D CalcNormal(entity_pos_t x, entity_pos_t z) = 0;
 
     virtual CVector3D CalcExactNormal(float x, float z) = 0;

source/simulation2/components/ICmpTerrainModifier.cpp

@@ +1 @@
+/* Copyright (C) 2013 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 "ICmpTerrainModifier.h"
+
+#include "simulation2/system/InterfaceScripted.h"
+#include "simulation2/scripting/ScriptComponent.h"
+
+BEGIN_INTERFACE_WRAPPER(TerrainModifier)
+END_INTERFACE_WRAPPER(TerrainModifier)
+
+
+class CCmpTerrainModifierScripted : public ICmpTerrainModifier
+{
+public:
+    DEFAULT_SCRIPT_WRAPPER(TerrainModifierScripted)
+
+    virtual fixed GetBBox()
+    {
+        return m_Script.Call<fixed>("GetBBox");
+    }
+
+    virtual void GetNewHeight(CFixedVector2D relPt, float oldHeight, float entHeight, float& newHeight, float& weight)
+    {
+        // TODO Use std::vector<float> instead???
+        CFixedVector2D v = m_Script.Call<CFixedVector2D>("GetNewHeight", relPt, oldHeight, entHeight);
+        newHeight = v.X.ToFloat();
+        weight = v.Y.ToFloat();
+    }
+};
+
+REGISTER_COMPONENT_SCRIPT_WRAPPER(TerrainModifierScripted)

source/simulation2/components/ICmpTerrainModifier.h

@@ +1 @@
+/* Copyright (C) 2013 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_ICMPTERRAINMODIFIER
+#define INCLUDED_ICMPTERRAINMODIFIER
+
+#include "simulation2/system/Interface.h"
+
+#include "simulation2/helpers/Position.h"
+#include "maths/FixedVector2D.h"
+
+class ICmpTerrainModifier : public IComponent
+{
+public:
+
+    /**
+     * the BBox size of vertices that certainly need to be queried
+     * other vertices outside the BBox can also be queried, but shouldn't influence the terrain
+     */
+    virtual fixed GetBBox() = 0;
+
+
+    virtual void GetNewHeight(CFixedVector2D relPt, float oldHeight, float entHeight, float& newHeight, float& weight) = 0;
+
+    DECLARE_INTERFACE_TYPE(TerrainModifier)
+};
+
+#endif // INCLUDED_ICMPTERRAINMODIFIER

source/simulation2/system/ComponentTest.h

@@ -229 +229 @@
     virtual void ReloadTerrain()
     {
     }
+
+    virtual void MakeVisualTerrainDirty()
+    {
+    }
+
+    virtual u16* GetSimHeightMap()
+    {
+        return NULL;
+    }
 };

source/tools/atlas/GameInterface/Handlers/ElevationHandlers.cpp

@@ -41 +41 @@
     void Init()
     {
         m_Heightmap = g_Game->GetWorld()->GetTerrain()->GetHeightMap();
+        CmpPtr<ICmpTerrain> cmpTerrain(*g_Game->GetSimulation2(), SYSTEM_ENTITY);
+        if (cmpTerrain)
+            m_SimHeightmap = cmpTerrain->GetSimHeightMap();
         m_VertsPerSide = g_Game->GetWorld()->GetTerrain()->GetVerticesPerSide();
     }
 
@@ -90 +93 @@
     void setNew(ssize_t x, ssize_t y, const u16& val)
     {
         m_Heightmap[y*m_VertsPerSide + x] = val;
+        if (m_SimHeightmap)
+            m_SimHeightmap[y*m_VertsPerSide + x] = val;
     }
 
     u16* m_Heightmap;
+    u16* m_SimHeightmap;
     ssize_t m_VertsPerSide;
 };