Finish CMapWorld and CMapUniverse rendering

DataSpec/DNACommon/Tweaks/ITweakAutoMapper.hpp

@@ -24,6 +24,8 @@ struct ITweakAutoMapper : public ITweak
     virtual const zeus::CColor& GetOutlineUnvisitedColor() const=0;
     virtual const zeus::CColor& GetSurfaceSelectVisitedColor() const=0;
     virtual const zeus::CColor& GetOutlineSelectVisitedColor() const=0;
+    virtual float GetMapSurfaceNormColorLinear() const=0;
+    virtual float GetMapSurfaceNormColorConstant() const=0;
     virtual float GetOpenMapScreenTime() const=0;
     virtual float GetCloseMapScreenTime() const=0;
     virtual float GetHintPanTime() const=0;

DataSpec/DNAMP1/Tweaks/CTweakAutoMapper.hpp

@@ -33,8 +33,8 @@ struct CTweakAutoMapper : public ITweakAutoMapper
     DNAColor x48_outlineColorUnvisited;
     DNAColor x4c_surfaceSelectColorVisited;
     DNAColor x50_outlineSelectColorVisited;
-    Value<float> x54_;
+    Value<float> x54_mapSurfaceNormColorLinear;
-    Value<float> x58_;
+    Value<float> x58_mapSurfaceNormColorConstant;
     Value<float> x5c_;
     float x60_ = 0.4f;
     Value<float> x64_openMapScreenTime;
@@ -99,6 +99,8 @@ struct CTweakAutoMapper : public ITweakAutoMapper
     const zeus::CColor& GetOutlineUnvisitedColor() const { return x48_outlineColorUnvisited; }
     const zeus::CColor& GetSurfaceSelectVisitedColor() const { return x4c_surfaceSelectColorVisited; }
     const zeus::CColor& GetOutlineSelectVisitedColor() const { return x50_outlineSelectColorVisited; }
+    float GetMapSurfaceNormColorLinear() const { return x54_mapSurfaceNormColorLinear; }
+    float GetMapSurfaceNormColorConstant() const { return x58_mapSurfaceNormColorConstant; }
     float GetOpenMapScreenTime() const { return x64_openMapScreenTime; }
     float GetCloseMapScreenTime() const { return x68_closeMapScreenTime; }
     float GetHintPanTime() const { return x6c_hintPanTime; }

Runtime/AutoMapper/CMapArea.cpp

@@ -38,11 +38,12 @@ void CMapArea::PostConstruct()
     }
 
     u8* tmp = x3c_vertexStart;
-    for (u32 i = 0 ; i<(x2c_vertexCount*3) ; ++i)
+    m_verts.reserve(x2c_vertexCount);
+    for (u32 i = 0 ; i<x2c_vertexCount ; ++i)
     {
         float* fl = reinterpret_cast<float*>(tmp);
-        *fl = hecl::SBig(*fl);
+        m_verts.emplace_back(hecl::SBig(fl[0]), hecl::SBig(fl[1]), hecl::SBig(fl[2]));
-        tmp += 4;
+        tmp += 12;
     }
 
     std::vector<u32> index;
@@ -57,8 +58,38 @@ void CMapArea::PostConstruct()
     {
         m_vbo = ctx.newStaticBuffer(boo::BufferUse::Vertex, x3c_vertexStart, 12, x2c_vertexCount);
         m_ibo = ctx.newStaticBuffer(boo::BufferUse::Index, index.data(), 4, index.size());
+
+        /* Only the map universe specifies Always; it draws a maximum of 133 instances */
+        size_t instCount = (xc_visibilityMode == EVisMode::Always) ? 133 : 1;
+
         for (u32 i = 0 ; i<x30_surfaceCount ; ++i)
-            m_surfaces[i].m_surfacePrims.emplace(ctx, m_vbo, m_ibo);
+        {
+            CMapAreaSurface& surf = m_surfaces[i];
+            surf.m_instances.reserve(instCount);
+            for (u32 inst = 0 ; inst < instCount ; ++inst)
+            {
+                surf.m_instances.emplace_back(ctx, m_vbo, m_ibo);
+                CMapAreaSurface::Instance& instance = surf.m_instances.back();
+
+                athena::io::MemoryReader r(surf.x1c_outlineOffset, INT_MAX);
+                u32 outlineCount = r.readUint32Big();
+
+                std::vector<CLineRenderer>& linePrims = instance.m_linePrims;
+                linePrims.reserve(outlineCount * 2);
+                for (u32 j=0 ; j<2 ; ++j)
+                {
+                    r.seek(4, athena::SeekOrigin::Begin);
+                    for (u32 i=0 ; i<outlineCount ; ++i)
+                    {
+                        u32 count = r.readUint32Big();
+                        r.seek(count);
+                        r.seekAlign4();
+                        linePrims.emplace_back(ctx, CLineRenderer::EPrimitiveMode::LineStrip, count, nullptr, false);
+                    }
+                }
+            }
+        }
+
         for (u32 i = 0 ; i<x28_mappableObjCount ; ++i)
         {
             CMappableObject& mapObj = m_mappableObjects[i];
@@ -251,42 +282,20 @@ void CMapArea::CMapAreaSurface::PostConstruct(const u8* buf, std::vector<u32>& i
 }
 
 void CMapArea::CMapAreaSurface::Draw(const zeus::CVector3f* verts, const zeus::CColor& surfColor,
-                                     const zeus::CColor& lineColor, float lineWidth) const
+                                     const zeus::CColor& lineColor, float lineWidth, int instIdx) const
 {
+    Instance& instance = const_cast<Instance&>(m_instances[instIdx]);
+
     if (surfColor.a)
-        const_cast<CMapSurfaceShader&>(*m_surfacePrims).draw(surfColor, m_primStart, m_primCount);
+        instance.m_surfacePrims.draw(surfColor, m_primStart, m_primCount);
 
     if (lineColor.a)
     {
         bool draw2 = lineWidth > 1.f;
-        int totalPrims = draw2 + 1;
         athena::io::MemoryReader r(x1c_outlineOffset, INT_MAX);
         u32 outlineCount = r.readUint32Big();
-        totalPrims *= outlineCount;
-
-        std::vector<CLineRenderer>& linePrims = const_cast<std::vector<CLineRenderer>&>(m_linePrims);
-        if (linePrims.size() < totalPrims)
-        {
-            linePrims.clear();
-            linePrims.reserve(totalPrims);
-            const_cast<CMapAreaSurface*>(this)->m_lineToken =
-            CGraphics::CommitResources([&](boo::IGraphicsDataFactory::Context& ctx)
-            {
-                for (u32 j=0 ; j<=draw2 ; ++j)
-                {
-                    r.seek(4, athena::SeekOrigin::Begin);
-                    for (u32 i=0 ; i<outlineCount ; ++i)
-                    {
-                        u32 count = r.readUint32Big();
-                        r.seek(count);
-                        r.seekAlign4();
-                        linePrims.emplace_back(ctx, CLineRenderer::EPrimitiveMode::LineStrip, count, nullptr, false);
-                    }
-                }
-                return true;
-            });
-        }
 
+        std::vector<CLineRenderer>& linePrims = instance.m_linePrims;
         zeus::CColor color = lineColor;
         if (draw2)
             color.a *= 0.5f;

Runtime/AutoMapper/CMapArea.hpp

@@ -25,15 +25,20 @@ public:
         const u8* x1c_outlineOffset;
         u32 m_primStart;
         u32 m_primCount;
-        std::experimental::optional<CMapSurfaceShader> m_surfacePrims;
+        struct Instance
-        std::vector<CLineRenderer> m_linePrims;
+        {
-        boo::GraphicsDataToken m_lineToken;
+            CMapSurfaceShader m_surfacePrims;
+            std::vector<CLineRenderer> m_linePrims;
+            Instance(boo::IGraphicsDataFactory::Context& ctx, boo::IGraphicsBufferS* vbo, boo::IGraphicsBufferS* ibo)
+            : m_surfacePrims(ctx, vbo, ibo) {}
+        };
+        std::vector<Instance> m_instances;
     public:
         CMapAreaSurface(const void* surfBuf);
         CMapAreaSurface(CMapAreaSurface&&) = default;
         void PostConstruct(const u8* buf, std::vector<u32>& index);
         void Draw(const zeus::CVector3f* verts, const zeus::CColor& surfColor,
-                  const zeus::CColor& lineColor, float lineWidth) const;
+                  const zeus::CColor& lineColor, float lineWidth, int instIdx=0) const;
         const zeus::CVector3f& GetNormal() const { return x0_normal; }
         const zeus::CVector3f& GetCenterPosition() const { return xc_centroid; }
     };
@@ -58,6 +63,7 @@ private:
     u8* x38_moStart;
     std::vector<CMappableObject> m_mappableObjects;
     u8* x3c_vertexStart;
+    std::vector<zeus::CVector3f> m_verts;
     u8* x40_surfaceStart;
     std::vector<CMapAreaSurface> m_surfaces;
     std::unique_ptr<u8[]> x44_buf;
@@ -77,6 +83,7 @@ public:
     u32 GetNumSurfaces() const { return m_surfaces.size(); }
     zeus::CTransform GetAreaPostTransform(const IWorld& world, TAreaId aid) const;
     static const zeus::CVector3f& GetAreaPostTranslate(const IWorld& world, TAreaId aid);
+    const zeus::CVector3f* GetVertices() const { return m_verts.data(); }
 };
 
 CFactoryFnReturn FMapAreaFactory(const SObjectTag& objTag, CInputStream& in, const CVParamTransfer&,

Runtime/AutoMapper/CMapUniverse.cpp

@@ -1,6 +1,7 @@
 #include "CMapUniverse.hpp"
 #include "GameGlobalObjects.hpp"
 #include "CSimplePool.hpp"
+#include "CGameState.hpp"
 
 namespace urde
 {
@@ -29,13 +30,13 @@ CMapUniverse::CMapWorldData::CMapWorldData(CInputStream& in, u32 version)
     }
 
     if (version != 0)
-        x54_.readRGBABig(in);
+        x54_surfColorSelected.readRGBABig(in);
     else
-        x54_.fromRGBA32(255 | (x10_worldAssetId & 0xFFFFFF00));
+        x54_surfColorSelected.fromRGBA32(255 | (x10_worldAssetId & 0xFFFFFF00));
 
-    x58_ = zeus::CColor::lerp(zeus::CColor::skWhite, x54_, 0.5f);
+    x58_outlineColorSelected = zeus::CColor::lerp(zeus::CColor::skWhite, x54_surfColorSelected, 0.5f);
-    x5c_ = zeus::CColor::lerp(zeus::CColor::skBlack, x54_, 0.5f);
+    x5c_surfColorUnselected = zeus::CColor::lerp(zeus::CColor::skBlack, x54_surfColorSelected, 0.5f);
-    x60_ = zeus::CColor::lerp(zeus::CColor::skWhite, x5c_, 0.5f);
+    x60_outlineColorUnselected = zeus::CColor::lerp(zeus::CColor::skWhite, x5c_surfColorUnselected, 0.5f);
 
     for (const zeus::CTransform& xf : x44_hexagonXfs)
         x64_centerPoint += xf.origin;
@@ -45,7 +46,88 @@ CMapUniverse::CMapWorldData::CMapWorldData(CInputStream& in, u32 version)
 
 void CMapUniverse::Draw(const CMapUniverseDrawParms& parms, const zeus::CVector3f&, float, float) const
 {
+    if (!x4_hexagonToken.IsLoaded())
+        return;
 
+    u32 totalSurfaceCount = 0;
+    for (const CMapWorldData& data : x10_worldDatas)
+        totalSurfaceCount += data.GetNumMapAreaDatas() * x4_hexagonToken->GetNumSurfaces();
+
+    std::vector<CMapObjectSortInfo> sortInfos;
+    sortInfos.reserve(totalSurfaceCount);
+
+    for (int w=0 ; w<x10_worldDatas.size() ; ++w)
+    {
+        const CMapWorldData& data = x10_worldDatas[w];
+        const CMapWorldInfo& mwInfo = *g_GameState->StateForWorld(data.GetWorldAssetId()).MapWorldInfo();
+        if (!mwInfo.IsAnythingSet())
+            continue;
+        zeus::CColor surfColor, outlineColor;
+        if (w == parms.GetFocusWorldIndex())
+        {
+            surfColor = data.GetSurfaceColorSelected();
+            surfColor.a *= parms.GetAlpha();
+            outlineColor = data.GetOutlineColorSelected();
+            outlineColor.a *= parms.GetAlpha();
+        }
+        else
+        {
+            surfColor = data.GetSurfaceColorUnselected();
+            surfColor.a *= parms.GetAlpha();
+            outlineColor = data.GetSurfaceColorUnselected();
+            outlineColor.a *= parms.GetAlpha();
+        }
+
+        for (int h=0 ; h<data.GetNumMapAreaDatas() ; ++h)
+        {
+            zeus::CTransform hexXf = parms.GetCameraTransform().inverse() * data.GetMapAreaData(h);
+            for (int s=0 ; s<x4_hexagonToken->GetNumSurfaces() ; ++s)
+            {
+                const CMapArea::CMapAreaSurface& surf = x4_hexagonToken->GetSurface(s);
+                zeus::CVector3f centerPos = hexXf * surf.GetCenterPosition();
+                sortInfos.emplace_back(centerPos.y, w, h, s, surfColor, outlineColor);
+            }
+        }
+    }
+
+    std::sort(sortInfos.begin(), sortInfos.end(),
+    [](const CMapObjectSortInfo& a, const CMapObjectSortInfo& b)
+    {
+        return a.GetZDistance() < b.GetZDistance();
+    });
+
+    int lastWldIdx = -1;
+    int lastHexIdx = -1;
+    int instIdx = 0;
+    for (const CMapObjectSortInfo& info : sortInfos)
+    {
+        const CMapWorldData& mwData = x10_worldDatas[info.GetWorldIndex()];
+        zeus::CColor surfColor = info.GetSurfaceColor();
+        zeus::CColor outlineColor = info.GetOutlineColor();
+        if (parms.GetWorldAssetId() == mwData.GetWorldAssetId() && parms.GetClosestArea() == info.GetAreaIndex())
+        {
+            surfColor = zeus::CColor::lerp(g_tweakAutoMapper->GetSurfaceSelectVisitedColor(),
+                                           g_tweakAutoMapper->GetAreaFlashPulseColor(),
+                                           parms.GetFlashPulse());
+            surfColor.a = info.GetSurfaceColor().a;
+            outlineColor = zeus::CColor::lerp(g_tweakAutoMapper->GetOutlineSelectVisitedColor(),
+                                              g_tweakAutoMapper->GetAreaFlashPulseColor(),
+                                              parms.GetFlashPulse());
+            outlineColor.a = info.GetOutlineColor().a;
+        }
+
+        zeus::CTransform hexXf = mwData.GetMapAreaData(info.GetAreaIndex());
+        hexXf.orthonormalize();
+        const CMapArea::CMapAreaSurface& surf = x4_hexagonToken->GetSurface(info.GetObjectIndex());
+        zeus::CColor color(std::max(0.f, (-parms.GetCameraTransform().basis[1]).dot(hexXf.rotate(surf.GetNormal()))) *
+            g_tweakAutoMapper->GetMapSurfaceNormColorLinear() + g_tweakAutoMapper->GetMapSurfaceNormColorConstant());
+        surfColor *= color;
+
+        if (info.GetAreaIndex() != lastHexIdx || info.GetWorldIndex() != lastWldIdx)
+            CGraphics::SetModelMatrix(parms.GetPaneProjectionTransform() * mwData.GetMapAreaData(info.GetAreaIndex()));
+
+        surf.Draw(x4_hexagonToken->GetVertices(), surfColor, outlineColor, 2.f, instIdx++);
+    }
 }
 
 CFactoryFnReturn FMapUniverseFactory(const SObjectTag&, CInputStream& in, const CVParamTransfer&,

Runtime/AutoMapper/CMapUniverse.hpp

@@ -42,18 +42,30 @@ public:
         const zeus::CTransform& GetCameraTransform() const { return x1c_view; }
         const zeus::CTransform& GetPaneProjectionTransform() const { return x18_model; }
         float GetAlpha() const { return x0_alpha; }
+        ResId GetWorldAssetId() const { return x8_wldRes; }
+        int GetClosestArea() const { return xc_closestHex; }
+        float GetFlashPulse() const { return x10_flashPulse; }
     };
 
     class CMapObjectSortInfo
     {
+        float x0_zDist;
+        int x4_wldIdx;
+        int x8_hexIdx;
+        int xc_surfIdx;
+        zeus::CColor x10_surfColor;
+        zeus::CColor x14_outlineColor;
     public:
-        CMapObjectSortInfo(float, int, int, int, const zeus::CColor&, const zeus::CColor&);
+        CMapObjectSortInfo(float zDist, int wldIdx, int hexIdx, int surfIdx,
-        zeus::CColor GetOutlineColor() const;
+                           const zeus::CColor& surf, const zeus::CColor& outline)
-        zeus::CColor GetSurfaceColor() const;
+        : x0_zDist(zDist), x4_wldIdx(wldIdx), x8_hexIdx(hexIdx), xc_surfIdx(surfIdx),
-        s32 GetObjectIndex() const;
+          x10_surfColor(surf), x14_outlineColor(outline) {}
-        s32 GetAreaIndex() const;
+        const zeus::CColor& GetOutlineColor() const { return x14_outlineColor; }
-        s32 GetWorldIndex() const;
+        const zeus::CColor& GetSurfaceColor() const { return x10_surfColor; }
-        float GetZDistance() const;
+        int GetObjectIndex() const { return xc_surfIdx; }
+        int GetAreaIndex() const { return x8_hexIdx; }
+        int GetWorldIndex() const { return x4_wldIdx; }
+        float GetZDistance() const { return x0_zDist; }
     };
 
     class CMapWorldData
@@ -62,10 +74,10 @@ public:
         ResId x10_worldAssetId;
         zeus::CTransform x14_transform;
         std::vector<zeus::CTransform> x44_hexagonXfs;
-        zeus::CColor x54_;
+        zeus::CColor x54_surfColorSelected;
-        zeus::CColor x58_ = zeus::CColor(1.0f, 0.0f, 1.0f);
+        zeus::CColor x58_outlineColorSelected = zeus::CColor(1.0f, 0.0f, 1.0f);
-        zeus::CColor x5c_ = zeus::CColor(1.0f, 0.0f, 1.0f);
+        zeus::CColor x5c_surfColorUnselected = zeus::CColor(1.0f, 0.0f, 1.0f);
-        zeus::CColor x60_ = zeus::CColor(1.0f, 0.0f, 1.0f);
+        zeus::CColor x60_outlineColorUnselected = zeus::CColor(1.0f, 0.0f, 1.0f);
         zeus::CVector3f x64_centerPoint = zeus::CVector3f::skZero;
     public:
         CMapWorldData(CInputStream& in, u32 version);
@@ -75,10 +87,10 @@ public:
         const zeus::CTransform& GetWorldTransform() const { return x14_transform; }
         const zeus::CTransform& GetMapAreaData(s32 idx) const { return x44_hexagonXfs[idx]; }
         u32 GetNumMapAreaDatas() const { return x44_hexagonXfs.size(); }
-        zeus::CColor GetOutlineColorUnselected() const;
+        const zeus::CColor& GetOutlineColorUnselected() const { return x60_outlineColorUnselected; }
-        zeus::CColor GetOutlineColorSelected() const;
+        const zeus::CColor& GetOutlineColorSelected() const { return x58_outlineColorSelected; }
-        zeus::CColor GetSurfaceColorUnselected() const;
+        const zeus::CColor& GetSurfaceColorUnselected() const { return x5c_surfColorUnselected; }
-        zeus::CColor GetSurfaceColorSelected() const;
+        const zeus::CColor& GetSurfaceColorSelected() const { return x54_surfColorSelected; }
     };
 
 private:

Runtime/AutoMapper/CMapWorld.cpp

@@ -23,7 +23,8 @@ CMapWorld::CMapWorld(CInputStream& in)
     for (u32 i=0 ; i<areaCount ; ++i)
     {
         ResId mapaId = in.readUint32Big();
-        x0_areas.emplace_back(mapaId, EMapAreaList::Unloaded, x0_areas.empty() ? nullptr : &x0_areas.back());
+        x0_areas.emplace_back(mapaId, EMapAreaList::Unloaded,
+                              x0_areas.empty() ? nullptr : &x0_areas.back());
     }
     x10_listHeads[2] = &x0_areas.back();
 }
@@ -174,7 +175,8 @@ void CMapWorld::Draw(const CMapWorld::CMapWorldDrawParms& parms, int curArea, in
     DrawAreas(parms, curArea, bfsInfos, inMapScreen);
 }
 
-void CMapWorld::DoBFS(const IWorld& wld, int startArea, int areaCount, float surfDepth, float outlineDepth,
+void CMapWorld::DoBFS(const IWorld& wld, int startArea, int areaCount,
+                      float surfDepth, float outlineDepth,
                       bool checkLoad, std::vector<CMapAreaBFSInfo>& bfsInfos) const
 {
     if (areaCount <= 0 || !IsMapAreaValid(wld, startArea, checkLoad))
@@ -240,7 +242,8 @@ void CMapWorld::DrawAreas(const CMapWorld::CMapWorldDrawParms& parms, int selAre
     {
         int thisArea = bfsInfo.GetAreaIndex();
         const CMapArea* mapa = GetMapArea(thisArea);
-        if (!mapa->GetIsVisibleToAutoMapper(mwInfo.IsWorldVisible(thisArea), mwInfo.IsAreaVisible(thisArea)))
+        if (!mapa->GetIsVisibleToAutoMapper(mwInfo.IsWorldVisible(thisArea),
+                                            mwInfo.IsAreaVisible(thisArea)))
             continue;
 
         float surfDepth = bfsInfo.GetSurfaceDrawDepth();
@@ -286,7 +289,8 @@ void CMapWorld::DrawAreas(const CMapWorld::CMapWorldDrawParms& parms, int selAre
         }
 
         zeus::CColor hintFlashColor =
-        zeus::CColor::lerp(zeus::CColor::skClear, zeus::CColor{1.f, 1.f, 1.f, 0.f}, parms.GetHintAreaFlashIntensity());
+        zeus::CColor::lerp(zeus::CColor::skClear, zeus::CColor{1.f, 1.f, 1.f, 0.f},
+                           parms.GetHintAreaFlashIntensity());
 
         zeus::CColor finalSurfColor, finalOutlineColor;
         if (thisArea == selArea && inMapScreen)
@@ -339,7 +343,8 @@ void CMapWorld::DrawAreas(const CMapWorld::CMapWorldDrawParms& parms, int selAre
                     for (int s=0 ; s<6 ; ++s)
                     {
                         zeus::CVector3f center = obj.BuildSurfaceCenterPoint(s);
-                        zeus::CVector3f pos = modelView * (CMapArea::GetAreaPostTranslate(parms.GetWorld(), thisArea) + center);
+                        zeus::CVector3f pos = modelView *
+                            (CMapArea::GetAreaPostTranslate(parms.GetWorld(), thisArea) + center);
                         sortInfos.emplace_back(pos.y, thisArea, CMapObjectSortInfo::EObjectCode::DoorSurface, si+s,
                                                zeus::CColor{1.f, 0.f, 1.f, 1.f}, zeus::CColor{1.f, 0.f, 1.f, 1.f});
                     }
@@ -347,17 +352,69 @@ void CMapWorld::DrawAreas(const CMapWorld::CMapWorldDrawParms& parms, int selAre
                 }
             }
 
-            zeus::CVector3f pos = modelView * (obj.GetTransform().origin + CMapArea::GetAreaPostTranslate(parms.GetWorld(), thisArea));
+            zeus::CVector3f pos = modelView * (obj.GetTransform().origin +
+                                               CMapArea::GetAreaPostTranslate(parms.GetWorld(), thisArea));
             sortInfos.emplace_back(pos.y, thisArea, doorType ? CMapObjectSortInfo::EObjectCode::Door :
                                                                CMapObjectSortInfo::EObjectCode::Object,
                                    i, zeus::CColor{1.f, 0.f, 1.f, 1.f}, zeus::CColor{1.f, 0.f, 1.f, 1.f});
         }
     }
 
-    if (sortInfos.empty())
+    std::sort(sortInfos.begin(), sortInfos.end(),
-        return;
+    [](const CMapObjectSortInfo& a, const CMapObjectSortInfo& b)
+    {
+        return a.GetZDistance() < b.GetZDistance();
+    });
 
-    /* TODO: Finish */
+    int lastAreaIdx = -1;
+    CMapObjectSortInfo::EObjectCode lastType = CMapObjectSortInfo::EObjectCode::Invalid;
+    for (const CMapObjectSortInfo& info : sortInfos)
+    {
+        const CMapArea* mapa = GetMapArea(info.GetAreaIndex());
+        zeus::CTransform areaPostXf = mapa->GetAreaPostTransform(parms.GetWorld(), info.GetAreaIndex());
+        if (info.GetObjectCode() == CMapObjectSortInfo::EObjectCode::Surface)
+        {
+            const CMapArea::CMapAreaSurface& surf = mapa->GetSurface(info.GetLocalObjectIndex());
+            zeus::CColor color(std::max(0.f, (-parms.GetCameraTransform().basis[1]).dot(
+                areaPostXf.rotate(surf.GetNormal()))) * g_tweakAutoMapper->GetMapSurfaceNormColorLinear() +
+                g_tweakAutoMapper->GetMapSurfaceNormColorConstant());
+            color *= info.GetSurfaceColor();
+            if (lastAreaIdx != info.GetAreaIndex() || lastType != CMapObjectSortInfo::EObjectCode::Surface)
+                CGraphics::SetModelMatrix(parms.GetPlaneProjectionTransform() * areaPostXf);
+            surf.Draw(mapa->GetVertices(), color, info.GetOutlineColor(), parms.GetOutlineWidthScale());
+        }
+        else if (info.GetObjectCode() == CMapObjectSortInfo::EObjectCode::Door ||
+                 info.GetObjectCode() == CMapObjectSortInfo::EObjectCode::Object)
+        {
+            const CMappableObject& mapObj = mapa->GetMappableObject(info.GetLocalObjectIndex());
+            zeus::CTransform objXf =
+                zeus::CTransform::Translate(CMapArea::GetAreaPostTranslate(parms.GetWorld(), info.GetAreaIndex())) *
+                mapObj.GetTransform();
+            if (info.GetObjectCode() == CMapObjectSortInfo::EObjectCode::Door)
+            {
+                CGraphics::SetModelMatrix(parms.GetPlaneProjectionTransform() * objXf);
+            }
+            else
+            {
+                CGraphics::SetModelMatrix(parms.GetPlaneProjectionTransform() * objXf *
+                    zeus::CTransform(parms.GetCameraTransform().buildMatrix3f() *
+                    zeus::CMatrix3f(parms.GetObjectScale())));
+            }
+            mapObj.Draw(selArea, mwInfo, parms.GetAlpha(), lastType != info.GetObjectCode());
+        }
+        else if (info.GetObjectCode() == CMapObjectSortInfo::EObjectCode::DoorSurface)
+        {
+            const CMappableObject& mapObj = mapa->GetMappableObject(info.GetLocalObjectIndex() / 6);
+            zeus::CTransform objXf = parms.GetPlaneProjectionTransform() *
+                                     zeus::CTransform::Translate(CMapArea::GetAreaPostTranslate(
+                                     parms.GetWorld(), info.GetAreaIndex())) * mapObj.GetTransform();
+            CGraphics::SetModelMatrix(objXf);
+            mapObj.DrawDoorSurface(selArea, mwInfo, parms.GetAlpha(), info.GetLocalObjectIndex() % 6,
+                                   lastType != info.GetObjectCode());
+        }
+        lastAreaIdx = info.GetAreaIndex();
+        lastType = info.GetObjectCode();
+    }
 }
 
 struct Support
@@ -696,14 +753,40 @@ void CMapWorld::RecalculateWorldSphere(const CMapWorldInfo& mwInfo, const IWorld
     }
 
     Circle circle = MinCircle(coords);
-    const_cast<CMapWorld*>(this)->x3c_ = circle.x8_radius;
+    const_cast<CMapWorld*>(this)->x3c_worldSphereRadius = circle.x8_radius;
-    const_cast<CMapWorld*>(this)->x30_ = zeus::CVector3f(circle.x0_point.x, circle.x0_point.y, (zMin + zMax) * 0.5f);
+    const_cast<CMapWorld*>(this)->x30_worldSpherePoint =
-    const_cast<CMapWorld*>(this)->x40_ = (zMax - zMin) * 0.5f;
+        zeus::CVector3f(circle.x0_point.x, circle.x0_point.y, (zMin + zMax) * 0.5f);
+    const_cast<CMapWorld*>(this)->x40_worldSphereHalfDepth = (zMax - zMin) * 0.5f;
 }
 
-zeus::CVector3f CMapWorld::ConstrainToWorldVolume(const zeus::CVector3f&, const zeus::CVector3f&) const
+zeus::CVector3f CMapWorld::ConstrainToWorldVolume(const zeus::CVector3f& point, const zeus::CVector3f& lookVec) const
 {
-    return {};
+    zeus::CVector3f ret = point;
+    if (std::fabs(lookVec.z) > FLT_EPSILON)
+    {
+        float f2 = point.z - (x40_worldSphereHalfDepth + x30_worldSpherePoint.z);
+        float f1 = point.z - (x30_worldSpherePoint.z - x40_worldSphereHalfDepth);
+        if (f2 > 0.f)
+            ret = point + lookVec * (-f2 / lookVec.z);
+        else if (f1 < 0.f)
+            ret = point + lookVec * (-f1 / lookVec.z);
+    }
+    else
+    {
+        ret.z = zeus::clamp(x30_worldSpherePoint.z - x40_worldSphereHalfDepth, ret.z,
+                            x40_worldSphereHalfDepth + x30_worldSpherePoint.z);
+    }
+
+    zeus::CVector2f tmp(x30_worldSpherePoint.x, x30_worldSpherePoint.y);
+    zeus::CVector2f vec2 = zeus::CVector2f(point.x, point.y) - tmp;
+    if (vec2.magnitude() > x3c_worldSphereRadius)
+    {
+        tmp += vec2.normalized() * x3c_worldSphereRadius;
+        ret.x = tmp.x;
+        ret.y = tmp.y;
+    }
+
+    return ret;
 }
 
 void CMapWorld::ClearTraversedFlags() const

Runtime/AutoMapper/CMapWorld.hpp

@@ -49,6 +49,7 @@ public:
     public:
         enum class EObjectCode
         {
+            Invalid = -1,
             Object = 1 << 16,
             DoorSurface = 2 << 16,
             Door = 3 << 16,
@@ -135,18 +136,20 @@ public:
         float GetAlphaSurfaceUnvisited() const { return x8_alphaSurfUnvisited; }
         float GetAlphaOutlineVisited() const { return x4_alphaOlVisited; }
         float GetAlphaSurfaceVisited() const { return x0_alphaSurfVisited; }
+        float GetAlpha() const { return x10_alpha; }
         const CMapWorldInfo& GetMapWorldInfo() const { return x28_mwInfo; }
         const CStateManager& GetStateManager() const { return x18_mgr; }
         bool GetIsSortDoorSurfaces() const { return x38_sortDoorSurfs; }
+        float GetObjectScale() const { return x34_objectScale; }
     };
 
 private:
     std::vector<CMapAreaData> x0_areas;
     rstl::reserved_vector<CMapAreaData*, 3> x10_listHeads;
     std::vector<bool> x20_traversed;
-    zeus::CVector3f x30_;
+    zeus::CVector3f x30_worldSpherePoint;
-    float x3c_ = 0.f;
+    float x3c_worldSphereRadius = 0.f;
-    float x40_ = 0.f;
+    float x40_worldSphereHalfDepth = 0.f;
 public:
     CMapWorld(CInputStream&);
     u32 GetNumAreas() const { return x0_areas.size(); }

Runtime/Graphics/Shaders/CMapSurfaceShader.cpp

@@ -14,9 +14,10 @@ CMapSurfaceShader::CMapSurfaceShader(boo::IGraphicsDataFactory::Context& ctx,
 
 void CMapSurfaceShader::draw(const zeus::CColor& color, u32 start, u32 count)
 {
-    m_uniform.mtx = CGraphics::GetPerspectiveProjectionMatrix(true) * CGraphics::g_GXModelView.toMatrix4f();
+    Uniform uniform = {
-    m_uniform.color = color;
+        CGraphics::GetPerspectiveProjectionMatrix(true) * CGraphics::g_GXModelView.toMatrix4f(), color
-    m_uniBuf->load(&m_uniform, sizeof(m_uniform));
+    };
+    m_uniBuf->load(&uniform, sizeof(uniform));
     CGraphics::SetShaderDataBinding(m_dataBind);
     CGraphics::DrawArrayIndexed(start, count);
 }

Runtime/Graphics/Shaders/CMapSurfaceShader.hpp

@@ -19,7 +19,6 @@ class CMapSurfaceShader
         zeus::CColor color;
     };
 
-    Uniform m_uniform;
     boo::IGraphicsBufferD* m_uniBuf;
     boo::IGraphicsBufferS* m_vbo;
     boo::IGraphicsBufferS* m_ibo;