Rotate objects around their origin along a global axis (scripted) without bpy.ops

Question

I have read so much about Blender rotation in the last two hours that my head is spinning, but I can not understand how to rotate strictly in global coordinates without using bpy.ops. In reality I will have a large number of objects and do this frequently, so I'd like to use a rotation method of the objects themselves, like one of these: obj.rotate_euler() or obj.matrix_world *= some_vector or obj.rotation_axis_angle()

but I don't understand how to use them for strictly single global axis rotations like the following example:

import bpy
import math

half_pi = 0.5 * math.pi

group = []
for y in [-3, 0, 3]:
    bpy.ops.mesh.primitive_cylinder_add(location=(0, y, 0)) # ops is OK here, but not in the rotations
    obj = bpy.context.active_object
    group.append(obj)

zangles = [1, 1.5, 2] # radains

for obj, zangle in zip(group, zangles):
    bpy.ops.object.select_all(action='DESELECT')
    obj.select = True
    bpy.ops.transform.rotate(value=half_pi, axis=(1, 0, 0))  # rotate about global X by 90 degrees
    bpy.ops.transform.rotate(value=zangle,  axis=(0, 0, 1))  # rotate about global Z by zangle

bpy.ops.object.select_all(action='DESELECT')

ops can rotate globally, but I don't see any methods associated with objects to to global rotation, and I can't figure out how to do that.

A link to a less theoretical, and more "if you want to do this, use this" scripted rotation explanation would also be greatly appreciated. I'm OK with the math, it's the Blender conventions I can not get a handle on.

Answer 1

TL;DR > Skip to last paragraph

Each object has it's own World Matrix. It's a 4x4 transform matrix that stores the object's final location, rotation and scale. By doing math operations directly on this matrix we can transform the object how ever we want.

Every world matrix can be decomposed into it's components:

loc, rot, scale = obj.matrix_world.decompose()

We get a

• location vector (size 3)
• rotation quaternion (size 4)
• scale vector (size 3)

Now about rotations. A rotation is either represented by a (3x3 or 4x4) Rotation Matrix (Euler or Matrix class in Blender), Quaternion vector (Quaternion class) or an axis (Vector of size 3) with rotation value (radians). They can be all converted between each other, but we just need the 4x4 rotation matrix. There are different options to construct it:

from mathutils import Matrix, Euler, Quaternion

# directly
Matrix.Rotation(angle, 4, axis)

# converting from Euler matrix
Euler((angleX, angleY, angleZ), 'XYZ').to_4x4()

# converting from quaternion
Quaternion((w, x, y, z)).to_matrix().to_4x4()

Transformations are done with matrix multiplication and the order in which they are multiplied is important, as the operation is not commutative. Doing:

matA @ matB @ matC

means the result will be like first transforming with matC, then matB and last matA (it's reversed from how you multiply them). All the transformations are applied in global space.

Here you can see what it looks like to do Translation @ Rotation (on the left) and Rotation @ Translation (on the right):

The first end-result we can substitute with a local translation and then local rotation, and the second we can substitute with a local rotation and then local translation. This means only the first matrix (matA) will represent a global transformation in the end, because all the others were influenced by it.

This is how a World Matrix is composed. The order is again important:

matrix_world = matLoc @ matRot @ matScale

To alter it and to add an extra global rotation, we need to sneak our rotation matrix between matRot and matLoc (so it's applied as last rotation = in global space):

new_matrix_world = origLoc @ matRot @ origRot @ origScale

Here's an example code:

import bpy
from math import radians
from mathutils import Matrix

# example on an active object
obj = bpy.context.active_object

# define some rotation
angle_in_degrees = 45
rot_mat = Matrix.Rotation(radians(angle_in_degrees), 4, 'X')   # you can also use as axis Y,Z or a custom vector like (x,y,z)

# decompose world_matrix's components, and from them assemble 4x4 matrices
orig_loc, orig_rot, orig_scale = obj.matrix_world.decompose()
orig_loc_mat = Matrix.Translation(orig_loc)
orig_rot_mat = orig_rot.to_matrix().to_4x4()
orig_scale_mat = Matrix.Scale(orig_scale[0],4,(1,0,0)) * Matrix.Scale(orig_scale[1],4,(0,1,0)) @ Matrix.Scale(orig_scale[2],4,(0,0,1))

# assemble the new matrix
obj.matrix_world = orig_loc_mat @ rot_mat @ orig_rot_mat @ orig_scale_mat 

Answer 2

Refining Ruslan's solution using 2.8 syntax:

def rotate_object(obj, angle_degrees, axis='Z'):
    ''' rotates an object '''
    from math import radians
    from mathutils import Matrix

    # local rotation about axis
    obj.rotation_euler = (obj.rotation_euler.to_matrix() @ Matrix.Rotation(radians(angle_degrees), 3, axis)).to_euler()

Answer 3

One line rotation:

from mathutils import Matrix
import math

obj = bpy.context.active_object
# rotate around global Z-axis
obj.rotation_euler = (Matrix.Rotation(math.pi, 3, 'Z') * obj.rotation_euler.to_matrix()).to_euler()
# or around local axis
obj.rotation_euler = (obj.rotation_euler.to_matrix() * Matrix.Rotation(math.pi, 3, 'Z')).to_euler()

Jerryno already explained the sequence of multiplication.

Answer 4

Does this do what you need?

import bpy
import math
from mathutils import Matrix

half_pi = 0.5 * math.pi

group = []
for y in [-3, 0, 3]:
    bpy.ops.mesh.primitive_cylinder_add(location=(0, y, 0)) # ops is OK here, but not in the rotations
    obj = bpy.context.active_object
    group.append(obj)

# use the Matrix.Rotation constructor to create a rotation matrix
# half_pi: rotation angle
# 4: matrix size, in this case we will create a 4x4 matrix. 3 and 2 are also valid values for creating 3x3 and 2x2 matrices 
# X: axis about which we want to rotate
hpiMat = Matrix.Rotation(half_pi, 4, 'X')

print (hpiMat)

# do the same again for the individual zangle rotations
aMat = Matrix.Rotation(1, 4, 'Z')
bMat = Matrix.Rotation(1.5, 4, 'Z')
cMat = Matrix.Rotation(2, 4, 'Z')

print (aMat)
print (bMat)
print (cMat)

zangles = [aMat, bMat, cMat] # list of zangle rotation matrices

for obj, zangle in zip(group, zangles):

    # construct the final rotation matrix for the object by multiplying the half pi matrix with the current zangle matrix
    finalMat = zangle * hpiMat

    # mulitply the final rotation matrix against the object's world matrix
    obj.matrix_world = obj.matrix_world * finalMat

also gives the output:

<Matrix 4x4 (1.0000, 0.0000,  0.0000, 0.0000)
            (0.0000, 0.0000, -1.0000, 0.0000)
            (0.0000, 1.0000,  0.0000, 0.0000)
            (0.0000, 0.0000,  0.0000, 1.0000)>
<Matrix 4x4 (0.5403, -0.8415, 0.0000, 0.0000)
            (0.8415,  0.5403, 0.0000, 0.0000)
            (0.0000,  0.0000, 1.0000, 0.0000)
            (0.0000,  0.0000, 0.0000, 1.0000)>
<Matrix 4x4 (0.0707, -0.9975, 0.0000, 0.0000)
            (0.9975,  0.0707, 0.0000, 0.0000)
            (0.0000,  0.0000, 1.0000, 0.0000)
            (0.0000,  0.0000, 0.0000, 1.0000)>
<Matrix 4x4 (-0.4161, -0.9093, 0.0000, 0.0000)
            ( 0.9093, -0.4161, 0.0000, 0.0000)
            ( 0.0000,  0.0000, 1.0000, 0.0000)
            ( 0.0000,  0.0000, 0.0000, 1.0000)>

Answer 5

You can also parent the object in an empty set it's rotation there and let the system computer the exact same thing through the parent chain but you also get animation etc. as a bonus.

Answer 6

Expanding on Jaroslav Jerryno Novotny's answer,
Incase anyone wants to change the global rotation TO a certain orientation and not BY

( what's the difference? in by you "add" to your existing rotation, in to you directly "=" the new rotation )

import bpy,math
from mathutils import Matrix, Vector


def global_rotation_matrix(x_deg=0,y_deg=0,z_deg=0,order="XYZ",size=4): # matrix= size x size
    
    # creating unit vector based on size
    unit_matrix=[]
    for i in range(size):
        axis_vector=[]
        for j in range(size):
            if(i==j):
                axis_vector.append(1)
            else:
                axis_vector.append(0)
        unit_matrix.append(axis_vector)
    
    # creating new global rotation matrix
    new_matrix=[]
    for vec in unit_matrix:
        vec=Vector(vec)
        for axis in reversed(order):
            if(axis=="X" or axis=="x"):
                vec=vec @ Matrix.Rotation(math.radians(x_deg),size, 'X')
            elif(axis=="Y" or axis=="y"):
                vec=vec @ Matrix.Rotation(math.radians(y_deg), size, 'Y')
            elif(axis=="Z" or axis=="z"):
                vec=vec @ Matrix.Rotation(math.radians(z_deg), size, 'Z')
        new_matrix.append(vec)
        
    return Matrix(new_matrix)

def global_rotate_obj(obj,x_deg=0,y_deg=0,z_deg=0,order="XYZ"):
    orig_loc, orig_rot, orig_scale = obj.matrix_world.decompose()
    orig_loc_mat = Matrix.Translation(orig_loc)
    orig_scale_mat = Matrix.Scale(orig_scale[0], 4, (1, 0, 0)) * Matrix.Scale(orig_scale[1], 4, (0, 1, 0)) @ Matrix.Scale(orig_scale[2], 4, (0, 0, 1))
    
    obj.matrix_world = orig_loc_mat @ global_rotation_matrix(x_deg,y_deg,z_deg,order) @ orig_scale_mat


obj=bpy.data.objects["Cube"]
global_rotate_obj(obj,10,0,0)

or using EMCS's solution & simplifying further:

import bpy,math
from mathutils import Matrix, Vector

def global_rotation_matrix(x_deg=0,y_deg=0,z_deg=0,order="XYZ",size=4): # matrix= size x size

    # creating unit vector based on size
    unit_matrix=[ [1 if i==j else 0 for j in range(size)] for i in range(size) ]

    # creating new global rotation matrix
    new_matrix=[]
    for vec in unit_matrix:
        vec=Vector(vec)
        for axis in reversed(order):
            if(axis=="X" or axis=="x"):
                vec=vec @ Matrix.Rotation(math.radians(x_deg),size, 'X')
            elif(axis=="Y" or axis=="y"):
                vec=vec @ Matrix.Rotation(math.radians(y_deg), size, 'Y')
            elif(axis=="Z" or axis=="z"):
                vec=vec @ Matrix.Rotation(math.radians(z_deg), size, 'Z')
        new_matrix.append(vec)

    return Matrix(new_matrix)

obj=bpy.data.objects["Cube"]
obj.rotation_euler = global_rotation_matrix(30,0,10).to_euler()