magnum.Color3 class

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_linear_rgb_int(linear: int) -> Color3

Create linear RGB color from 24-bit linear representation

def from_srgb_int(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, /) -> 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, line: Vector3) -> Vector3

Vector projected onto a line

def projected_onto_normalized(self, line: Vector3) -> Vector3

Vector projected onto a normalized line

def resized(self, length: float) -> Vector3

Resized vector

def saturation(self, /) -> float

Saturation

def sum(self, /) -> float

Sum of values in the vector

def to_hsv(self, /) -> tuple[Deg, float, float]

Convert to HSV representation

def to_linear_rgb_int(self, /) -> int

Convert to 24-bit integral linear RGB representation

def to_srgb_int(self, /) -> int

Convert to 24-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 __buffer__(self, flags, /)

Return a buffer object that exposes the underlying memory of the object.

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 __getstate__(self, /) -> bytes

Dumps the in-memory representation of vector components

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: 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 __release_buffer__(self, buffer, /)

Release the buffer object that exposes the underlying memory of the object.

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 __setstate__(self, arg0: bytes, /) -> None

Treats the data as the in-memory representation of vector components

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

Method documentation