Vanilla-like camera

game/camera.h

@@ -30,6 +30,7 @@ class Camera final {
       Dive,
       Fall,
       Cutscene,
+      FirstPerson,
       };
 
     enum MarvinMode {
@@ -49,7 +50,7 @@ class Camera final {
     void reset(const Npc* pl);
 
     void save(Serialize &s);
-    void load(Serialize &s,Npc* pl);
+    void load(Serialize &s, Npc* pl);
 
     void changeZoom(int delta);
     void setViewport(uint32_t w, uint32_t h);
@@ -62,7 +63,7 @@ class Camera final {
     void moveLeft(uint64_t dt);
     void moveRight(uint64_t dt);
 
-    void setMode(Mode m);
+    void setMode(const Mode m);
     void setMarvinMode(MarvinMode m);
     bool isMarvin() const;
     bool isFree() const;
@@ -85,17 +86,15 @@ class Camera final {
     void tick(uint64_t dt);
     void debugDraw(DbgPainter& p);
 
-    Tempest::PointF    spin()     const;
-    Tempest::PointF    destSpin() const;
-
-    Tempest::Vec3      destPosition() const;
+    Tempest::PointF    spin() const;
+    Tempest::Vec3      destTarget() const;
+    float              azimuth() const;
 
     void               setSpin(const Tempest::PointF& p);
-    void               setDestSpin(const Tempest::PointF& p);
+    void               setTarget(const Tempest::Vec3& pos);
 
+    void               setAngles(const Tempest::PointF& pos);
     void               setPosition(const Tempest::Vec3& pos);
-    void               setDestPosition(const Tempest::Vec3& pos);
-
     void               setDialogDistance(float d);
 
     void               onRotateMouse(const Tempest::PointF& dpos);
@@ -119,29 +118,34 @@ class Camera final {
     float              zFar()  const;
 
   private:
+    struct Pin {
+      Tempest::Vec3       origin = {};
+      Tempest::Vec3       spin   = {};
+      };
+
     struct State {
       float               range  = 3.f;
       Tempest::Vec3       spin   = {};
       Tempest::Vec3       target = {};
       };
 
-    struct Pin {
-      Tempest::Vec3       origin = {};
-      Tempest::Vec3       spin   = {};
+    struct Interpolated {
+      Tempest::Vec3       target    = {};
+      Tempest::Vec3       rotOffset = {};
       };
 
-    Tempest::Vec3         cameraPos = {};
-    Tempest::Vec3         origin    = {};
-    Tempest::Vec3         rotOffset = {};
-    Tempest::Vec3         offsetAng = {};
-    State                 src, dst;
-
+    State                 state;
+    Interpolated          inter;
     Pin                   pin;
 
-    float                 dlgDist    = 0;
-    float                 userRange  = 0.13f;
+    Tempest::Vec3         origin    = {};
+    Tempest::Vec3         angles    = {};
+    Tempest::Vec3         veloTrans = {};
+    float                 userRange  = 0;
+
     float                 targetVelo = 0;
-    float                 veloTrans  = 0;
+
+    float                 dlgRange   = 0;
 
     Tempest::Matrix4x4    proj;
     uint32_t              vpWidth=0;
@@ -159,29 +163,30 @@ class Camera final {
 
     mutable int           raysCasted = 0;
 
-    static float          maxDist;
-    static float          baseSpeeed;
-    static float          offsetAngleMul;
     static const float    minLength;
 
-    void                  calcControlPoints(float dtF);
+    void                  tickFirstPerson(float dtF);
+    void                  tickThirdPerson(float dtF);
 
-    Tempest::Vec3         calcOffsetAngles(const Tempest::Vec3& srcOrigin, const Tempest::Vec3& target) const;
-    Tempest::Vec3         calcOffsetAngles(Tempest::Vec3 srcOrigin, Tempest::Vec3 dstOrigin, Tempest::Vec3 target) const;
-    Tempest::Vec3         calcCameraColision(const Tempest::Vec3& target, const Tempest::Vec3& origin, const Tempest::Vec3& rotSpin, float dist) const;
+    Tempest::Vec3         clampRotation(Tempest::Vec3 spin);
+    float                 calcCameraColision(const Tempest::Vec3& target, const Tempest::Vec3& dir, const Tempest::Vec3& rotSpin, float dist) const;
+    Tempest::Vec3         calcCameraColision(const Tempest::Vec3& from, const Tempest::Vec3& dir) const;
+
+    Tempest::Vec3         calcLookAtAngles(const Tempest::Vec3& origin, const Tempest::Vec3& target,
+                                           const Tempest::Vec3& rotOffset, const Tempest::Vec3& defSpin) const;
 
     void                  implMove(Tempest::KeyEvent::KeyType t, uint64_t dt);
+
     Tempest::Matrix4x4    mkView    (const Tempest::Vec3& pos, const Tempest::Vec3& spin) const;
     Tempest::Matrix4x4    mkRotation(const Tempest::Vec3& spin) const;
     Tempest::Matrix4x4    mkViewShadow(const Tempest::Vec3& cameraPos, float rotation,
                                        const Tempest::Matrix4x4& viewProj, const Tempest::Vec3& lightDir, size_t layer) const;
     Tempest::Matrix4x4    mkViewShadowVsm(const Tempest::Vec3& cameraPos, const Tempest::Vec3& ldir) const;
-    void                  resetDst();
 
-    void                  clampRotation(Tempest::Vec3& spin);
+    Tempest::Vec3         followTarget(Tempest::Vec3 pos,  Tempest::Vec3 dest, float dtF);
+    Tempest::Vec3         followTrans (Tempest::Vec3 pos,  Tempest::Vec3 dest, float dtF, float velo);
+    Tempest::Vec3         followRot   (Tempest::Vec3 spin, Tempest::Vec3 dest, float dtF, float velo);
 
-    void                  followCamera(Tempest::Vec3& pos,  Tempest::Vec3 dest, float dtF);
-    void                  followPos   (Tempest::Vec3& pos,  Tempest::Vec3 dest, float dtF);
     void                  followAng   (Tempest::Vec3& spin, Tempest::Vec3 dest, float dtF);
     static void           followAng   (float& ang, float dest, float speed, float dtF);
 

game/game/definitions/cameradefinitions.cpp

@@ -1,8 +1,13 @@
 #include "cameradefinitions.h"
 
+#include <Tempest/Log>
+#include <zenkit/vobs/Camera.hh>
+
 #include "gothic.h"
 #include "utils/string_frm.h"
 
+using namespace Tempest;
+
 CameraDefinitions::CameraDefinitions() {
   auto vm = Gothic::inst().createPhoenixVm("Camera.dat");
 
@@ -28,6 +33,28 @@ CameraDefinitions::CameraDefinitions() {
   camModSwim      = getCam("CAMMODSWIM");
   camModDive      = getCam("CAMMODDIVE");
   camModFall      = getCam("CAMMODFALL");
+
+  // dialog presets: unused yet
+  std::vector<zenkit::VCutsceneCamera> cameras;
+  try {
+    std::unique_ptr<zenkit::Read> read;
+    auto zen = Resources::openReader("DialogCams.ZEN", read);
+
+    while(!read->eof()) {
+      zenkit::ArchiveObject   obj {};
+      zenkit::VCutsceneCamera preset {};
+      zen->read_object_begin(obj);
+      preset.load(*zen, Gothic::inst().version().game == 1 ? zenkit::GameVersion::GOTHIC_1
+                                                           : zenkit::GameVersion::GOTHIC_2);
+      cameras.emplace_back(std::move(preset));
+      if(!zen->read_object_end()) {
+        zen->skip_object(true);
+        }
+      }
+    }
+  catch(...) {
+    Log::e("unable to load Zen-file: \"DialogCams.ZEN\"");
+    }
   }
 
 const zenkit::ICamera& CameraDefinitions::mobsiCam(std::string_view tag, std::string_view pos) const {

game/game/playercontrol.cpp

@@ -247,14 +247,9 @@ bool PlayerControl::isPressed(KeyCodec::Action a) const {
   return ctrl[a];
   }
 
-void PlayerControl::onRotateMouse(float dAngle) {
-  dAngle = std::max(-40.f,std::min(dAngle,40.f));
-  rotMouse += dAngle*0.3f;
-  }
-
-void PlayerControl::onRotateMouseDy(float dAngle) {
-  dAngle = std::max(-100.f,std::min(dAngle,100.f));
-  rotMouseY += dAngle*0.2f;
+void PlayerControl::onRotateMouse(float dAngleX, float dAngleY) {
+  rotMouse  += dAngleX;
+  rotMouseY += dAngleY;
   }
 
 void PlayerControl::tickFocus() {
@@ -563,8 +558,6 @@ bool PlayerControl::tickMove(uint64_t dt) {
   if(pl==nullptr)
     return true;
 
-  static const float speedRotX = 750.f;
-  rotMouse = std::min(std::abs(rotMouse), speedRotX*dtF) * (rotMouse>=0 ? 1 : -1);
   implMove(dt);
 
   float runAngle = pl->runAngle();
@@ -664,7 +657,7 @@ void PlayerControl::implMove(uint64_t dt) {
     return;
     }
 
-  int rotation=0;
+  int rotation = 0;
   if(allowRot) {
     if(this->wantsToTurnLeft()) {
       rot += rspeed;
@@ -680,7 +673,7 @@ void PlayerControl::implMove(uint64_t dt) {
       if(rotMouse>0)
         rotation = -1; else
         rotation = 1;
-      rot +=rotMouse;
+      rot += rotMouse;
       rotMouse  = 0;
       }
     rotY+=rotMouseY;
@@ -1034,29 +1027,17 @@ void PlayerControl::quitPicklock(Npc& pl) {
 
 void PlayerControl::assignRunAngle(Npc& pl, float rotation, uint64_t dt) {
   float dtF    = (float(dt)/1000.f);
-  float angle  = pl.rotation();
-  float dangle = (rotation-angle)/dtF;
-  float sgn    = (dangle>0 ? 1 : -1);
-  auto& wrld   = pl.world();
+  auto  camera = Gothic::inst().camera();
 
-  if(std::fabs(dangle)<0.1f || pl.walkMode()!=WalkBit::WM_Run) {
-    if(runAngleSmooth<wrld.tickCount())
-      runAngleDest = 0;
-    return;
+  float dest = 0;
+  if(camera!=nullptr && pl.walkMode()==WalkBit::WM_Run && pl.bodyState()==BS_RUN) {
+    const float az   = camera->azimuth();
+    const float maxV = 14.5f;
+    dest = std::min(std::abs(az), maxV)*(az>=0 ? 1 : -1);
     }
 
-  const float maxV = 15.0f;
-  dangle = std::pow(std::abs(dangle)/maxV,2.f)*maxV*sgn;
-
-  float dest = 0;
-  if(angle<rotation)
-    dest =  std::min( dangle,maxV);
-  if(angle>rotation)
-    dest = -std::min(-dangle,maxV);
-
-  float a = std::clamp(dtF*2.5f, 0.f, 1.f);
-  runAngleDest   = runAngleDest*(1.f-a)+dest*a;
-  runAngleSmooth = wrld.tickCount() + 200;
+  float a = std::min(dtF*5.f, 1.f);
+  runAngleDest = runAngleDest*(1.f-a)+dest*a;
   }
 
 void PlayerControl::setAnimRotate(Npc& pl, float rotation, int anim, bool force, uint64_t dt) {
@@ -1065,15 +1046,15 @@ void PlayerControl::setAnimRotate(Npc& pl, float rotation, int anim, bool force,
   float dangle = (rotation-angle)/dtF;
   auto& wrld   = pl.world();
 
-  if(std::fabs(dangle)<100.f && !force) // 100 deg per second threshold
+  if(std::fabs(dangle)<30.f && !force) // 30 deg per second threshold
     anim = 0;
   if(anim!=0 && pl.isAttackAnim())
     anim = 0;
   if(rotationAni==anim && anim!=0)
     force = true;
   if(!force && wrld.tickCount()<turnAniSmooth)
     return;
-  turnAniSmooth = wrld.tickCount() + 150;
+  turnAniSmooth = wrld.tickCount() + 100;
   rotationAni   = anim;
   pl.setAnimRotate(anim);
   }

game/game/playercontrol.h

@@ -23,8 +23,7 @@ class PlayerControl final {
     void  onKeyPressed (KeyCodec::Action a, Tempest::Event::KeyType key, KeyCodec::Mapping mapping = KeyCodec::Mapping::Primary);
     void  onKeyReleased(KeyCodec::Action a, KeyCodec::Mapping mapping = KeyCodec::Mapping::Primary);
     bool  isPressed(KeyCodec::Action a) const;
-    void  onRotateMouse(float dAngle);
-    void  onRotateMouseDy(float dAngle);
+    void  onRotateMouse(float dAngleX, float dAngleY);
 
     void  changeZoom(int delta);
     void  tickFocus();
@@ -147,7 +146,6 @@ class PlayerControl final {
     size_t         pickLockProgress = 0;
 
     float          runAngleDest   = 0.f;
-    uint64_t       runAngleSmooth = 0;
     uint64_t       turnAniSmooth  = 0;
     int            rotationAni    = 0;
     bool           g2Ctrl         = false;

game/game/serialize.h

@@ -33,7 +33,7 @@ class SaveGameHeader;
 class Serialize {
   public:
     enum Version : uint16_t {
-      Current    = 53,
+      Current    = 54,
       MinVersion = 36,
 
       Last_2025  = 53,

game/graphics/worldview.cpp

@@ -37,7 +37,7 @@ bool WorldView::isInPfxRange(const Vec3& pos) const {
 
 void WorldView::tick(uint64_t /*dt*/) {
   auto& cam = owner.gameSession().camera();
-  pfxGroup.setViewerPos(cam.destPosition());
+  pfxGroup.setViewerPos(cam.originLwc());
   }
 
 void WorldView::resetRendering() {