Add new functions related to underwater effects

Client/mods/deathmatch/logic/luadefs/CLuaCameraDefs.cpp

@@ -29,6 +29,8 @@ void CLuaCameraDefs::LoadFunctions()
         {"getCameraGoggleEffect", ArgumentParserWarn<false, GetCameraGoggleEffect>},
         {"getCameraFieldOfView", GetCameraFieldOfView},
         {"getCameraDrunkLevel", ArgumentParserWarn<false, GetCameraDrunkLevel>},
+        {"getCameraUnderwaterEffect", ArgumentParser<GetCameraUnderwaterEffect>},
+        {"getCameraUnderwaterDarkness", ArgumentParser<GetCameraUnderwaterDarkness>},
 
         // Cam set funcs
         {"setCameraMatrix", SetCameraMatrix},
@@ -41,6 +43,11 @@ void CLuaCameraDefs::LoadFunctions()
         {"setCameraViewMode", ArgumentParserWarn<false, SetCameraViewMode>},
         {"setCameraGoggleEffect", SetCameraGoggleEffect},
         {"setCameraDrunkLevel", ArgumentParserWarn<false, SetCameraDrunkLevel>},
+        {"setCameraUnderwaterEffectEnabled", ArgumentParser<SetCameraUnderwaterEffectEnabled>},
+        {"setCameraUnderwaterEffectSpeed", ArgumentParser<SetCameraUnderwaterEffectSpeed>},
+        {"setCameraUnderwaterDarkness", ArgumentParser<SetCameraUnderwaterDarkness>},
+        {"resetCameraUnderwaterEffect", ArgumentParser<ResetCameraUnderwaterEffect>},
+        {"resetCameraUnderwaterDarkness", ArgumentParser<ResetCameraUnderwaterDarkness>},
     };
 
     // Add functions
@@ -68,6 +75,8 @@ void CLuaCameraDefs::AddClass(lua_State* luaVM)
     lua_classfunction(luaVM, "getFarClipDistance", "getFarClipDistance");
     lua_classfunction(luaVM, "getNearClipDistance", "getNearClipDistance");
     lua_classfunction(luaVM, "getType", ArgumentParser<GetElementType>);
+    lua_classfunction(luaVM, "getUnderwaterEffect", ArgumentParser<GetCameraUnderwaterEffect>);
+    lua_classfunction(luaVM, "getUnderwaterDarkness", ArgumentParser<GetCameraUnderwaterDarkness>);
 
     lua_classfunction(luaVM, "setPosition", OOP_SetCameraPosition);
     lua_classfunction(luaVM, "setRotation", OOP_SetCameraRotation);
@@ -80,6 +89,11 @@ void CLuaCameraDefs::AddClass(lua_State* luaVM)
     lua_classfunction(luaVM, "setClip", "setCameraClip");
     lua_classfunction(luaVM, "setFarClipDistance", "setFarClipDistance");
     lua_classfunction(luaVM, "setNearClipDistance", "setNearClipDistance");
+    lua_classfunction(luaVM, "setUnderwaterEffectEnabled", ArgumentParser<SetCameraUnderwaterEffectEnabled>);
+    lua_classfunction(luaVM, "setUnderwaterEffectSpeed", ArgumentParser<SetCameraUnderwaterEffectSpeed>);
+    lua_classfunction(luaVM, "setUnderwaterDarkness", ArgumentParser<SetCameraUnderwaterDarkness>);
+    lua_classfunction(luaVM, "resetUnderwaterEffect", ArgumentParser<ResetCameraUnderwaterEffect>);
+    lua_classfunction(luaVM, "resetUnderwaterDarkness", ArgumentParser<ResetCameraUnderwaterDarkness>);
 
     lua_classvariable(luaVM, "interior", "setCameraInterior", "getCameraInterior");
     lua_classvariable(luaVM, "target", "setCameraTarget", "getCameraTarget");
@@ -162,6 +176,16 @@ unsigned char CLuaCameraDefs::GetCameraDrunkLevel()
     return g_pGame->GetPlayerInfo()->GetCamDrunkLevel();
 }
 
+CLuaMultiReturn<bool, float, float> CLuaCameraDefs::GetCameraUnderwaterEffect()
+{
+    return g_pMultiplayer->GetUnderwaterEffect();
+}
+
+CLuaMultiReturn<bool, float> CLuaCameraDefs::GetCameraUnderwaterDarkness()
+{
+    return g_pMultiplayer->GetUnderwaterDarkness();
+}
+
 int CLuaCameraDefs::SetCameraMatrix(lua_State* luaVM)
 {
     CVector          vecPosition;
@@ -464,6 +488,42 @@ int CLuaCameraDefs::SetCameraGoggleEffect(lua_State* luaVM)
     return 1;
 }
 
+bool CLuaCameraDefs::SetCameraUnderwaterEffectEnabled(bool bEnabled)
+{
+    g_pMultiplayer->SetUnderwaterEffectEnabled(bEnabled);
+
+    return true;
+}
+
+bool CLuaCameraDefs::SetCameraUnderwaterEffectSpeed(float fSpeed, float fFrequency)
+{
+    g_pMultiplayer->SetUnderwaterEffectSpeed(fSpeed, fFrequency);
+
+    return true;
+}
+
+bool CLuaCameraDefs::SetCameraUnderwaterDarkness(bool bEnabled, std::optional<float> fFullDarknessDepth)
+{
+    g_pMultiplayer->SetUnderwaterDarkness(bEnabled, fFullDarknessDepth.value_or(90.0f));
+
+    return true;
+}
+
+bool CLuaCameraDefs::ResetCameraUnderwaterEffect()
+{
+    g_pMultiplayer->SetUnderwaterEffectEnabled(false);
+    g_pMultiplayer->SetUnderwaterEffectSpeed(0.0015f, 0.04f);
+
+    return true;
+}
+
+bool CLuaCameraDefs::ResetCameraUnderwaterDarkness()
+{
+    g_pMultiplayer->SetUnderwaterDarkness(true, 90.0f);
+
+    return true;
+}
+
 bool CLuaCameraDefs::SetCameraDrunkLevel(short drunkLevel)
 {
     if (drunkLevel < 0 || drunkLevel > 255)

Client/mods/deathmatch/logic/luadefs/CLuaCameraDefs.h

@@ -31,6 +31,8 @@ class CLuaCameraDefs : public CLuaDefs
     static std::string                                                             GetCameraGoggleEffect();
     LUA_DECLARE(GetCameraFieldOfView);
     static unsigned char GetCameraDrunkLevel();
+    static CLuaMultiReturn<bool, float, float> GetCameraUnderwaterEffect();
+    static CLuaMultiReturn<bool, float>        GetCameraUnderwaterDarkness();
 
     // Cam set funcs
     LUA_DECLARE(SetCameraMatrix);
@@ -43,6 +45,12 @@ class CLuaCameraDefs : public CLuaDefs
     LUA_DECLARE(SetCameraGoggleEffect);
     static bool SetCameraDrunkLevel(short drunkLevel);
 
+    static bool SetCameraUnderwaterEffectEnabled(bool bEnabled);
+    static bool SetCameraUnderwaterEffectSpeed(float fSpeed, float fFrequency);
+    static bool SetCameraUnderwaterDarkness(bool bEnabled, std::optional<float> fFullDarknessDepth);
+    static bool ResetCameraUnderwaterEffect();
+    static bool ResetCameraUnderwaterDarkness();
+
     // For OOP only
     LUA_DECLARE(OOP_GetCameraPosition);
     LUA_DECLARE(OOP_SetCameraPosition);

Client/multiplayer_sa/CMultiplayerSA.h

@@ -200,6 +200,12 @@ class CMultiplayerSA : public CMultiplayer
     bool IsNightVisionEnabled();
     bool IsThermalVisionEnabled();
 
+    std::tuple<bool, float, float> GetUnderwaterEffect();
+    std::tuple<bool, float> GetUnderwaterDarkness();
+    void SetUnderwaterEffectEnabled(bool bEnabled);
+    void SetUnderwaterEffectSpeed(float fSpeed, float fFrequency);
+    void SetUnderwaterDarkness(bool bEnabled, float fFullDarknessDepth);
+
     void AllowWindowsCursorShowing(bool bAllow);
 
     CShotSyncData* GetLocalShotSyncData();

Client/multiplayer_sa/CMultiplayerSA_Postprocess.cpp

@@ -154,6 +154,38 @@ void CMultiplayerSA::SetNightVisionEnabled(bool bEnabled, bool bNoiseEnabled)
     }
 }
 
+void CMultiplayerSA::SetUnderwaterEffectEnabled(bool bEnabled)
+{
+    if (bEnabled)
+    {
+        MemPutFast<BYTE>(0xC402D3, 1);
+    }
+    else
+    {
+        MemPutFast<BYTE>(0xC402D3, 0);
+    }
+}
+
+void CMultiplayerSA::SetUnderwaterEffectSpeed(float fSpeed, float fFrequency)
+{
+    MemPutFast<float>(0x8D5138, fSpeed);
+    MemPutFast<float>(0x8D513C, fFrequency);
+}
+
+void CMultiplayerSA::SetUnderwaterDarkness(bool bEnabled, float fFullDarknessDepth)
+{
+    if (bEnabled)
+    {
+        MemPutFast<BYTE>(0x8D5144, 1);
+    }
+    else
+    {
+        MemPutFast<BYTE>(0x8D5144, 0);
+    }
+
+    MemPutFast<float>(0x8D5148, fFullDarknessDepth);
+}
+
 void CMultiplayerSA::SetThermalVisionEnabled(bool bEnabled, bool bNoiseEnabled)
 {
     if (bEnabled)
@@ -184,8 +216,26 @@ bool CMultiplayerSA::IsThermalVisionEnabled()
     return (*(BYTE*)0xC402B9 == 1);
 }
 
-void CMultiplayerSA::InitHooks_Postprocess()
+std::tuple<bool, float, float> CMultiplayerSA::GetUnderwaterEffect()
+{
+    bool bEnabled = (*(BYTE*)0xC402D3 == 1);
+    float fSpeed = (*(float*)0x8D5138);
+    float fFrequency = (*(float*)0x8D513C);
+
+    return std::tuple<bool, float, float>(bEnabled, fSpeed, fFrequency);
+}
+
+
+std::tuple<bool, float> CMultiplayerSA::GetUnderwaterDarkness()
 {
+    bool bEnabled = (*(BYTE*)0x8D5144);
+    float fFullDarknessDepth = (*(float*)0x8D5148);
+
+    return std::tuple<bool, float>(bEnabled, fFullDarknessDepth);
+}
+
+void CMultiplayerSA::InitHooks_Postprocess()
+    {
     HookInstallCall(HOOKPOS_GrainEffect_NightModifier, (DWORD)GrainEffect::NightModifier::ApplyEffect);
     HookInstallCall(HOOKPOS_GrainEffect_InfraredModifier, (DWORD)GrainEffect::InfraredModifier::ApplyEffect);
     HookInstallCall(HOOKPOS_GrainEffect_RainModifier, (DWORD)GrainEffect::RainModifier::ApplyEffect);

Client/sdk/multiplayer/CMultiplayer.h

@@ -407,4 +407,10 @@ class CMultiplayer
     virtual unsigned int EntryInfoNodePool_NoOfUsedSpaces() const noexcept = 0;
     virtual unsigned int PtrNodeSingleLinkPool_NoOfUsedSpaces() const noexcept = 0;
     virtual unsigned int PtrNodeDoubleLinkPool_NoOfUsedSpaces() const noexcept = 0;
+
+    virtual std::tuple<bool, float, float> GetUnderwaterEffect() = 0;
+    virtual std::tuple<bool, float> GetUnderwaterDarkness() = 0;
+    virtual void SetUnderwaterEffectEnabled(bool bEnabled) = 0;
+    virtual void SetUnderwaterEffectSpeed(float fSpeed, float fFrequency) = 0;
+    virtual void SetUnderwaterDarkness(bool bEnabled, float fFullDarknessDepth) = 0;
 };