Add camera rotation support, closes #977

Author: CodeDoctorDE

app/lib/cubits/editor_renderer.dart

@@ -132,25 +132,14 @@ class RendererCubit extends Cubit<RendererRuntimeState> {
     final transform = transformCubit.state;
     final resolution = settingsCubit.state.renderResolution;
     final friction = transform.friction;
-    final realWidth = size.width / transform.size;
-    final realHeight = size.height / transform.size;
-    Rect rect = Rect.fromLTWH(
-      transform.position.dx,
-      transform.position.dy,
-      realWidth,
-      realHeight,
-    );
+    Rect rect = transform.localToGlobalRect(Offset.zero & size);
     if (friction != null) {
       final beginPosition = transform.position - friction.beginOffset;
-      final topLeft = Offset(
-        min(transform.position.dx, beginPosition.dx),
-        min(transform.position.dy, beginPosition.dy),
-      );
-      final frictionSize = Size(
-        realWidth + (friction.beginOffset.dx * transform.size).abs(),
-        realHeight + (friction.beginOffset.dy * transform.size).abs(),
+      rect = rect.expandToInclude(
+        transform
+            .withPosition(beginPosition)
+            .localToGlobalRect(Offset.zero & size),
       );
-      rect = topLeft & frictionSize;
     }
     return _snapViewportRect(rect, size, transform, resolution);
   }
@@ -161,10 +150,7 @@ class RendererCubit extends Cubit<RendererRuntimeState> {
     CameraTransform transform,
     RenderResolution resolution,
   ) {
-    final screenRect = Rect.fromPoints(
-      transform.globalToLocal(rect.topLeft),
-      transform.globalToLocal(rect.bottomRight),
-    );
+    final screenRect = transform.globalToLocalRect(rect);
     final snappedRect = _expandScreenRect(
       Rect.fromLTRB(
         screenRect.left.floorToDouble(),
@@ -177,10 +163,7 @@ class RendererCubit extends Cubit<RendererRuntimeState> {
         (size.height * resolution.multiplier).ceilToDouble(),
       ),
     );
-    return Rect.fromPoints(
-      transform.localToGlobal(snappedRect.topLeft),
-      transform.localToGlobal(snappedRect.bottomRight),
-    );
+    return transform.localToGlobalRect(snappedRect);
   }
 
   Rect _expandScreenRect(Rect rect, Size minimumSize) {

app/lib/cubits/editor_session.dart

@@ -81,6 +81,7 @@ class EditorSessionCubit extends Cubit<PersistedDocumentState> {
     _transformCubit.state.pixelRatio,
     Offset(state.camera.positionX, state.camera.positionY),
     state.camera.zoom,
+    state.camera.rotation,
   );
 
   int resolveToolIndex(DocumentInfo info) {
@@ -107,6 +108,7 @@ class EditorSessionCubit extends Cubit<PersistedDocumentState> {
       positionX: transform.position.dx,
       positionY: transform.position.dy,
       zoom: transform.size,
+      rotation: transform.rotation,
     );
     if (state.camera == camera) return;
     emit(state.copyWith(camera: camera));

app/lib/cubits/transform.dart

@@ -41,30 +41,70 @@ sealed class CameraTransform with _$CameraTransform {
     @Default(1) double pixelRatio,
     @Default(Offset.zero) Offset position,
     @Default(1) double size,
+    @Default(0) double rotation,
     FrictionState? friction,
   ]) = _CameraTransform;
 
   CameraTransform withPosition(Offset position) =>
-      CameraTransform(pixelRatio, position, size);
+      CameraTransform(pixelRatio, position, size, rotation);
 
   CameraTransform withPointPosition(Point<double> position) =>
-      CameraTransform(pixelRatio, position.toOffset(), size);
+      CameraTransform(pixelRatio, position.toOffset(), size, rotation);
 
   CameraTransform withSize(double size, [Offset cursor = Offset.zero]) {
     // Set size and focus on cursor if provided
     final double newSize = size.clamp(kMinZoom, kMaxZoom);
-    var mx = localToGlobal(cursor);
-    mx = (mx - position) * newSize;
-
     return CameraTransform(
       pixelRatio,
-      position + (mx - cursor) / newSize,
+      localToGlobal(cursor) - cursor.rotate(Offset.zero, -rotation) / newSize,
       newSize,
+      rotation,
+    );
+  }
+
+  CameraTransform withRotation(double rotation, [Offset cursor = Offset.zero]) {
+    final normalized = (rotation + pi) % (2 * pi) - pi;
+    return CameraTransform(
+      pixelRatio,
+      localToGlobal(cursor) - cursor.rotate(Offset.zero, -normalized) / size,
+      size,
+      normalized,
+    );
+  }
+
+  Offset localToGlobal(Offset local) =>
+      local.rotate(Offset.zero, -rotation) / size + position;
+
+  Offset globalToLocal(Offset global) =>
+      ((global - position) * size).rotate(Offset.zero, rotation);
+
+  Offset localToGlobalDelta(Offset delta) =>
+      delta.rotate(Offset.zero, -rotation) / size;
+
+  Rect localToGlobalRect(Rect rect) => _transformRect(rect, localToGlobal);
+
+  Rect globalToLocalRect(Rect rect) => _transformRect(rect, globalToLocal);
+
+  Rect _transformRect(Rect rect, Offset Function(Offset) transform) {
+    final points = [
+      transform(rect.topLeft),
+      transform(rect.topRight),
+      transform(rect.bottomLeft),
+      transform(rect.bottomRight),
+    ];
+    return Rect.fromLTRB(
+      points.map((point) => point.dx).reduce(min),
+      points.map((point) => point.dy).reduce(min),
+      points.map((point) => point.dx).reduce(max),
+      points.map((point) => point.dy).reduce(max),
     );
   }
 
-  Offset localToGlobal(Offset local) => local / size + position;
-  Offset globalToLocal(Offset global) => (global - position) * size;
+  void applyToCanvas(Canvas canvas) {
+    canvas.rotate(rotation);
+    canvas.scale(size);
+    canvas.translate(-position.dx, -position.dy);
+  }
 
   double _getFinalTime(
     double velocity,
@@ -125,6 +165,7 @@ sealed class CameraTransform with _$CameraTransform {
       pixelRatio,
       finalPosition,
       finalScale,
+      rotation,
       frictionState,
     );
   }
@@ -134,12 +175,13 @@ sealed class CameraTransform with _$CameraTransform {
       pixelRatio,
       this.position - position,
       this.size - size,
+      rotation,
       null,
     );
   }
 
   CameraTransform improve(RenderResolution resolution, Rect rect) {
-    return CameraTransform(pixelRatio, rect.topLeft, size, friction);
+    return CameraTransform(pixelRatio, rect.topLeft, size, 0, friction);
   }
 }
 
@@ -149,14 +191,21 @@ class TransformCubit extends Cubit<CameraTransform> {
 
   void move(Offset delta) => emit(state.withPosition(state.position + delta));
 
-  void teleport(Offset position, [double? scale]) =>
-      emit(state.withPosition(position).withSize(scale ?? state.size));
+  void teleport(Offset position, [double? scale, double? rotation]) => emit(
+    state
+        .withPosition(position)
+        .withSize(scale ?? state.size)
+        .withRotation(rotation ?? state.rotation),
+  );
 
   void zoom(double delta, [Offset cursor = Offset.zero]) =>
       emit(state.withSize(state.size * delta, cursor));
 
   void focus(Offset cursor) => emit(state.withSize(state.size, cursor));
 
+  void rotate(double delta, [Offset cursor = Offset.zero]) =>
+      emit(state.withRotation(state.rotation + delta, cursor));
+
   void reset() => emit(CameraTransform(state.pixelRatio));
 
   void size(double size, [Offset cursor = Offset.zero]) =>
@@ -519,6 +568,18 @@ class TransformCubit extends Cubit<CameraTransform> {
     teleport(clamped.position, clamped.size);
   }
 
+  void rotateConstrained(
+    double delta, {
+    required EditorRuntimeContext runtime,
+    Offset cursor = Offset.zero,
+    bool force = false,
+  }) {
+    if (delta == 0 || (runtime.viewCubit.state.locks.lockRotation && !force)) {
+      return;
+    }
+    rotate(delta, cursor);
+  }
+
   void sizeConstrained(
     double size, {
     required EditorRuntimeContext runtime,

app/lib/cubits/transform.freezed.dart

@@ -55,6 +55,7 @@ sealed class PersistedCameraState with _$PersistedCameraState {
     @Default(0) double positionX,
     @Default(0) double positionY,
     @Default(1) double zoom,
+    @Default(0) double rotation,
   }) = _PersistedCameraState;
 
   factory PersistedCameraState.fromJson(Map<String, dynamic> json) =>
@@ -71,6 +72,7 @@ sealed class PersistentLockState with _$PersistentLockState {
     @Default(false) bool lockZoom,
     @Default(false) bool lockHorizontal,
     @Default(false) bool lockVertical,
+    @Default(false) bool lockRotation,
   }) = _PersistentLockState;
 
   factory PersistentLockState.fromJson(Map<String, dynamic> json) =>