Engine: fix Camera rotation matrixes

ivan-mogilko · ivan-mogilko · commit b15056563c6f · 2026-06-17T04:05:40.000+03:00
diff --git a/Common/util/geometry.h b/Common/util/geometry.h
@@ -138,31 +138,55 @@ struct PointT
         return Pt(X - p.X, Y - p.Y);
     }
 
-    inline Pt operator *(T mul) const
+    inline Pt operator *(const Pt &p) const
+    {
+        return Pt(X * p.X, Y * p.Y);
+    }
+
+    inline Pt operator /(const Pt &p) const
+    {
+        return Pt(X / p.X, Y / p.Y);
+    }
+
+    inline Pt &operator *=(const Pt p)
+    {
+        X *= p.X;
+        Y *= p.Y;
+        return *this;
+    }
+
+    inline Pt &operator /=(const Pt p)
+    {
+        X /= p.X;
+        Y /= p.Y;
+        return *this;
+    }
+
+    inline Pt operator *(const T &mul) const
     {
         return Pt(X * mul, Y * mul);
     }
 
-    inline Pt operator /(T div) const
+    inline Pt operator /(const T &div) const
     {
         return Pt(X / div, Y / div);
     }
 
-    inline Pt &operator *=(T mul)
+    inline Pt &operator *=(const T &mul)
     {
         X *= mul;
         Y *= mul;
         return *this;
     }
 
-    inline Pt &operator /=(T div)
+    inline Pt &operator /=(const T &div)
     {
         X /= div;
         Y /= div;
         return *this;
     }
 
-    inline bool Equals(const T x, const T y) const
+    inline bool Equals(const T &x, const T &y) const
     {
         return X == x && Y == y;
     }
diff --git a/Engine/ac/draw.cpp b/Engine/ac/draw.cpp
@@ -2967,7 +2967,7 @@ static void construct_roomview_hw(const Viewport *viewport)
             camera->GetRotation(), camera->GetEffectivePivot());
 
         gfxDriver->BeginSpriteBatch(view_rc, view_trans, RENDER_BATCH_ROOM_LAYER);
-        gfxDriver->BeginSpriteBatch(Rect(), cam_trans);
+        gfxDriver->BeginSpriteBatch(Rect(), cam_trans, cam_rc.GetSize());
         gfxDriver->SetStageScreen(cam_rc.GetSize(), cam_rc.Left, cam_rc.Top);
         put_sprite_list_on_screen(true);
         gfxDriver->EndSpriteBatch();
diff --git a/Engine/game/viewport.cpp b/Engine/game/viewport.cpp
@@ -259,14 +259,19 @@ void Viewport::AdjustTransformation()
         float scale_x = (float)_position.GetWidth() / (float)cam_rc.GetWidth();
         float scale_y = (float)_position.GetHeight() / (float)cam_rc.GetHeight();
         float rotate = locked_cam->GetRotation();
+        Pointf pivot = locked_cam->GetEffectivePivot();
 
         glm::mat4 mat_v2c = glmex::make_transform2d(cam_rc.Left, cam_rc.Top,
-            1.f / scale_x, 1.f / scale_y, -Math::DegreesToRadians(rotate), -0.5 * cam_rc.GetWidth(), -0.5 * cam_rc.GetHeight());
+            1.f / scale_x, 1.f / scale_y, Math::DegreesToRadians(rotate),
+            -cam_rc.GetWidth() * pivot.X, -cam_rc.GetHeight() * pivot.Y
+            );
         _v2cTransform = glmex::translate(mat_v2c, -_position.Left, -_position.Top);
 
         glm::mat4 mat_c2v = glmex::translate(_position.Left, _position.Top);
         _c2vTransform = glmex::inv_transform2d(mat_c2v, -cam_rc.Left, -cam_rc.Top,
-            scale_x, scale_y, Math::DegreesToRadians(rotate), 0.5 * cam_rc.GetWidth(), 0.5 * cam_rc.GetHeight());;
+            scale_x, scale_y, -Math::DegreesToRadians(rotate),
+            cam_rc.GetWidth() * pivot.X, cam_rc.GetHeight() * pivot.Y
+            );
     }
 }
 
diff --git a/Engine/gfx/ali3dogl.cpp b/Engine/gfx/ali3dogl.cpp
@@ -1939,13 +1939,13 @@ void OGLGraphicsDriver::InitSpriteBatch(size_t index, const SpriteBatchDesc &des
     // Translate scaled node into Top-Left screen coordinates
     float scaled_offx = _srcRect.GetWidth() * ((1.f - desc.Transform.ScaleX) * 0.5f);
     float scaled_offy = _srcRect.GetHeight() * ((1.f - desc.Transform.ScaleY) * 0.5f);
-    float pivotx = _srcRect.GetWidth() / 2.f - (_srcRect.GetWidth() * desc.Transform.Pivot.X);
-    float pivoty = _srcRect.GetHeight() / 2.f - (_srcRect.GetHeight() * desc.Transform.Pivot.Y);
+    float pivotx = -_srcRect.GetWidth() * 0.5f + desc.SizeRef.Width * desc.Transform.ScaleX * desc.Transform.Pivot.X;
+    float pivoty = -_srcRect.GetHeight() * 0.5f + desc.SizeRef.Height * desc.Transform.ScaleY * desc.Transform.Pivot.Y;
     model = glmex::translate(model, -scaled_offx, -(-scaled_offy));
-    // Classic Scale-Rotate-Translate, but inverse, because it's GLM
-    glm::mat4 msrt = glmex::make_transform2d((float)desc.Transform.X, (float)-desc.Transform.Y,
+    // Inverse transformation, because it should affect the textures drawn within this batch
+    glm::mat4 msrt = glmex::make_inv_transform2d((float)desc.Transform.X, (float)-desc.Transform.Y,
         desc.Transform.ScaleX, desc.Transform.ScaleY,
-        -Math::DegreesToRadians(desc.Transform.Rotate), pivotx, -pivoty);
+        Math::DegreesToRadians(desc.Transform.Rotate), pivotx, -pivoty);
     model = model * msrt;
 
     // Also create separate viewport transformation matrix:
@@ -1954,7 +1954,7 @@ void OGLGraphicsDriver::InitSpriteBatch(size_t index, const SpriteBatchDesc &des
     glm::mat4 mat_viewport = glmex::make_transform2d(
         (float)desc.Transform.X, (float)desc.Transform.Y,
         desc.Transform.ScaleX, desc.Transform.ScaleY, // CHECKME: rotation args here
-        -Math::DegreesToRadians(desc.Transform.Rotate), pivotx, -pivoty);
+        Math::DegreesToRadians(desc.Transform.Rotate), pivotx, -pivoty);
     glm::mat4 vp_flip_off = glmex::translate(
         _srcRect.GetWidth() * ((1.f - flip_sx) * 0.5f),
         _srcRect.GetHeight() * ((1.f - flip_sy) * 0.5f));
diff --git a/Engine/gfx/gfxdriverbase.cpp b/Engine/gfx/gfxdriverbase.cpp
@@ -91,13 +91,24 @@ bool GraphicsDriverBase::GetVsync() const
 
 void GraphicsDriverBase::BeginSpriteBatch(const Rect &viewport, const SpriteTransform &transform, uint32_t filter_flags)
 {
-    BeginSpriteBatch(SpriteBatchDesc(_actSpriteBatch, viewport, transform, kFlip_None, nullptr, filter_flags));
+    BeginSpriteBatch(SpriteBatchDesc(_actSpriteBatch, viewport, transform, Size(), kFlip_None, nullptr, filter_flags));
+}
+
+void GraphicsDriverBase::BeginSpriteBatch(const Rect &viewport, const SpriteTransform &transform, const Size &size_ref, uint32_t filter_flags)
+{
+    BeginSpriteBatch(SpriteBatchDesc(_actSpriteBatch, viewport, transform, size_ref, kFlip_None, nullptr, filter_flags));
 }
 
 void GraphicsDriverBase::BeginSpriteBatch(const Rect &viewport, const SpriteTransform &transform,
     GraphicFlip flip, PBitmap surface, uint32_t filter_flags)
 {
-    BeginSpriteBatch(SpriteBatchDesc(_actSpriteBatch, viewport, transform, flip, surface, filter_flags));
+    BeginSpriteBatch(SpriteBatchDesc(_actSpriteBatch, viewport, transform, Size(), flip, surface, filter_flags));
+}
+
+void GraphicsDriverBase::BeginSpriteBatch(const Rect &viewport, const SpriteTransform &transform, const Size &size_ref,
+    GraphicFlip flip, PBitmap surface, uint32_t filter_flags)
+{
+    BeginSpriteBatch(SpriteBatchDesc(_actSpriteBatch, viewport, transform, size_ref, flip, surface, filter_flags));
 }
 
 void GraphicsDriverBase::BeginSpriteBatch(IDriverDependantBitmap *render_target,
diff --git a/Engine/gfx/gfxdriverbase.h b/Engine/gfx/gfxdriverbase.h
@@ -47,6 +47,8 @@ struct SpriteBatchDesc
     SpriteTransform          Transform;
     // Optional flip, applied to the whole batch as the last transform
     Common::GraphicFlip      Flip = Common::kFlip_None;
+    // Reference size, used mainly for deducing absolute rotation pivot
+    Size                     SizeRef;
     // Optional bitmap to draw sprites upon. Used exclusively by the software rendering mode.
     // TODO: merge with the RenderTexture?
     PBitmap                  Surface;
@@ -58,11 +60,12 @@ struct SpriteBatchDesc
 
     SpriteBatchDesc() = default;
     SpriteBatchDesc(uint32_t parent, const Rect viewport, const SpriteTransform &transform,
-        Common::GraphicFlip flip = Common::kFlip_None, PBitmap surface = nullptr,
+        Size size_ref = Size(), Common::GraphicFlip flip = Common::kFlip_None, PBitmap surface = nullptr,
         uint32_t filter_flags = 0)
         : Parent(parent)
         , Viewport(viewport)
         , Transform(transform)
+        , SizeRef(size_ref)
         , Flip(flip)
         , Surface(surface)
         , FilterFlags(filter_flags)
@@ -75,6 +78,7 @@ struct SpriteBatchDesc
         : Parent(parent)
         , Viewport(viewport)
         , Transform(transform)
+        , SizeRef(render_target ? Size(render_target->GetWidth(), render_target->GetHeight()) : Size())
         , Flip(flip)
         , RenderTarget(render_target)
         , FilterFlags(filter_flags)
@@ -145,15 +149,18 @@ class GraphicsDriverBase : public IGraphicsDriver
     //
     // Prepares next sprite batch, a list of sprites with defined viewport and optional
     // global model transformation.
-    void        BeginSpriteBatch(const Rect &viewport, const SpriteTransform &transform, uint32_t filter_flags = 0) override;
+    void        BeginSpriteBatch(const Rect &viewport, const SpriteTransform &transform, uint32_t filter_flags) override;
+    void        BeginSpriteBatch(const Rect &viewport, const SpriteTransform &transform, const Size &size_ref, uint32_t filter_flags) override;
     // Begins a sprite batch with defined viewport and a global model transformation
     // and a global flip setting. Optionally provides a surface which should be rendered
     // underneath the rest of the sprites.
     void        BeginSpriteBatch(const Rect &viewport, const SpriteTransform &transform,
-                    Common::GraphicFlip flip, PBitmap surface = nullptr, uint32_t filter_flags = 0) override;
+                    Common::GraphicFlip flip, PBitmap surface, uint32_t filter_flags) override;
+    void        BeginSpriteBatch(const Rect &viewport, const SpriteTransform &transform, const Size &size_ref,
+                    Common::GraphicFlip flip, PBitmap surface, uint32_t filter_flags) override;
     // Begins a sprite batch which will be rendered on a target texture.
     void        BeginSpriteBatch(IDriverDependantBitmap *render_target, const Rect &viewport, const SpriteTransform &transform,
-                    Common::GraphicFlip flip = Common::kFlip_None, uint32_t filter_flags = 0) override;
+                    Common::GraphicFlip flip, uint32_t filter_flags) override;
     // Ends current sprite batch
     void        EndSpriteBatch() override;
     // Clears all sprite batches, resets batch counter
diff --git a/Engine/gfx/graphicsdriver.h b/Engine/gfx/graphicsdriver.h
@@ -329,13 +329,16 @@ class IGraphicsDriver
     // Optionally you can assign "filter flags" to this batch; this lets to filter certain
     // batches out during some operations, such as fading effects or making screenshots.
     virtual void BeginSpriteBatch(const Rect &viewport, const SpriteTransform &transform, uint32_t filter_flags = 0) = 0;
+    virtual void BeginSpriteBatch(const Rect &viewport, const SpriteTransform &transform, const Size &size_ref, uint32_t filter_flags = 0) = 0;
     // Begins a sprite batch with defined viewport and a global model transformation
     // and a global flip setting. Optionally provides a surface which should be rendered
     // underneath the rest of the sprites.
     // TODO: merge GraphicFlip with SpriteTransform.
     // TODO: can we merge PBitmap surface and render_target from overriden method?
     virtual void BeginSpriteBatch(const Rect &viewport, const SpriteTransform &transform,
         Common::GraphicFlip flip, PBitmap surface = nullptr, uint32_t filter_flags = 0) = 0;
+    virtual void BeginSpriteBatch(const Rect &viewport, const SpriteTransform &transform, const Size &size_ref,
+        Common::GraphicFlip flip, PBitmap surface = nullptr, uint32_t filter_flags = 0) = 0;
     // Begins a sprite batch which will be rendered on a target texture.
     // This batch will ignore any parent transforms, regardless whether it's nested
     // or not. Its common child batches will also be rendered on the same texture.
diff --git a/Engine/platform/windows/gfx/ali3dd3d.cpp b/Engine/platform/windows/gfx/ali3dd3d.cpp
@@ -1942,13 +1942,14 @@ size_t D3DGraphicsDriver::RenderSpriteBatch(const D3DSpriteBatch &batch, size_t
 void D3DGraphicsDriver::InitSpriteBatch(size_t index, const SpriteBatchDesc &desc)
 {
     // Create transformation matrix for this batch
-    // Classic Scale-Rotate-Translate, but inverse, because it's GLM
-    float pivotx = _srcRect.GetWidth() / 2.f - _srcRect.GetWidth() * desc.Transform.Pivot.X;
-    float pivoty = _srcRect.GetHeight() / 2.f - _srcRect.GetHeight() * desc.Transform.Pivot.Y;
-    glm::mat4 msrt = glmex::make_transform2d(
+    float pivotx = -_srcRect.GetWidth() * 0.5f + desc.SizeRef.Width * desc.Transform.ScaleX * desc.Transform.Pivot.X;
+    float pivoty = -_srcRect.GetHeight() * 0.5f + desc.SizeRef.Height * desc.Transform.ScaleY * desc.Transform.Pivot.Y;
+
+    // Inverse transformation, because it should affect the textures drawn within this batch
+    glm::mat4 msrt = glmex::make_inv_transform2d(
         (float)desc.Transform.X, (float)-desc.Transform.Y,
         desc.Transform.ScaleX, desc.Transform.ScaleY,
-        -Math::DegreesToRadians(desc.Transform.Rotate), pivotx, -pivoty);
+        Math::DegreesToRadians(desc.Transform.Rotate), pivotx, -pivoty);
     // Translate scaled node into Top-Left screen coordinates
     float scaled_offx = _srcRect.GetWidth() * ((1.f - desc.Transform.ScaleX) * 0.5f);
     float scaled_offy = _srcRect.GetHeight() * ((1.f - desc.Transform.ScaleY) * 0.5f);
@@ -1974,7 +1975,7 @@ void D3DGraphicsDriver::InitSpriteBatch(size_t index, const SpriteBatchDesc &des
     glm::mat4 mat_viewport = glmex::make_transform2d(
         (float)desc.Transform.X, (float)desc.Transform.Y,
         desc.Transform.ScaleX, desc.Transform.ScaleY,
-        -Math::DegreesToRadians(desc.Transform.Rotate), pivotx, -pivoty);
+        Math::DegreesToRadians(desc.Transform.Rotate), pivotx, -pivoty);
     glm::mat4 vp_flip_off = glmex::translate(
         _srcRect.GetWidth() * ((1.f - flip_sx) * 0.5f),
         _srcRect.GetHeight() * ((1.f - flip_sy) * 0.5f));

Original file line number	Diff line number	Diff line change
`@@ -138,31 +138,55 @@ struct PointT`
`138`	`138`	`return Pt(X - p.X, Y - p.Y);`
`139`	`139`	`}`
`140`	`140`
`141`		`- inline Pt operator *(T mul) const`
	`141`	`+ inline Pt operator *(const Pt &p) const`
	`142`	`+ {`
	`143`	`+ return Pt(X * p.X, Y * p.Y);`
	`144`	`+ }`
	`145`	`+`
	`146`	`+ inline Pt operator /(const Pt &p) const`
	`147`	`+ {`
	`148`	`+ return Pt(X / p.X, Y / p.Y);`
	`149`	`+ }`
	`150`	`+`
	`151`	`+ inline Pt &operator *=(const Pt p)`
	`152`	`+ {`
	`153`	`+ X *= p.X;`
	`154`	`+ Y *= p.Y;`
	`155`	`+ return *this;`
	`156`	`+ }`
	`157`	`+`
	`158`	`+ inline Pt &operator /=(const Pt p)`
	`159`	`+ {`
	`160`	`+ X /= p.X;`
	`161`	`+ Y /= p.Y;`
	`162`	`+ return *this;`
	`163`	`+ }`
	`164`	`+`
	`165`	`+ inline Pt operator *(const T &mul) const`
`142`	`166`	`{`
`143`	`167`	`return Pt(X * mul, Y * mul);`
`144`	`168`	`}`
`145`	`169`
`146`		`- inline Pt operator /(T div) const`
	`170`	`+ inline Pt operator /(const T &div) const`
`147`	`171`	`{`
`148`	`172`	`return Pt(X / div, Y / div);`
`149`	`173`	`}`
`150`	`174`
`151`		`- inline Pt &operator *=(T mul)`
	`175`	`+ inline Pt &operator *=(const T &mul)`
`152`	`176`	`{`
`153`	`177`	`X *= mul;`
`154`	`178`	`Y *= mul;`
`155`	`179`	`return *this;`
`156`	`180`	`}`
`157`	`181`
`158`		`- inline Pt &operator /=(T div)`
	`182`	`+ inline Pt &operator /=(const T &div)`
`159`	`183`	`{`
`160`	`184`	`X /= div;`
`161`	`185`	`Y /= div;`
`162`	`186`	`return *this;`
`163`	`187`	`}`
`164`	`188`
`165`		`- inline bool Equals(const T x, const T y) const`
	`189`	`+ inline bool Equals(const T &x, const T &y) const`
`166`	`190`	`{`
`167`	`191`	`return X == x && Y == y;`
`168`	`192`	`}`
Original file line number	Diff line number	Diff line change
`@@ -91,13 +91,24 @@ bool GraphicsDriverBase::GetVsync() const`
`91`	`91`
`92`	`92`	`void GraphicsDriverBase::BeginSpriteBatch(const Rect &viewport, const SpriteTransform &transform, uint32_t filter_flags)`
`93`	`93`	`{`
`94`		`- BeginSpriteBatch(SpriteBatchDesc(_actSpriteBatch, viewport, transform, kFlip_None, nullptr, filter_flags));`
	`94`	`+ BeginSpriteBatch(SpriteBatchDesc(_actSpriteBatch, viewport, transform, Size(), kFlip_None, nullptr, filter_flags));`
	`95`	`+}`
	`96`	`+`
	`97`	`+void GraphicsDriverBase::BeginSpriteBatch(const Rect &viewport, const SpriteTransform &transform, const Size &size_ref, uint32_t filter_flags)`
	`98`	`+{`
	`99`	`+ BeginSpriteBatch(SpriteBatchDesc(_actSpriteBatch, viewport, transform, size_ref, kFlip_None, nullptr, filter_flags));`
`95`	`100`	`}`
`96`	`101`
`97`	`102`	`void GraphicsDriverBase::BeginSpriteBatch(const Rect &viewport, const SpriteTransform &transform,`
`98`	`103`	`GraphicFlip flip, PBitmap surface, uint32_t filter_flags)`
`99`	`104`	`{`
`100`		`- BeginSpriteBatch(SpriteBatchDesc(_actSpriteBatch, viewport, transform, flip, surface, filter_flags));`
	`105`	`+ BeginSpriteBatch(SpriteBatchDesc(_actSpriteBatch, viewport, transform, Size(), flip, surface, filter_flags));`
	`106`	`+}`
	`107`	`+`
	`108`	`+void GraphicsDriverBase::BeginSpriteBatch(const Rect &viewport, const SpriteTransform &transform, const Size &size_ref,`
	`109`	`+ GraphicFlip flip, PBitmap surface, uint32_t filter_flags)`
	`110`	`+{`
	`111`	`+ BeginSpriteBatch(SpriteBatchDesc(_actSpriteBatch, viewport, transform, size_ref, flip, surface, filter_flags));`
`101`	`112`	`}`
`102`	`113`
`103`	`114`	`void GraphicsDriverBase::BeginSpriteBatch(IDriverDependantBitmap *render_target,`