from __future__ import annotations """ Android RenderScript 组件 — RenderScript, Allocation, Element, Type, Script 等 方法签名完全对齐 Android SDK (android.renderscript 包) """ import math from typing import Any, Callable, Dict, List, Optional, Tuple, Union from .._core import Stub, AndroidOnlyError # ═══════════════════════════════════════════════════════════════ # RenderScript # ═══════════════════════════════════════════════════════════════ class RenderScript(Stub): """RenderScript — RenderScript 运行时上下文 (桌面仅存根)""" # 优先级 Priority_LOW = 0 Priority_NORMAL = 1 Priority_HIGH = 2 # 上下文类型 ContextType_NORMAL = 0 ContextType_DEBUG = 1 ContextType_PROFILE = 2 def __init__(self): super().__init__() self._context_type = RenderScript.ContextType_NORMAL self._error_handler: Optional[Callable] = None self._message_handler: Optional[Callable] = None self._priority = RenderScript.Priority_NORMAL self._initialized = False @staticmethod def create(context: Any = None) -> "RenderScript": """创建 RenderScript 上下文""" rs = RenderScript() rs._initialized = True return rs @staticmethod def createMultiContext(context: Any = None, context_type: int = ContextType_NORMAL, flags: int = 0, api_version: int = 0) -> "RenderScript": """创建多上下文 RenderScript""" rs = RenderScript() rs._context_type = context_type rs._initialized = True return rs def setPriority(self, priority: int): """设置优先级""" self._priority = priority def getPriority(self) -> int: return self._priority def setErrorHandler(self, handler: Callable): """设置错误处理器""" self._error_handler = handler def setMessageHandler(self, handler: Callable): """设置消息处理器""" self._message_handler = handler def finish(self): """等待所有挂起渲染完成""" pass def destroy(self): """销毁 RenderScript 上下文""" self._initialized = False def getApplicationContext(self) -> Any: return None def getErrorHandler(self) -> Optional[Callable]: return self._error_handler def getMessageHandler(self) -> Optional[Callable]: return self._message_handler def isDestroyed(self) -> bool: return not self._initialized def nvLoadAll(self): pass def nvLoadFont(self, name: str) -> int: return 0 def nvLoadProp(self, name: str) -> int: return 0 def toString(self) -> str: return f"RenderScript(priority={self._priority}, initialized={self._initialized})" def hashCode(self) -> int: return id(self) & 0x7FFFFFFF def equals(self, other) -> bool: return self is other # ═══════════════════════════════════════════════════════════════ # Element # ═══════════════════════════════════════════════════════════════ class Element(Stub): """Element — RenderScript 数据类型元素""" # 预定义数据类型 F32: "Element" = None F64: "Element" = None I8: "Element" = None I16: "Element" = None I32: "Element" = None I64: "Element" = None U8: "Element" = None U16: "Element" = None U32: "Element" = None U64: "Element" = None BOOLEAN: "Element" = None ALLOCATION: "Element" = None A_8: "Element" = None RGB_565: "Element" = None RGBA_4444: "Element" = None RGBA_8888: "Element" = None F32_2: "Element" = None F32_3: "Element" = None F32_4: "Element" = None F64_2: "Element" = None F64_3: "Element" = None F64_4: "Element" = None I8_2: "Element" = None I8_3: "Element" = None I8_4: "Element" = None I16_2: "Element" = None I16_3: "Element" = None I16_4: "Element" = None I32_2: "Element" = None I32_3: "Element" = None I32_4: "Element" = None I64_2: "Element" = None I64_3: "Element" = None I64_4: "Element" = None U8_2: "Element" = None U8_3: "Element" = None U8_4: "Element" = None U16_2: "Element" = None U16_3: "Element" = None U16_4: "Element" = None U32_2: "Element" = None U32_3: "Element" = None U32_4: "Element" = None U64_2: "Element" = None U64_3: "Element" = None U64_4: "Element" = None # 数据类型 DataType = type("DataType", (), { "NONE": 0, "FLOAT_32": 1, "FLOAT_64": 2, "SIGNED_8": 3, "SIGNED_16": 4, "SIGNED_32": 5, "SIGNED_64": 6, "UNSIGNED_8": 7, "UNSIGNED_16": 8, "UNSIGNED_32": 9, "UNSIGNED_64": 10, "BOOLEAN": 11, "UNSIGNED_5_6_5": 12, "UNSIGNED_5_5_5_1": 13, "UNSIGNED_4_4_4_4": 14, "MATRIX_4X4": 15, "MATRIX_3X3": 16, "UNSIGNED_2_10_10_10": 17, "RS_ELEMENT": 18, }) # 数据类型大小 DataType = DataType() def __init__(self, rs: Optional[RenderScript] = None, data_type: int = 0, vector_size: int = 1): super().__init__() self._rs = rs self._data_type = data_type self._vector_size = vector_size self._element_size = self._compute_size() def _compute_size(self) -> int: base_sizes = { Element.DataType.FLOAT_32: 4, Element.DataType.FLOAT_64: 8, Element.DataType.SIGNED_8: 1, Element.DataType.SIGNED_16: 2, Element.DataType.SIGNED_32: 4, Element.DataType.SIGNED_64: 8, Element.DataType.UNSIGNED_8: 1, Element.DataType.UNSIGNED_16: 2, Element.DataType.UNSIGNED_32: 4, Element.DataType.UNSIGNED_64: 8, Element.DataType.BOOLEAN: 1, Element.DataType.UNSIGNED_5_6_5: 2, Element.DataType.UNSIGNED_5_5_5_1: 2, Element.DataType.UNSIGNED_4_4_4_4: 2, Element.DataType.MATRIX_4X4: 64, Element.DataType.MATRIX_3X3: 36, Element.DataType.RS_ELEMENT: 4, } return base_sizes.get(self._data_type, 4) * self._vector_size def getBytesSize(self) -> int: return self._element_size def getVectorSize(self) -> int: return self._vector_size def getDataType(self) -> int: return self._data_type def isCompatible(self, e: "Element") -> bool: return self._data_type == e._data_type and self._vector_size == e._vector_size def getSubElement(self, index: int) -> Optional["Element"]: return None def getSubElementCount(self) -> int: return 0 def getSubElementArraySize(self, index: int) -> int: return 0 def getSubElementOffsetBytes(self, index: int) -> int: return 0 def toString(self) -> str: return f"Element(dataType={self._data_type}, vectorSize={self._vector_size})" def hashCode(self) -> int: return hash((self._data_type, self._vector_size)) & 0x7FFFFFFF def equals(self, other) -> bool: if not isinstance(other, Element): return False return self._data_type == other._data_type and self._vector_size == other._vector_size @staticmethod def BOOL(rs: RenderScript) -> "Element": return Element(rs, Element.DataType.BOOLEAN, 1) @staticmethod def U8(rs: RenderScript) -> "Element": return Element(rs, Element.DataType.UNSIGNED_8, 1) @staticmethod def I8(rs: RenderScript) -> "Element": return Element(rs, Element.DataType.SIGNED_8, 1) @staticmethod def U16(rs: RenderScript) -> "Element": return Element(rs, Element.DataType.UNSIGNED_16, 1) @staticmethod def I16(rs: RenderScript) -> "Element": return Element(rs, Element.DataType.SIGNED_16, 1) @staticmethod def U32(rs: RenderScript) -> "Element": return Element(rs, Element.DataType.UNSIGNED_32, 1) @staticmethod def I32(rs: RenderScript) -> "Element": return Element(rs, Element.DataType.SIGNED_32, 1) @staticmethod def U64(rs: RenderScript) -> "Element": return Element(rs, Element.DataType.UNSIGNED_64, 1) @staticmethod def I64(rs: RenderScript) -> "Element": return Element(rs, Element.DataType.SIGNED_64, 1) @staticmethod def F32(rs: RenderScript) -> "Element": return Element(rs, Element.DataType.FLOAT_32, 1) @staticmethod def F64(rs: RenderScript) -> "Element": return Element(rs, Element.DataType.FLOAT_64, 1) @staticmethod def createVector(rs: RenderScript, data_type: int, size: int) -> "Element": return Element(rs, data_type, size) @staticmethod def createPixel(rs: RenderScript, data_type: int, pixel_type: int) -> "Element": return Element(rs, data_type, 4) # ═══════════════════════════════════════════════════════════════ # Type # ═══════════════════════════════════════════════════════════════ class Type(Stub): """Type — RenderScript 内存分配类型""" CubemapFace = type("CubemapFace", (), { "POSITIVE_X": 0, "NEGATIVE_X": 1, "POSITIVE_Y": 2, "NEGATIVE_Y": 3, "POSITIVE_Z": 4, "NEGATIVE_Z": 5, }) def __init__(self, rs: Optional[RenderScript] = None, element: Optional[Element] = None, dim_x: int = 0, dim_y: int = 0, dim_z: int = 0, mipmaps: bool = False, faces: bool = False): super().__init__() self._rs = rs self._element = element self._dim_x = dim_x self._dim_y = dim_y self._dim_z = dim_z self._mipmaps = mipmaps self._faces = faces self._yuv_format = 0 def getElement(self) -> Optional[Element]: return self._element def getX(self) -> int: return self._dim_x def getY(self) -> int: return self._dim_y def getZ(self) -> int: return self._dim_z def getCount(self) -> int: return self._dim_x * max(self._dim_y, 1) * max(self._dim_z, 1) def hasMipmaps(self) -> bool: return self._mipmaps def hasFaces(self) -> bool: return self._faces def getYuvFormat(self) -> int: return self._yuv_format def setYuvFormat(self, yuv_format: int): self._yuv_format = yuv_format def toString(self) -> str: return (f"Type(element={self._element}, dims={self._dim_x}x{self._dim_y}" f"x{self._dim_z}, mipmaps={self._mipmaps})") def hashCode(self) -> int: return hash((self._dim_x, self._dim_y, self._dim_z)) & 0x7FFFFFFF def equals(self, other) -> bool: if not isinstance(other, Type): return False return (self._dim_x == other._dim_x and self._dim_y == other._dim_y and self._dim_z == other._dim_z) # ── Builder ── class Builder(Stub): """Builder — Type 构建器""" def __init__(self, rs: RenderScript, element: Element): super().__init__() self._rs = rs self._element = element self._dim_x = 0 self._dim_y = 0 self._dim_z = 0 self._mipmaps = False self._faces = False self._yuv_format = 0 def setX(self, value: int) -> "Type.Builder": self._dim_x = value return self def setY(self, value: int) -> "Type.Builder": self._dim_y = value return self def setZ(self, value: int) -> "Type.Builder": self._dim_z = value return self def setMipmaps(self, enable: bool) -> "Type.Builder": self._mipmaps = enable return self def setFaces(self, enable: bool) -> "Type.Builder": self._faces = enable return self def setYuvFormat(self, yuv_format: int) -> "Type.Builder": self._yuv_format = yuv_format return self def create(self) -> Type: t = Type(self._rs, self._element, self._dim_x, self._dim_y, self._dim_z, self._mipmaps, self._faces) t._yuv_format = self._yuv_format return t # ═══════════════════════════════════════════════════════════════ # Allocation # ═══════════════════════════════════════════════════════════════ class Allocation(Stub): """Allocation — RenderScript 内存分配""" # 使用类型 USAGE_SCRIPT = 0x0001 USAGE_GRAPHICS_TEXTURE = 0x0002 USAGE_GRAPHICS_VERTEX = 0x0004 USAGE_GRAPHICS_CONSTANTS = 0x0008 USAGE_GRAPHICS_RENDER_TARGET = 0x0010 USAGE_IO_INPUT = 0x0020 USAGE_IO_OUTPUT = 0x0040 USAGE_SHARED = 0x0080 # Mipmap 控制 MIPMAP_FULL = 0 MIPMAP_ON_SYNC_TO_TEXTURE = 1 def __init__(self, rs: Optional[RenderScript] = None, type_: Optional[Type] = None, usage: int = USAGE_SCRIPT): super().__init__() self._rs = rs self._type = type_ self._usage = usage self._data: Any = None self._element_size = type_.getElement().getBytesSize() if type_ and type_.getElement() else 0 @staticmethod def createTyped(rs: RenderScript, type_: Type, usage: int = USAGE_SCRIPT) -> "Allocation": """创建分配""" alloc = Allocation(rs, type_, usage) total_size = type_.getCount() * type_.getElement().getBytesSize() if type_.getElement() else 0 alloc._data = bytearray(total_size) return alloc @staticmethod def createFromBitmap(rs: RenderScript, bitmap: Any, usage: int = USAGE_SCRIPT) -> "Allocation": """从位图创建分配""" # 尝试获取位图尺寸 width, height = 0, 0 try: width = bitmap.getWidth() if hasattr(bitmap, 'getWidth') else 0 height = bitmap.getHeight() if hasattr(bitmap, 'getHeight') else 0 except Exception: pass element = Element(rs, Element.DataType.UNSIGNED_8, 4) type_ = Type(rs, element, width, height) alloc = Allocation(rs, type_, usage) alloc._data = bytearray(width * height * 4) return alloc @staticmethod def createFromBitmapBoxed(rs: RenderScript, bitmap: Any, usage: int = USAGE_SCRIPT) -> "Allocation": return Allocation.createFromBitmap(rs, bitmap, usage) def copyFrom(self, data: Any): """从数组或位图复制数据""" if isinstance(data, (bytes, bytearray)): self._data = bytearray(data) elif hasattr(data, '__iter__'): import struct try: self._data = bytearray(struct.pack(f'<{len(list(data))}f', *[float(v) for v in data])) except Exception: self._data = bytearray(len(list(data)) * 4) else: self._data = bytearray(1024) def copyTo(self, data: Any): """将数据复制到目标""" if isinstance(data, bytearray) and self._data: data[:] = self._data elif isinstance(data, list): data.clear() if self._data: for i in range(0, len(self._data), 4): data.append(int.from_bytes(self._data[i:i+4], 'little')) def resize(self, dim_x: int): """重新调整分配大小""" if self._type: self._type._dim_x = dim_x self._data = bytearray(self._type.getCount() * self._element_size) def getType(self) -> Optional[Type]: return self._type def getUsage(self) -> int: return self._usage def getElement(self) -> Optional[Element]: return self._type.getElement() if self._type else None def syncAll(self, src_location: int): pass def destroy(self): self._data = None def toString(self) -> str: return (f"Allocation(type={self._type}, usage={self._usage}, " f"data_size={len(self._data) if self._data else 0})") def hashCode(self) -> int: return id(self) & 0x7FFFFFFF def equals(self, other) -> bool: return self is other # ═══════════════════════════════════════════════════════════════ # Matrix4f # ═══════════════════════════════════════════════════════════════ class Matrix4f(Stub): """Matrix4f — 4x4 浮点矩阵""" def __init__(self): super().__init__() self._matrix = [0.0] * 16 self._matrix[0] = 1.0 # 单位矩阵 self._matrix[5] = 1.0 self._matrix[10] = 1.0 self._matrix[15] = 1.0 def getArray(self) -> List[float]: return list(self._matrix) def setArray(self, array: List[float]): if len(array) >= 16: self._matrix = list(array[:16]) def loadIdentity(self): self._matrix = [0.0] * 16 self._matrix[0] = 1.0 self._matrix[5] = 1.0 self._matrix[10] = 1.0 self._matrix[15] = 1.0 def load(self, src: "Matrix4f"): self._matrix = list(src._matrix) def loadRotate(self, rot: float, x: float, y: float, z: float): angle_rad = math.radians(rot) c = math.cos(angle_rad) s = math.sin(angle_rad) self.loadIdentity() if x == 1 and y == 0 and z == 0: self._matrix[5] = c self._matrix[6] = -s self._matrix[9] = s self._matrix[10] = c elif x == 0 and y == 1 and z == 0: self._matrix[0] = c self._matrix[2] = s self._matrix[8] = -s self._matrix[10] = c elif x == 0 and y == 0 and z == 1: self._matrix[0] = c self._matrix[1] = -s self._matrix[4] = s self._matrix[5] = c def loadScale(self, x: float, y: float, z: float): self.loadIdentity() self._matrix[0] = x self._matrix[5] = y self._matrix[10] = z def loadTranslate(self, x: float, y: float, z: float): self.loadIdentity() self._matrix[12] = x self._matrix[13] = y self._matrix[14] = z def loadMultiply(self, lhs: "Matrix4f", rhs: "Matrix4f"): for i in range(4): for j in range(4): self._matrix[i * 4 + j] = sum( lhs._matrix[i * 4 + k] * rhs._matrix[k * 4 + j] for k in range(4) ) def multiply(self, rhs: "Matrix4f"): result = [0.0] * 16 for i in range(4): for j in range(4): result[i * 4 + j] = sum( self._matrix[i * 4 + k] * rhs._matrix[k * 4 + j] for k in range(4) ) self._matrix = result def transpose(self): for i in range(4): for j in range(i + 1, 4): self._matrix[i * 4 + j], self._matrix[j * 4 + i] = \ self._matrix[j * 4 + i], self._matrix[i * 4 + j] def toString(self) -> str: rows = [] for i in range(4): row = self._matrix[i*4:(i+1)*4] rows.append(f"[{', '.join(f'{v:.4f}' for v in row)}]") return f"Matrix4f({', '.join(rows)})" def hashCode(self) -> int: return hash(tuple(self._matrix)) & 0x7FFFFFFF def equals(self, other) -> bool: if not isinstance(other, Matrix4f): return False return self._matrix == other._matrix # ═══════════════════════════════════════════════════════════════ # Matrix3f # ═══════════════════════════════════════════════════════════════ class Matrix3f(Stub): """Matrix3f — 3x3 浮点矩阵""" def __init__(self): super().__init__() self._matrix = [0.0] * 9 self._matrix[0] = 1.0 self._matrix[4] = 1.0 self._matrix[8] = 1.0 def getArray(self) -> List[float]: return list(self._matrix) def setArray(self, array: List[float]): if len(array) >= 9: self._matrix = list(array[:9]) def loadIdentity(self): self._matrix = [0.0] * 9 self._matrix[0] = 1.0 self._matrix[4] = 1.0 self._matrix[8] = 1.0 def load(self, src: "Matrix3f"): self._matrix = list(src._matrix) def loadMultiply(self, lhs: "Matrix3f", rhs: "Matrix3f"): for i in range(3): for j in range(3): self._matrix[i * 3 + j] = sum( lhs._matrix[i * 3 + k] * rhs._matrix[k * 3 + j] for k in range(3) ) def multiply(self, rhs: "Matrix3f"): result = [0.0] * 9 for i in range(3): for j in range(3): result[i * 3 + j] = sum( self._matrix[i * 3 + k] * rhs._matrix[k * 3 + j] for k in range(3) ) self._matrix = result def transpose(self): for i in range(3): for j in range(i + 1, 3): self._matrix[i * 3 + j], self._matrix[j * 3 + i] = \ self._matrix[j * 3 + i], self._matrix[i * 3 + j] def toString(self) -> str: rows = [] for i in range(3): row = self._matrix[i*3:(i+1)*3] rows.append(f"[{', '.join(f'{v:.4f}' for v in row)}]") return f"Matrix3f({', '.join(rows)})" def hashCode(self) -> int: return hash(tuple(self._matrix)) & 0x7FFFFFFF def equals(self, other) -> bool: if not isinstance(other, Matrix3f): return False return self._matrix == other._matrix # ═══════════════════════════════════════════════════════════════ # Script (base) # ═══════════════════════════════════════════════════════════════ class Script(Stub): """Script — RenderScript 脚本基类""" def __init__(self, rs: Optional[RenderScript] = None): super().__init__() self._rs = rs self._kernel_groups: List[Any] = [] def setVar(self, index: int, value: Any): """设置脚本变量""" pass def getVar(self, index: int) -> Any: return None def setTimeZone(self, timezone: str): pass def forEach(self, slot: int, ains: List[Allocation], aout: Allocation, vdata: Any = None): """执行 forEach 内核""" raise AndroidOnlyError("Script.forEach() 仅在 Android (RenderScript) 设备上可用") def invoke(self, slot: int): """调用可调用函数""" pass def bindAllocation(self, va: Allocation, slot: int): """绑定分配""" pass def destroy(self): pass def toString(self) -> str: return f"Script@{hex(id(self))}" def hashCode(self) -> int: return id(self) & 0x7FFFFFFF def equals(self, other) -> bool: return self is other # ═══════════════════════════════════════════════════════════════ # ScriptC # ═══════════════════════════════════════════════════════════════ class ScriptC(Script): """ScriptC — 编译的 RenderScript 内核脚本""" def __init__(self, rs: RenderScript, resource_id: int = 0): super().__init__(rs) self._resource_id = resource_id def toString(self) -> str: return f"ScriptC(resourceId={self._resource_id})" # ═══════════════════════════════════════════════════════════════ # ScriptIntrinsicBlur # ═══════════════════════════════════════════════════════════════ class ScriptIntrinsicBlur(Script): """ScriptIntrinsicBlur — 高斯模糊内在函数""" def __init__(self, rs: RenderScript): super().__init__(rs) self._radius: float = 5.0 self._input: Optional[Allocation] = None @staticmethod def create(rs: RenderScript, e: Element) -> "ScriptIntrinsicBlur": """创建模糊内在函数""" return ScriptIntrinsicBlur(rs) def setRadius(self, radius: float): """设置模糊半径""" self._radius = max(0.0, min(radius, 25.0)) def setInput(self, alloc: Allocation): """设置输入分配""" self._input = alloc def forEach(self, aout: Allocation): """执行模糊""" if self._input and aout: pass # 在桌面环境不执行实际模糊 def toString(self) -> str: return f"ScriptIntrinsicBlur(radius={self._radius})" # ═══════════════════════════════════════════════════════════════ # ScriptIntrinsicConvolve3x3 # ═══════════════════════════════════════════════════════════════ class ScriptIntrinsicConvolve3x3(Script): """ScriptIntrinsicConvolve3x3 — 3x3 卷积内在函数""" def __init__(self, rs: RenderScript): super().__init__(rs) self._coefficients: List[float] = [0.0] * 9 self._input: Optional[Allocation] = None @staticmethod def create(rs: RenderScript, e: Element) -> "ScriptIntrinsicConvolve3x3": """创建卷积内在函数""" return ScriptIntrinsicConvolve3x3(rs) def setCoefficients(self, coeffs: List[float]): """设置卷积系数""" for i in range(min(len(coeffs), 9)): self._coefficients[i] = coeffs[i] def setInput(self, alloc: Allocation): """设置输入分配""" self._input = alloc def forEach(self, aout: Allocation): """执行卷积""" pass def toString(self) -> str: return f"ScriptIntrinsicConvolve3x3(coefficients={self._coefficients})" # ═══════════════════════════════════════════════════════════════ # 初始化 Element 静态实例 # ═══════════════════════════════════════════════════════════════ def _init_elements(): """初始化 Element 预定义实例（在模块导入时调用）""" rs = RenderScript.create() Element.F32 = Element.F32(rs) Element.F64 = Element.F64(rs) Element.I8 = Element.I8(rs) Element.I16 = Element.I16(rs) Element.I32 = Element.I32(rs) Element.I64 = Element.I64(rs) Element.U8 = Element.U8(rs) Element.U16 = Element.U16(rs) Element.U32 = Element.U32(rs) Element.U64 = Element.U64(rs) Element.BOOLEAN = Element.BOOL(rs) Element.ALLOCATION = Element(rs, Element.DataType.RS_ELEMENT, 1) Element.A_8 = Element.createPixel(rs, Element.DataType.UNSIGNED_8, 1) Element.RGB_565 = Element.createPixel(rs, Element.DataType.UNSIGNED_5_6_5, 3) Element.RGBA_4444 = Element.createPixel(rs, Element.DataType.UNSIGNED_4_4_4_4, 4) Element.RGBA_8888 = Element.createPixel(rs, Element.DataType.UNSIGNED_8, 4) Element.F32_2 = Element.createVector(rs, Element.DataType.FLOAT_32, 2) Element.F32_3 = Element.createVector(rs, Element.DataType.FLOAT_32, 3) Element.F32_4 = Element.createVector(rs, Element.DataType.FLOAT_32, 4) Element.F64_2 = Element.createVector(rs, Element.DataType.FLOAT_64, 2) Element.F64_3 = Element.createVector(rs, Element.DataType.FLOAT_64, 3) Element.F64_4 = Element.createVector(rs, Element.DataType.FLOAT_64, 4) Element.I8_2 = Element.createVector(rs, Element.DataType.SIGNED_8, 2) Element.I8_3 = Element.createVector(rs, Element.DataType.SIGNED_8, 3) Element.I8_4 = Element.createVector(rs, Element.DataType.SIGNED_8, 4) Element.I16_2 = Element.createVector(rs, Element.DataType.SIGNED_16, 2) Element.I16_3 = Element.createVector(rs, Element.DataType.SIGNED_16, 3) Element.I16_4 = Element.createVector(rs, Element.DataType.SIGNED_16, 4) Element.I32_2 = Element.createVector(rs, Element.DataType.SIGNED_32, 2) Element.I32_3 = Element.createVector(rs, Element.DataType.SIGNED_32, 3) Element.I32_4 = Element.createVector(rs, Element.DataType.SIGNED_32, 4) Element.I64_2 = Element.createVector(rs, Element.DataType.SIGNED_64, 2) Element.I64_3 = Element.createVector(rs, Element.DataType.SIGNED_64, 3) Element.I64_4 = Element.createVector(rs, Element.DataType.SIGNED_64, 4) Element.U8_2 = Element.createVector(rs, Element.DataType.UNSIGNED_8, 2) Element.U8_3 = Element.createVector(rs, Element.DataType.UNSIGNED_8, 3) Element.U8_4 = Element.createVector(rs, Element.DataType.UNSIGNED_8, 4) Element.U16_2 = Element.createVector(rs, Element.DataType.UNSIGNED_16, 2) Element.U16_3 = Element.createVector(rs, Element.DataType.UNSIGNED_16, 3) Element.U16_4 = Element.createVector(rs, Element.DataType.UNSIGNED_16, 4) Element.U32_2 = Element.createVector(rs, Element.DataType.UNSIGNED_32, 2) Element.U32_3 = Element.createVector(rs, Element.DataType.UNSIGNED_32, 3) Element.U32_4 = Element.createVector(rs, Element.DataType.UNSIGNED_32, 4) Element.U64_2 = Element.createVector(rs, Element.DataType.UNSIGNED_64, 2) Element.U64_3 = Element.createVector(rs, Element.DataType.UNSIGNED_64, 3) Element.U64_4 = Element.createVector(rs, Element.DataType.UNSIGNED_64, 4) _init_elements() # ═══════════════════════════════════════════════════════════════ # __all__ # ═══════════════════════════════════════════════════════════════ __all__ = [ "RenderScript", "Allocation", "Element", "Type", "Script", "ScriptIntrinsicBlur", "ScriptIntrinsicConvolve3x3", "ScriptC", "Matrix4f", "Matrix3f", ]