Ticket #2337: Culling.patch

source/graphics/Camera.cpp

@@ -126 +126 @@
     m_ViewFrustum.m_aPlanes[5].m_Norm.Y = -scissor[0].Z*MatFinal._42 + MatFinal._32;
     m_ViewFrustum.m_aPlanes[5].m_Norm.Z = -scissor[0].Z*MatFinal._43 + MatFinal._33;
     m_ViewFrustum.m_aPlanes[5].m_Dist   = -scissor[0].Z*MatFinal._44 + MatFinal._34;
+
+    for (size_t i = 0; i < 6; ++i)
+        m_ViewFrustum.m_aPlanes[i].Normalize();
 }
 
 void CCamera::ClipFrustum(const CPlane& clipPlane)
 {
-    m_ViewFrustum.AddPlane(clipPlane);
+    CPlane normClipPlane = clipPlane;
+    normClipPlane.Normalize();
+    m_ViewFrustum.AddPlane(normClipPlane);
 }
 
 void CCamera::SetViewPort(const SViewPort& viewport)

source/graphics/Frustum.cpp

@@ -93 +93 @@
     }
     return false;
 }
+
 bool CFrustum::IsSphereVisible (const CVector3D &center, float radius) const
 {
-    for (size_t i=0; i<m_NumPlanes; i++)
+    for (size_t i = 0; i < m_NumPlanes; i++)
     {
-        float Dist = m_aPlanes[i].DistanceToPlane (center);
-        
-        //is it behind the plane
-        if (Dist < 0)
-        {
-            //if non of it falls in front its outside the
-            //frustum
-            if (-Dist > radius)
-                return false;
-        }
+        float Dist = m_aPlanes[i].DistanceToPlane(center);
+        // If none of the sphere is in front of the plane, then
+        // it is outside the frustum
+        if (-Dist > radius)
+            return false;
     }
 
     return true;
 }
 
-
 bool CFrustum::IsBoxVisible (const CVector3D &position,const CBoundingBoxAligned &bounds) const
 {
     //basically for every plane we calculate the furthest point

source/graphics/GameView.cpp

@@ -486 +486 @@
         m->CullCamera.SetProjection(m->ViewNear, m->ViewFar, GetCullFOV());
         m->CullCamera.UpdateFrustum();
     }
+    m->ViewCamera.UpdateFrustum();
     g_Renderer.SetSceneCamera(m->ViewCamera, m->CullCamera);
 
     CheckLightEnv();
@@ -1055 +1056 @@
 
 float CGameView::GetCullFOV() const
 {
-    return m->ViewFOV + DEGTORAD(6.0f); //add 6 degrees to the default FOV for use with the culling frustum;
+    // XXXX
+    return m->ViewFOV;
 }
 
 void CGameView::SetCameraProjection()

source/graphics/MapReader.cpp

@@ -131 +131 @@
         RegMemFun(this, &CMapReader::UnpackMap, L"CMapReader::UnpackMap", 1200);
 
     // read the corresponding XML file
-    RegMemFun(this, &CMapReader::ReadXML, L"CMapReader::ReadXML", 5800);
+    RegMemFun(this, &CMapReader::ReadXML, L"CMapReader::ReadXML", 50);
 
-    // apply data to the world
+    // apply terrain data to the world
+    RegMemFun(this, &CMapReader::ApplyTerrainData, L"CMapReader::ApplyTerrainData", 5);
+    
+    // read entities
+    RegMemFun(this, &CMapReader::ReadXMLEntities, L"CMapReader::ReadXMLEntities", 5800);
+    
+    // apply misc data to the world
     RegMemFun(this, &CMapReader::ApplyData, L"CMapReader::ApplyData", 5);
 
     // load map settings script (must be done after reading map)
@@ -189 +195 @@
     // parse RMS results into camera settings
     RegMemFun(this, &CMapReader::ParseCamera, L"CMapReader::ParseCamera", 5);
 
+    // apply terrain data to the world
+    RegMemFun(this, &CMapReader::ApplyTerrainData, L"CMapReader::ApplyTerrainData", 5);
+
     // parse RMS results into entities
     RegMemFun(this, &CMapReader::ParseEntities, L"CMapReader::ParseEntities", 1000);
 
-    // apply data to the world
+    // apply misc data to the world
     RegMemFun(this, &CMapReader::ApplyData, L"CMapReader::ApplyData", 5);
 
     // load map settings script (must be done after reading map)
@@ -264 +273 @@
     return 0;
 }
 
-// ApplyData: take all the input data, and rebuild the scene from it
-int CMapReader::ApplyData()
+int CMapReader::ApplyTerrainData()
 {
     if (m_PatchesPerSide == 0)
     {
@@ -295 +303 @@
             }
         }
     }
+    
+    CmpPtr<ICmpTerrain> cmpTerrain(*pSimContext, SYSTEM_ENTITY);
+    if (cmpTerrain)
+        cmpTerrain->ReloadTerrain();
+    
+    return 0;
+}
+
+// ApplyData: take all the input data, and rebuild the scene from it
+int CMapReader::ApplyData()
+{
 
     // copy over the lighting parameters
     if (pLightEnv)
@@ -327 +346 @@
         }
     }
 
-    CmpPtr<ICmpTerrain> cmpTerrain(*pSimContext, SYSTEM_ENTITY);
-    if (cmpTerrain)
-        cmpTerrain->ReloadTerrain();
-
     return 0;
 }
 
@@ -398 +413 @@
 
     CStr ReadScriptSettings();
 
+    // read everything except for entities
+    void ReadXML();
+
     // return semantics: see Loader.cpp!LoadFunc.
-    int ProgressiveRead();
+    int ProgressiveReadEntities();
 
 private:
     CXeromyces xmb_file;
@@ -1071 +1089 @@
     return 0;
 }
 
-int CXMLReader::ProgressiveRead()
+void CXMLReader::ReadXML()
 {
-    // yield after this time is reached. balances increased progress bar
-    // smoothness vs. slowing down loading.
-    const double end_time = timer_Time() + 200e-3;
-
-    int ret;
-
-    while (node_idx < nodes.Count)
+    for (int i = 0; i < nodes.Count; ++i)
     {
-        XMBElement node = nodes.Item(node_idx);
+        XMBElement node = nodes.Item(i);
         CStr name = xmb_file.GetElementString(node.GetNodeName());
         if (name == "Terrain")
         {
@@ -1097 +1109 @@
         }
         else if (name == "ScriptSettings")
         {
-            //Already loaded - this is to prevent an assertion
+            // Already loaded - this is to prevent an assertion
         }
         else if (name == "Entities")
         {
-            if (!m_MapReader.m_SkipEntities)
-            {
-                ret = ReadEntities(node, end_time);
-                if (ret != 0)   // error or timed out
-                    return ret;
-            }
+            // Handled by ProgressiveReadEntities instead
         }
         else if (name == "Paths")
         {
@@ -1126 +1133 @@
             debug_printf(L"Invalid XML element in map file: %hs\n", name.c_str());
             debug_warn(L"Invalid map XML data");
         }
+               }
+    }
 
+int CXMLReader::ProgressiveReadEntities()
+{
+    // yield after this time is reached. balances increased progress bar
+    // smoothness vs. slowing down loading.
+    const double end_time = timer_Time() + 200e-3;
+    
+    int ret;
+    
+    while (node_idx < nodes.Count)
+    {
+        XMBElement node = nodes.Item(node_idx);
+        CStr name = xmb_file.GetElementString(node.GetNodeName());
+        if (name == "Entities")
+        {
+            if (!m_MapReader.m_SkipEntities)
+            {
+                ret = ReadEntities(node, end_time);
+                if (ret != 0)   // error or timed out
+                    return ret;
+            }
+        }
         node_idx++;
     }
-
+    
     return 0;
 }
 
@@ -1167 +1197 @@
     return 0;
 }
 
-// progressive
 int CMapReader::ReadXML()
 {
     if (!xml_reader)
         xml_reader = new CXMLReader(filename_xml, *this);
+    
+    xml_reader->ReadXML();
+    
+    return 0;
+}
 
-    int ret = xml_reader->ProgressiveRead();
+// progressive
+int CMapReader::ReadXMLEntities()
+{
+    if (!xml_reader)
+        xml_reader = new CXMLReader(filename_xml, *this);
+    
+    int ret = xml_reader->ProgressiveReadEntities();
     // finished or failed
     if (ret <= 0)
     {

source/graphics/MapReader.h

@@ -79 +79 @@
 
     // ApplyData: take all the input data, and rebuild the scene from it
     int ApplyData();
+    int ApplyTerrainData();
 
-    // ReadXML: read some other data (entities, etc) in XML format
+    // read some misc data from the XML file
     int ReadXML();
+    
+    // read entity data from the XML file
+    int ReadXMLEntities();
 
     // clean up everything used during delayed load
     int DelayLoadFinished();

source/graphics/Overlay.h

@@ -154 +154 @@
     CColor m_Color;
 };
 
+struct SOverlaySphere
+{
+    SOverlaySphere() : m_Radius(0) { }
+    
+    CVector3D m_Center;
+    float m_Radius;
+    CColor m_Color;
+};
+
 // TODO: OverlayText
 
 #endif // INCLUDED_GRAPHICS_OVERLAY

source/maths/BoundingBoxAligned.h

@@ -54 +54 @@
      * computing this result, and then taking the axis-aligned bounding boxes from the result again.
      */
     void Transform(const CMatrix3D& m, CBoundingBoxOriented& result) const;
-
+    
+    /**
+     * Translates these bounds by @p v, and writes the result to @p result.
+     */
+    void Translate(const CVector3D& v, CBoundingBoxAligned& result) const
+    {
+        result.m_Data[0] = m_Data[0] + v;
+        result.m_Data[1] = m_Data[1] + v;
+    }
+    
     CVector3D& operator[](int index) { return m_Data[index]; }
     const CVector3D& operator[](int index) const { return m_Data[index]; }
 

source/ps/CStrInternStatic.h

@@ -107 +107 @@
 X(normalMap)
 X(normalMap2)
 X(objectColor)
+X(overlay_solid)
 X(particle)
 X(particle_solid)
 X(playerColor)

source/renderer/OverlayRenderer.cpp

@@ -88 +88 @@
     std::vector<SOverlayTexturedLine*> texlines;
     std::vector<SOverlaySprite*> sprites;
     std::vector<SOverlayQuad*> quads;
+    std::vector<SOverlaySphere*> spheres;
 
     QuadBatchMap quadBatchMap;
 
@@ -223 +224 @@
     m->quads.push_back(overlay);
 }
 
+void OverlayRenderer::Submit(SOverlaySphere* overlay)
+{
+    m->spheres.push_back(overlay);
+}
+
 void OverlayRenderer::EndFrame()
 {
     m->lines.clear();
     m->texlines.clear();
     m->sprites.clear();
     m->quads.clear();
+    m->spheres.clear();
+    
     // this should leave the capacity unchanged, which is okay since it
     // won't be very large or very variable
     
@@ -384 +392 @@
 
     RenderTexturedOverlayLines();
     RenderQuadOverlays();
+    RenderSphereOverlays();
 }
 
 void OverlayRenderer::RenderTexturedOverlayLines()
@@ -629 +638 @@
     glDisable(GL_TEXTURE_2D);
 #endif
 }
+
+static void TessellateSphereFace(const CVector3D& a, u16 ai,
+                                 const CVector3D& b, u16 bi,
+                                 const CVector3D& c, u16 ci,
+                                 std::vector<float>& vertexes, std::vector<u16>& indexes, int level)
+{
+    if (level == 0)
+    {
+        indexes.push_back(ai);
+        indexes.push_back(bi);
+        indexes.push_back(ci);
+    }
+    else
+    {
+        CVector3D d = (a + b).Normalized();
+        CVector3D e = (b + c).Normalized();
+        CVector3D f = (c + a).Normalized();
+        int di = vertexes.size() / 3; vertexes.push_back(d.X); vertexes.push_back(d.Y); vertexes.push_back(d.Z);
+        int ei = vertexes.size() / 3; vertexes.push_back(e.X); vertexes.push_back(e.Y); vertexes.push_back(e.Z);
+        int fi = vertexes.size() / 3; vertexes.push_back(f.X); vertexes.push_back(f.Y); vertexes.push_back(f.Z);
+        TessellateSphereFace(a,ai, d,di, f,fi, vertexes, indexes, level-1);
+        TessellateSphereFace(d,di, b,bi, e,ei, vertexes, indexes, level-1);
+        TessellateSphereFace(f,fi, e,ei, c,ci, vertexes, indexes, level-1);
+        TessellateSphereFace(d,di, e,ei, f,fi, vertexes, indexes, level-1);
+    }
+}
+
+static void TessellateSphere(std::vector<float>& vertexes, std::vector<u16>& indexes, int level)
+{
+    /* Start with a tetrahedron, then tessellate */
+    float s = sqrtf(0.5f);
+#define VERT(a,b,c) vertexes.push_back(a); vertexes.push_back(b); vertexes.push_back(c);
+    VERT(-s,  0, -s);
+    VERT( s,  0, -s);
+    VERT( s,  0,  s);
+    VERT(-s,  0,  s);
+    VERT( 0, -1,  0);
+    VERT( 0,  1,  0);
+#define FACE(a,b,c) \
+TessellateSphereFace( \
+CVector3D(vertexes[a*3], vertexes[a*3+1], vertexes[a*3+2]), a, \
+CVector3D(vertexes[b*3], vertexes[b*3+1], vertexes[b*3+2]), b, \
+CVector3D(vertexes[c*3], vertexes[c*3+1], vertexes[c*3+2]), c, \
+vertexes, indexes, level);
+    FACE(0,4,1);
+    FACE(1,4,2);
+    FACE(2,4,3);
+    FACE(3,4,0);
+    FACE(1,5,0);
+    FACE(2,5,1);
+    FACE(3,5,2);
+    FACE(0,5,3);
+#undef FACE
+#undef VERT
+}
+
+void OverlayRenderer::RenderSphereOverlays()
+{
+    PROFILE3_GPU("overlays (spheres)");
+    
+    if (g_Renderer.GetRenderPath() != CRenderer::RP_SHADER)
+        return;
+    
+    if (m->spheres.empty())
+        return;
+    
+    glDisable(GL_TEXTURE_2D);
+    glEnable(GL_BLEND);
+    glDepthMask(0);
+    
+    glEnableClientState(GL_VERTEX_ARRAY);
+    
+    CShaderProgramPtr shader;
+    CShaderTechniquePtr tech;
+    
+    tech = g_Renderer.GetShaderManager().LoadEffect(str_overlay_solid);
+    tech->BeginPass();
+    shader = tech->GetShader();
+    
+    static std::vector<float> vertexes;
+    static std::vector<u16> indexes;
+    ONCE(TessellateSphere(vertexes, indexes, 3));
+    
+    shader->VertexPointer(3, GL_FLOAT, 0, &vertexes[0]);
+    
+    for (size_t i = 0; i < m->spheres.size(); ++i)
+    {
+        SOverlaySphere* sphere = m->spheres[i];
+        
+        CMatrix3D transform;
+        transform.SetIdentity();
+        transform.Scale(sphere->m_Radius, sphere->m_Radius, sphere->m_Radius);
+        transform.Translate(sphere->m_Center);
+        
+        shader->Uniform(str_transform, transform);
+        
+        shader->Uniform(str_color, sphere->m_Color);
+        
+        glDrawElements(GL_TRIANGLES, indexes.size(), GL_UNSIGNED_SHORT, &indexes[0]);
+        
+        g_Renderer.GetStats().m_DrawCalls++;
+        g_Renderer.GetStats().m_OverlayTris = indexes.size()/3;
+    }
+    
+    tech->EndPass();
+    
+    glDisableClientState(GL_VERTEX_ARRAY);
+    
+    glDepthMask(1);
+    glDisable(GL_BLEND);
+}

source/renderer/OverlayRenderer.h

@@ -24 +24 @@
 struct SOverlayTexturedLine;
 struct SOverlaySprite;
 struct SOverlayQuad;
+struct SOverlaySphere;
 class CCamera;
 
 struct OverlayRendererInternals;
@@ -74 +75 @@
      */
     void Submit(SOverlayQuad* overlay);
 
+    void Submit(SOverlaySphere* overlay);
+
     /**
      * Prepare internal data structures for rendering.
      * Must be called after all Submit calls for a frame, and before
@@ -132 +135 @@
      */
     void RenderQuadOverlays();
 
+    void RenderSphereOverlays();
+
 private:
     OverlayRendererInternals* m;
 };

source/renderer/Renderer.cpp

@@ -1127 +1127 @@
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // RenderReflections: render the water reflections to the reflection texture
-SScreenRect CRenderer::RenderReflections(const CShaderDefines& context, const CBoundingBoxAligned& scissor)
+void CRenderer::RenderReflections(Scene& scene, const CBoundingBoxAligned& scissor)
 {
     PROFILE3_GPU("water reflections");
 
+    CShaderDefines context = m->globalContext;
+
     WaterManager& wm = m->waterManager;
 
     // Remember old camera
@@ -1143 +1145 @@
     // of the view so we can see wavy reflections of slightly off-screen objects.
     m_ViewCamera.m_Orientation.Scale(1, -1, 1);
     m_ViewCamera.m_Orientation.Translate(0, 2*wm.m_WaterHeight, 0);
-    m_ViewCamera.UpdateFrustum(scissor);
     m_ViewCamera.ClipFrustum(CVector4D(0, 1, 0, -wm.m_WaterHeight));
 
     SViewPort vp;
@@ -1152 +1153 @@
     vp.m_X = 0;
     vp.m_Y = 0;
     m_ViewCamera.SetViewPort(vp);
-    m_ViewCamera.SetProjection(normalCamera.GetNearPlane(), normalCamera.GetFarPlane(), normalCamera.GetFOV()*1.05f); // Slightly higher than view FOV
     CMatrix3D scaleMat;
     scaleMat.SetScaling(m_Height/float(std::max(1, m_Width)), 1.0f, 1.0f);
     m_ViewCamera.m_ProjMat = scaleMat * m_ViewCamera.m_ProjMat;
@@ -1162 +1162 @@
     CVector4D camPlane(0, 1, 0, -wm.m_WaterHeight);
     SetObliqueFrustumClipping(camPlane);
 
+    // enumerate objects for our frustrum.
+    m_ViewCamera.UpdateFrustum();
+    CFrustum frustum = m_ViewCamera.GetFrustum();
+    scene.EnumerateObjects(frustum, this);
+    m->particleManager.RenderSubmit(*this, frustum);
+    
+    m->terrainRenderer.PrepareForRendering();
+    m->particleRenderer.PrepareForRendering(context);
+
+    
     // Save the model-view-projection matrix so the shaders can use it for projective texturing
     wm.m_ReflectionMatrix = m_ViewCamera.GetViewProjection();
 
-    SScreenRect screenScissor;
-    screenScissor.x1 = (GLint)floor((scissor[0].X*0.5f+0.5f)*vp.m_Width);
-    screenScissor.y1 = (GLint)floor((scissor[0].Y*0.5f+0.5f)*vp.m_Height);
-    screenScissor.x2 = (GLint)ceil((scissor[1].X*0.5f+0.5f)*vp.m_Width);
-    screenScissor.y2 = (GLint)ceil((scissor[1].Y*0.5f+0.5f)*vp.m_Height);
-
-    if (screenScissor.x1 < screenScissor.x2 && screenScissor.y1 < screenScissor.y2)
-    {
-        glEnable(GL_SCISSOR_TEST);
-        glScissor(screenScissor.x1, screenScissor.y1, screenScissor.x2 - screenScissor.x1, screenScissor.y2 - screenScissor.y1);
-
-        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
-
-        glFrontFace(GL_CW);
+    //glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    
+    // Save the post-processing framebuffer.
+    GLint fbo;
+    glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, &fbo);
+    
+    GLuint waterBuffer = 0;
+    pglGenFramebuffersEXT(1, &waterBuffer);
+    pglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, waterBuffer);
+    
+    glEnable(GL_TEXTURE_2D);
 
-        // Render sky, terrain and models
-        m->skyManager.RenderSky();
-        ogl_WarnIfError();
-        RenderPatches(context, &m_ViewCamera.GetFrustum());
-        ogl_WarnIfError();
-        RenderModels(context, &m_ViewCamera.GetFrustum());
-        ogl_WarnIfError();
-        RenderTransparentModels(context, TRANSPARENT_OPAQUE, &m_ViewCamera.GetFrustum());
-        ogl_WarnIfError();
+    glBindTexture(GL_TEXTURE_2D, wm.m_ReflectionTexture);
+    pglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, wm.m_ReflectionTexture, 0);
+    
+    glFrontFace(GL_CW);
 
-        glFrontFace(GL_CCW);
+    glClearColor(0.5f,0.5f,1.0f,0.0f);
+    glClear(GL_COLOR_BUFFER_BIT);
 
-        glDisable(GL_SCISSOR_TEST);
+    
+    // Render sky, terrain and models
+    m->skyManager.RenderSky();
+    ogl_WarnIfError();
+    RenderPatches(context, &m_ViewCamera.GetFrustum());
+    ogl_WarnIfError();
+    RenderModels(context, &m_ViewCamera.GetFrustum());
+    ogl_WarnIfError();
+    RenderTransparentModels(context, TRANSPARENT_OPAQUE, &m_ViewCamera.GetFrustum());
+    ogl_WarnIfError();
+    
+    glFrontFace(GL_CCW);
 
-        // Copy the image to a texture
-        pglActiveTextureARB(GL_TEXTURE0);
-        glEnable(GL_TEXTURE_2D);
-        glBindTexture(GL_TEXTURE_2D, wm.m_ReflectionTexture);
-        glCopyTexSubImage2D(GL_TEXTURE_2D, 0,
-                screenScissor.x1, screenScissor.y1,
-                screenScissor.x1, screenScissor.y1,
-                screenScissor.x2 - screenScissor.x1, screenScissor.y2 - screenScissor.y1);
-    }
+    // rebind post-processing frambuffer.
+    pglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
 
     // Reset old camera
     m_ViewCamera = normalCamera;
     m->SetOpenGLCamera(m_ViewCamera);
-
-    return screenScissor;
 }
 
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // RenderRefractions: render the water refractions to the refraction texture
-SScreenRect CRenderer::RenderRefractions(const CShaderDefines& context, const CBoundingBoxAligned &scissor)
+void CRenderer::RenderRefractions(const CBoundingBoxAligned &scissor)
 {
     PROFILE3_GPU("water refractions");
 
+    CShaderDefines context = m->globalContext;
+    
     WaterManager& wm = m->waterManager;
 
     // Remember old camera
@@ -1249 +1256 @@
     // Save the model-view-projection matrix so the shaders can use it for projective texturing
     wm.m_RefractionMatrix = m_ViewCamera.GetViewProjection();
 
-    SScreenRect screenScissor;
-    screenScissor.x1 = (GLint)floor((scissor[0].X*0.5f+0.5f)*vp.m_Width);
-    screenScissor.y1 = (GLint)floor((scissor[0].Y*0.5f+0.5f)*vp.m_Height);
-    screenScissor.x2 = (GLint)ceil((scissor[1].X*0.5f+0.5f)*vp.m_Width);
-    screenScissor.y2 = (GLint)ceil((scissor[1].Y*0.5f+0.5f)*vp.m_Height);
-    if (screenScissor.x1 < screenScissor.x2 && screenScissor.y1 < screenScissor.y2)
-    {
-        glEnable(GL_SCISSOR_TEST);
-        glScissor(screenScissor.x1, screenScissor.y1, screenScissor.x2 - screenScissor.x1, screenScissor.y2 - screenScissor.y1);
-
-        glClearColor(0.5f, 0.5f, 0.5f, 1.0f);       // a neutral gray to blend in with shores
-        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
-
-        // Render terrain and models
-        RenderPatches(context, &m_ViewCamera.GetFrustum());
-        ogl_WarnIfError();
-        RenderModels(context, &m_ViewCamera.GetFrustum());
-        ogl_WarnIfError();
-        RenderTransparentModels(context, TRANSPARENT_OPAQUE, &m_ViewCamera.GetFrustum());
-        ogl_WarnIfError();
-
-        glDisable(GL_SCISSOR_TEST);
-
-        // Copy the image to a texture
-        pglActiveTextureARB(GL_TEXTURE0);
-        glEnable(GL_TEXTURE_2D);
-        glBindTexture(GL_TEXTURE_2D, wm.m_RefractionTexture);
-        glCopyTexSubImage2D(GL_TEXTURE_2D, 0,
-                screenScissor.x1, screenScissor.y1,
-                screenScissor.x1, screenScissor.y1,
-                screenScissor.x2 - screenScissor.x1, screenScissor.y2 - screenScissor.y1);
-    }
+    //glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    
+    // Save the post-processing framebuffer.
+    GLint fbo;
+    glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, &fbo);
+    
+    GLuint waterBuffer = 0;
+    pglGenFramebuffersEXT(1, &waterBuffer);
+    pglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, waterBuffer);
+    
+    glBindTexture(GL_TEXTURE_2D, wm.m_RefractionTexture);
+    pglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, wm.m_RefractionTexture, 0);
+    
+    glClearColor(0.5f,0.5f,1.0f,0.0f);
+    glClear(GL_COLOR_BUFFER_BIT);
+    
+    glEnable(GL_TEXTURE_2D);
+    
+    // Render sky, terrain and models
+    m->skyManager.RenderSky();
+    ogl_WarnIfError();
+    RenderPatches(context, &m_ViewCamera.GetFrustum());
+    ogl_WarnIfError();
+    RenderModels(context, &m_ViewCamera.GetFrustum());
+    ogl_WarnIfError();
+    RenderTransparentModels(context, TRANSPARENT_OPAQUE, &m_ViewCamera.GetFrustum());
+    ogl_WarnIfError();
+    
+    // rebind post-processing frambuffer.
+    pglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
+    glBindTexture(GL_TEXTURE_2D, 0);
 
     // Reset old camera
     m_ViewCamera = normalCamera;
     m->SetOpenGLCamera(m_ViewCamera);
-
-    return screenScissor;
 }
 
 
@@ -1429 +1433 @@
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // RenderSubmissions: force rendering of any batched objects
-void CRenderer::RenderSubmissions()
+void CRenderer::RenderSubmissions(const CBoundingBoxAligned& waterScissor)
 {
     PROFILE3("render submissions");
     
@@ -1474 +1478 @@
     }
 
     ogl_WarnIfError();
-
-    CBoundingBoxAligned waterScissor;
-    if (m_WaterManager->m_RenderWater)
-    {
-        waterScissor = m->terrainRenderer.ScissorWater(m_ViewCamera.GetViewProjection());
-        if (waterScissor.GetVolume() > 0 && m_WaterManager->WillRenderFancyWater())
-        {
-            PROFILE3_GPU("water scissor");
-            SScreenRect dirty = { 0, 0, 0, 0 };
-            if (m_Options.m_WaterRefraction && m_Options.m_WaterReflection)
-            {
-                SScreenRect reflectionScissor = RenderReflections(context, waterScissor);
-                SScreenRect refractionScissor = RenderRefractions(context, waterScissor);
-                dirty.x1 = std::min(reflectionScissor.x1, refractionScissor.x1);
-                dirty.y1 = std::min(reflectionScissor.y1, refractionScissor.y1);
-                dirty.x2 = std::max(reflectionScissor.x2, refractionScissor.x2);
-                dirty.y2 = std::max(reflectionScissor.y2, refractionScissor.y2);
-            }
-            else if (m_Options.m_WaterRefraction)
-            {
-                SScreenRect refractionScissor = RenderRefractions(context, waterScissor);
-                dirty.x1 = refractionScissor.x1;
-                dirty.y1 = refractionScissor.y1;
-                dirty.x2 = refractionScissor.x2;
-                dirty.y2 = refractionScissor.y2;
-            }
-            else if (m_Options.m_WaterReflection)
-            {
-                SScreenRect reflectionScissor = RenderReflections(context, waterScissor);
-                dirty.x1 = reflectionScissor.x1;
-                dirty.y1 = reflectionScissor.y1;
-                dirty.x2 = reflectionScissor.x2;
-                dirty.y2 = reflectionScissor.y2;
-            }
-            if (dirty.x1 < dirty.x2 && dirty.y1 < dirty.y2)
-            {
-                glEnable(GL_SCISSOR_TEST);
-                glScissor(dirty.x1, dirty.y1, dirty.x2 - dirty.x1, dirty.y2 - dirty.y1);
-                glClearColor(m_ClearColor[0], m_ClearColor[1], m_ClearColor[2], m_ClearColor[3]);
-                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
-                glDisable(GL_SCISSOR_TEST);
-            }
-        }
-    }
-
     if (m_Options.m_ShowSky)
     {
         m->skyManager.RenderSky();
@@ -1540 +1499 @@
     ogl_WarnIfError();
 
     // render water
-    if (m_WaterManager->m_RenderWater && g_Game && waterScissor.GetVolume() > 0)
+    if (m_WaterManager->m_RenderWater && g_Game && waterScissor.GetVolume() > 0.0f)
     {
         // render transparent stuff, but only the solid parts that can occlude block water
         RenderTransparentModels(context, TRANSPARENT_OPAQUE);
@@ -1729 +1688 @@
     m->overlayRenderer.Submit(overlay);
 }
 
+void CRenderer::Submit(SOverlaySphere* overlay)
+{
+    m->overlayRenderer.Submit(overlay);
+}
+
 void CRenderer::Submit(CModelDecal* decal)
 {
     m->terrainRenderer.Submit(decal);
@@ -1780 +1744 @@
 
     m->particleManager.RenderSubmit(*this, frustum);
 
+    CBoundingBoxAligned waterScissor;
+    waterScissor = m->terrainRenderer.ScissorWater(m_ViewCamera.GetViewProjection());
+
     ogl_WarnIfError();
 
-    RenderSubmissions();
+    RenderSubmissions(waterScissor);
+
+    RenderRefractions(waterScissor);
+    
+    // empty lists
+    m->terrainRenderer.EndFrame();
+    m->overlayRenderer.EndFrame();
+    m->particleRenderer.EndFrame();
+    
+    // Finish model renderers
+    m->Model.NormalSkinned->EndFrame();
+    m->Model.TranspSkinned->EndFrame();
+    if (m->Model.NormalUnskinned != m->Model.NormalSkinned)
+        m->Model.NormalUnskinned->EndFrame();
+    if (m->Model.TranspUnskinned != m->Model.TranspSkinned)
+        m->Model.TranspUnskinned->EndFrame();
+
+    ogl_WarnIfError();
+    
+    RenderReflections(scene, waterScissor);
 
     m_CurrentScene = NULL;
 }

source/renderer/Renderer.h

@@ -349 +349 @@
     void Submit(SOverlayQuad* overlay);
     void Submit(CModelDecal* decal);
     void Submit(CParticleEmitter* emitter);
+    void Submit(SOverlaySphere* overlay);
     void SubmitNonRecursive(CModel* model);
     //END: Implementation of SceneCollector
 
     // render any batched objects
-    void RenderSubmissions();
+    void RenderSubmissions(const CBoundingBoxAligned& waterScissor);
 
     // patch rendering stuff
     void RenderPatches(const CShaderDefines& context, const CFrustum* frustum = 0);
@@ -370 +371 @@
     void RenderShadowMap(const CShaderDefines& context);
 
     // render water reflection and refraction textures
-    SScreenRect RenderReflections(const CShaderDefines& context, const CBoundingBoxAligned& scissor);
-    SScreenRect RenderRefractions(const CShaderDefines& context, const CBoundingBoxAligned& scissor);
+    void RenderReflections(Scene& scene, const CBoundingBoxAligned& scissor);
+    void RenderRefractions(const CBoundingBoxAligned& scissor);
 
     // debugging
     void DisplayFrustum();

source/renderer/Scene.h

@@ -40 +40 @@
 struct SOverlayTexturedLine;
 struct SOverlaySprite;
 struct SOverlayQuad;
+struct SOverlaySphere;
 
 class SceneCollector;
 
@@ -110 +111 @@
     virtual void Submit(SOverlayQuad* overlay) = 0;
 
     /**
+     * Submit a sphere overlay.
+     */
+    virtual void Submit(SOverlaySphere* overlay) = 0;
+    
+    /**
      * Submit a terrain decal.
      */
     virtual void Submit(CModelDecal* decal) = 0;

source/simulation2/MessageTypes.h

@@ -27 +27 @@
 
 #include "simulation2/components/ICmpPathfinder.h"
 
+#include "maths/Vector3D.h"
+
 #define DEFAULT_MESSAGE_IMPL(name) \
     virtual int GetType() const { return MT_##name; } \
     virtual const char* GetScriptHandlerName() const { return "On" #name; } \
@@ -258 +260 @@
     entity_angle_t a;
 };
 
+class CMessageInterpolatedPositionChanged : public CMessage
+{
+    public:
+    DEFAULT_MESSAGE_IMPL(InterpolatedPositionChanged)
+    
+    CMessageInterpolatedPositionChanged(entity_id_t entity, bool inWorld, const CVector3D& pos0, const CVector3D& pos1) :
+    entity(entity), inWorld(inWorld), pos0(pos0), pos1(pos1)
+    {
+    }
+    
+    entity_id_t entity;
+    bool inWorld;
+    CVector3D pos0;
+    CVector3D pos1;
+};
+
 /**
  * Sent by CCmpUnitMotion during Update, whenever the motion status has changed
  * since the previous update.
@@ -277 +295 @@
 };
 
 /**
+ * Sent when water height has been changed.
+ */
+class CMessageWaterChanged : public CMessage
+{
+    public:
+    DEFAULT_MESSAGE_IMPL(WaterChanged)
+    
+    CMessageWaterChanged()
+    {
+    }
+};
+
+/**
  * Sent when terrain (texture or elevation) has been changed.
  */
 class CMessageTerrainChanged : public CMessage

source/simulation2/Simulation2.cpp

@@ -104 +104 @@
         componentManager.AddComponent(systemEntity, CID_TemplateManager, noParam);
 
         componentManager.AddComponent(systemEntity, CID_CommandQueue, noParam);
+        componentManager.AddComponent(systemEntity, CID_ModelRenderer, noParam);
         componentManager.AddComponent(systemEntity, CID_ObstructionManager, noParam);
         componentManager.AddComponent(systemEntity, CID_ParticleManager, noParam);
         componentManager.AddComponent(systemEntity, CID_Pathfinder, noParam);

source/simulation2/TypeList.h

@@ -42 +42 @@
 MESSAGE(Destroy)
 MESSAGE(OwnershipChanged)
 MESSAGE(PositionChanged)
+MESSAGE(InterpolatedPositionChanged)
 MESSAGE(MotionChanged)
 MESSAGE(RangeUpdate)
 MESSAGE(TerrainChanged)
+MESSAGE(WaterChanged)
 MESSAGE(TerritoriesChanged)
 MESSAGE(PathResult)
 MESSAGE(ValueModification)
@@ -90 +92 @@
 INTERFACE(Minimap)
 COMPONENT(Minimap)
 
+INTERFACE(ModelRenderer)
+COMPONENT(ModelRenderer)
+
 INTERFACE(Motion)
 COMPONENT(MotionBall)
 COMPONENT(MotionScripted)

source/simulation2/components/CCmpPosition.cpp

@@ -43 +43 @@
     {
         componentManager.SubscribeToMessageType(MT_TurnStart);
         componentManager.SubscribeToMessageType(MT_Interpolate);
+        componentManager.SubscribeToMessageType(MT_TerrainChanged);
+        componentManager.SubscribeToMessageType(MT_WaterChanged);
 
         // TODO: if this component turns out to be a performance issue, it should
         // be optimised by creating a new PositionStatic component that doesn't subscribe
@@ -59 +61 @@
         UPRIGHT = 0,
         PITCH = 1,
         PITCH_ROLL = 2,
-        ROLL=3,
+        ROLL = 3,
     } m_AnchorType;
 
-    bool m_Floating;
     float m_RotYSpeed; // maximum radians per second, used by InterpolatedRotY to follow RotY
 
+    bool m_Floating;
     // Dynamic state:
 
     bool m_InWorld;
     // m_LastX/Z contain the position from the start of the most recent turn
     // m_PrevX/Z conatain the position from the turn before that
+    bool m_RelativeToGround; // whether m_YOffset is relative to terrain/water plane, or an absolute height
     entity_pos_t m_X, m_Z, m_LastX, m_LastZ, m_PrevX, m_PrevZ; // these values contain undefined junk if !InWorld
     entity_pos_t m_YOffset, m_LastYOffset;
-    bool m_RelativeToGround; // whether m_YOffset is relative to terrain/water plane, or an absolute height
 
     entity_angle_t m_RotX, m_RotY, m_RotZ;
 
@@ -221 +223 @@
         m_InWorld = false;
 
         AdvertisePositionChanges();
+        AdvertiseInterpolatedPositionChanges();
     }
 
     virtual void MoveTo(entity_pos_t x, entity_pos_t z)
@@ -237 +240 @@
         }
 
         AdvertisePositionChanges();
+        AdvertiseInterpolatedPositionChanges();
     }
     
     virtual void MoveAndTurnTo(entity_pos_t x, entity_pos_t z, entity_angle_t ry)
@@ -254 +258 @@
         }
         
         AdvertisePositionChanges();
+        AdvertiseInterpolatedPositionChanges();
     }
 
     virtual void JumpTo(entity_pos_t x, entity_pos_t z)
@@ -268 +273 @@
         m_LastInterpolatedRotZ = m_InterpolatedRotZ;
 
         AdvertisePositionChanges();
+        AdvertiseInterpolatedPositionChanges();
     }
 
     virtual void SetHeightOffset(entity_pos_t dy)
@@ -284 +290 @@
         }
 
         AdvertisePositionChanges();
+        AdvertiseInterpolatedPositionChanges();
     }
 
     virtual entity_pos_t GetHeightOffset()
@@ -303 +310 @@
             m_LastYOffset = m_YOffset;
             m_YOffset = y;  
         }
+        
+        AdvertisePositionChanges();
+        AdvertiseInterpolatedPositionChanges();
     }
 
     virtual bool IsFloating()
@@ -495 +505 @@
         
         return m;
     }
+    
+    void GetInterpolatedPositions(CVector3D& pos0, CVector3D& pos1)
+    {
+        float baseY0 = 0;
+        float baseY1 = 0;
+        float x0 = m_LastX.ToFloat();
+        float z0 = m_LastZ.ToFloat();
+        float x1 = m_X.ToFloat();
+        float z1 = m_Z.ToFloat();
+        if (m_RelativeToGround)
+        {
+            CmpPtr<ICmpTerrain> cmpTerrain(GetSimContext(), SYSTEM_ENTITY);
+            if (cmpTerrain)
+            {
+                baseY0 = cmpTerrain->GetExactGroundLevel(x0, z0);
+                baseY1 = cmpTerrain->GetExactGroundLevel(x1, z1);
+            }
+            
+            if (m_Floating)
+            {
+                CmpPtr<ICmpWaterManager> cmpWaterManager(GetSimContext(), SYSTEM_ENTITY);
+                if (cmpWaterManager)
+                {
+                    baseY0 = std::max(baseY0, cmpWaterManager->GetExactWaterLevel(x0, z0));
+                    baseY1 = std::max(baseY1, cmpWaterManager->GetExactWaterLevel(x1, z1));
+                }
+            }
+        }
+        
+        float y0 = baseY0 + m_LastYOffset.ToFloat();
+        float y1 = baseY1 + m_YOffset.ToFloat();
+        
+        pos0 = CVector3D(x0, y0, z0);
+        pos1 = CVector3D(x1, y1, z1);
+    }
 
     virtual void HandleMessage(const CMessage& msg, bool UNUSED(global))
     {
@@ -558 +603 @@
 
             break;
         }
+        case MT_TerrainChanged:
+        case MT_WaterChanged:
+        {
+            AdvertiseInterpolatedPositionChanges();
+            break;
+        }
     }
 };
 
@@ -575 +626 @@
             GetSimContext().GetComponentManager().PostMessage(GetEntityId(), msg);
         }
     }
-
+    
+    void AdvertiseInterpolatedPositionChanges()
+    {
+        if (m_InWorld)
+        {
+            CVector3D pos0, pos1;
+            GetInterpolatedPositions(pos0, pos1);
+            
+            CMessageInterpolatedPositionChanged msg(GetEntityId(), true, pos0, pos1);
+            GetSimContext().GetComponentManager().PostMessage(GetEntityId(), msg);
+        }
+        else
+        {
+            CMessageInterpolatedPositionChanged msg(GetEntityId(), false, CVector3D(), CVector3D());
+            GetSimContext().GetComponentManager().PostMessage(GetEntityId(), msg);
+        }
+    }
+    
     void UpdateXZRotation()
     {
         if (!m_InWorld)

source/simulation2/components/CCmpRangeManager.cpp

@@ -1361 +1361 @@
             return VIS_VISIBLE;
 
         // Fogged if the 'retain in fog' flag is set, and in a non-visible explored region
-        if (los.IsExplored(i, j))
+        if (los.IsExplored(i, j, true))
         {
             CmpPtr<ICmpVision> cmpVision(ent);
             if (forceRetainInFog || (cmpVision && cmpVision->GetRetainInFog()))

source/simulation2/components/CCmpTerrain.cpp

@@ -144 +144 @@
     virtual void MakeDirty(i32 i0, i32 j0, i32 i1, i32 j1)
     {
         CMessageTerrainChanged msg(i0, j0, i1, j1);
-        GetSimContext().GetComponentManager().PostMessage(GetEntityId(), msg);
+        GetSimContext().GetComponentManager().BroadcastMessage(msg);
     }
 };
 

source/simulation2/components/CCmpVisualActor.cpp

@@ -23 +23 @@
 #include "simulation2/MessageTypes.h"
 
 #include "ICmpFootprint.h"
+#include "ICmpModelRenderer.h"
 #include "ICmpOwnership.h"
 #include "ICmpPosition.h"
 #include "ICmpRangeManager.h"
@@ -40 +41 @@
 #include "graphics/Unit.h"
 #include "graphics/UnitAnimation.h"
 #include "graphics/UnitManager.h"
+#include "maths/BoundingSphere.h"
 #include "maths/Matrix3D.h"
 #include "maths/Vector3D.h"
 #include "ps/CLogger.h"
@@ -54 +56 @@
     static void ClassInit(CComponentManager& componentManager)
     {
         componentManager.SubscribeToMessageType(MT_Update_Final);
-        componentManager.SubscribeToMessageType(MT_Interpolate);
-        componentManager.SubscribeToMessageType(MT_RenderSubmit);
+        //componentManager.SubscribeToMessageType(MT_Interpolate);
+        componentManager.SubscribeToMessageType(MT_InterpolatedPositionChanged);
+        //componentManager.SubscribeToMessageType(MT_RenderSubmit);
         componentManager.SubscribeToMessageType(MT_OwnershipChanged);
-        componentManager.SubscribeGloballyToMessageType(MT_TerrainChanged);
+        componentManager.SubscribeToMessageType(MT_TerrainChanged);
+        componentManager.SubscribeToMessageType(MT_Destroy);
     }
 
     DEFAULT_COMPONENT_ALLOCATOR(VisualActor)
@@ -92 +96 @@
     /// Whether the visual actor has been rendered at least once.
     /// Necessary because the visibility update runs on simulation update,
     /// which may not occur immediately if the game starts paused.
-    bool m_PreviouslyRendered;
+    //bool m_PreviouslyRendered;
+    
+    bool m_VisibilityDirty;
+    
+    ICmpModelRenderer::tag_t m_ModelTag;
 
 public:
     static std::string GetSchema()
@@ -178 +186 @@
 
     virtual void Init(const CParamNode& paramNode)
     {
-        m_PreviouslyRendered = false;
+        // m_PreviouslyRendered = false;
+        m_VisibilityDirty = true;
         m_Unit = NULL;
         m_Visibility = ICmpRangeManager::VIS_HIDDEN;
         m_R = m_G = m_B = fixed::FromInt(1);
@@ -295 +304 @@
             Interpolate(msgData.deltaSimTime, msgData.offset);
             break;
         }
-        case MT_RenderSubmit:
-        {
-            const CMessageRenderSubmit& msgData = static_cast<const CMessageRenderSubmit&> (msg);
-            RenderSubmit(msgData.collector, msgData.frustum, msgData.culling);
-            break;
-        }
+        //case MT_RenderSubmit:
+        //{
+        //  const CMessageRenderSubmit& msgData = static_cast<const CMessageRenderSubmit&> (msg);
+        //  RenderSubmit(msgData.collector, msgData.frustum, msgData.culling);
+        //  break;
+        //}
         case MT_OwnershipChanged:
         {
             const CMessageOwnershipChanged& msgData = static_cast<const CMessageOwnershipChanged&> (msg);
@@ -313 +322 @@
             m_Unit->GetModel().SetTerrainDirty(msgData.i0, msgData.j0, msgData.i1, msgData.j1);
             break;
         }
+        case MT_InterpolatedPositionChanged:
+        {
+            const CMessageInterpolatedPositionChanged& msgData = static_cast<const CMessageInterpolatedPositionChanged&> (msg);
+            if (m_ModelTag.valid())
+            {
+                CmpPtr<ICmpModelRenderer> cmpModelRenderer(GetSimContext(), SYSTEM_ENTITY);
+                cmpModelRenderer->UpdateUnitPos(m_ModelTag, msgData.inWorld, msgData.pos0, msgData.pos1);
+            }
+            break;
+        }
+        case MT_Destroy:
+        {
+            if (m_ModelTag.valid())
+            {
+                CmpPtr<ICmpModelRenderer> cmpModelRenderer(GetSimContext(), SYSTEM_ENTITY);
+                cmpModelRenderer->RemoveUnit(m_ModelTag);
+                m_ModelTag = ICmpModelRenderer::tag_t();
+            }
+            break;
+        }
         }
     }
 
@@ -450 +479 @@
         m_G = g;
         m_B = b;
         UNUSED2(a); // TODO: why is this even an argument?
+
+        if (m_Unit)
+        {
+            CModelAbstract& model = m_Unit->GetModel();
+            model.SetShadingColor(CColor(m_R.ToFloat(), m_G.ToFloat(), m_B.ToFloat(), 1.0f));
+        }
     }
 
     virtual void SetVariable(std::string name, float value)
@@ -507 +542 @@
     void Update(fixed turnLength);
     void UpdateVisibility();
     void Interpolate(float frameTime, float frameOffset);
-    void RenderSubmit(SceneCollector& collector, const CFrustum& frustum, bool culling);
+    //void RenderSubmit(SceneCollector& collector, const CFrustum& frustum, bool culling);
 };
 
 REGISTER_COMPONENT_TYPE(VisualActor)
@@ -516 +551 @@
 
 void CCmpVisualActor::InitModel(const CParamNode& paramNode)
 {
-    if (GetSimContext().HasUnitManager())
+    if (!GetSimContext().HasUnitManager())
+        return;
+    
+    std::set<CStr> selections;
+    m_Unit = GetSimContext().GetUnitManager().CreateUnit(m_ActorName, GetActorSeed(), selections);
+    if (!m_Unit)
+        return;
+    
+    CModelAbstract& model = m_Unit->GetModel();
+    if (model.ToCModel())
     {
-        std::set<CStr> selections;
-        m_Unit = GetSimContext().GetUnitManager().CreateUnit(m_ActorName, GetActorSeed(), selections);
-        if (m_Unit)
-        {
-            CModelAbstract& model = m_Unit->GetModel();
-            if (model.ToCModel())
-            {
-                u32 modelFlags = 0;
-
-                if (paramNode.GetChild("SilhouetteDisplay").ToBool())
-                    modelFlags |= MODELFLAG_SILHOUETTE_DISPLAY;
-
-                if (paramNode.GetChild("SilhouetteOccluder").ToBool())
-                    modelFlags |= MODELFLAG_SILHOUETTE_OCCLUDER;
-
-                CmpPtr<ICmpVision> cmpVision(GetEntityHandle());
-                if (cmpVision && cmpVision->GetAlwaysVisible())
-                    modelFlags |= MODELFLAG_IGNORE_LOS;
-
-                model.ToCModel()->AddFlagsRec(modelFlags);
-            }
-
-            if (paramNode.GetChild("DisableShadows").IsOk())
-            {
-                if (model.ToCModel())
-                    model.ToCModel()->RemoveShadowsRec();
-                else if (model.ToCModelDecal())
-                    model.ToCModelDecal()->RemoveShadows();
-            }
-
-            // Initialize the model's selection shape descriptor. This currently relies on the component initialization order; the 
-            // Footprint component must be initialized before this component (VisualActor) to support the ability to use the footprint
-            // shape for the selection box (instead of the default recursive bounding box). See TypeList.h for the order in
-            // which components are initialized; if for whatever reason you need to get rid of this dependency, you can always just
-            // initialize the selection shape descriptor on-demand.
-            InitSelectionShapeDescriptor(paramNode);
+        u32 modelFlags = 0;
+        
+        if (paramNode.GetChild("SilhouetteDisplay").ToBool())
+        modelFlags |= MODELFLAG_SILHOUETTE_DISPLAY;
+        
+        if (paramNode.GetChild("SilhouetteOccluder").ToBool())
+        modelFlags |= MODELFLAG_SILHOUETTE_OCCLUDER;
+        
+        CmpPtr<ICmpVision> cmpVision(GetEntityHandle());
+        if (cmpVision && cmpVision->GetAlwaysVisible())
+        modelFlags |= MODELFLAG_IGNORE_LOS;
+        
+        model.ToCModel()->AddFlagsRec(modelFlags);
+    }
 
-            m_Unit->SetID(GetEntityId());
+    if (paramNode.GetChild("DisableShadows").IsOk())
+    {
+        if (model.ToCModel())
+        model.ToCModel()->RemoveShadowsRec();
+        else if (model.ToCModelDecal())
+        model.ToCModelDecal()->RemoveShadows();
+    }
+    
+    // Initialize the model's selection shape descriptor. This currently relies on the component initialization order; the
+    // Footprint component must be initialized before this component (VisualActor) to support the ability to use the footprint
+    // shape for the selection box (instead of the default recursive bounding box). See TypeList.h for the order in
+    // which components are initialized; if for whatever reason you need to get rid of this dependency, you can always just
+    // initialize the selection shape descriptor on-demand.
+    InitSelectionShapeDescriptor(paramNode);
+    
+    m_Unit->SetID(GetEntityId());
+    
+    model.SetShadingColor(CColor(m_R.ToFloat(), m_G.ToFloat(), m_B.ToFloat(), 1.0f));
+    
+    if (!m_ModelTag.valid())
+    {
+        CmpPtr<ICmpModelRenderer> cmpModelRenderer(GetSimContext(), SYSTEM_ENTITY);
+        if (cmpModelRenderer)
+        {
+            // TODO: account for props, animations
+            // TODO: use object bounds
+            CBoundingBoxAligned bounds = m_Unit->GetModel().GetWorldBoundsRec();
+            CBoundingSphere boundSphere = CBoundingSphere::FromSweptBox(bounds);
+            m_ModelTag = cmpModelRenderer->AddUnit(GetEntityHandle(), m_Unit, boundSphere);
         }
     }
 }
@@ -636 +686 @@
     if (!m_Unit)
         return;
 
-    std::set<CStr> selections;
-    CUnit* newUnit = GetSimContext().GetUnitManager().CreateUnit(m_ActorName, GetActorSeed(), selections);
-
-    if (!newUnit)
-        return;
-
     // Save some data from the old unit
     CColor shading = m_Unit->GetModel().GetShadingColor();
     player_id_t playerID = m_Unit->GetModel().GetPlayerID();
@@ -669 +713 @@
     m_Unit->GetModel().SetShadingColor(shading);
 
     m_Unit->GetModel().SetPlayerID(playerID);
+    
+    if (m_ModelTag.valid())
+    {
+        CmpPtr<ICmpModelRenderer> cmpModelRenderer(GetSimContext(), SYSTEM_ENTITY);
+        CBoundingBoxAligned bounds = m_Unit->GetModel().GetWorldBoundsRec();
+        CBoundingSphere boundSphere = CBoundingSphere::FromSweptBox(bounds);
+        cmpModelRenderer->UpdateUnit(m_ModelTag, m_Unit, boundSphere);
+    }
 }
 
 void CCmpVisualActor::Update(fixed UNUSED(turnLength))
 {
     if (m_Unit == NULL)
         return;
-
+    
+    if (m_ModelTag.valid())
+    {
+        CmpPtr<ICmpModelRenderer> cmpModelRenderer(GetSimContext(), SYSTEM_ENTITY);
+        if(cmpModelRenderer->isCulled(m_ModelTag))
+            return;
+    }
     UpdateVisibility();
-
     // If we're in the special movement mode, select an appropriate animation
     if (!m_AnimRunThreshold.IsZero())
     {
@@ -742 +799 @@
     }
     else
         m_Visibility = ICmpRangeManager::VIS_HIDDEN;
-
-    if (m_Visibility != oldVisibility)
+    
+    bool oldHidden = (oldVisibility == ICmpRangeManager::VIS_HIDDEN);
+    bool newHidden = (m_Visibility == ICmpRangeManager::VIS_HIDDEN);
+    if (oldHidden != newHidden)
     {
         // Change the visibility of the visual actor's selectable if it has one.
         CmpPtr<ICmpSelectable> cmpSelectable(GetEntityHandle());
         if (cmpSelectable)
-            cmpSelectable->SetVisibility(m_Visibility == ICmpRangeManager::VIS_HIDDEN ? false : true);
+        cmpSelectable->SetVisibility(!newHidden);
+        
+        if (m_ModelTag.valid())
+        {
+            CmpPtr<ICmpModelRenderer> cmpModelRenderer(GetSimContext(), SYSTEM_ENTITY);
+            cmpModelRenderer->UpdateUnitVisible(m_ModelTag, !newHidden);
+        }
     }
+    
+    m_VisibilityDirty = false;
 }
 
-void CCmpVisualActor::Interpolate(float frameTime, float frameOffset)
+void CCmpVisualActor::Interpolate(float frameTime, float UNUSED(frameOffset))
 {
     if (m_Unit == NULL)
         return;
 
+    if (m_VisibilityDirty)
+        UpdateVisibility();
+
+    if (m_ModelTag.valid())
+    {
+        CmpPtr<ICmpModelRenderer> cmpModelRenderer(GetSimContext(), SYSTEM_ENTITY);
+        if(cmpModelRenderer->isCulled(m_ModelTag))
+            return;
+    }
+    
+    m_Unit->UpdateModel(frameTime);
+
+    // If not hidden, then we need to set up some extra state for rendering
+    if (m_Visibility != ICmpRangeManager::VIS_HIDDEN)
+    {
+        m_Unit->GetModel().ValidatePosition();
+        m_Unit->GetModel().SetShadingColor(CColor(m_R.ToFloat(), m_G.ToFloat(), m_B.ToFloat(), 1.0f));
+    }
+
+    /*
     // Disable rendering of the unit if it has no position
     CmpPtr<ICmpPosition> cmpPosition(GetEntityHandle());
     if (!cmpPosition || !cmpPosition->IsInWorld())
@@ -791 +878 @@
             {
                 CVector3D pos = transform.GetTranslation();
                 float ground = cmpTerrain->GetExactGroundLevel(pos.X, pos.Z);
-                dy += std::max(0.f, pos.Y - ground);
+                dy = std::max(0.f, pos.Y - ground);
             }
 
             transform.Translate(0.0f, (m_ConstructionProgress.ToFloat() - 1.0f) * dy, 0.0f);
@@ -801 +888 @@
     CModelAbstract& model = m_Unit->GetModel();
 
     model.SetTransform(transform);
-    m_Unit->UpdateModel(frameTime);
-
-    // If not hidden, then we need to set up some extra state for rendering
-    if (m_Visibility != ICmpRangeManager::VIS_HIDDEN)
-    {
-        model.ValidatePosition();
-        model.SetShadingColor(CColor(m_R.ToFloat(), m_G.ToFloat(), m_B.ToFloat(), 1.0f));
-    }
+    */
 }
 
+/*
 void CCmpVisualActor::RenderSubmit(SceneCollector& collector, const CFrustum& frustum, bool culling)
 {
     if (m_Unit == NULL)
@@ -832 +913 @@
 
     collector.SubmitRecursive(&model);
 }
+ */

source/simulation2/components/CCmpWaterManager.cpp

@@ -103 +103 @@
 
         // Tell the terrain it'll need to recompute its cached render data
         GetSimContext().GetTerrain().MakeDirty(RENDERDATA_UPDATE_VERTICES);
+
+        CMessageWaterChanged msg;
+        GetSimContext().GetComponentManager().BroadcastMessage(msg);
     }
 
     virtual entity_pos_t GetWaterLevel(entity_pos_t UNUSED(x), entity_pos_t UNUSED(z))

source/simulation2/components/ICmpRangeManager.h

@@ -252 +252 @@
         /**
          * Returns whether the given vertex is explored (i.e. was (or still is) within a unit's LOS).
          */
-        inline bool IsExplored(ssize_t i, ssize_t j)
+        inline bool IsExplored(ssize_t i, ssize_t j, bool extended = false)
         {
             if (!(i >= 0 && j >= 0 && i < m_VerticesPerSide && j < m_VerticesPerSide))
                 return false;
@@ -261 +261 @@
             if ((m_Data[j*m_VerticesPerSide + i] & m_PlayerMask) & 0x55555555u)
                 return true;
             else
+            {
+                if (extended/*m_HighQual*/) // TODO: this should be a setting
+                {
+                    if (i > 0 && (m_Data[j*m_VerticesPerSide + i - 1] & m_PlayerMask) & 0x55555555u)
+                        return true;
+                    if (i < m_VerticesPerSide - 1 && (m_Data[j*m_VerticesPerSide + i + 1] & m_PlayerMask) & 0x55555555u)
+                        return true;
+                    if (j > 0 && (m_Data[(j-1)*m_VerticesPerSide + i] & m_PlayerMask) & 0x55555555u)
+                        return true;
+                    if (j < m_VerticesPerSide - 1 && (m_Data[(j+1)*m_VerticesPerSide + i] & m_PlayerMask) & 0x55555555u)
+                        return true;
+                }
                 return false;
+            }
         }
 
         /**

source/simulation2/scripting/MessageTypeConversions.cpp

@@ -216 +216 @@
 
 ////////////////////////////////
 
+jsval CMessageInterpolatedPositionChanged::ToJSVal(ScriptInterface& UNUSED(scriptInterface)) const
+{
+    LOGWARNING(L"CMessageInterpolatedPositionChanged::ToJSVal not implemented");
+    return JSVAL_VOID;
+}
+
+CMessage* CMessageInterpolatedPositionChanged::FromJSVal(ScriptInterface& UNUSED(scriptInterface), jsval UNUSED(val))
+{
+    LOGWARNING(L"CMessageInterpolatedPositionChanged::FromJSVal not implemented");
+    return NULL;
+}
+
+////////////////////////////////
+
+
 jsval CMessageMotionChanged::ToJSVal(ScriptInterface& scriptInterface) const
 {
     TOJSVAL_SETUP();
@@ -256 +271 @@
 
 ////////////////////////////////
 
+jsval CMessageWaterChanged::ToJSVal(ScriptInterface& scriptInterface) const
+{
+    TOJSVAL_SETUP();
+    return OBJECT_TO_JSVAL(obj);
+}
+
+CMessage* CMessageWaterChanged::FromJSVal(ScriptInterface& UNUSED(scriptInterface), jsval UNUSED(val))
+{
+    return new CMessageWaterChanged();
+}
+
+////////////////////////////////
+
+
 jsval CMessageTerritoriesChanged::ToJSVal(ScriptInterface& scriptInterface) const
 {
     TOJSVAL_SETUP();