pyglet 2.1.6__py3-none-any.whl → 2.1.9__py3-none-any.whl

pyglet/libs/win32/__init__.py

@@ -114,6 +114,8 @@ _user32.DestroyWindow.restype = BOOL
 _user32.DestroyWindow.argtypes = [HWND]
 _user32.DispatchMessageW.restype = LRESULT
 _user32.DispatchMessageW.argtypes = [LPMSG]
+_user32.EnumDisplayDevicesW.restype = BOOL
+_user32.EnumDisplayDevicesW.argtypes = [LPCWSTR, DWORD, POINTER(DISPLAY_DEVICEW), DWORD]
 _user32.EnumDisplayMonitors.restype = BOOL
 _user32.EnumDisplayMonitors.argtypes = [HDC, LPRECT, MONITORENUMPROC, LPARAM]
 _user32.EnumDisplaySettingsW.restype = BOOL
@@ -131,6 +133,8 @@ _user32.GetDesktopWindow.restype = HWND
 _user32.GetDesktopWindow.argtypes = []
 _user32.GetKeyState.restype = c_short
 _user32.GetKeyState.argtypes = [c_int]
+_user32.GetLayeredWindowAttributes.restype = BOOL
+_user32.GetLayeredWindowAttributes.argtypes = [HWND, POINTER(COLORREF), POINTER(BYTE), POINTER(DWORD)]
 _user32.GetMessageW.restype = BOOL
 _user32.GetMessageW.argtypes = [LPMSG, HWND, UINT, UINT]
 _user32.GetMonitorInfoW.restype = BOOL
@@ -139,6 +143,8 @@ _user32.GetQueueStatus.restype = DWORD
 _user32.GetQueueStatus.argtypes = [UINT]
 _user32.GetSystemMetrics.restype = c_int
 _user32.GetSystemMetrics.argtypes = [c_int]
+_user32.GetWindowLongW.restype = LONG
+_user32.GetWindowLongW.argtypes = [HWND, c_int]
 _user32.LoadCursorW.restype = HCURSOR
 _user32.LoadCursorW.argtypes = [HINSTANCE, c_wchar_p]
 _user32.LoadIconW.restype = HICON
@@ -183,6 +189,8 @@ _user32.SetFocus.restype = HWND
 _user32.SetFocus.argtypes = [HWND]
 _user32.SetForegroundWindow.restype = BOOL
 _user32.SetForegroundWindow.argtypes = [HWND]
+_user32.SetLayeredWindowAttributes.restype = BOOL
+_user32.SetLayeredWindowAttributes.argtypes = [HWND, COLORREF, BYTE, DWORD]
 _user32.SetTimer.restype = UINT_PTR
 _user32.SetTimer.argtypes = [HWND, UINT_PTR, UINT, TIMERPROC]
 _user32.KillTimer.restype = UINT_PTR
@@ -249,6 +257,10 @@ _dwmapi.DwmIsCompositionEnabled.restype = c_int
 _dwmapi.DwmIsCompositionEnabled.argtypes = [POINTER(INT)]
 _dwmapi.DwmFlush.restype = c_int
 _dwmapi.DwmFlush.argtypes = []
+_dwmapi.DwmGetColorizationColor.restype = HRESULT
+_dwmapi.DwmGetColorizationColor.argtypes = [POINTER(DWORD), POINTER(BOOL)]
+_dwmapi.DwmEnableBlurBehindWindow.restype = HRESULT
+_dwmapi.DwmEnableBlurBehindWindow.argtypes = [HWND, POINTER(DWM_BLURBEHIND)]
 
 # _shell32
 _shell32.DragAcceptFiles.restype = c_void

pyglet/libs/win32/constants.py

@@ -5083,3 +5083,7 @@ DEVICE_NOTIFY_WINDOW_HANDLE = 0
 DEVICE_NOTIFY_SERVICE_HANDLE = 1
 
 USER_DEFAULT_SCREEN_DPI = 96
+
+QDC_ONLY_ACTIVE_PATHS = 0x00000002
+DISPLAYCONFIG_DEVICE_INFO_GET_SOURCE_NAME = 0x00000001
+DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_NAME = 0x00000002

pyglet/libs/win32/types.py

@@ -676,3 +676,100 @@ class DEV_BROADCAST_DEVICEINTERFACE(Structure):
         ('dbcc_classguid', com.GUID),
         ('dbcc_name', ctypes.c_wchar * 256)
     )
+
+
+class DISPLAY_DEVICEW(ctypes.Structure):
+    _fields_ = [
+        ('cb', DWORD),
+        ('DeviceName', WCHAR * 32),
+        ('DeviceString', WCHAR * 128),
+        ('StateFlags', DWORD),
+        ('DeviceID', WCHAR * 128),
+        ('DeviceKey', WCHAR * 128),
+    ]
+
+
+# Structures below are to retrieve a monitor name...
+class LUID(ctypes.Structure):
+    _fields_ = [('LowPart', DWORD), ('HighPart', LONG)]
+
+
+class _SourceInfoStruct(ctypes.Structure):
+    _fields_ = [('cloneGroupId', UINT32, 16), ('sourceModeInfoIdx', UINT32, 16)]
+
+
+class _DisplayUnion(ctypes.Union):
+    _fields_ = [('modeInfoIdx', UINT32), ('DUMMYSTRUCTNAME', _SourceInfoStruct)]
+
+
+class DISPLAYCONFIG_PATH_SOURCE_INFO(ctypes.Structure):
+    _fields_ = [('adapterId', LUID), ('id', UINT32), ('DUMMYUNIONNAME', _DisplayUnion), ('statusFlags', UINT32)]
+
+
+class _DummyStructTarget(ctypes.Structure):
+    _fields_ = [
+        ('desktopModeInfoIdx', UINT32, 16),
+        ('targetModeInfoIdx', UINT32, 16),
+    ]
+
+
+class _DummyUnionTarget(ctypes.Union):
+    _fields_ = [('modeInfoIdx', UINT32), ('DUMMYSTRUCTNAME', _DummyStructTarget)]
+
+
+class DISPLAYCONFIG_RATIONAL(ctypes.Structure):
+    _fields_ = [('Numerator', UINT32), ('Denominator', UINT32)]
+
+    def __repr__(self):
+        return f"DISPLAYCONFIG_RATIONAL(num={self.Numerator}, denom={self.Denominator})"
+
+
+class DISPLAYCONFIG_PATH_TARGET_INFO(ctypes.Structure):
+    _fields_ = [
+        ('adapterId', LUID),
+        ('id', UINT32),
+        ('DUMMYUNIONNAME', _DummyUnionTarget),
+        ('outputTechnology', UINT32),
+        ('rotation', UINT32),
+        ('scaling', UINT32),
+        ('refreshRate', DISPLAYCONFIG_RATIONAL),
+        ('scanLineOrdering', UINT32),
+        ('targetAvailable', BOOL),
+        ('statusFlags', UINT32),
+    ]
+
+
+class DISPLAYCONFIG_PATH_INFO(ctypes.Structure):
+    _fields_ = [
+        ('sourceInfo', DISPLAYCONFIG_PATH_SOURCE_INFO),
+        ('targetInfo', DISPLAYCONFIG_PATH_TARGET_INFO),
+        ('flags', UINT32),
+    ]
+
+
+class DISPLAYCONFIG_DEVICE_INFO_HEADER(ctypes.Structure):
+    _fields_ = [('type', UINT32),
+                ('size', UINT32),
+                ('adapterId', LUID),
+                ('id', UINT32)
+                ]
+
+
+class DISPLAYCONFIG_SOURCE_DEVICE_NAME(ctypes.Structure):
+    _fields_ = [
+        ('header', DISPLAYCONFIG_DEVICE_INFO_HEADER),
+        ('viewGdiDeviceName', WCHAR * 32)
+    ]
+
+
+class DISPLAYCONFIG_TARGET_DEVICE_NAME(ctypes.Structure):
+    _fields_ = [
+        ('header', DISPLAYCONFIG_DEVICE_INFO_HEADER),
+        ('flags', UINT32),
+        ('outputTechnology', UINT32),
+        ('edidManufactureId', UINT16),
+        ('edidProductCodeId', UINT16),
+        ('connectorInstance', UINT32),
+        ('monitorFriendlyDeviceName', WCHAR * 64),
+        ('monitorDevicePath', WCHAR * 128),
+    ]

pyglet/libs/x11/xrandr.py

@@ -0,0 +1,166 @@
+import warnings
+from ctypes import c_ulong, c_int, POINTER, Structure, c_char_p, c_uint, c_ushort
+
+import pyglet
+from pyglet.libs.x11.xlib import (
+    Time,
+    Window,
+    Display,
+    XCloseDisplay,
+    XDefaultRootWindow,
+    XOpenDisplay,
+)
+
+lib = None
+try:
+    lib = pyglet.lib.load_library("Xrandr")
+except ImportError:
+    if pyglet.options.debug_lib:
+        warnings.warn("Xrandr could not be loaded.")
+    raise ImportError
+
+RRCrtc      = c_ulong        # typedef XID
+RROutput    = c_ulong        # typedef XID
+RRMode      = c_ulong        # typedef XID
+Connection  = c_ushort       # Connection in Xrandr.h
+SubpixelOrder = c_ushort     # SubpixelOrder in Xrandr.h
+XRRModeFlags = c_ulong
+
+class XRRModeInfo(Structure):
+    _fields_ = [
+        ("id",          RRMode),     # mode ID
+        ("width",       c_uint),   # horizontal resolution
+        ("height",      c_uint),   # vertical resolution
+        ("dotClock",    c_ulong),    # pixel clock (in Hz)
+        ("hSyncStart",  c_uint),
+        ("hSyncEnd",    c_uint),
+        ("hTotal",      c_uint),
+        ("hSkew",       c_uint),
+        ("vSyncStart",  c_uint),
+        ("vSyncEnd",    c_uint),
+        ("vTotal",      c_uint),
+        ("name",        c_char_p),
+        ("nameLength",  c_uint),
+        ("modeFlags",   XRRModeFlags),
+    ]
+
+
+class XRRScreenResources(Structure):
+    _fields_ = [
+        ("timestamp",        Time),
+        ("configTimestamp",  Time),
+        ("ncrtc",            c_int),
+        ("crtcs",            POINTER(RRCrtc)),
+        ("noutput",          c_int),
+        ("outputs",          POINTER(RROutput)),
+        ("nmode",            c_int),
+        ("modes",            POINTER(XRRModeInfo)),
+    ]
+
+
+class XRROutputInfo(Structure):
+    _fields_ = [
+        ("timestamp",      Time),
+        ("crtc",           RRCrtc),
+        ("name",           c_char_p),
+        ("nameLen",        c_int),
+        ("mm_width",       c_ulong),
+        ("mm_height",      c_ulong),
+        ("connection",     Connection),
+        ("subpixel_order", SubpixelOrder),
+        ("ncrtc",          c_int),
+        ("crtcs",          POINTER(RRCrtc)),
+        ("nclone",         c_int),
+        ("clones",         POINTER(RROutput)),
+        ("nmode",          c_int),
+        ("npreferred",     c_int),
+        ("modes",          POINTER(RRMode)),
+    ]
+
+class XRRCrtcInfo(Structure):
+    _fields_ = [
+        ("timestamp",  Time),
+        ("x",          c_int),
+        ("y",          c_int),
+        ("width",      c_uint),
+        ("height",     c_uint),
+        ("mode",       RRMode),
+        ("rotation",   c_int),
+        ("noutput",    c_int),
+        ("outputs",    POINTER(RROutput)),
+        ("rotations",  c_ushort),
+        ("npossible",  c_int),
+        ("possible",   POINTER(RROutput)),
+    ]
+
+
+if lib:
+    XRRQueryVersion = lib.XRRQueryVersion
+    XRRQueryVersion.argtypes = [POINTER(Display), POINTER(c_int), POINTER(c_int)]
+    XRRQueryVersion.restype    = c_int
+
+    XRRGetScreenResources = lib.XRRGetScreenResources
+    XRRGetScreenResources.argtypes = [POINTER(Display), Window]
+    XRRGetScreenResources.restype = POINTER(XRRScreenResources)
+
+    XRRGetOutputPrimary = lib.XRRGetOutputPrimary
+    XRRGetOutputPrimary.argtypes = [POINTER(Display), Window]
+    XRRGetOutputPrimary.restype = RROutput
+
+    XRRGetScreenResourcesCurrent = lib.XRRGetScreenResourcesCurrent
+    XRRGetScreenResourcesCurrent.argtypes = [POINTER(Display), Window]
+    XRRGetScreenResourcesCurrent.restype = POINTER(XRRScreenResources)
+
+    XRRFreeScreenResources = lib.XRRFreeScreenResources
+    XRRFreeScreenResources.argtypes = [POINTER(XRRScreenResources)]
+    XRRFreeScreenResources.restype = None
+
+    XRRGetOutputInfo = lib.XRRGetOutputInfo
+    XRRGetOutputInfo.argtypes = [POINTER(Display), POINTER(XRRScreenResources), RROutput]
+    XRRGetOutputInfo.restype  = POINTER(XRROutputInfo)
+
+    XRRFreeOutputInfo = lib.XRRFreeOutputInfo
+    XRRFreeOutputInfo.argtypes = [POINTER(XRROutputInfo)]
+    XRRFreeOutputInfo.restype = None
+
+    XRRGetCrtcInfo = lib.XRRGetCrtcInfo
+    XRRGetCrtcInfo.argtypes = [POINTER(Display), POINTER(XRRScreenResources), RRCrtc]
+    XRRGetCrtcInfo.restype = POINTER(XRRCrtcInfo)
+
+    XRRSetCrtcConfig = lib.XRRSetCrtcConfig
+    XRRSetCrtcConfig.argtypes = argtypes = [POINTER(Display), POINTER(XRRScreenResources), RRCrtc, Time, c_int, c_int, RRMode, c_int,  POINTER(RROutput), c_int]
+    XRRSetCrtcConfig.restype = c_int
+
+    XRRFreeCrtcInfo = lib.XRRFreeCrtcInfo
+    XRRFreeCrtcInfo.argtypes = [POINTER(XRRCrtcInfo)]
+    XRRFreeCrtcInfo.restype    = None
+
+def list_connected_outputs():
+    dpy = XOpenDisplay(None)
+    if not dpy:
+        raise RuntimeError("Cannot open DISPLAY")
+
+    root = XDefaultRootWindow(dpy)
+    res_p = XRRGetScreenResources(dpy, root)
+    if not res_p:
+        XCloseDisplay(dpy)
+        raise RuntimeError("Failed to get screen resources")
+
+    res = res_p.contents
+    outputs = []
+    for i in range(res.noutput):
+        out_id = res.outputs[i]
+        info_p = XRRGetOutputInfo(dpy, res_p, out_id)
+        if info_p:
+            info = info_p.contents
+            if info.connection == 0:  # Connected.
+                outputs.append(info.name.decode())
+            XRRFreeOutputInfo(info_p)
+
+    XRRFreeScreenResources(res_p)
+    XCloseDisplay(dpy)
+    return outputs
+
+if __name__ == "__main__":
+    for name in list_connected_outputs():
+        print(name)

pyglet/libs/x11/xrender.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import warnings
+from ctypes import Structure, c_ushort, c_ulong, c_int, c_void_p, POINTER
+import pyglet.lib
+from pyglet.libs.x11.xlib import Visual
+
+lib = None
+try:
+    lib = pyglet.lib.load_library("Xrender")
+except ImportError:
+    if pyglet.options.debug_lib:
+        warnings.warn("XRender could not be loaded.")
+
+
+class XRenderDirectFormat(Structure):
+    _fields_ = [
+        ('red', c_ushort),
+        ('redMask', c_ushort),
+        ('green', c_ushort),
+        ('greenMask', c_ushort),
+        ('blue', c_ushort),
+        ('blueMask', c_ushort),
+        ('alpha', c_ushort),
+        ('alphaMask', c_ushort),
+    ]
+
+class XRenderPictFormat(Structure):
+    _fields_ = [
+        ('id', c_ulong),
+        ('type', c_int),
+        ('depth', c_int),
+        ('direct', XRenderDirectFormat),
+        ('colormap', c_ulong),
+    ]
+
+# XRenderFindVisualFormat(Display *dpy, Visual *visual)
+try:
+    XRenderFindVisualFormat = lib.XRenderFindVisualFormat
+    XRenderFindVisualFormat.argtypes = [c_void_p, POINTER(Visual)]
+    XRenderFindVisualFormat.restype = POINTER(XRenderPictFormat)
+except ValueError:
+    XRenderFindVisualFormat = None

pyglet/libs/x11/xsync.py

@@ -406,6 +406,49 @@ XSyncGetPriority = _lib.XSyncGetPriority
 XSyncGetPriority.restype = c_int
 XSyncGetPriority.argtypes = [POINTER(Display), XID, POINTER(c_int)]
 
+# Shape kind
+ShapeBounding = 0
+ShapeClip = 1
+ShapeInput = 2
+
+# Shape operation
+ShapeSet = 0
+ShapeUnion = 1
+ShapeIntersect = 2
+ShapeSubtract = 3
+ShapeInvert = 4
+
+XShapeCombineRegion = _lib.XShapeCombineRegion
+XShapeCombineRegion.argtypes = [
+    POINTER(Display),
+    c_void_p,
+    ctypes.c_int,  # shape kind
+    ctypes.c_int, ctypes.c_int,  # x, y offset
+    c_void_p,
+    ctypes.c_int   # ShapeOp
+]
+
+XShapeCombineMask = _lib.XShapeCombineMask
+XShapeCombineMask.argtypes = [
+    Display,       # *display
+    c_void_p,        # dest window
+    ctypes.c_int,  # shape_kind (e.g., ShapeInput)
+    ctypes.c_int,  # x offset
+    ctypes.c_int,  # y offset
+    ctypes.c_ulong,  # Pixmap (can be 0 for None)
+    ctypes.c_int   # ShapeOp (e.g., ShapeSet)
+]
+XShapeCombineMask.restype = None
+
+XShapeQueryExtension = _lib.XShapeQueryExtension
+XShapeQueryExtension.argtypes = [Display, ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_int)]
+XShapeQueryExtension.restype = Bool
+
+def has_shape_support(display: Display) -> bool:
+    event_base = ctypes.c_int()
+    error_base = ctypes.c_int()
+    return XShapeQueryExtension(display, ctypes.byref(event_base), ctypes.byref(error_base))
+
 
 __all__ = ['SYNC_MAJOR_VERSION', 'SYNC_MINOR_VERSION', 'X_SyncInitialize',
 'X_SyncListSystemCounters', 'X_SyncCreateCounter', 'X_SyncSetCounter',

pyglet/math.py

@@ -191,7 +191,7 @@ class Vec2(_typing.NamedTuple):
             )
 
     def __lt__(self, other: tuple[float, float]) -> bool:
-        return self[0] ** 2 + self[0] ** 2 < other[0] ** 2 + other[1] ** 2
+        return self[0] ** 2 + self[1] ** 2 < other[0] ** 2 + other[1] ** 2
 
     @staticmethod
     def from_heading(heading: float, length: float = 1.0) -> Vec2:
@@ -301,8 +301,7 @@ class Vec2(_typing.NamedTuple):
         This simply means the vector will have a length of 1.0. If the vector
         has a length of 0, the original vector will be returned.
         """
-        d = _math.sqrt(self[0] ** 2 + self[1] ** 2)
-        if d:
+        if d := _math.sqrt(self[0] ** 2 + self[1] ** 2):
             return Vec2(self[0] / d, self[1] / d)
         return self
 
@@ -823,7 +822,8 @@ class Vec4(_typing.NamedTuple):
             )
 
     def __lt__(self, other: Vec4 | tuple[float, float, float, float]) -> bool:
-        return self[0] ** 2 + self[1] ** 2 + self[2] ** 2 < other[0] ** 2 + other[1] ** 2 + other[2] ** 2
+        return (self[0] ** 2 + self[1] ** 2 + self[2] ** 2 + self[3] ** 2 <
+                other[0] ** 2 + other[1] ** 2 + other[2] ** 2 + other[3] ** 2)
 
     def length(self) -> float:
         """Calculate the length of the vector: ``sqrt(x ** 2 + y ** 2 + z ** 2 + w ** 2)``."""
@@ -872,8 +872,7 @@ class Vec4(_typing.NamedTuple):
         This means that the vector will have the same direction, but a length of 1.0.
         If the vector has a length of 0, the original vector will be returned.
         """
-        d = _math.sqrt(self[0] ** 2 + self[1] ** 2 + self[2] ** 2 + self[3] ** 2)
-        if d:
+        if d := _math.sqrt(self[0] ** 2 + self[1] ** 2 + self[2] ** 2 + self[3] ** 2):
             return Vec4(self[0] / d, self[1] / d, self[2] / d, self[3] / d)
         return self
 
@@ -1053,7 +1052,21 @@ class Mat3(_typing.NamedTuple):
     def __matmul__(self, other: Mat3) -> Mat3: ...
 
     def __matmul__(self, other) -> Vec3 | Mat3:
-        if isinstance(other, Vec3):
+        try:
+            # extract the elements in row-column form. (matrix is stored column first)
+            a11, a12, a13, a21, a22, a23, a31, a32, a33 = self
+            b11, b12, b13, b21, b22, b23, b31, b32, b33 = other
+
+            # Multiply and sum rows * columns
+            return Mat3(
+                # Column 1
+                a11 * b11 + a21 * b12 + a31 * b13, a12 * b11 + a22 * b12 + a32 * b13, a13 * b11 + a23 * b12 + a33 * b13,
+                # Column 2
+                a11 * b21 + a21 * b22 + a31 * b23, a12 * b21 + a22 * b22 + a32 * b23, a13 * b21 + a23 * b22 + a33 * b23,
+                # Column 3
+                a11 * b31 + a21 * b32 + a31 * b33, a12 * b31 + a22 * b32 + a32 * b33, a13 * b31 + a23 * b32 + a33 * b33,
+            )
+        except ValueError:
             x, y, z = other
             # extract the elements in row-column form. (matrix is stored column first)
             a11, a12, a13, a21, a22, a23, a31, a32, a33 = self
@@ -1063,24 +1076,6 @@ class Mat3(_typing.NamedTuple):
                 a13 * x + a23 * y + a33 * z,
             )
 
-        if not isinstance(other, Mat3):
-            msg = "Can only multiply with Mat3 or Vec3 types"
-            raise TypeError(msg)
-
-        # extract the elements in row-column form. (matrix is stored column first)
-        a11, a12, a13, a21, a22, a23, a31, a32, a33 = self
-        b11, b12, b13, b21, b22, b23, b31, b32, b33 = other
-
-        # Multiply and sum rows * columns
-        return Mat3(
-            # Column 1
-            a11 * b11 + a21 * b12 + a31 * b13, a12 * b11 + a22 * b12 + a32 * b13, a13 * b11 + a23 * b12 + a33 * b13,
-            # Column 2
-            a11 * b21 + a21 * b22 + a31 * b23, a12 * b21 + a22 * b22 + a32 * b23, a13 * b21 + a23 * b22 + a33 * b23,
-            # Column 3
-            a11 * b31 + a21 * b32 + a31 * b33, a12 * b31 + a22 * b32 + a32 * b33, a13 * b31 + a23 * b32 + a33 * b33,
-        )
-
     def __repr__(self) -> str:
         return f"{self.__class__.__name__}{self[0:3]}\n    {self[3:6]}\n    {self[6:9]}"
 
@@ -1357,7 +1352,26 @@ class Mat4(_typing.NamedTuple):
     def __matmul__(self, other: Mat4) -> Mat4: ...
 
     def __matmul__(self, other):
-        if isinstance(other, Vec4):
+        try:
+            # extract the elements in row-column form. (matrix is stored column first)
+            a11, a12, a13, a14, a21, a22, a23, a24, a31, a32, a33, a34, a41, a42, a43, a44 = self
+            b11, b12, b13, b14, b21, b22, b23, b24, b31, b32, b33, b34, b41, b42, b43, b44 = other
+            # Multiply and sum rows * columns:
+            return Mat4(
+                # Column 1
+                a11 * b11 + a21 * b12 + a31 * b13 + a41 * b14, a12 * b11 + a22 * b12 + a32 * b13 + a42 * b14,
+                a13 * b11 + a23 * b12 + a33 * b13 + a43 * b14, a14 * b11 + a24 * b12 + a34 * b13 + a44 * b14,
+                # Column 2
+                a11 * b21 + a21 * b22 + a31 * b23 + a41 * b24, a12 * b21 + a22 * b22 + a32 * b23 + a42 * b24,
+                a13 * b21 + a23 * b22 + a33 * b23 + a43 * b24, a14 * b21 + a24 * b22 + a34 * b23 + a44 * b24,
+                # Column 3
+                a11 * b31 + a21 * b32 + a31 * b33 + a41 * b34, a12 * b31 + a22 * b32 + a32 * b33 + a42 * b34,
+                a13 * b31 + a23 * b32 + a33 * b33 + a43 * b34, a14 * b31 + a24 * b32 + a34 * b33 + a44 * b34,
+                # Column 4
+                a11 * b41 + a21 * b42 + a31 * b43 + a41 * b44, a12 * b41 + a22 * b42 + a32 * b43 + a42 * b44,
+                a13 * b41 + a23 * b42 + a33 * b43 + a43 * b44, a14 * b41 + a24 * b42 + a34 * b43 + a44 * b44,
+            )
+        except ValueError:
             x, y, z, w = other
             # extract the elements in row-column form. (matrix is stored column first)
             a11, a12, a13, a14, a21, a22, a23, a24, a31, a32, a33, a34, a41, a42, a43, a44 = self
@@ -1368,35 +1382,15 @@ class Mat4(_typing.NamedTuple):
                 x * a14 + y * a24 + z * a34 + w * a44,
             )
 
-        if not isinstance(other, Mat4):
-            msg = "Can only multiply with Mat4 or Vec4 types"
-            raise TypeError(msg)
-
-        # extract the elements in row-column form. (matrix is stored column first)
-        a11, a12, a13, a14, a21, a22, a23, a24, a31, a32, a33, a34, a41, a42, a43, a44 = self
-        b11, b12, b13, b14, b21, b22, b23, b24, b31, b32, b33, b34, b41, b42, b43, b44 = other
-        # Multiply and sum rows * columns:
-        return Mat4(
-            # Column 1
-            a11 * b11 + a21 * b12 + a31 * b13 + a41 * b14, a12 * b11 + a22 * b12 + a32 * b13 + a42 * b14,
-            a13 * b11 + a23 * b12 + a33 * b13 + a43 * b14, a14 * b11 + a24 * b12 + a34 * b13 + a44 * b14,
-            # Column 2
-            a11 * b21 + a21 * b22 + a31 * b23 + a41 * b24, a12 * b21 + a22 * b22 + a32 * b23 + a42 * b24,
-            a13 * b21 + a23 * b22 + a33 * b23 + a43 * b24, a14 * b21 + a24 * b22 + a34 * b23 + a44 * b24,
-            # Column 3
-            a11 * b31 + a21 * b32 + a31 * b33 + a41 * b34, a12 * b31 + a22 * b32 + a32 * b33 + a42 * b34,
-            a13 * b31 + a23 * b32 + a33 * b33 + a43 * b34, a14 * b31 + a24 * b32 + a34 * b33 + a44 * b34,
-            # Column 4
-            a11 * b41 + a21 * b42 + a31 * b43 + a41 * b44, a12 * b41 + a22 * b42 + a32 * b43 + a42 * b44,
-            a13 * b41 + a23 * b42 + a33 * b43 + a43 * b44, a14 * b41 + a24 * b42 + a34 * b43 + a44 * b44,
-        )
-
     def __repr__(self) -> str:
         return f"{self.__class__.__name__}{self[0:4]}\n    {self[4:8]}\n    {self[8:12]}\n    {self[12:16]}"
 
 
 class Quaternion(_typing.NamedTuple):
-    """Quaternion."""
+    """Quaternion.
+
+    Quaternions are 4-dimensional complex numbers, useful for describing 3D rotations.
+    """
 
     w: float = 1.0
     x: float = 0.0
@@ -1412,6 +1406,8 @@ class Quaternion(_typing.NamedTuple):
         raise NotImplementedError
 
     def to_mat4(self) -> Mat4:
+        """Calculate a 4x4 transform matrix which applies a rotation."""
+
         w = self.w
         x = self.x
         y = self.y
@@ -1437,6 +1433,8 @@ class Quaternion(_typing.NamedTuple):
         return Mat4(a, b, c, 0.0, e, f, g, 0.0, i, j, k, 0.0, 0.0, 0.0, 0.0, 1.0)
 
     def to_mat3(self) -> Mat3:
+        """Create a 3x3 rotation matrix."""
+
         w = self.w
         x = self.x
         y = self.y
@@ -1462,21 +1460,34 @@ class Quaternion(_typing.NamedTuple):
         return Mat3(*(a, b, c, e, f, g, i, j, k))
 
     def length(self) -> float:
-        """Calculate the length of the Quaternion.
-
-        The distance between the coordinates and the origin.
-        """
+        """Calculate the length of the quaternion from the origin."""
         return _math.sqrt(self.w**2 + self.x**2 + self.y**2 + self.z**2)
 
     def conjugate(self) -> Quaternion:
+        """Calculate the conjugate of this quaternion.
+
+        This operation:
+        #. leaves the :py:attr:`.w` component alone
+        #. inverts the sign of the :py:attr:`.x`, :py:attr:`.y`, and :py:attr:`.z` components
+
+        """
         return Quaternion(self.w, -self.x, -self.y, -self.z)
 
     def dot(self, other: Quaternion) -> float:
+        """Calculate the dot product with another quaternion."""
         a, b, c, d = self
         e, f, g, h = other
         return a * e + b * f + c * g + d * h
 
     def normalize(self) -> Quaternion:
+        """Calculate a unit quaternion from the instance.
+
+        The returned quaternion will be a scaled-down version
+        of the instance which has:
+
+        * a length of ``1``
+        * the same relative of its components
+        """
         m = self.length()
         if m == 0:
             return self

pyglet/media/buffered_logger.py

@@ -1,5 +1,5 @@
 """
-Responsabilities
+Responsibilities
 
     Handles accumulation of debug events while playing media_player and  saves
     when sample's play ends.