eagle-engine 0.1.0__py3-none-any.whl

eagle/gfx/orbit_camera.py

@@ -0,0 +1,105 @@
+"""OrbitCamera — орбитальная камера с управлением мышью и колесом."""
+from __future__ import annotations
+import math
+import pygame
+from eagle.gfx.camera import Camera
+from eagle.math import Vec3
+
+
+class OrbitCamera:
+    def __init__(
+        self,
+        target: Vec3 | tuple | None = None,
+        distance: float = 5.0,
+        *,
+        yaw: float = 0.0,          # горизонтальный угол (рад), 0 = смотреть с +Z
+        pitch: float = 0.25,       # вертикальный угол (рад), 0 = горизонтально
+        fov_deg: float = 60.0,
+        near: float = 0.1,
+        far: float = 10000.0,
+        sensitivity: float = 0.005,
+        zoom_speed: float = 1.1,
+        min_distance: float = 0.5,
+        max_distance: float = 500.0,
+    ):
+        self.camera = Camera(
+            position=Vec3(0, 0, distance),
+            target=target if isinstance(target, Vec3) else Vec3.from_array(target or (0, 0, 0)),
+            fov_deg=fov_deg, near=near, far=far,
+        )
+        self.distance = distance
+        self.yaw = yaw
+        self.pitch = pitch
+        self.sensitivity = sensitivity
+        self.zoom_speed = zoom_speed
+        self.min_distance = min_distance
+        self.max_distance = max_distance
+        self._grab = False
+        self._update_camera()
+
+    # --- API ---
+    @property
+    def target(self) -> Vec3:
+        return self.camera.target
+
+    @target.setter
+    def target(self, v):
+        if isinstance(v, Vec3):
+            self.camera.target = v
+        else:
+            self.camera.target = Vec3.from_array(v)
+        self._update_camera()
+
+    def set_grab(self, enable: bool) -> None:
+        """Захват мыши (relative mode). Toggle по клику или кнопке."""
+        self._grab = enable
+        pygame.event.set_grab(enable)
+        pygame.mouse.set_visible(not enable)
+        if enable:
+            pygame.mouse.set_pos(pygame.display.get_window_size()[0] // 2,
+                                 pygame.display.get_window_size()[1] // 2)
+
+    @property
+    def grabbed(self) -> bool:
+        return self._grab
+
+    # --- управление ---
+    def handle_event(self, event: pygame.event.Event) -> None:
+        """Вызови из @engine.on_event."""
+        if event.type == pygame.MOUSEBUTTONDOWN:
+            if event.button == 1:                  # ЛКМ — захватить
+                self.set_grab(True)
+            elif event.button == 4:                # колесо вверх — приблизить
+                self.distance = max(self.min_distance, self.distance / self.zoom_speed)
+                self._update_camera()
+            elif event.button == 5:                # колесо вниз — отдалить
+                self.distance = min(self.max_distance, self.distance * self.zoom_speed)
+                self._update_camera()
+
+        elif event.type == pygame.MOUSEMOTION and self._grab:
+            dx, dy = event.rel
+            self.yaw   -= dx * self.sensitivity
+            self.pitch -= dy * self.sensitivity
+            # ограничиваем pitch, чтобы не перевернуться
+            self.pitch = max(-math.pi / 2 + 0.01, min(math.pi / 2 - 0.01, self.pitch))
+            self._update_camera()
+
+        elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
+            self.set_grab(False)
+
+    def _update_camera(self) -> None:
+        # Сферические координаты: yaw вокруг Y, pitch — вверх/вниз
+        cp = math.cos(self.pitch)
+        sp = math.sin(self.pitch)
+        cy = math.cos(self.yaw)
+        sy = math.sin(self.yaw)
+
+        # Позиция = target + distance * (направление от target к камере)
+        offset_x = cp * sy
+        offset_y = sp
+        offset_z = cp * cy
+        self.camera.position = Vec3(
+            self.camera.target.x + offset_x * self.distance,
+            self.camera.target.y + offset_y * self.distance,
+            self.camera.target.z + offset_z * self.distance,
+        )

eagle/gfx/shader.py

@@ -0,0 +1,76 @@
+"""Обёртка над ModernGL-программой."""
+from __future__ import annotations
+import os
+import moderngl
+from eagle.math.mat import Mat4
+from eagle.math.vec import Vec3
+
+
+class Shader:
+    def __init__(self, vert: str, frag: str, *, vert_path: str | None = None, frag_path: str | None = None):
+        self._vert_src = vert
+        self._frag_src = frag
+        self._vert_path = vert_path
+        self._frag_path = frag_path
+        self._prog: moderngl.Program | None = None
+        self._uniforms: dict[str, object] = {}
+
+    def build(self, ctx: moderngl.Context) -> None:
+        if self._prog is not None:
+            self._prog.release()
+        self._prog = ctx.program(vertex_shader=self._vert_src, fragment_shader=self._frag_src)
+        self._uniforms.clear()
+
+    def release(self) -> None:
+        if self._prog:
+            self._prog.release()
+            self._prog = None
+
+    @property
+    def program(self) -> moderngl.Program:
+        if self._prog is None:
+            raise RuntimeError("Shader not built: call build(ctx)")
+        return self._prog
+
+    def __setitem__(self, name, value):
+        self._uniforms[name] = value
+
+    def _apply(self):
+        prog = self.program
+        for name, value in self._uniforms.items():
+            if name not in prog:
+                continue
+            if isinstance(value, Mat4):
+                prog[name].write(value.gl_bytes)
+            elif isinstance(value, Vec3):
+                prog[name].value = value.xyz
+            elif isinstance(value, (int, float, tuple, list)):
+                prog[name].value = value
+
+    def use(self):
+        """Применить все накопленные uniform'ы. Программа активируется автоматически при записи."""
+        self._apply()
+
+    def reload(self):
+        if self._vert_path:
+            with open(self._vert_path, "r", encoding="utf-8") as f:
+                self._vert_src = f.read()
+        if self._frag_path:
+            with open(self._frag_path, "r", encoding="utf-8") as f:
+                self._frag_src = f.read()
+        if self._prog is not None:
+            self.build(self._prog.ctx)
+
+
+def shader_from_files(vert_path: str, frag_path: str) -> Shader:
+    with open(vert_path, "r", encoding="utf-8") as f:
+        v = f.read()
+    with open(frag_path, "r", encoding="utf-8") as f:
+        fr = f.read()
+    return Shader(v, fr, vert_path=vert_path, frag_path=frag_path)
+
+
+def shader_from_package(rel_vert: str, rel_frag: str) -> Shader:
+    here = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    base = os.path.join(here, "assets", "shaders")
+    return shader_from_files(os.path.join(base, rel_vert), os.path.join(base, rel_frag))

eagle/gfx/texture.py

@@ -0,0 +1,49 @@
+"""Texture — из файла / из pygame.Surface."""
+from __future__ import annotations
+import pygame
+import moderngl
+
+
+class Texture:
+    def __init__(self, surface: pygame.Surface, *, flip: bool = False):
+        # НЕ convert_alpha здесь: display может быть ещё не создан.
+        self._surface = surface
+        self._flip = flip
+        self._tex: moderngl.Texture | None = None
+
+    @classmethod
+    def from_file(cls, path: str, *, flip: bool = True) -> "Texture":
+        return cls(pygame.image.load(path), flip=flip)
+
+    def build(self, ctx: moderngl.Context) -> None:
+        self.release()
+        # Конвертация — здесь, когда display уже создан.
+        surf = self._surface.convert_alpha()
+        w, h = surf.get_size()
+        data = pygame.image.tostring(surf, "RGBA", self._flip)
+        self._tex = ctx.texture((w, h), 4, data)
+        self._tex.build_mipmaps()
+        self._tex.filter = (moderngl.LINEAR_MIPMAP_LINEAR, moderngl.LINEAR)
+        self._tex.anisotropy = 8.0
+
+    def update_from_surface(self, surface: pygame.Surface) -> None:
+        if self._tex is None:
+            return
+        surf = surface.convert_alpha()
+        if surf.get_size() != (self._tex.width, self._tex.height):
+            raise ValueError("surface size mismatch")
+        self._tex.write(pygame.image.tostring(surf, "RGBA", self._flip))
+
+    def release(self):
+        if self._tex:
+            self._tex.release(); self._tex = None
+
+    @property
+    def gl_texture(self):
+        if self._tex is None:
+            raise RuntimeError("Texture not built")
+        return self._tex
+
+    def use(self, unit: int = 0):
+        if self._tex:
+            self._tex.use(unit)

eagle/loaders/__init__.py

@@ -0,0 +1,5 @@
+from eagle.loaders.obj import load_obj
+from eagle.loaders.stl import load_stl
+from eagle.loaders.mtl import load_mtl, MTLMaterial
+
+__all__ = ["load_obj", "load_stl", "load_mtl", "MTLMaterial"]

eagle/loaders/mtl.py

@@ -0,0 +1,51 @@
+"""Загрузчик .mtl — материалы для .obj."""
+from __future__ import annotations
+import os
+import pygame
+
+
+class MTLMaterial:
+    def __init__(self):
+        self.name = ""
+        self.diffuse = (0.8, 0.8, 0.85)   # Kd
+        self.ambient = (0.2, 0.2, 0.2)    # Ka
+        self.specular = (0.5, 0.5, 0.5)   # Ks
+        self.shininess = 32.0             # Ns
+        self.diffuse_map: str | None = None
+        self.texture_surface: pygame.Surface | None = None
+
+
+def load_mtl(path: str) -> dict[str, MTLMaterial]:
+    materials: dict[str, MTLMaterial] = {}
+    current: MTLMaterial | None = None
+
+    with open(path, "r", encoding="utf-8", errors="ignore") as f:
+        for line in f:
+            line = line.strip()
+            if not line or line.startswith("#"):
+                continue
+            parts = line.split()
+            tag = parts[0]
+            if tag == "newmtl":
+                current = MTLMaterial()
+                current.name = parts[1]
+                materials[current.name] = current
+            elif current is None:
+                continue
+            elif tag == "Kd":
+                current.diffuse = (float(parts[1]), float(parts[2]), float(parts[3]))
+            elif tag == "Ka":
+                current.ambient = (float(parts[1]), float(parts[2]), float(parts[3]))
+            elif tag == "Ks":
+                current.specular = (float(parts[1]), float(parts[2]), float(parts[3]))
+            elif tag == "Ns":
+                current.shininess = float(parts[1])
+            elif tag == "map_Kd":
+                tex_name = " ".join(parts[1:])
+                tex_path = os.path.join(os.path.dirname(path), tex_name)
+                current.diffuse_map = tex_path
+                if os.path.exists(tex_path):
+                    # НЕ convert_alpha: дисплей может быть ещё не создан.
+                    # Texture.build() сделает convert_alpha после инициализации.
+                    current.texture_surface = pygame.image.load(tex_path)
+    return materials

eagle/loaders/obj.py

@@ -0,0 +1,151 @@
+"""Загрузчик .obj с разбиением на sub-meshes по материалам."""
+from __future__ import annotations
+import os
+import numpy as np
+import pygame
+from eagle.gfx.mesh import Mesh
+from eagle.gfx.model import Model, ModelPart
+from eagle.gfx.texture import Texture
+from eagle.loaders.mtl import load_mtl, MTLMaterial
+
+
+def load_obj(path: str) -> Model:
+    """Возвращает Model (несколько sub-meshes, по одному на материал)."""
+    positions: list[tuple[float, float, float]] = []
+    normals:   list[tuple[float, float, float]] = []
+    uvs:       list[tuple[float, float]] = []
+
+    # Для каждого материала: { key → (local_index, [vertex_data]) , indices: [] }
+    per_mat_verts: dict[int, list[list[float]]] = {}
+    per_mat_idx:   dict[int, list[int]] = {}
+    per_mat_dedup: dict[int, dict[tuple, int]] = {}
+
+    materials: list[MTLMaterial] = []
+    mat_name_to_idx: dict[str, int] = {}
+    current_mat_idx = -1
+
+    def ensure_mat(name: str) -> int:
+        if name in mat_name_to_idx:
+            return mat_name_to_idx[name]
+        m = MTLMaterial(); m.name = name
+        materials.append(m)
+        idx = len(materials) - 1
+        mat_name_to_idx[name] = idx
+        return idx
+
+    mtllib_loaded = False
+
+    with open(path, "r", encoding="utf-8", errors="ignore") as f:
+        for line in f:
+            line = line.strip()
+            if not line or line.startswith("#"):
+                continue
+            parts = line.split()
+            tag = parts[0]
+
+            if tag == "mtllib" and not mtllib_loaded:
+                mtl_name = " ".join(parts[1:])
+                mtl_path = os.path.join(os.path.dirname(path), mtl_name)
+                if os.path.exists(mtl_path):
+                    loaded = load_mtl(mtl_path)
+                    for name, mat in loaded.items():
+                        if name not in mat_name_to_idx:
+                            mat_name_to_idx[name] = len(materials)
+                            materials.append(mat)
+                mtllib_loaded = True
+
+            elif tag == "usemtl":
+                name = parts[1]
+                current_mat_idx = ensure_mat(name)
+
+            elif tag == "v":
+                positions.append((float(parts[1]), float(parts[2]), float(parts[3])))
+            elif tag == "vn":
+                normals.append((float(parts[1]), float(parts[2]), float(parts[3])))
+            elif tag == "vt":
+                uvs.append((float(parts[1]), float(parts[2])))
+
+            elif tag == "f":
+                if current_mat_idx < 0:
+                    current_mat_idx = ensure_mat("__default__")
+                face = []
+                for tok in parts[1:]:
+                    if "/" in tok:
+                        comp = tok.split("/")
+                        v_str = comp[0]
+                        vt_str = comp[1] if len(comp) > 1 and comp[1] else "0"
+                        vn_str = comp[2] if len(comp) > 2 and comp[2] else "0"
+                        v = int(v_str) - 1
+                        vt = int(vt_str) - 1 if vt_str and vt_str != "0" else -1
+                        vn = int(vn_str) - 1 if vn_str and vn_str != "0" else -1
+                    else:
+                        v = int(tok) - 1; vt = -1; vn = -1
+                    face.append((v, vn, vt))
+
+                if len(face) >= 3:
+                    verts_l = per_mat_verts.setdefault(current_mat_idx, [])
+                    idx_l   = per_mat_idx.setdefault(current_mat_idx, [])
+                    dedup   = per_mat_dedup.setdefault(current_mat_idx, {})
+
+                    for i in range(1, len(face) - 1):
+                        for vert in (face[0], face[i], face[i + 1]):
+                            v_i, n_i, u_i = vert
+                            key = (v_i, n_i, u_i)
+                            if key not in dedup:
+                                p = positions[v_i]
+                                n = normals[n_i] if n_i >= 0 and n_i < len(normals) else (0.0, 0.0, 0.0)
+                                uv = uvs[u_i] if u_i >= 0 and u_i < len(uvs) else (0.0, 0.0)
+                                dedup[key] = len(verts_l)
+                                verts_l.append([*p, *n, *uv])
+                            idx_l.append(dedup[key])
+
+    model = Model()
+    for mat_idx, verts_l in per_mat_verts.items():
+        verts_arr = np.array(verts_l, dtype=np.float32).reshape(-1, 8)
+        idx_l = per_mat_idx[mat_idx]
+        if not normals:
+            verts_arr = _compute_flat_normals(verts_arr, idx_l)
+
+        mesh = Mesh.from_arrays(verts_arr, np.array(idx_l, dtype=np.uint32))
+
+        mat = materials[mat_idx] if mat_idx < len(materials) else MTLMaterial()
+        color = mat.diffuse if mat.diffuse else (0.8, 0.8, 0.85)
+
+        texture = None
+        if mat.texture_surface is not None:
+            texture = Texture(mat.texture_surface, flip=True)
+            # Built later (engine.ctx нужен)
+            
+        print(f"[obj] part '{mat.name}': verts={len(verts_l)}, indices={len(idx_l)}, "
+              f"texture={'YES' if texture else 'NO'}, "
+              f"tex_path={mat.diffuse_map}, color={color}")
+
+        model.add_part(ModelPart(
+            mesh, color=color, texture=texture,
+            shininess=max(1.0, mat.shininess),
+            specular=0.3,
+            name=mat.name,
+        ))
+
+    if len(model) == 0:
+        raise ValueError(f"no geometry found in {path}")
+    print(f"[obj] total parts: {len(model)}")
+    return model
+
+
+def _compute_flat_normals(verts: np.ndarray, indices: list[int]) -> np.ndarray:
+    V = verts[:, :3]
+    idx = np.array(indices, dtype=np.int64).reshape(-1, 3)
+    e1 = V[idx[:, 1]] - V[idx[:, 0]]
+    e2 = V[idx[:, 2]] - V[idx[:, 0]]
+    face_n = np.cross(e1, e2)
+    face_n /= np.maximum(np.linalg.norm(face_n, axis=1, keepdims=True), 1e-12)
+    n = np.zeros_like(V)
+    for k in range(3):
+        np.add.at(n, idx[:, k], face_n)
+    norm = np.linalg.norm(n, axis=1, keepdims=True)
+    norm[norm < 1e-12] = 1
+    n /= norm
+    out = verts.copy()
+    out[:, 3:6] = n.astype(np.float32)
+    return out

eagle/loaders/stl.py

@@ -0,0 +1,55 @@
+"""Загрузчик .stl (ASCII и бинарный)."""
+from __future__ import annotations
+import struct
+import numpy as np
+from eagle.gfx.mesh import Mesh
+
+
+def load_stl(path: str) -> Mesh:
+    with open(path, "rb") as f:
+        head = f.read(80)
+        rest = f.read(4)
+        size = struct.unpack("<I", rest)[0] if len(rest) == 4 else 0
+        is_ascii = head[:5].lower() == b"solid" and size == 0
+
+    if is_ascii:
+        return _load_ascii(path)
+    return _load_binary(path)
+
+
+def _load_binary(path: str) -> Mesh:
+    with open(path, "rb") as f:
+        f.read(80)
+        n_tris = struct.unpack("<I", f.read(4))[0]
+        data = np.frombuffer(f.read(n_tris * 50), dtype=np.uint8).reshape(n_tris, 50)
+    floats = data[:, :48].copy().view("<f4").reshape(n_tris, 12)
+    normals = floats[:, :3]
+    v0 = floats[:, 3:6]; v1 = floats[:, 6:9]; v2 = floats[:, 9:12]
+    tri_pos = np.stack([v0, v1, v2], axis=1).reshape(-1, 3)
+    tri_n   = np.repeat(normals, 3, axis=0)
+    tri_uv  = np.zeros((len(tri_pos), 2), dtype=np.float32)
+    verts = np.hstack([tri_pos, tri_n, tri_uv]).astype(np.float32)
+    indices = np.arange(len(verts), dtype=np.uint32)
+    return Mesh.from_arrays(verts, indices)
+
+
+def _load_ascii(path: str) -> Mesh:
+    verts_list, normals_list = [], []
+    cur_n = (0.0, 0.0, 0.0)
+    with open(path, "r", encoding="utf-8", errors="ignore") as f:
+        for line in f:
+            parts = line.strip().split()
+            if not parts: continue
+            if parts[0] == "facet" and len(parts) >= 5 and parts[1] == "normal":
+                cur_n = (float(parts[2]), float(parts[3]), float(parts[4]))
+            elif parts[0] == "vertex":
+                verts_list.append((float(parts[1]), float(parts[2]), float(parts[3])))
+                normals_list.append(cur_n)
+    if not verts_list:
+        raise ValueError("empty STL file")
+    tri_pos = np.array(verts_list, dtype=np.float32)
+    tri_n = np.array(normals_list, dtype=np.float32)
+    tri_uv = np.zeros((len(tri_pos), 2), dtype=np.float32)
+    verts = np.hstack([tri_pos, tri_n, tri_uv]).astype(np.float32)
+    indices = np.arange(len(verts), dtype=np.uint32)
+    return Mesh.from_arrays(verts, indices)

eagle/math/__init__.py

@@ -0,0 +1,5 @@
+from eagle.math.vec import Vec2, Vec3, Vec4
+from eagle.math.mat import Mat4
+from eagle.math.transform import Transform
+
+__all__ = ["Vec2", "Vec3", "Vec4", "Mat4", "Transform"]

eagle/math/mat.py

@@ -0,0 +1,122 @@
+"""Mat4 — матрица 4x4 float32 (column-major для OpenGL)."""
+from __future__ import annotations
+import math
+import numpy as np
+from eagle.math.vec import Vec3
+
+
+class Mat4:
+    __slots__ = ("_m",)
+
+    def __init__(self, m=None):
+        if m is None:
+            self._m = np.eye(4, dtype=np.float32)
+        else:
+            self._m = np.asarray(m, dtype=np.float32).reshape(4, 4).copy()
+
+    @classmethod
+    def identity(cls): return cls()
+
+    @classmethod
+    def translation(cls, x, y, z):
+        m = cls()
+        m._m[0, 3] = x; m._m[1, 3] = y; m._m[2, 3] = z
+        return m
+
+    @classmethod
+    def scale(cls, x, y=None, z=None):
+        if y is None: y = x
+        if z is None: z = x
+        m = cls()
+        m._m[0, 0] = x; m._m[1, 1] = y; m._m[2, 2] = z
+        return m
+
+    @classmethod
+    def rotation_x(cls, rad):
+        c, s = math.cos(rad), math.sin(rad)
+        m = cls()
+        m._m[1, 1] = c;  m._m[1, 2] = -s
+        m._m[2, 1] = s;  m._m[2, 2] = c
+        return m
+
+    @classmethod
+    def rotation_y(cls, rad):
+        c, s = math.cos(rad), math.sin(rad)
+        m = cls()
+        m._m[0, 0] = c;  m._m[0, 2] = s
+        m._m[2, 0] = -s; m._m[2, 2] = c
+        return m
+
+    @classmethod
+    def rotation_z(cls, rad):
+        c, s = math.cos(rad), math.sin(rad)
+        m = cls()
+        m._m[0, 0] = c;  m._m[0, 1] = -s
+        m._m[1, 0] = s;  m._m[1, 1] = c
+        return m
+
+    @classmethod
+    def rotation_axis(cls, axis, rad):
+        a = axis.normalized().array
+        x, y, z = a
+        c, s = math.cos(rad), math.sin(rad)
+        C = 1 - c
+        m = cls()
+        m._m[0, :3] = [x*x*C + c,   x*y*C - z*s, x*z*C + y*s]
+        m._m[1, :3] = [y*x*C + z*s, y*y*C + c,   y*z*C - x*s]
+        m._m[2, :3] = [z*x*C - y*s, z*y*C + x*s, z*z*C + c]
+        return m
+
+    @classmethod
+    def perspective(cls, fov_deg, aspect, near, far):
+        f = 1.0 / math.tan(math.radians(fov_deg) / 2.0)
+        m = cls(np.zeros((4, 4), dtype=np.float32))
+        m._m[0, 0] = f / aspect
+        m._m[1, 1] = f
+        m._m[2, 2] = (far + near) / (near - far)
+        m._m[2, 3] = (2 * far * near) / (near - far)
+        m._m[3, 2] = -1.0
+        return m
+
+    @classmethod
+    def ortho(cls, left, right, bottom, top, near, far):
+        m = cls(np.zeros((4, 4), dtype=np.float32))
+        m._m[0, 0] = 2.0 / (right - left)
+        m._m[1, 1] = 2.0 / (top - bottom)
+        m._m[2, 2] = -2.0 / (far - near)
+        m._m[0, 3] = -(right + left) / (right - left)
+        m._m[1, 3] = -(top + bottom) / (top - bottom)
+        m._m[2, 3] = -(far + near) / (far - near)
+        m._m[3, 3] = 1.0
+        return m
+
+    @classmethod
+    def look_at(cls, eye, target, up=None):
+        if up is None: up = Vec3.up()
+        f = (target - eye).normalized()
+        s = f.cross(up).normalized()
+        u = s.cross(f)
+        m = cls()
+        m._m[0, :3] = s.array
+        m._m[1, :3] = u.array
+        m._m[2, :3] = -f.array
+        m._m[0, 3] = -s.dot(eye)
+        m._m[1, 3] = -u.dot(eye)
+        m._m[2, 3] =  f.dot(eye)
+        return m
+
+    def __matmul__(self, other):
+        if isinstance(other, Mat4):
+            return Mat4(self._m @ other._m)
+        return self._m @ np.asarray(other, dtype=np.float32)
+
+    def transpose(self): return Mat4(self._m.T)
+    def inverse(self):   return Mat4(np.linalg.inv(self._m))
+
+    @property
+    def array(self): return self._m
+
+    @property
+    def gl_bytes(self): return self._m.T.tobytes(order="C")
+
+    def __repr__(self): return f"Mat4(\n{self._m}\n)"

eagle/math/transform.py

@@ -0,0 +1,37 @@
+"""Transform — TRS → матрица модели. Кеш с проверкой изменений."""
+from __future__ import annotations
+import numpy as np
+from eagle.math.vec import Vec3
+from eagle.math.mat import Mat4
+
+
+class Transform:
+    def __init__(self):
+        object.__setattr__(self, "position", Vec3.zero())
+        object.__setattr__(self, "rotation", Vec3.zero())   # Эйлеровы углы в радианах
+        object.__setattr__(self, "scale", Vec3.one())
+        object.__setattr__(self, "_model", Mat4.identity())
+        object.__setattr__(self, "_last_pos", self.position.array.copy())
+        object.__setattr__(self, "_last_rot", self.rotation.array.copy())
+        object.__setattr__(self, "_last_scl", self.scale.array.copy())
+
+    def matrix(self) -> Mat4:
+        # Проверяем, изменились ли компоненты с прошлого раза
+        if (np.array_equal(self.position.array, self._last_pos)
+                and np.array_equal(self.rotation.array, self._last_rot)
+                and np.array_equal(self.scale.array, self._last_scl)):
+            return self._model
+
+        T = Mat4.translation(*self.position.xyz)
+        Rx = Mat4.rotation_x(self.rotation.x)
+        Ry = Mat4.rotation_y(self.rotation.y)
+        Rz = Mat4.rotation_z(self.rotation.z)
+        S  = Mat4.scale(*self.scale.xyz)
+        object.__setattr__(self, "_model", T @ Rz @ Ry @ Rx @ S)
+        object.__setattr__(self, "_last_pos", self.position.array.copy())
+        object.__setattr__(self, "_last_rot", self.rotation.array.copy())
+        object.__setattr__(self, "_last_scl", self.scale.array.copy())
+        return self._model
+
+    def __setattr__(self, name, value):
+        object.__setattr__(self, name, value)