CWater and CCloud basic implementation

Added rewritten implementation for CWater and CCloud
Won't link yet because of missing functions

1 files changed, 266 insertions, 1 deletions

diff --git a/src/graphics/engine/cloud.cpp b/src/graphics/engine/cloud.cpp
index d0e5ed8..e46b074 100644
--- a/src/graphics/engine/cloud.cpp
+++ b/src/graphics/engine/cloud.cpp
@@ -19,5 +19,270 @@
 
 #include "graphics/engine/cloud.h"
 
+#include "common/iman.h"
+#include "graphics/engine/engine.h"
+#include "graphics/engine/terrain.h"
+#include "math/geometry.h"
 
-// TODO implementation
+
+const int CLOUD_LINE_PREALLOCATE_COUNT = 100;
+
+const int DIMEXPAND = 4;    // extension of the dimensions
+
+
+Gfx::CCloud::CCloud(CInstanceManager* iMan, Gfx::CEngine* engine)
+{
+    m_iMan = iMan;
+    m_iMan->AddInstance(CLASS_CLOUD, this);
+
+    m_engine = engine;
+    m_terrain = nullptr;
+
+    m_level = 0.0f;
+    m_wind  = Math::Vector(0.0f, 0.0f, 0.0f);
+    m_subdiv = 8;
+    m_enable = true;
+
+    m_line.reserve(CLOUD_LINE_PREALLOCATE_COUNT);
+}
+
+Gfx::CCloud::~CCloud()
+{
+    m_iMan = nullptr;
+    m_engine = nullptr;
+    m_terrain = nullptr;
+}
+
+bool Gfx::CCloud::EventProcess(const Event &event)
+{
+    /* TODO!
+    if ( event.event == EVENT_FRAME )
+        return EventFrame(event); */
+
+    return true;
+}
+
+bool Gfx::CCloud::EventFrame(const Event &event)
+{
+    /* TODO!
+    if (m_engine->GetPause()) return true;
+
+    m_time += event.rTime;
+
+    if (m_level == 0.0f) return true;
+
+    if (m_time - m_lastTest < 0.2f) return true;
+
+    m_lastTest = m_time; */
+
+    return true;
+}
+
+void Gfx::CCloud::AdjustLevel(Math::Vector &pos, Math::Vector &eye, float deep,
+                              Math::Point &uv1, Math::Point &uv2)
+{
+    uv1.x = (pos.x+20000.0f)/1280.0f;
+    uv1.y = (pos.z+20000.0f)/1280.0f;
+    uv1.x -= m_time*(m_wind.x/100.0f);
+    uv1.y -= m_time*(m_wind.z/100.0f);
+
+    uv2.x = 0.0f;
+    uv2.y = 0.0f;
+
+    float dist = Math::DistanceProjected(pos, eye);
+    float factor = powf(dist/deep, 2.0f);
+    pos.y -= m_level*factor*10.0f;
+}
+
+void Gfx::CCloud::Draw()
+{
+    /* TODO!
+    LPDIRECT3DDEVICE7 device;
+    D3DVERTEX2*     vertex;
+    Math::Matrix*       matView;
+    D3DMATERIAL7    material;
+    Math::Matrix        matrix;
+    Math::Vector        n, pos, p, eye;
+    Math::Point         uv1, uv2;
+    float           iDeep, deep, size, fogStart, fogEnd;
+    int             i, j, u;
+
+    if ( !m_enable )  return;
+    if ( m_level == 0.0f )  return;
+    if ( m_lineUsed == 0 )  return;
+
+    vertex = (D3DVERTEX2*)malloc(sizeof(D3DVERTEX2)*(m_brick+2)*2);
+
+    iDeep = m_engine->GetDeepView();
+    deep = (m_brick*m_size)/2.0f;
+    m_engine->SetDeepView(deep);
+    m_engine->SetFocus(m_engine->GetFocus());
+    m_engine->UpdateMatProj();  // increases the depth of view
+
+    fogStart = deep*0.15f;
+    fogEnd   = deep*0.24f;
+
+    device = m_engine->GetD3DDevice();
+    device->SetRenderState(D3DRENDERSTATE_AMBIENT, 0x00000000);
+    device->SetRenderState(D3DRENDERSTATE_LIGHTING, false);
+    device->SetRenderState(D3DRENDERSTATE_ZENABLE, false);
+    device->SetRenderState(D3DRENDERSTATE_FOGENABLE, true);
+    device->SetRenderState(D3DRENDERSTATE_FOGSTART, F2DW(fogStart));
+    device->SetRenderState(D3DRENDERSTATE_FOGEND,   F2DW(fogEnd));
+
+    matView = m_engine->GetMatView();
+    {
+      D3DMATRIX mat = MAT_TO_D3DMAT(*matView);
+      device->SetTransform(D3DTRANSFORMSTATE_VIEW, &mat);
+    }
+
+    ZeroMemory( &material, sizeof(D3DMATERIAL7) );
+    material.diffuse = m_diffuse;
+    material.ambient = m_ambient;
+    m_engine->SetMaterial(material);
+
+    m_engine->SetTexture(m_filename, 0);
+    m_engine->SetTexture(m_filename, 1);
+
+    m_engine->SetState(D3DSTATETTb|D3DSTATEFOG|D3DSTATEWRAP);
+
+    matrix.LoadIdentity();
+    {
+      D3DMATRIX mat = MAT_TO_D3DMAT(matrix);
+      device->SetTransform(D3DTRANSFORMSTATE_WORLD, &mat);
+    }
+
+    size = m_size/2.0f;
+    eye = m_engine->GetEyePt();
+    n = Math::Vector(0.0f, -1.0f, 0.0f);
+
+    // Draws all the lines.
+    for ( i=0 ; i<m_lineUsed ; i++ )
+    {
+        pos.y = m_level;
+        pos.z = m_line[i].pz;
+        pos.x = m_line[i].px1;
+
+        u = 0;
+        p.x = pos.x-size;
+        p.z = pos.z+size;
+        p.y = pos.y;
+        AdjustLevel(p, eye, deep, uv1, uv2);
+        vertex[u++] = D3DVERTEX2(p, n, uv1.x,uv1.y, uv2.x,uv2.y);
+
+        p.x = pos.x-size;
+        p.z = pos.z-size;
+        p.y = pos.y;
+        AdjustLevel(p, eye, deep, uv1, uv2);
+        vertex[u++] = D3DVERTEX2(p, n, uv1.x,uv1.y, uv2.x,uv2.y);
+
+        for ( j=0 ; j<m_line[i].len ; j++ )
+        {
+            p.x = pos.x+size;
+            p.z = pos.z+size;
+            p.y = pos.y;
+            AdjustLevel(p, eye, deep, uv1, uv2);
+            vertex[u++] = D3DVERTEX2(p, n, uv1.x,uv1.y, uv2.x,uv2.y);
+
+            p.x = pos.x+size;
+            p.z = pos.z-size;
+            p.y = pos.y;
+            AdjustLevel(p, eye, deep, uv1, uv2);
+            vertex[u++] = D3DVERTEX2(p, n, uv1.x,uv1.y, uv2.x,uv2.y);
+
+            pos.x += size*2.0f;
+        }
+
+        device->DrawPrimitive(D3DPT_TRIANGLESTRIP, D3DFVF_VERTEX2, vertex, u, NULL);
+        m_engine->AddStatisticTriangle(u-2);
+    }
+
+    m_engine->SetDeepView(iDeep);
+    m_engine->SetFocus(m_engine->GetFocus());
+    m_engine->UpdateMatProj();  // gives depth to initial
+
+    free(vertex); */
+}
+
+void Gfx::CCloud::CreateLine(int x, int y, int len)
+{
+    Gfx::CloudLine line;
+
+    line.x   = x;
+    line.y   = y;
+    line.len = len;
+
+    float offset = m_brick*m_size/2.0f - m_size/2.0f;
+
+    line.px1 = m_size* line.x - offset;
+    line.px2 = m_size*(line.x+line.len) - offset;
+    line.pz  = m_size* line.y - offset;
+
+    m_line.push_back(line);
+}
+
+void Gfx::CCloud::Create(const std::string& fileName,
+                         Gfx::Color diffuse, Gfx::Color ambient,
+                         float level)
+{
+    m_diffuse  = diffuse;
+    m_ambient  = ambient;
+    m_level    = level;
+    m_time     = 0.0f;
+    m_lastTest = 0.0f;
+    m_fileName = fileName;
+
+    if (! m_fileName.empty())
+    {
+        m_engine->LoadTexture(m_fileName, 0);
+        m_engine->LoadTexture(m_fileName, 1);
+    }
+
+    if (m_terrain == nullptr)
+        m_terrain = static_cast<CTerrain*>(m_iMan->SearchInstance(CLASS_TERRAIN));
+
+    m_wind = m_terrain->GetWind();
+
+    m_brick = m_terrain->GetBrick()*m_terrain->GetMosaic()*DIMEXPAND;
+    m_size  = m_terrain->GetSize();
+
+    m_brick /= m_subdiv*DIMEXPAND;
+    m_size  *= m_subdiv*DIMEXPAND;
+
+    if (m_level == 0.0f)
+        return;
+
+    m_line.clear();
+    for (int y = 0; y < m_brick; y++)
+        CreateLine(0, y, m_brick);
+
+    return;
+}
+
+void Gfx::CCloud::Flush()
+{
+    m_level = 0.0f;
+}
+
+
+void Gfx::CCloud::SetLevel(float level)
+{
+    m_level = level;
+
+    Create(m_fileName, m_diffuse, m_ambient, m_level);
+}
+
+float Gfx::CCloud::GetLevel()
+{
+    return m_level;
+}
+
+void Gfx::CCloud::SetEnable(bool enable)
+{
+    m_enable = enable;
+}
+
+bool Gfx::CCloud::GetEnable()
+{
+    return m_enable;
+}