Welcome to Python-flavored Magnum! Please note that, while already being rather stable, this functionality is still considered experimental and some APIs might get changed without preserving full backwards compatibility.

magnum.Color3 class

Color in linear RGB color space

Static methods

def blue(blue: float = 1.0) -> Color3
Blue color
def cyan(red: float = 0.0) -> Color3
Cyan color
def from_hsv(hue: Deg, saturation: float, value: float) -> Color3
Create RGB color from HSV representation
def from_srgb(srgb: int) -> Color3
Create linear RGB color from 24-bit sRGB representation
def from_xyz(xyz: Vector3) -> Color3
Create RGB color from CIE XYZ representation
def green(green: float = 1.0) -> Color3
Green color
def magenta(green: float = 0.0) -> Color3
Magenta color
def red(red: float = 1.0) -> Color3
Red color
def x_axis(length: float = 1.0) -> Vector3
Vector in a direction of X axis (right)
def x_scale(scale: float) -> Vector3
Scaling vector in a direction of X axis (width)
def y_axis(length: float = 1.0) -> Vector3
Vector in a direction of Y axis (up)
def y_scale(scale: float) -> Vector3
Scaling vector in a direction of Y axis (height)
def yellow(blue: float = 0.0) -> Color3
Yellow color
def z_axis(length: float = 1.0) -> Vector3
Vector in a direction of Z axis (backward)
def z_scale(scale: float) -> Vector3
Scaling vector in a direction of Z axis (depth)
def zero_init() -> Color3
Construct a zero vector
def zero_init() -> Color3
Construct a zero vector

Methods

def dot(self, /) -> float
Dot product of the vector
def flipped(self, /) -> Vector3
Flipped vector
def hue(self, /) -> Deg
Hue
def is_normalized(self, /) -> bool
Whether the vector is normalized
def is_zero(self, /) -> bool
Whether the vector is zero
def length(self, /) -> float
Vector length
def length_inverted(self, /) -> float
Inverse vector length
def max(self, /) -> float
Maximal value in the vector
def min(self, /) -> float
Minimal value in the vector
def minmax(self, /) -> typing.Tuple[float, float]
Minimal and maximal value in the vector
def normalized(self, /) -> Vector3
Normalized vector (of unit length)
def product(self, /) -> float
Product of values in the vector
def projected(self, arg0: Vector3, /) -> Vector3
Vector projected onto a line
def projected_onto_normalized(self, arg0: Vector3, /) -> Vector3
Vector projected onto a normalized line
def resized(self, arg0: float, /) -> Vector3
Resized vector
def saturation(self, /) -> float
Saturation
def sum(self, /) -> float
Sum of values in the vector
def to_hsv(self, /) -> typing.Tuple[Deg, float, float]
Convert to HSV representation
def to_srgb_int(self, /) -> int
Convert to 32-bit integral sRGB representation
def to_xyz(self, /) -> Vector3
Convert to CIE XYZ representation
def value(self, /) -> float
Value

Special methods

def __add__(self, arg0: Color3, /) -> Color3
Add a vector
def __eq__(self, arg0: Vector3, /) -> bool
Equality comparison
def __ge__(self, arg0: Vector3, /) -> BitVector3
Component-wise greater than or equal comparison
def __getattr__(self, arg0: str, /) -> object
Vector swizzle
def __getitem__(self, arg0: int, /) -> float
Value at given position
def __gt__(self, arg0: Vector3, /) -> BitVector3
Component-wise greater than comparison
def __iadd__(self, arg0: Color3, /) -> Color3
Add and assign a vector
def __imul__(self, arg0: float, /) -> Color3
Multiply with a scalar and assign
def __imul__(self, arg0: Color3, /) -> Color3
Multiply a vector component-wise and assign
def __init__(self, arg0: buffer, /) -> None
Construct from a buffer
def __init__(self, /) -> None
Default constructor
def __init__(self, /) -> None
Default constructor
def __init__(self, arg0: float, arg1: float, arg2: float, /) -> None
Constructor
def __init__(self, arg0: float, /) -> None
Construct with one value for all components
def __init__(self, arg0: Vector3, /) -> None
Construct from a vector
def __init__(self, arg0: typing.Tuple[float, float, float], /) -> None
Construct from a tuple
def __isub__(self, arg0: Color3, /) -> Color3
Subtract and assign a vector
def __itruediv__(self, arg0: float, /) -> Color3
Divide with a scalar and assign
def __itruediv__(self, arg0: Color3, /) -> Color3
Divide a vector component-wise and assign
def __le__(self, arg0: Vector3, /) -> BitVector3
Component-wise less than or equal comparison
def __len__() -> int
Vector size. Returns 3.
def __lt__(self, arg0: Vector3, /) -> BitVector3
Component-wise less than comparison
def __mul__(self, arg0: float, /) -> Color3
Multiply with a scalar
def __mul__(self, arg0: Color3, /) -> Color3
Multiply a vector component-wise
def __ne__(self, arg0: Vector3, /) -> bool
Non-equality comparison
def __neg__(self, /) -> Color3
Negated vector
def __repr__(self, /) -> str
Object representation
def __rmul__(self, arg0: float, /) -> Color3
Multiply a scalar with a vector
def __rtruediv__(self, arg0: float, /) -> Color3
Divide a vector with a scalar and invert
def __setattr__(self, arg0: str, arg1: object, /) -> None
Vector swizzle
def __setitem__(self, arg0: int, arg1: float, /) -> None
Set a value at given position
def __sub__(self, arg0: Color3, /) -> Color3
Subtract a vector
def __truediv__(self, arg0: float, /) -> Color3
Divide with a scalar
def __truediv__(self, arg0: Color3, /) -> Color3
Divide a vector component-wise

Properties

b: float get set
B component
g: float get set
G component
r: float get set
R component
x: float get set
X component
xy: Vector2 get set
XY part of the vector
y: float get set
Y component
z: float get set
Z component