eagle-engine 0.1.0__tar.gz

eagle_engine-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ilya Titov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

eagle_engine-0.1.0/MANIFEST.in

@@ -0,0 +1,14 @@
+include LICENSE
+include README.md
+include pyproject.toml
+
+# Только нужное из eagle/assets
+recursive-include eagle/assets *.vert *.frag *.png
+
+# Явно исключить мусор
+global-exclude __pycache__
+global-exclude *.py[co]
+global-exclude .pytest_cache
+global-exclude .ruff_cache
+global-exclude *.egg-info
+global-exclude .DS_Store

eagle_engine-0.1.0/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: eagle-engine
+Version: 0.1.0
+Summary: 3D-движок как расширение PyGame: GPU-рендеринг через ModernGL
+Author: Eagle Engine contributors
+License: MIT
+Project-URL: Homepage, https://github.com/your-username/eagle-engine
+Project-URL: Repository, https://github.com/your-username/eagle-engine
+Project-URL: Issues, https://github.com/your-username/eagle-engine/issues
+Keywords: pygame,3d,engine,opengl,moderngl,gamedev
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Games/Entertainment
+Classifier: Topic :: Multimedia :: Graphics :: 3D Rendering
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pygame-ce>=2.4
+Requires-Dist: moderngl>=5.8
+Requires-Dist: numpy>=1.24
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: ruff>=0.4; extra == "dev"
+Requires-Dist: build>=1.0; extra == "dev"
+Requires-Dist: twine>=5.0; extra == "dev"
+Dynamic: license-file
+
+# Eagle Engine
+
+3D-extension for PyGame with GPU-rendering by ModernGL (OpenGL 3.3 Core).
+
+## Installation
+
+```bash
+pip install eagle-engine
+```
+Quickstart
+
+```python
+import pygame
+from eagle.core import Engine
+from eagle.primitives import Cube
+from eagle.gfx import Camera
+
+engine = Engine(800, 600, "Eagle")
+camera = Camera(position=(0, 0, 3))
+cube = Cube()
+
+@engine.on_render_3d
+def render():
+    engine.draw(cube, camera)
+
+@engine.on_render_2d
+def hud():
+    font = pygame.font.SysFont("Arial", 20)
+    engine.surface.blit(font.render("Hello Eagle", True, "white"), (16, 16))
+
+engine.run()
+```
+
+## Contents
+
+* SDL2 window + OpenGL 3.3 Core + MSAA ×4
+
+* Math (Vec3/Mat4/Transform) on numpy
+
+* Blinn-Phong-lighting
+
+* 9 primitives: Cube, Sphere, Icosphere, Plane, Grid, Cylinder, Cone, Torus, Axes
+
+* Loaders of .obj (+.mtl, textures) and .stl (ASCII + binary)
+
+* SceneObject / Scene with transfomation hierarhy
+
+* 2D-overlay by pygame.Surface → GL-texture
+
+* Camera with orbital controls (mouse + mouse wheel)
+
+## License
+
+MIT

eagle_engine-0.1.0/README.md

@@ -0,0 +1,54 @@
+# Eagle Engine
+
+3D-extension for PyGame with GPU-rendering by ModernGL (OpenGL 3.3 Core).
+
+## Installation
+
+```bash
+pip install eagle-engine
+```
+Quickstart
+
+```python
+import pygame
+from eagle.core import Engine
+from eagle.primitives import Cube
+from eagle.gfx import Camera
+
+engine = Engine(800, 600, "Eagle")
+camera = Camera(position=(0, 0, 3))
+cube = Cube()
+
+@engine.on_render_3d
+def render():
+    engine.draw(cube, camera)
+
+@engine.on_render_2d
+def hud():
+    font = pygame.font.SysFont("Arial", 20)
+    engine.surface.blit(font.render("Hello Eagle", True, "white"), (16, 16))
+
+engine.run()
+```
+
+## Contents
+
+* SDL2 window + OpenGL 3.3 Core + MSAA ×4
+
+* Math (Vec3/Mat4/Transform) on numpy
+
+* Blinn-Phong-lighting
+
+* 9 primitives: Cube, Sphere, Icosphere, Plane, Grid, Cylinder, Cone, Torus, Axes
+
+* Loaders of .obj (+.mtl, textures) and .stl (ASCII + binary)
+
+* SceneObject / Scene with transfomation hierarhy
+
+* 2D-overlay by pygame.Surface → GL-texture
+
+* Camera with orbital controls (mouse + mouse wheel)
+
+## License
+
+MIT

eagle_engine-0.1.0/eagle/__init__.py

@@ -0,0 +1,6 @@
+"""Eagle Engine — 3D-расширение для PyGame с GPU-рендерингом."""
+__version__ = "0.1.0"
+
+from eagle.core import Engine  # noqa: F401
+
+__all__ = ["Engine", "__version__"]

eagle_engine-0.1.0/eagle/assets/shaders/basic.frag

@@ -0,0 +1,32 @@
+#version 330 core
+
+in vec3 v_world_pos;
+in vec3 v_normal;
+in vec2 v_uv;
+
+uniform vec3  u_camera_pos;
+uniform vec3  u_light_dir;
+uniform vec3  u_light_color;
+uniform vec3  u_ambient;
+uniform vec3  u_color;
+uniform float u_shininess;
+uniform float u_specular;
+uniform int   u_use_texture;
+uniform sampler2D u_texture;
+
+out vec4 frag_color;
+
+void main() {
+    vec3 albedo = u_color;
+    if (u_use_texture == 1) {
+        albedo *= texture(u_texture, v_uv).rgb;
+    }
+    vec3 N = normalize(v_normal);
+    vec3 L = normalize(-u_light_dir);
+    vec3 V = normalize(u_camera_pos - v_world_pos);
+    vec3 H = normalize(L + V);
+    float diff = max(dot(N, L), 0.0);
+    float spec = pow(max(dot(N, H), 0.0), u_shininess) * u_specular;
+    vec3 color = albedo * (u_ambient + u_light_color * diff) + u_light_color * spec;
+    frag_color = vec4(color, 1.0);
+}

eagle_engine-0.1.0/eagle/assets/shaders/basic.vert

@@ -0,0 +1,22 @@
+#version 330 core
+
+in vec3 in_position;
+in vec3 in_normal;
+in vec2 in_uv;
+
+uniform mat4 u_model;
+uniform mat4 u_view;
+uniform mat4 u_proj;
+uniform mat3 u_normal_mat;
+
+out vec3 v_world_pos;
+out vec3 v_normal;
+out vec2 v_uv;
+
+void main() {
+    vec4 world = u_model * vec4(in_position, 1.0);
+    v_world_pos = world.xyz;
+    v_normal    = normalize(u_normal_mat * in_normal);
+    v_uv        = in_uv;
+    gl_Position = u_proj * u_view * world;
+}

eagle_engine-0.1.0/eagle/assets/shaders/unlit.frag

@@ -0,0 +1,7 @@
+#version 330 core
+in vec2 v_uv;
+uniform sampler2D u_texture;
+out vec4 frag_color;
+void main() {
+    frag_color = texture(u_texture, v_uv);
+}

eagle_engine-0.1.0/eagle/assets/shaders/unlit.vert

@@ -0,0 +1,8 @@
+#version 330 core
+in vec2 in_position;
+in vec2 in_uv;
+out vec2 v_uv;
+void main() {
+    v_uv = in_uv;
+    gl_Position = vec4(in_position, 0.0, 1.0);
+}

eagle_engine-0.1.0/eagle/core/__init__.py

@@ -0,0 +1,3 @@
+from eagle.core.engine import Engine
+
+__all__ = ["Engine"]

eagle_engine-0.1.0/eagle/core/engine.py

@@ -0,0 +1,255 @@
+"""Engine — окно + GL-контекст + цикл + 2D-оверлей + splash."""
+from __future__ import annotations
+from typing import Callable
+
+import numpy as np
+import pygame
+import moderngl
+
+from eagle.gfx.shader import shader_from_package, Shader
+from eagle.gfx.texture import Texture
+from eagle.gfx.camera import Camera
+from eagle.gfx.mesh import Mesh
+from eagle.math.mat import Mat4
+from eagle.core.splash import load_logo, make_icon, Splash
+
+
+class CallbackList:
+    """Список подписчиков. Как декоратор — регистрирует, как dispatch — исполняет."""
+    __slots__ = ("_subs",)
+
+    def __init__(self):
+        self._subs: list[Callable] = []
+
+    def __call__(self, fn: Callable) -> Callable:
+        self._subs.append(fn)
+        return fn
+
+    def dispatch(self, *args) -> None:
+        for fn in self._subs:
+            fn(*args)
+
+    def __len__(self):
+        return len(self._subs)
+
+
+class Engine:
+    def __init__(
+        self,
+        width: int = 800,
+        height: int = 600,
+        title: str = "Eagle Engine",
+        *,
+        vsync: bool = True,
+        target_fps: int | None = 60,
+        logo_path: str | None = None,
+        logo: pygame.Surface | None = None,
+        splash: bool = True,
+    ):
+        pygame.init()
+        pygame.display.gl_set_attribute(pygame.GL_CONTEXT_MAJOR_VERSION, 3)
+        pygame.display.gl_set_attribute(pygame.GL_CONTEXT_MINOR_VERSION, 3)
+        pygame.display.gl_set_attribute(pygame.GL_CONTEXT_PROFILE_MASK, pygame.GL_CONTEXT_PROFILE_CORE)
+        pygame.display.gl_set_attribute(pygame.GL_DEPTH_SIZE, 24)
+        pygame.display.gl_set_attribute(pygame.GL_DOUBLEBUFFER, 1)
+        pygame.display.gl_set_attribute(pygame.GL_MULTISAMPLESAMPLES, 4)
+
+        self.width = width
+        self.height = height
+        self.screen = pygame.display.set_mode(
+            (width, height),
+            pygame.OPENGL | pygame.DOUBLEBUF | pygame.RESIZABLE,
+            vsync=1 if vsync else 0,
+        )
+        pygame.display.set_caption(title)
+
+        # --- логотип и иконка ---
+        if logo is not None:
+            _logo_surf = logo.convert_alpha()
+        elif logo_path is not None:
+            _logo_surf = load_logo(logo_path)
+        else:
+            _logo_surf = load_logo()  # встроенный eagle/assets/logo.png
+
+        pygame.display.set_icon(make_icon(_logo_surf, size=64))
+
+        self._splash = Splash(_logo_surf, width, height) if splash else None
+
+        # --- OpenGL / ModernGL ---
+        self.ctx = moderngl.create_context(require=330)
+        self.ctx.enable(moderngl.DEPTH_TEST | moderngl.CULL_FACE | moderngl.BLEND)
+        self.ctx.blend_func = moderngl.SRC_ALPHA, moderngl.ONE_MINUS_SRC_ALPHA
+        self.ctx.gc_mode = "auto"
+
+        self.surface = pygame.Surface((width, height), pygame.SRCALPHA)
+
+        self._overlay_tex = Texture(self.surface, flip=False)
+        self._overlay_tex.build(self.ctx)
+        self._overlay_shader = shader_from_package("unlit.vert", "unlit.frag")
+        self._overlay_shader.build(self.ctx)
+        # CCW-порядок для TRIANGLE_STRIP, v=0 сверху, v=1 снизу.
+        quad = np.array([
+            -1, -1,  0, 1,   # лево-низ
+             1, -1,  1, 1,   # право-низ
+            -1,  1,  0, 0,   # лево-верх
+             1,  1,  1, 0,   # право-верх
+        ], dtype="f4")
+        self._overlay_vao = self.ctx.vertex_array(
+            self._overlay_shader.program,
+            [(self.ctx.buffer(quad.tobytes()), "2f 2f", "in_position", "in_uv")],
+        )
+
+        self._basic_shader: Shader = shader_from_package("basic.vert", "basic.frag")
+        self._basic_shader.build(self.ctx)
+
+        self.running = True
+        self.clock = pygame.time.Clock()
+        self.target_fps = target_fps
+        self._elapsed = 0.0
+        self._last_dt = 0.0
+
+        # --- колбэки (декораторы) ---
+        self.on_update    = CallbackList()
+        self.on_render_3d = CallbackList()
+        self.on_render_2d = CallbackList()
+        self.on_event     = CallbackList()
+
+        # --- освещение ---
+        self.light_dir   = (0.3, -0.7, -0.6)
+        self.light_color = (1.0, 1.0, 1.0)
+        self.ambient     = (0.25, 0.25, 0.28)
+
+    # ============================================================
+    #                       ЦИКЛ
+    # ============================================================
+    def tick(self) -> float:
+        dt = self.clock.tick(self.target_fps if self.target_fps else 0) / 1000.0
+        self._last_dt = dt
+        self._elapsed += dt
+
+        skip_splash = False
+        for ev in pygame.event.get():
+            if ev.type == pygame.QUIT:
+                self.running = False
+            elif ev.type == pygame.VIDEORESIZE:
+                self.width, self.height = ev.w, ev.h
+                self.surface = pygame.Surface((self.width, self.height), pygame.SRCALPHA)
+                self.ctx.viewport = (0, 0, self.width, self.height)
+                self._overlay_tex.release()
+                self._overlay_tex = Texture(self.surface, flip=False)
+                self._overlay_tex.build(self.ctx)
+            elif ev.type in (pygame.KEYDOWN, pygame.MOUSEBUTTONDOWN):
+                skip_splash = True
+            self.on_event.dispatch(ev)
+
+        if self._splash is not None and not self._splash.done:
+            self._splash.update(dt)
+            if skip_splash:
+                self._splash._t = self._splash.duration + self._splash.fade
+                self._splash._done = True
+            return dt
+
+        self.on_update.dispatch(dt)
+        return dt
+
+    def clear(self, color=(0.10, 0.10, 0.14, 1.0)):
+        self.ctx.clear(*color, depth=1.0)
+        self.ctx.viewport = (0, 0, self.width, self.height)
+
+    # ============================================================
+    #                       РИСОВАНИЕ
+    # ============================================================
+    def draw(self, obj, camera: Camera, *, model: Mat4 | None = None,
+             color=(0.85, 0.85, 0.9), shininess=32.0, specular=0.4, texture=None):
+        """obj — Mesh (голая геометрия) или Model (несколько частей с материалами)."""
+        from eagle.gfx.model import Model
+
+        if isinstance(obj, Model):
+            for part in obj.parts:
+                self._draw_mesh(part.mesh, camera, model=model,
+                                color=part.color, shininess=part.shininess,
+                                specular=part.specular, texture=part.texture)
+        else:
+            self._draw_mesh(obj, camera, model=model, color=color,
+                            shininess=shininess, specular=specular, texture=texture)
+
+    def _draw_mesh(self, mesh, camera, *, model, color, shininess, specular, texture):
+        if model is None:
+            model = Mat4.identity()
+        camera.set_aspect(self.width / max(1, self.height))
+
+        sh = self._basic_shader
+        sh["u_model"] = model
+        sh["u_view"]  = camera.view_matrix()
+        sh["u_proj"]  = camera.projection_matrix()
+        nm = np.linalg.inv(model.array[:3, :3]).T.astype(np.float32)
+        sh.program["u_normal_mat"].write(nm.tobytes(order="C"))
+        sh["u_camera_pos"]  = camera.position.xyz
+        sh["u_light_dir"]   = self.light_dir
+        sh["u_light_color"] = self.light_color
+        sh["u_ambient"]     = self.ambient
+        sh["u_color"]       = color
+        sh["u_shininess"]   = shininess
+        sh["u_specular"]    = specular
+
+        if texture is not None:
+            if texture._tex is None:
+                texture.build(self.ctx)
+            texture.use(0)
+            sh["u_texture"] = 0
+            sh["u_use_texture"] = 1
+        else:
+            sh["u_use_texture"] = 0
+
+        sh.use()
+        if mesh._vao is None:
+            mesh.build(self.ctx, sh.program)
+        mesh.render()
+
+    def present(self):
+        # 2D-оверлей: без depth-test, без culling (это плоский квад лицом к камере)
+        self.ctx.disable(moderngl.DEPTH_TEST)
+        self.ctx.disable(moderngl.CULL_FACE)
+        self.ctx.enable(moderngl.BLEND)
+        self._overlay_tex.update_from_surface(self.surface)
+        self._overlay_shader.use()
+        self._overlay_tex.use(0)
+        self._overlay_shader["u_texture"] = 0
+        self._overlay_vao.render(moderngl.TRIANGLE_STRIP)
+        self.ctx.enable(moderngl.DEPTH_TEST)
+        self.ctx.enable(moderngl.CULL_FACE)
+        pygame.display.flip()
+
+    # ============================================================
+    #                       ГЛАВНЫЙ ЦИКЛ
+    # ============================================================
+    def run(self):
+        try:
+            while self.running:
+                self.tick()
+                self.clear()
+
+                if self._splash is not None and not self._splash.done:
+                    self.surface.fill((0, 0, 0, 0))
+                    self._splash.draw(self.surface)
+                    self.present()
+                    continue
+
+                self.on_render_3d.dispatch()
+                self.surface.fill((0, 0, 0, 0))
+                self.on_render_2d.dispatch()
+                self.present()
+        finally:
+            self.shutdown()
+
+    def shutdown(self):
+        self.running = False
+        self._overlay_tex.release()
+        self._overlay_shader.release()
+        self._overlay_vao.release()
+        self._basic_shader.release()
+        pygame.quit()
+
+    @property
+    def time(self):
+        return self._elapsed

eagle_engine-0.1.0/eagle/core/splash.py

@@ -0,0 +1,88 @@
+"""Splash-заставка с логотипом Eagle."""
+from __future__ import annotations
+import os
+import pygame
+
+
+def load_logo(path: str | None = None) -> pygame.Surface:
+    """Загружает логотип. Если path=None — встроенный eagle/assets/logo.png."""
+    if path is None:
+        here = os.path.dirname(os.path.abspath(__file__))
+        path = os.path.join(os.path.dirname(here), "assets", "logo.png")
+    if not os.path.exists(path):
+        # Fallback: пустая поверхность, чтобы не падать
+        surf = pygame.Surface((256, 256), pygame.SRCALPHA)
+        return surf
+    return pygame.image.load(path).convert_alpha()
+
+
+def make_icon(logo: pygame.Surface, size: int = 64) -> pygame.Surface:
+    """Ресайз логотипа под иконку окна. Сохраняет пропорции, паддинг прозрачный."""
+    w, h = logo.get_size()
+    scale = size / max(w, h)
+    nw, nh = max(1, int(w * scale)), max(1, int(h * scale))
+    resized = pygame.transform.smoothscale(logo, (nw, nh))
+    icon = pygame.Surface((size, size), pygame.SRCALPHA)
+    icon.blit(resized, ((size - nw) // 2, (size - nh) // 2))
+    return icon
+
+
+class Splash:
+    """Splash-заставка в окне. Показывается duration секунд, потом fade-out за fade секунд."""
+
+    def __init__(self, logo: pygame.Surface, engine_w: int, engine_h: int,
+                 duration: float = 2.0, fade: float = 0.6):
+        self.duration = duration
+        self.fade = fade
+        self._t = 0.0
+        self._done = False
+
+        # Размер логотипа на экране: min(0.35 * размер окна)
+        target = int(min(engine_w, engine_h) * 0.35)
+        w, h = logo.get_size()
+        scale = target / max(w, h)
+        self._logo = pygame.transform.smoothscale(logo, (int(w * scale), int(h * scale)))
+        self._engine_w = engine_w
+        self._engine_h = engine_h
+
+        # Шрифт и текст подписи рендерим один раз — не пересоздаём каждый кадр
+        self._font = pygame.font.SysFont("Arial", 18, bold=True)
+        self._label = self._font.render("Eagle Engine", True, (240, 240, 240))
+
+    @property
+    def done(self) -> bool:
+        return self._done
+
+    def update(self, dt: float) -> None:
+        if self._done:
+            return
+        self._t += dt
+        if self._t >= self.duration + self.fade:
+            self._done = True
+
+    def draw(self, surface: pygame.Surface) -> None:
+        if self._done:
+            return
+
+        # Фон — тот же цвет, что у engine.clear
+        surface.fill((25, 25, 35, 255))
+
+        # Прозрачность: 255 → 0 при fade-out
+        alpha = 255
+        if self._t > self.duration:
+            alpha = int(255 * (1.0 - (self._t - self.duration) / self.fade))
+            alpha = max(0, min(255, alpha))
+
+        lw, lh = self._logo.get_size()
+        x = (self._engine_w - lw) // 2
+        y = (self._engine_h - lh) // 2
+
+        logo_copy = self._logo.copy()
+        logo_copy.set_alpha(alpha)
+        surface.blit(logo_copy, (x, y))
+
+        # Подпись
+        label = self._label.copy()
+        label.set_alpha(alpha)
+        tw = label.get_width()
+        surface.blit(label, ((self._engine_w - tw) // 2, y + lh + 20))

eagle_engine-0.1.0/eagle/gfx/__init__.py

@@ -0,0 +1,10 @@
+from eagle.gfx.shader import Shader, shader_from_files, shader_from_package
+from eagle.gfx.mesh import Mesh
+from eagle.gfx.model import Model, ModelPart
+from eagle.gfx.camera import Camera
+from eagle.gfx.orbit_camera import OrbitCamera
+from eagle.gfx.texture import Texture
+from eagle.gfx.material import Material
+
+__all__ = ["Shader", "shader_from_files", "shader_from_package",
+           "Mesh", "Model", "ModelPart", "Camera", "OrbitCamera", "Texture", "Material"]

eagle_engine-0.1.0/eagle/gfx/camera.py

@@ -0,0 +1,41 @@
+"""Camera — перспектива / орто + look-at."""
+from __future__ import annotations
+from eagle.math.vec import Vec3
+from eagle.math.mat import Mat4
+
+
+def _as_vec3(v, default: Vec3) -> Vec3:
+    if v is None:
+        return default
+    if isinstance(v, Vec3):
+        return v
+    if isinstance(v, (tuple, list)):
+        return Vec3.from_array(v)
+    raise TypeError(f"Camera: cannot convert {type(v)} to Vec3")
+
+
+class Camera:
+    def __init__(self, position=None, target=None, fov_deg=60.0, near=0.1, far=1000.0):
+        self.position = _as_vec3(position, Vec3(0.0, 0.0, 3.0))
+        self.target   = _as_vec3(target,   Vec3.zero())
+        self.up       = Vec3.up()
+        self.fov_deg  = fov_deg
+        self.near     = near
+        self.far      = far
+        self._aspect  = 1.0
+        self._ortho   = None
+
+    def set_aspect(self, aspect): self._aspect = aspect
+    def set_ortho(self, l, r, b, t, near=-1.0, far=1.0): self._ortho = (l, r, b, t, near, far)
+    def clear_ortho(self): self._ortho = None
+
+    def view_matrix(self) -> Mat4:
+        return Mat4.look_at(self.position, self.target, self.up)
+
+    def projection_matrix(self) -> Mat4:
+        if self._ortho is not None:
+            return Mat4.ortho(*self._ortho)
+        return Mat4.perspective(self.fov_deg, self._aspect, self.near, self.far)
+
+    def view_proj(self) -> Mat4:
+        return self.projection_matrix() @ self.view_matrix()

eagle_engine-0.1.0/eagle/gfx/material.py

@@ -0,0 +1,11 @@
+"""Material — базовый Blinn-Phong."""
+from __future__ import annotations
+from eagle.gfx.texture import Texture
+
+
+class Material:
+    def __init__(self, color=(0.8, 0.8, 0.85), shininess=32.0, specular=0.4, texture: Texture | None = None):
+        self.color = color
+        self.shininess = shininess
+        self.specular = specular
+        self.texture = texture