precision_drawing_tools/pdt_view.py

   1 # ***** BEGIN GPL LICENSE BLOCK *****
   2 #
   3 #
   4 # This program is free software; you can redistribute it and/or
   5 # modify it under the terms of the GNU General Public License
   6 # as published by the Free Software Foundation; either version 2
   7 # of the License, or (at your option) any later version.
   8 #
   9 # This program is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 # GNU General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU General Public License
  15 # along with this program; if not, write to the Free Software Foundation,
  16 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17 #
  18 # ***** END GPL LICENCE BLOCK *****
  19 #
  20 # -----------------------------------------------------------------------
  21 # Author: Alan Odom (Clockmender), Rune Morling (ermo) Copyright (c) 2019
  22 #
  23 # Contains code which was inspired by the "Reset 3D View" plugin authored
  24 # by Reiner Prokein (tiles) Copyright (c) 2014 (see T37718)
  25 # -----------------------------------------------------------------------
  26 #
  27 import bpy
  28 from bpy.types import Operator
  29 from math import pi
  30 from mathutils import Quaternion
  31 from .pdt_functions import debug, euler_to_quaternion
  32
  33
  34 class PDT_OT_ViewRot(Operator):
  35     """Rotate View by Absolute Coordinates."""
  36
  37     bl_idname = "pdt.viewrot"
  38     bl_label = "Rotate View"
  39     bl_options = {"REGISTER", "UNDO"}
  40     bl_description = "View Rotation by Absolute Values"
  41
  42     def execute(self, context):
  43         """View Rotation by Absolute Values.
  44
  45         Note:
  46             Rotations are converted to 3x3 Quaternion Rotation Matrix.
  47             This is an Absolute Rotation, not an Incremental Orbit.
  48             Uses pg.rotation_coords scene variable
  49
  50         Args:
  51             context: Blender bpy.context instance.
  52
  53         Returns:
  54             Status Set.
  55         """
  56
  57         scene = context.scene
  58         pg = scene.pdt_pg
  59         roll_value = euler_to_quaternion(
  60             pg.rotation_coords.x * pi / 180,
  61             pg.rotation_coords.y * pi / 180,
  62             pg.rotation_coords.z * pi / 180,
  63         )
  64         context.region_data.view_rotation = roll_value
  65         return {"FINISHED"}
  66
  67
  68 class PDT_OT_ViewRotL(Operator):
  69     """Rotate View Left."""
  70
  71     bl_idname = "pdt.viewleft"
  72     bl_label = "Rotate Left"
  73     bl_options = {"REGISTER", "UNDO"}
  74     bl_description = "View Orbit Left by Delta Value"
  75
  76     def execute(self, context):
  77         """View Orbit Left by Delta Value.
  78
  79         Note:
  80             Uses pg.vrotangle scene variable
  81             Orbits view to the left about its vertical axis
  82
  83         Args:
  84             context: Blender bpy.context instance.
  85
  86         Returns:
  87             Status Set.
  88         """
  89
  90         scene = context.scene
  91         pg = scene.pdt_pg
  92         bpy.ops.view3d.view_orbit(angle=(pg.vrotangle * pi / 180), type="ORBITLEFT")
  93         return {"FINISHED"}
  94
  95
  96 class PDT_OT_ViewRotR(Operator):
  97     """Rotate View Right."""
  98
  99     bl_idname = "pdt.viewright"
 100     bl_label = "Rotate Right"
 101     bl_options = {"REGISTER", "UNDO"}
 102     bl_description = "View Orbit Right by Delta Value"
 103
 104     def execute(self, context):
 105         """View Orbit Right by Delta Value.
 106
 107         Note:
 108             Uses pg.vrotangle scene variable
 109             Orbits view to the right about its vertical axis
 110
 111         Args:
 112             context: Blender bpy.context instance.
 113
 114         Returns:
 115             Status Set.
 116         """
 117
 118         scene = context.scene
 119         pg = scene.pdt_pg
 120         bpy.ops.view3d.view_orbit(angle=(pg.vrotangle * pi / 180), type="ORBITRIGHT")
 121         return {"FINISHED"}
 122
 123
 124 class PDT_OT_ViewRotU(Operator):
 125     """Rotate View Up."""
 126
 127     bl_idname = "pdt.viewup"
 128     bl_label = "Rotate Up"
 129     bl_options = {"REGISTER", "UNDO"}
 130     bl_description = "View Orbit Up by Delta Value"
 131
 132     def execute(self, context):
 133         """View Orbit Up by Delta Value.
 134
 135         Note:
 136             Uses pg.vrotangle scene variable
 137             Orbits view up about its horizontal axis
 138
 139         Args:
 140             context: Blender bpy.context instance.
 141
 142         Returns:
 143             Status Set.
 144         """
 145
 146         scene = context.scene
 147         pg = scene.pdt_pg
 148         bpy.ops.view3d.view_orbit(angle=(pg.vrotangle * pi / 180), type="ORBITUP")
 149         return {"FINISHED"}
 150
 151
 152 class PDT_OT_ViewRotD(Operator):
 153     """Rotate View Down."""
 154
 155     bl_idname = "pdt.viewdown"
 156     bl_label = "Rotate Down"
 157     bl_options = {"REGISTER", "UNDO"}
 158     bl_description = "View Orbit Down by Delta Value"
 159
 160     def execute(self, context):
 161         """View Orbit Down by Delta Value.
 162
 163         Note:
 164             Uses pg.vrotangle scene variable
 165             Orbits view down about its horizontal axis
 166
 167         Args:
 168             context: Blender bpy.context instance.
 169
 170         Returns:
 171             Status Set.
 172         """
 173
 174         scene = context.scene
 175         pg = scene.pdt_pg
 176         bpy.ops.view3d.view_orbit(angle=(pg.vrotangle * pi / 180), type="ORBITDOWN")
 177         return {"FINISHED"}
 178
 179
 180 class PDT_OT_ViewRoll(Operator):
 181     """Roll View."""
 182
 183     bl_idname = "pdt.viewroll"
 184     bl_label = "Roll View"
 185     bl_options = {"REGISTER", "UNDO"}
 186     bl_description = "View Roll by Delta Value"
 187
 188     def execute(self, context):
 189         """View Roll by Delta Value.
 190
 191         Note:
 192             Uses pg.vrotangle scene variable
 193             Rolls view about its normal axis
 194
 195         Args:
 196             context: Blender bpy.context instance.
 197
 198         Returns:
 199             Status Set.
 200         """
 201
 202         scene = context.scene
 203         pg = scene.pdt_pg
 204         bpy.ops.view3d.view_roll(angle=(pg.vrotangle * pi / 180), type="ANGLE")
 205         return {"FINISHED"}
 206
 207
 208 class PDT_OT_ViewIso(Operator):
 209     """Set View Isometric."""
 210
 211     bl_idname = "pdt.viewiso"
 212     bl_label = "Isometric View"
 213     bl_options = {"REGISTER", "UNDO"}
 214     bl_description = "Isometric View"
 215
 216     def execute(self, context):
 217         """Set Isometric View.
 218
 219         Note:
 220             Set view orientation to Orthographic Isometric
 221
 222         Args:
 223             context: Blender bpy.context instance.
 224
 225         Returns:
 226             Status Set.
 227         """
 228
 229         # Rotate view 45 degrees about Z then 32.2644 about X
 230         context.region_data.view_rotation = Quaternion((0.8205, 0.4247, -0.1759, -0.3399))
 231         context.region_data.view_perspective = "ORTHO"
 232         return {"FINISHED"}
 233
 234
 235 class PDT_OT_Reset3DView(Operator):
 236     """Reset Views to Factory Default."""
 237
 238     bl_idname = "pdt.reset_3d_view"
 239     bl_label = "Reset 3D View"
 240     bl_options = {"REGISTER", "UNDO"}
 241     bl_description = "Reset 3D View to Blender Defaults"
 242
 243     def execute(self, context):
 244         """Reset 3D View to Blender Defaults.
 245
 246         Args:
 247             context: Blender bpy.context instance.
 248
 249         Returns:
 250             Status Set.
 251         """
 252
 253         # The default view_distance to the origin when starting up Blender
 254         default_view_distance = 17.986562728881836
 255         default_view_distance = (
 256             bpy.data.screens["Layout"].areas[-1].spaces[0].region_3d.view_distance
 257         )
 258         # The default view_matrix when starting up Blender
 259         default_view_matrix = (
 260             (0.41, -0.4017, 0.8188, 0.0),
 261             (0.912, 0.1936, -0.3617, 0.0),
 262             (-0.0133, 0.8950, 0.4458, 0.0),
 263             (0.0, 0.0, -17.9866, 1.0),
 264         )
 265
 266         view = context.region_data
 267         debug(f"is_orthographic_side_view: {view.is_orthographic_side_view}")
 268         if view.is_orthographic_side_view:
 269             # When the view is orthographic, reset the distance and location.
 270             # The rotation already fits.
 271             debug(f"view_distance before reset: {view.view_distance}")
 272             debug(f"view_location before reset: {view.view_location}")
 273             view.view_distance = default_view_distance
 274             view.view_location = (-0.0, -0.0, -0.0)
 275             view.update()
 276             debug(f"view_distance AFTER reset: {view.view_distance}")
 277             debug(f"view_location AFTER reset: {view.view_location}")
 278         else:
 279             # Otherwise, the view matrix needs to be reset.
 280             debug(f"view_matrix before reset:\n{view.view_matrix}")
 281             view.view_matrix = default_view_matrix
 282             view.view_distance = default_view_distance
 283             view.update()
 284             debug(f"view_matrix AFTER reset:\n{view.view_matrix}")
 285
 286         return {"FINISHED"}