View-Toggle 2x4: TOP/ISO/PERSP/Cam + N/O/S/W mit Norden-Rotation

User-Vorschlag: Architektur-konformes View-Layout — 3D-Views oben, 4
Gebaeudeansichten unten. Plus Norden-Rotation als Doc-Setting damit bei
rotierten Projekten (swissBUILDINGS, Sonnenberechnungen) die richtigen
Wandansichten gepickt werden.

Backend (rhino/kamera.py):
- get_north_angle/set_north_angle — doc.Strings["dossier_north_angle"]
  (Grad im Uhrzeigersinn von +Y, default 0°)
- _scene_target_and_diag(doc) — gemeinsamer Helper fuer Szenen-Center +
  Diagonal-Distanz
- set_cardinal_view(vp, 'N'|'O'|'S'|'W'): rotiert Kamera-Position via
  Norden-Vektor. Parallel-Projektion, Camera-Z = Target-Z (echte
  Elevation), Up-Vektor +Z.
- set_top_view(vp): Plan-Ansicht mit Norden = Up-Vektor (Plan rotiert
  visuell wenn Norden != +Y)
- _set_iso(vp, octant): Octant-Richtung jetzt aus north+east-Vektoren
  konstruiert → ISO rotiert mit Norden mit
- Bridge-Handler SET_NORTH_ANGLE + state.northAngle, notify Oberleiste

Backend (oberleiste.py):
- SET_VIEW erweitert: Top → kamera.set_top_view, N/O/S/W →
  kamera.set_cardinal_view, Iso → kamera._set_iso. Front/Right/etc bleibt
  als Legacy direkt-Rhino-Call.
- State liefert northAngle

Frontend (OberleisteApp):
- VIEWS_ROW1: TOP/ISO/PERSP + Kamera-Settings-Button (Icons only)
- VIEWS_ROW2: N/O/S/W als DM-Mono-Buchstaben
- 2x4-Grid, VIEW_W=140 (konsistent mit Massstab-Pills), CELL_W=35
- matchView nur fuer Top/Iso/Perspective; Cardinals haben keinen
  Active-State (Viewport-Name ist nicht zuverlaessig erkennbar)

Frontend (KameraApp):
- Plan-Norden Section mit Number-Input (Grad, 0.5°-Step) + Reset-Button
- Hinweis-Text dass Wirkung auf TOP/ISO/N/O/S/W geht

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

rhino/kamera.py

@@ -23,6 +23,112 @@ import panel_base
 
 PANEL_GUID_STR = "9c3f8a2d-7b4e-4a6f-9c12-1d4e5f6a7b89"
 _PRESETS_KEY   = "dossier_kamera_presets"
+_NORTH_KEY     = "dossier_north_angle"  # Grad im Uhrzeigersinn von +Y
+
+
+# ---------------------------------------------------------------------------
+# Norden-Rotation: Default +Y = Norden. Bei rotierten Projekten (Site-Plaene,
+# swissBUILDINGS in LV95-Orientierung) kann der User einen Winkel definieren.
+# Wirkt auf N/O/S/W-View-Buttons + (optional) Iso-Octanten.
+
+def get_north_angle(doc):
+    if doc is None: return 0.0
+    try:
+        v = doc.Strings.GetValue(_NORTH_KEY)
+        return float(v) if v else 0.0
+    except Exception:
+        return 0.0
+
+
+def set_north_angle(doc, angle):
+    if doc is None: return
+    try:
+        a = float(angle) % 360.0
+        doc.Strings.SetString(_NORTH_KEY, "{:.3f}".format(a))
+    except Exception as ex:
+        print("[KAMERA] set north:", ex)
+
+
+def _scene_target_and_diag(doc):
+    """Centroid der Szenen-BBox + Diagonal-Laenge. Fallback (0,0,0)/50m."""
+    target = rg.Point3d(0, 0, 0)
+    diag = 50.0
+    try:
+        scene_bb = None
+        for obj in doc.Objects:
+            if obj is None: continue
+            gb = obj.Geometry.GetBoundingBox(True)
+            if not gb.IsValid: continue
+            if scene_bb is None: scene_bb = gb
+            else: scene_bb.Union(gb)
+        if scene_bb is not None and scene_bb.IsValid:
+            target = scene_bb.Center
+            diag = max(scene_bb.Diagonal.Length, 10.0)
+    except Exception: pass
+    return target, diag
+
+
+def set_cardinal_view(vp, cardinal):
+    """Setzt N/O/S/W-Ansicht unter Beruecksichtigung der Norden-Rotation.
+    cardinal: 'N' | 'O' | 'S' | 'W'."""
+    if vp is None: return
+    doc = Rhino.RhinoDoc.ActiveDoc
+    if doc is None: return
+    try:
+        north_deg = get_north_angle(doc)
+        # Norden-Einheitsvektor (Uhrzeigersinn-Rotation von +Y aus Top-View):
+        # angle=0 → (0,1,0); angle=90 → (1,0,0); angle=180 → (0,-1,0).
+        nrad = math.radians(north_deg)
+        north = (math.sin(nrad), math.cos(nrad))
+        east  = (math.cos(nrad), -math.sin(nrad))
+        c = cardinal.upper()
+        if   c == "N": dx, dy = north
+        elif c == "S": dx, dy = -north[0], -north[1]
+        elif c == "O" or c == "E": dx, dy = east
+        elif c == "W": dx, dy = -east[0], -east[1]
+        else: return
+
+        target, diag = _scene_target_and_diag(doc)
+        dist = diag * 1.6
+        # Kamera auf Hoehe des Target-Z (echte Elevation, horizontal blickend)
+        loc = rg.Point3d(target.X + dx * dist,
+                          target.Y + dy * dist,
+                          target.Z)
+        if not vp.IsParallelProjection:
+            vp.ChangeToParallelProjection(True)
+        vp.SetCameraLocations(target, loc)
+        # Camera-Up muss +Z sein (sonst kippt die Ansicht)
+        try: vp.CameraUp = rg.Vector3d.ZAxis
+        except Exception: pass
+        try: vp.ZoomExtents()
+        except Exception: pass
+        Rhino.RhinoDoc.ActiveDoc.Views.ActiveView.Redraw()
+    except Exception as ex:
+        print("[KAMERA] set cardinal:", ex)
+
+
+def set_top_view(vp):
+    """Plan-Ansicht (oben), rotiert nach Norden-Setting."""
+    if vp is None: return
+    doc = Rhino.RhinoDoc.ActiveDoc
+    if doc is None: return
+    try:
+        target, diag = _scene_target_and_diag(doc)
+        loc = rg.Point3d(target.X, target.Y, target.Z + diag * 2)
+        if not vp.IsParallelProjection:
+            vp.ChangeToParallelProjection(True)
+        vp.SetCameraLocations(target, loc)
+        # Plan-Norden zeigt nach oben im Viewport → Up-Vector = north
+        north_deg = get_north_angle(doc)
+        nrad = math.radians(north_deg)
+        try:
+            vp.CameraUp = rg.Vector3d(math.sin(nrad), math.cos(nrad), 0)
+        except Exception: pass
+        try: vp.ZoomExtents()
+        except Exception: pass
+        Rhino.RhinoDoc.ActiveDoc.Views.ActiveView.Redraw()
+    except Exception as ex:
+        print("[KAMERA] set top:", ex)
 
 
 def _read_viewport(vp):
@@ -128,39 +234,26 @@ def _set_viewport(vp, data):
 
 
 def _set_iso(vp, octant="NE"):
-    """Setzt eine standard-architektonische Iso-Ansicht.
+    """Setzt eine standard-architektonische Iso-Ansicht (35.26° vertikal,
-    octant: 'NE' | 'NW' | 'SE' | 'SW' — die XY-Diagonale aus der die Kamera blickt.
+    45° horizontal). octant: 'NE' | 'NW' | 'SE' | 'SW' — die XY-Diagonale
-    Winkel: 35.264° (true iso) vertikal, 45° horizontal."""
+    relativ zum Norden des Projekts (= rotiert mit dossier_north_angle)."""
     if vp is None: return
+    doc = Rhino.RhinoDoc.ActiveDoc
+    if doc is None: return
     try:
-        # Aktuelle Szenen-BBox als Target-Mitte
+        target, diag = _scene_target_and_diag(doc)
-        doc = Rhino.RhinoDoc.ActiveDoc
+        # Octant-Basisvektor (vor Norden-Rotation): NE = (+1,+1)
-        bb = doc.Objects.GetSelectedObjects(False, False)
+        sign_e = 1 if "E" in octant.upper() else -1
-        # Falls keine Selektion: ganze Szene
+        sign_n = 1 if "N" in octant.upper() else -1
-        try:
+        north_deg = get_north_angle(doc)
-            bbox = doc.Objects.BoundingBoxCorners
+        nrad = math.radians(north_deg)
-        except Exception:
+        # Norden-Vektor + Osten-Vektor im Welt-Koordinatensystem
-            bbox = None
+        north_vec = (math.sin(nrad), math.cos(nrad))
-        target = rg.Point3d(0, 0, 0)
+        east_vec  = (math.cos(nrad), -math.sin(nrad))
-        diag = 50.0
+        # Iso-XY-Richtung = sign_e * east + sign_n * north
-        try:
+        dx = sign_e * east_vec[0] + sign_n * north_vec[0]
-            scene_bb = None
+        dy = sign_e * east_vec[1] + sign_n * north_vec[1]
-            for obj in doc.Objects:
+        dz = 1.0
-                if obj is None: continue
-                gb = obj.Geometry.GetBoundingBox(True)
-                if not gb.IsValid: continue
-                if scene_bb is None: scene_bb = gb
-                else: scene_bb.Union(gb)
-            if scene_bb is not None and scene_bb.IsValid:
-                target = scene_bb.Center
-                diag = max(scene_bb.Diagonal.Length, 10.0)
-        except Exception: pass
-
-        sign_x = 1 if "E" in octant.upper() else -1
-        sign_y = 1 if "N" in octant.upper() else -1
-
-        # True iso direction: (sign_x, sign_y, 1) normalized * distance
-        dx = sign_x; dy = sign_y; dz = 1.0
         L = math.sqrt(dx*dx + dy*dy + dz*dz)
         dist = diag * 1.6
         loc = rg.Point3d(target.X + dx/L * dist,
@@ -197,8 +290,9 @@ def _payload():
     doc = Rhino.RhinoDoc.ActiveDoc
     vp = _active_viewport()
     return {
-        "viewport": _read_viewport(vp),
+        "viewport":   _read_viewport(vp),
-        "presets":  _load_presets(doc),
+        "presets":    _load_presets(doc),
+        "northAngle": get_north_angle(doc),
     }
 
 
@@ -229,6 +323,14 @@ class KameraBridge(panel_base.BaseBridge):
             vp = _active_viewport()
             _set_iso(vp, p.get("octant") or "NE")
             self._send_state()
+        elif t == "SET_NORTH_ANGLE":
+            set_north_angle(Rhino.RhinoDoc.ActiveDoc, p.get("angle") or 0)
+            self._send_state()
+            # Topbar refreshen damit dort der neue Winkel sichtbar ist
+            try:
+                b = sc.sticky.get("oberleiste_bridge")
+                if b is not None: b._send_state(force=True)
+            except Exception: pass
         elif t == "SET_PROJECTION":
             vp = _active_viewport()
             if vp is not None:

rhino/oberleiste.py

@@ -875,20 +875,40 @@ class OberleisteBridge(panel_base.BaseBridge):
         # --- View-Switcher ----------------------------------------------
         elif t == "SET_VIEW":
             v = p.get("view")
-            if v in ("Top", "Front", "Right", "Perspective", "Left", "Back", "Bottom"):
+            try:
+                import kamera
+                vp = kamera._active_viewport()
+            except Exception:
+                vp = None
+            if v == "Top":
+                # Plan rotiert mit Norden — Up-Vektor zeigt Norden
+                try:
+                    import kamera
+                    kamera.set_top_view(vp)
+                except Exception as ex:
+                    print("[OBERLEISTE] top:", ex)
+                self._send_state(force=True)
+            elif v == "Perspective":
                 _run("_-{} _Enter".format(v))
                 self._send_state(force=True)
             elif v == "Iso":
-                # Standard-Architektur-Isometrie aus NE, true-iso 35°/45°.
-                # Implementiert in kamera.py — Logik dort, damit Kamera-
-                # Panel und Topbar dieselbe Berechnung teilen.
                 try:
                     import kamera
-                    vp = kamera._active_viewport()
                     kamera._set_iso(vp, "NE")
                 except Exception as ex:
                     print("[OBERLEISTE] iso:", ex)
                 self._send_state(force=True)
+            elif v in ("N", "O", "S", "W"):
+                try:
+                    import kamera
+                    kamera.set_cardinal_view(vp, v)
+                except Exception as ex:
+                    print("[OBERLEISTE] cardinal:", ex)
+                self._send_state(force=True)
+            elif v in ("Front", "Right", "Left", "Back", "Bottom"):
+                # Legacy direkte Rhino-Views (falls noch wo benutzt)
+                _run("_-{} _Enter".format(v))
+                self._send_state(force=True)
 
         # --- Kamera-Panel oeffnen ---------------------------------------
         elif t == "OPEN_KAMERA_PANEL":
@@ -1177,6 +1197,12 @@ class OberleisteBridge(panel_base.BaseBridge):
                 self._fonts_sent = True
         except Exception:
             info["textSettings"] = {}
+        # Norden-Rotation fuer N/O/S/W-Buttons
+        try:
+            import kamera
+            info["northAngle"] = kamera.get_north_angle(doc)
+        except Exception:
+            info["northAngle"] = 0
         # Command-Line State
         prompt = _get_command_prompt()
         info["cmdPrompt"]  = prompt

src/KameraApp.jsx

@@ -4,6 +4,7 @@ import {
   onMessage, notifyReady,
   setKameraViewport, setKameraProjection, setKameraIso,
   kameraZoomExtents, saveKameraPreset, applyKameraPreset, deleteKameraPreset,
+  setKameraNorthAngle,
 } from './lib/rhinoBridge'
 
 const labelXs = {
@@ -76,11 +77,13 @@ export default function KameraApp() {
   const [vp, setVp] = useState(null)
   const [presets, setPresets] = useState([])
   const [presetName, setPresetName] = useState('')
+  const [northAngle, setNorthAngleState] = useState(0)
 
   useEffect(() => {
     onMessage('STATE', (s) => {
       setVp(s.viewport || null)
       setPresets(s.presets || [])
+      if (typeof s.northAngle === 'number') setNorthAngleState(s.northAngle)
     })
     notifyReady()
   }, [])
@@ -142,6 +145,38 @@ export default function KameraApp() {
         </div>
       </div>
 
+      {/* Plan-Norden — Rotations-Winkel im Uhrzeigersinn von +Y */}
+      <div style={{ display: 'flex', flexDirection: 'column', gap: 6 }}>
+        <span style={labelXs}>Plan-Norden (Rotation von +Y, im Uhrzeigersinn)</span>
+        <div style={{ display: 'flex', alignItems: 'center', gap: 8 }}>
+          <input
+            type="number" min={0} max={360} step={0.5}
+            value={northAngle.toFixed(1)}
+            onChange={(e) => {
+              const a = parseFloat(e.target.value)
+              if (!isNaN(a)) {
+                setNorthAngleState(a)
+                setKameraNorthAngle(a)
+              }
+            }}
+            style={{ flex: 1, fontSize: 12, padding: '4px 8px',
+                      fontFamily: 'DM Mono, monospace' }}
+          />
+          <span style={{ fontSize: 11, color: 'var(--text-muted)' }}>°</span>
+          <button
+            onClick={() => { setNorthAngleState(0); setKameraNorthAngle(0) }}
+            className="btn-outlined"
+            style={{ padding: '4px 10px', fontSize: 10 }}
+            title="Norden zurueck auf +Y (0°)"
+          >Reset</button>
+        </div>
+        <span style={{ fontSize: 10, color: 'var(--text-muted)', lineHeight: 1.4 }}>
+          Norden = +Y bei 0°. Bei rotierten Projekten (z.B. swissBUILDINGS in
+          LV95-Orientierung oder Sonnenberechnungen) hier den Plan-Norden in
+          Grad eintragen. Wirkt auf TOP, ISO und N/O/S/W-Ansichten.
+        </span>
+      </div>
+
       {/* Iso-Quick-Picker */}
       <div style={{ display: 'flex', flexDirection: 'column', gap: 6 }}>
         <span style={labelXs}>Isometrie (Standard, true-iso 35°/45°)</span>

src/OberleisteApp.jsx

@@ -22,12 +22,19 @@ const PRESETS = [
   { value: 500, label: '1:500' }, { value: 1000, label: '1:1000' },
 ]
 
-const VIEWS = [
+// Reihe 1: 3D-Ansichten (Top, Iso, Persp) + Kamera-Button
-  { value: 'Top',         icon: 'view_quilt',     label: 'Top' },
+// Reihe 2: 4 Gebaeudeansichten (Norden/Osten/Sueden/Westen) — Buchstaben
-  { value: 'Front',       icon: 'north',          label: 'Front' },
+//          als Symbol, rotieren mit dossier_north_angle.
-  { value: 'Right',       icon: 'east',           label: 'Right' },
+const VIEWS_ROW1 = [
-  { value: 'Iso',         icon: 'view_in_ar',     label: 'Iso' },
+  { value: 'Top',         icon: 'crop_landscape', kind: 'icon' },
-  { value: 'Perspective', icon: '3d_rotation',    label: 'Persp' },
+  { value: 'Iso',         icon: 'view_in_ar',     kind: 'icon' },
+  { value: 'Perspective', icon: '3d_rotation',    kind: 'icon' },
+]
+const VIEWS_ROW2 = [
+  { value: 'N', label: 'N', kind: 'letter' },
+  { value: 'O', label: 'O', kind: 'letter' },
+  { value: 'S', label: 'S', kind: 'letter' },
+  { value: 'W', label: 'W', kind: 'letter' },
 ]
 
 function fmtScale(s) {
@@ -307,6 +314,7 @@ export default function OberleisteApp() {
     massePresets: [], masseActiveId: null,
     textSettings: { font: 'Helvetica', size: 0.20, bold: false, italic: false },
     textFonts: [],
+    northAngle: 0,
   })
   const [appliedScale, setAppliedScale] = useState(null)
   const appliedScaleRef = useRef(null)
@@ -365,20 +373,19 @@ export default function OberleisteApp() {
     if (appliedScale && appliedScale > 0) setMassstab(appliedScale)
   }
 
-  // Aktuelles View-Match. Orthogonale Standard-Views matchen via viewName.
+  // Aktuelles View-Match. Top/Persp/Iso werden via parallel-Flag und
-  // 'Iso' und 'Perspective' werden via parallel-Flag unterschieden — die
+  // viewName unterschieden. N/O/S/W: kein zuverlaessiges View-Match
-  // Rhino-Viewport-Namen sind beide oft "Perspective".
+  // ueber den Viewport-Namen (wir setzen die Camera direkt) — daher
+  // kein Active-State fuer Cardinals.
   const matchView = (v) => {
     const name = (state.viewName || '').toLowerCase()
-    const ortho = ['top', 'front', 'right', 'bottom', 'left', 'back']
+    if (v === 'Top') return name === 'top'
+    if (v === 'Perspective') return state.parallel === false
     if (v === 'Iso') {
-      // Parallel-Projektion + kein orthogonaler Standardname → Iso
+      const ortho = ['top', 'front', 'right', 'bottom', 'left', 'back']
       return state.parallel === true && !ortho.includes(name)
     }
-    if (v === 'Perspective') {
+    return false
-      return state.parallel === false
-    }
-    return name === v.toLowerCase()
   }
 
   // (Command-Bar wurde entfernt — Rhinos eigene Command-Line wird benutzt.)
@@ -435,52 +442,88 @@ export default function OberleisteApp() {
         <Icon name="settings" size={14} />
       </button>
       <div style={sep} />
-      {/* ====== VIEW (Top/Front/Right/Iso/Persp + Kamera) ======
+      {/* ====== VIEW 2x4 Grid ======
-          Segmented-Pill-Gruppe analog Vectorworks. Active = accent fill. */}
+          Reihe 1: TOP / ISO / PERSP / 📷 (Kamera-Settings)
-      <div style={{ display: 'inline-flex', flexShrink: 0 }}>
+          Reihe 2: N / O / S / W (rotieren mit dossier_north_angle)
-        {VIEWS.map((v, idx) => {
+      */}
-          const isFirst = idx === 0
+      {(() => {
-          const isLast = idx === VIEWS.length - 1
+        const VIEW_W = 140  // konsistent mit Massstab-Pills
-          const isActive = matchView(v.value)
+        const CELL_W = Math.floor(VIEW_W / 4)
-          return (
+        const cellStyle = (isActive, isFirst) => ({
-            <button
+          height: BAR_H, width: CELL_W,
-              key={v.value}
+          background: isActive ? 'var(--accent)' : 'var(--bg-input)',
-              onClick={() => setView(v.value)}
+          color: isActive ? 'var(--bg-panel)' : 'var(--text-primary)',
-              title={`Ansicht ${v.label}`}
+          border: 'none',
-              onMouseEnter={(e) => {
+          borderLeft: isFirst ? 'none' : '1px solid var(--border)',
-                if (isActive) return
+          display: 'inline-flex', alignItems: 'center', justifyContent: 'center',
-                e.currentTarget.style.background = 'var(--bg-item-hover)'
+          gap: 4, fontWeight: isActive ? 600 : 500,
-                e.currentTarget.style.color = 'var(--accent-light)'
+          cursor: 'pointer', flexShrink: 0, padding: 0,
-              }}
+          transition: 'background 0.15s, color 0.15s',
-              onMouseLeave={(e) => {
+        })
-                if (isActive) return
+        const hoverIn = (isActive) => (e) => {
-                e.currentTarget.style.background = 'var(--bg-input)'
+          if (isActive) return
-                e.currentTarget.style.color = 'var(--text-primary)'
+          e.currentTarget.style.background = 'var(--bg-item-hover)'
-              }}
+          e.currentTarget.style.color = 'var(--accent-light)'
-              style={{
+        }
-                height: BAR_H, padding: '0 10px',
+        const hoverOut = (isActive) => (e) => {
-                background: isActive ? 'var(--accent)' : 'var(--bg-input)',
+          if (isActive) return
-                color: isActive ? 'var(--bg-panel)' : 'var(--text-primary)',
+          e.currentTarget.style.background = 'var(--bg-input)'
-                border: '1px solid var(--border)',
+          e.currentTarget.style.color = 'var(--text-primary)'
-                borderLeft: isFirst ? '1px solid var(--border)' : 'none',
+        }
-                borderTopLeftRadius: isFirst ? 999 : 0,
+        // Reihe 1: 3 View-Icons + Kamera-Settings
-                borderBottomLeftRadius: isFirst ? 999 : 0,
+        const row1 = [
-                borderTopRightRadius: isLast ? 999 : 0,
+          ...VIEWS_ROW1,
-                borderBottomRightRadius: isLast ? 999 : 0,
+          { value: '__camera__', icon: 'videocam', kind: 'icon' },
-                display: 'inline-flex', alignItems: 'center', gap: 4,
+        ]
-                fontSize: 10, fontWeight: isActive ? 600 : 500,
+        return (
-                cursor: 'pointer', flexShrink: 0,
+          <div style={{
-                transition: 'background 0.15s, color 0.15s',
+            display: 'flex', flexDirection: 'column', gap: 4, flexShrink: 0,
-              }}
+          }}>
-            >
+            {/* Reihe 1 */}
-              <Icon name={v.icon} size={13} />
+            <div style={{
-              <span>{v.label}</span>
+              display: 'inline-flex', width: VIEW_W,
-            </button>
+              border: '1px solid var(--border)', borderRadius: 999,
-          )
+              overflow: 'hidden', flexShrink: 0,
-        })}
+            }}>
-      </div>
+              {row1.map((v, idx) => {
-      <BarButton icon="videocam" onClick={() => openKameraPanel()}
+                const isActive = v.value !== '__camera__' && matchView(v.value)
-                  title="Kamera-Einstellungen (Position, Target, Linse, Presets)" />
+                const label = v.value === '__camera__' ? 'Kamera-Einstellungen'
+                  : `Ansicht ${v.value}`
+                return (
+                  <button key={v.value}
+                    onClick={() => v.value === '__camera__'
+                      ? openKameraPanel() : setView(v.value)}
+                    title={label}
+                    onMouseEnter={hoverIn(isActive)}
+                    onMouseLeave={hoverOut(isActive)}
+                    style={cellStyle(isActive, idx === 0)}>
+                    <Icon name={v.icon} size={13} />
+                  </button>
+                )
+              })}
+            </div>
+            {/* Reihe 2: N/O/S/W als Buchstaben */}
+            <div style={{
+              display: 'inline-flex', width: VIEW_W,
+              border: '1px solid var(--border)', borderRadius: 999,
+              overflow: 'hidden', flexShrink: 0,
+            }}>
+              {VIEWS_ROW2.map((v, idx) => (
+                <button key={v.value}
+                  onClick={() => setView(v.value)}
+                  title={`Ansicht aus ${v.value} (Norden = ${(state.northAngle || 0).toFixed(0)}°)`}
+                  onMouseEnter={hoverIn(false)}
+                  onMouseLeave={hoverOut(false)}
+                  style={cellStyle(false, idx === 0)}>
+                  <span style={{
+                    fontFamily: 'DM Mono, monospace', fontSize: 11, fontWeight: 600,
+                  }}>{v.label}</span>
+                </button>
+              ))}
+            </div>
+          </div>
+        )
+      })()}
 
       <div style={sep} />
 

src/lib/rhinoBridge.js

@@ -191,6 +191,7 @@ export function kameraZoomExtents()      { send('ZOOM_EXTENTS', {}) }
 export function saveKameraPreset(name)   { send('SAVE_PRESET', { name }) }
 export function applyKameraPreset(id)    { send('APPLY_PRESET', { id }) }
 export function deleteKameraPreset(id)   { send('DELETE_PRESET', { id }) }
+export function setKameraNorthAngle(angle) { send('SET_NORTH_ANGLE', { angle: Number(angle) || 0 }) }
 // Ebenenkombinationen (gehosted in Oberleiste, gleicher Store wie EBENEN)
 export function pickLayerCombination(name)   { send('PICK_LAYER_COMBINATION',   { name: name || null }) }
 export function saveLayerCombination(name)   { send('SAVE_LAYER_COMBINATION',   { name }) }