eagle-engine 0.1.0__py3-none-any.whl

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/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/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/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/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/core/__init__.py

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

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/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/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/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/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

eagle/gfx/mesh.py

@@ -0,0 +1,83 @@
+"""Mesh — VAO + VBO + (опционально) EBO. Формат вершины: 8 float32."""
+from __future__ import annotations
+import numpy as np
+import moderngl
+
+
+class Mesh:
+    def __init__(self):
+        self._vertices: np.ndarray | None = None
+        self._indices: np.ndarray | None = None
+        self._vao: moderngl.VertexArray | None = None
+        self._vbo: moderngl.Buffer | None = None
+        self._ibo: moderngl.Buffer | None = None
+        self._mode = moderngl.TRIANGLES
+
+    @classmethod
+    def from_arrays(cls, vertices, indices=None):
+        m = cls()
+        m._vertices = np.asarray(vertices, dtype=np.float32).reshape(-1, 8)
+        if indices is not None:
+            m._indices = np.asarray(indices, dtype=np.uint32).reshape(-1)
+        return m
+
+    def _fix_winding(self) -> None:
+        """Развернуть треугольники, у которых обход не совпадает с нормалями.
+        Работает только для TRIANGLES с индексами и нормалями."""
+        if self._indices is None or self._mode != moderngl.TRIANGLES:
+            return
+        tri = self._indices.reshape(-1, 3)
+        V = self._vertices
+
+        p0, p1, p2 = V[tri[:, 0], :3], V[tri[:, 1], :3], V[tri[:, 2], :3]
+        n_geo = np.cross(p1 - p0, p2 - p0)
+        n_v = (V[tri[:, 0], 3:6] + V[tri[:, 1], 3:6] + V[tri[:, 2], 3:6])
+        # dot(n_geo, n_vert) < 0 → обход "наизнанку"
+        flip = np.einsum("ij,ij->i", n_geo, n_v) < 0.0
+
+        if flip.any():
+            tri_f = tri.copy()
+            tri_f[flip, 1], tri_f[flip, 2] = tri[flip, 2].copy(), tri[flip, 1].copy()
+            self._indices = tri_f.flatten().astype(np.uint32)
+
+    def build(self, ctx: moderngl.Context, prog: moderngl.Program) -> None:
+        self.release()
+        if self._vertices is None:
+            raise RuntimeError("Mesh has no vertices")
+        self._fix_winding()
+
+        self._vbo = ctx.buffer(self._vertices.tobytes(order="C"))
+        if self._indices is not None:
+            self._ibo = ctx.buffer(self._indices.tobytes(order="C"))
+            self._vao = ctx.vertex_array(
+                prog,
+                [(self._vbo, "3f 3f 2f", "in_position", "in_normal", "in_uv")],
+                self._ibo,
+            )
+        else:
+            self._vao = ctx.vertex_array(
+                prog,
+                [(self._vbo, "3f 3f 2f", "in_position", "in_normal", "in_uv")],
+            )
+
+    def release(self) -> None:
+        if self._vao: self._vao.release(); self._vao = None
+        if self._vbo: self._vbo.release(); self._vbo = None
+        if self._ibo: self._ibo.release(); self._ibo = None
+
+    def render(self) -> None:
+        if self._vao is None:
+            raise RuntimeError("Mesh not built: call build(ctx, prog)")
+        if self._indices is not None:
+            self._vao.render(self._mode)
+        else:
+            self._vao.render(self._mode, vertices=self._vertices.shape[0])
+
+    @property
+    def vertex_count(self): return 0 if self._vertices is None else self._vertices.shape[0]
+    @property
+    def index_count(self):  return 0 if self._indices is None else self._indices.shape[0]
+    @property
+    def vertices(self): return self._vertices
+    @property
+    def indices(self): return self._indices

eagle/gfx/model.py

@@ -0,0 +1,46 @@
+"""Model — контейнер sub-meshes с материалами."""
+from __future__ import annotations
+from eagle.gfx.mesh import Mesh
+from eagle.gfx.texture import Texture
+
+
+class ModelPart:
+    def __init__(self, mesh: Mesh, *, color=(0.8, 0.8, 0.85),
+                 texture: Texture | None = None,
+                 shininess: float = 32.0, specular: float = 0.4,
+                 name: str = ""):
+        self.mesh = mesh
+        self.color = color
+        self.texture = texture
+        self.shininess = shininess
+        self.specular = specular
+        self.name = name
+
+
+class Model:
+    def __init__(self):
+        self.parts: list[ModelPart] = []
+
+    def add_part(self, part: ModelPart) -> "Model":
+        self.parts.append(part)
+        return self
+
+    def build_textures(self, ctx) -> None:
+        """Строит GL-текстуры для всех частей (после создания Engine)."""
+        for p in self.parts:
+            if p.texture is not None and p.texture._tex is None:
+                p.texture.build(ctx)
+
+    @property
+    def vertices(self):
+        """Bounding-box-friendly: склеиваем вершины всех частей (для авто-подгонки камеры)."""
+        import numpy as np
+        if not self.parts:
+            return None
+        return np.vstack([p.mesh.vertices for p in self.parts if p.mesh.vertices is not None])
+
+    def __iter__(self):
+        return iter(self.parts)
+
+    def __len__(self):
+        return len(self.parts)