aether-engine 1.3.0__tar.gz → 1.4.0__tar.gz

{aether_engine-1.3.0/aether_engine.egg-info → aether_engine-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aether-engine
-Version: 1.3.0
+Version: 1.4.0
 Summary: 3D/2D game engine by entiti937 — OpenGL, physics, FPS, mandatory branding splash
 Home-page: https://pypi.org/project/aether-engine/
 Author: entiti937
@@ -28,13 +28,16 @@ Provides-Extra: physics
 Requires-Dist: pymunk>=6.0; extra == "physics"
 Provides-Extra: models
 Requires-Dist: trimesh>=3.21; extra == "models"
+Provides-Extra: build
+Requires-Dist: pyinstaller>=6.0; extra == "build"
 Provides-Extra: full
+Requires-Dist: pymunk>=6.0; extra == "full"
+Requires-Dist: pygame-ce>=2.5; extra == "full"
+Requires-Dist: imageio>=2.31; extra == "full"
 Requires-Dist: trimesh>=3.21; extra == "full"
 Requires-Dist: freetype-py>=2.4; extra == "full"
-Requires-Dist: pygame-ce>=2.5; extra == "full"
+Requires-Dist: pyinstaller>=6.0; extra == "full"
 Requires-Dist: pyyaml>=6.0; extra == "full"
-Requires-Dist: pymunk>=6.0; extra == "full"
-Requires-Dist: imageio>=2.31; extra == "full"
 Dynamic: author
 Dynamic: classifier
 Dynamic: description
@@ -49,7 +52,7 @@ Dynamic: summary
 # Aether Engine
 
 **3D / 2D игровой движок на Python + OpenGL**  
-**Разработчик:** entiti937 · **Версия:** 1.3.0 · **Лицензия:** MIT  
+**Разработчик:** entiti937 · **Версия:** 1.4.0 · **Лицензия:** MIT  
 **PyPI:** https://pypi.org/project/aether-engine/
 
 > Полное руководство: [`docs/GUIDE.md`](docs/GUIDE.md)
@@ -62,18 +65,21 @@ Dynamic: summary
 pip install -U "aether-engine[full]"
 ```
 
-## Что нового в 1.3.0
+## Что нового в 1.4.0
 
-- **Обязательный splash** при старте любой игры (чёрный экран, белый текст, entiti937)
-- **Водяной знак** в каждом кадре + защита от удаления брендинга
-- **Кириллица** — системные шрифты, UTF-8 консоль, полный Unicode в UI
-- Компиляция защищённых модулей при сборке пакета
+- Splash как в Unreal (fade-in) — **только при загрузке**, не в игре
+- `aether help` / `aether build` — справка и сборка в `.exe`
+- `ChunkedVoxelMesher` — оптимизация вокселей на уровне движка
+- Исправлен текст splash (кириллица через Pillow)
+- Убран постоянный водяной знак во время геймплея
 
 ## Showcase-игра
 
 Minecraft-like sandbox **на этом же движке**:
 
 ```bash
+aether help
+aether build games/aether_craft.py --name AetherCraft
 python games/aether_craft.py
 ```
 

{aether_engine-1.3.0 → aether_engine-1.4.0}/README.md

@@ -1,7 +1,7 @@
 # Aether Engine
 
 **3D / 2D игровой движок на Python + OpenGL**  
-**Разработчик:** entiti937 · **Версия:** 1.3.0 · **Лицензия:** MIT  
+**Разработчик:** entiti937 · **Версия:** 1.4.0 · **Лицензия:** MIT  
 **PyPI:** https://pypi.org/project/aether-engine/
 
 > Полное руководство: [`docs/GUIDE.md`](docs/GUIDE.md)
@@ -14,18 +14,21 @@
 pip install -U "aether-engine[full]"
 ```
 
-## Что нового в 1.3.0
+## Что нового в 1.4.0
 
-- **Обязательный splash** при старте любой игры (чёрный экран, белый текст, entiti937)
-- **Водяной знак** в каждом кадре + защита от удаления брендинга
-- **Кириллица** — системные шрифты, UTF-8 консоль, полный Unicode в UI
-- Компиляция защищённых модулей при сборке пакета
+- Splash как в Unreal (fade-in) — **только при загрузке**, не в игре
+- `aether help` / `aether build` — справка и сборка в `.exe`
+- `ChunkedVoxelMesher` — оптимизация вокселей на уровне движка
+- Исправлен текст splash (кириллица через Pillow)
+- Убран постоянный водяной знак во время геймплея
 
 ## Showcase-игра
 
 Minecraft-like sandbox **на этом же движке**:
 
 ```bash
+aether help
+aether build games/aether_craft.py --name AetherCraft
 python games/aether_craft.py
 ```
 

{aether_engine-1.3.0 → aether_engine-1.4.0}/aether/__init__.py

@@ -31,7 +31,9 @@ from aether.audio.sfx import SfxBank
 from aether.resources.save_load import save_json, load_json
 from aether.physics.raycast import Raycaster
 
-__version__ = "1.3.0"
+__version__ = "1.4.0"
+
+from aether.graphics.voxel_mesh import ChunkedVoxelMesher
 
 __all__ = [
     "Engine",
@@ -62,5 +64,6 @@ __all__ = [
     "save_json",
     "load_json",
     "Raycaster",
+    "ChunkedVoxelMesher",
     "__version__",
 ]

aether_engine-1.4.0/aether/__main__.py

@@ -0,0 +1,6 @@
+"""python -m aether"""
+
+from aether.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

aether_engine-1.4.0/aether/cli.py

@@ -0,0 +1,145 @@
+"""Aether Engine CLI — help, docs, build."""
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from aether import __version__
+from aether.core._identity import creator, engine_name
+
+
+QUICK_REFERENCE = f"""
+{engine_name()} v{__version__} — разработчик: {creator()}
+================================================================
+
+УСТАНОВКА
+  pip install -U "aether-engine[full]"
+
+МИНИМАЛЬНЫЙ КОД (3D)
+  from aether import Engine, Scene, Entity, MeshFactory, Material, Camera
+  from aether.scene.component import Transform, MeshRenderer
+
+  engine = Engine(1280, 720, "My Game")
+  scene = Scene("Main")
+  cam = Camera(position=(0, 2, 6), yaw=-90)
+  scene.set_main_camera(cam)
+
+  cube = Entity("Cube")
+  cube.add_component(Transform(position=(0, 1, 0)))
+  mat = Material(); mat.albedo[:] = (0.2, 0.9, 0.3)
+  cube.add_component(MeshRenderer(mesh=MeshFactory.create_cube(), material=mat))
+  scene.spawn(cube)
+
+  engine.load_scene(scene)
+  engine.enable_first_person(cam)   # FPS
+  engine.run()                      # ESC — выход
+
+FPS / КАМЕРА
+  engine.enable_first_person(camera, eye_height=1.7, walk_speed=6)
+  engine.free_camera = True         # WASD + Tab (мышь)
+
+2D РЕЖИМ
+  engine.set_mode("2d")
+  engine.renderer2d.add_sprite(Sprite(x=0, y=0, width=40, height=40, color=(1,0,0,1)))
+
+МОДЕЛИ
+  from aether import ModelLoader
+  mesh = ModelLoader.load("hero.glb")   # obj/stl/glb/gltf/fbx...
+
+ВОКСЕЛИ (ОПТИМИЗАЦИЯ)
+  from aether.graphics.voxel_mesh import ChunkedVoxelMesher
+  mesher = ChunkedVoxelMesher(world.get_block)
+  mesher.notify_block_change(x, y, z)
+  meshes = mesher.flush_dirty()       # только изменённые чанки
+
+ФИЗИКА
+  engine.physics3d.create_body_for_entity(ent, collider=BoxCollider())
+  engine.physics2d.create_box(x, y, w, h, mass=1.0)
+
+ВВОД
+  import glfw
+  engine.input.get_key(glfw.KEY_W)
+  engine.input.get_key_down(glfw.KEY_SPACE)
+
+АПДЕЙТ
+  engine.on_update(lambda dt: ...)
+
+СБОРКА В EXE
+  aether build my_game.py
+  aether build my_game.py --name MyGame --console
+
+ИНСТРУМЕНТЫ
+  aether help          — эта справка
+  aether docs          — краткий гайд по API
+  aether-editor        — 3D редактор моделей
+  python games/aether_craft.py
+
+ПОЛНАЯ ДОКУМЕНТАЦИЯ: docs/GUIDE.md
+PyPI: https://pypi.org/project/aether-engine/
+"""
+
+
+def cmd_help(_args):
+    print(QUICK_REFERENCE)
+    return 0
+
+
+def cmd_docs(_args):
+    guide = Path(__file__).resolve().parents[2] / "docs" / "GUIDE.md"
+    if guide.exists():
+        print(guide.read_text(encoding="utf-8"))
+    else:
+        print(QUICK_REFERENCE)
+    return 0
+
+
+def cmd_build(args):
+    from aether.tools.packager import build_exe
+
+    return build_exe(
+        args.script,
+        name=args.name,
+        onefile=not args.dir,
+        windowed=not args.console,
+        icon=args.icon,
+    )
+
+
+def cmd_editor(_args):
+    from aether.editor.model_editor import main as editor_main
+
+    editor_main()
+    return 0
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(
+        prog="aether",
+        description=f"{engine_name()} CLI by {creator()}",
+    )
+    parser.add_argument("--version", action="version", version=f"{engine_name()} {__version__}")
+
+    sub = parser.add_subparsers(dest="command")
+
+    sub.add_parser("help", help="Краткая справка по API и командам").set_defaults(func=cmd_help)
+    sub.add_parser("docs", help="Полная документация").set_defaults(func=cmd_docs)
+    sub.add_parser("editor", help="3D редактор моделей").set_defaults(func=cmd_editor)
+
+    p_build = sub.add_parser("build", help="Собрать игру в .exe (PyInstaller)")
+    p_build.add_argument("script", help="Путь к main.py игры")
+    p_build.add_argument("--name", help="Имя exe", default=None)
+    p_build.add_argument("--console", action="store_true", help="Показать консоль")
+    p_build.add_argument("--dir", action="store_true", help="Папка вместо onefile")
+    p_build.add_argument("--icon", help="Иконка .ico", default=None)
+    p_build.set_defaults(func=cmd_build)
+
+    args = parser.parse_args(argv)
+    if not args.command:
+        cmd_help(args)
+        return 0
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

{aether_engine-1.3.0 → aether_engine-1.4.0}/aether/core/_identity.py

@@ -21,7 +21,7 @@ _B = {
     ]),
     "sig": bytes([
         230, 194, 211, 207, 194, 213, 135, 226, 201, 192, 206, 201, 194,
-        135, 150, 137, 148, 137, 151,
+        135, 150, 137, 147, 137, 151,
     ]),
 }
 

aether_engine-1.4.0/aether/core/boot_splash.py

@@ -0,0 +1,217 @@
+"""UE-style boot splash — fade-in text on black, preload only."""
+from __future__ import annotations
+
+import math
+import time
+
+import glfw
+import numpy as np
+from OpenGL.GL import *
+from PIL import Image, ImageDraw, ImageFont
+
+from aether.core._identity import creator, splash_line1, splash_line2, verify_token
+from aether.utils.fonts import resolve_system_font
+
+_SPLASH_VERT = """
+#version 330 core
+layout(location = 0) in vec2 aPos;
+layout(location = 1) in vec2 aUV;
+out vec2 vUV;
+uniform float uAlpha;
+void main() {
+    vUV = aUV;
+    gl_Position = vec4(aPos, 0.0, 1.0);
+}
+"""
+
+_SPLASH_FRAG = """
+#version 330 core
+in vec2 vUV;
+out vec4 FragColor;
+uniform sampler2D uTex;
+uniform float uAlpha;
+void main() {
+    vec4 c = texture(uTex, vUV);
+    FragColor = vec4(c.rgb, c.a * uAlpha);
+}
+"""
+
+
+class BootSplash:
+    """Animated preload splash (Unreal-style fade). Shown ONLY during Engine init."""
+
+    MIN_SHOW_SEC = 2.4
+    FADE_IN_SEC = 0.85
+    FADE_OUT_SEC = 0.55
+
+    def __init__(self, window):
+        self.window = window
+        self.width = window.width
+        self.height = window.height
+        self._started = time.monotonic()
+        self._progress = 0.0
+        self._status = ""
+        self._font = None
+        self._font_small = None
+        self._load_fonts()
+        self._init_gl()
+        self.draw(0.0, "Загрузка...")
+
+    def _load_fonts(self):
+        path = resolve_system_font()
+        if not path:
+            return
+        try:
+            self._font = ImageFont.truetype(path, 36)
+            self._font_small = ImageFont.truetype(path, 22)
+        except Exception:
+            self._font = ImageFont.load_default()
+            self._font_small = self._font
+
+    def _init_gl(self):
+        from aether.graphics.shader import Shader
+
+        self._shader = Shader(_SPLASH_VERT, _SPLASH_FRAG)
+        self._vao = glGenVertexArrays(1)
+        self._vbo = glGenBuffers(1)
+        self._tex = glGenTextures(1)
+        quad = np.array(
+            [
+                -1, -1, 0, 0,
+                 1, -1, 1, 0,
+                 1,  1, 1, 1,
+                -1, -1, 0, 0,
+                 1,  1, 1, 1,
+                -1,  1, 0, 1,
+            ],
+            dtype=np.float32,
+        )
+        glBindVertexArray(self._vao)
+        glBindBuffer(GL_ARRAY_BUFFER, self._vbo)
+        glBufferData(GL_ARRAY_BUFFER, quad.nbytes, quad, GL_STATIC_DRAW)
+        glEnableVertexAttribArray(0)
+        glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 16, ctypes.c_void_p(0))
+        glEnableVertexAttribArray(1)
+        glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 16, ctypes.c_void_p(8))
+        glBindVertexArray(0)
+
+    def _fade_alpha(self) -> float:
+        t = time.monotonic() - self._started
+        if t < self.FADE_IN_SEC:
+            return self._ease_out(t / self.FADE_IN_SEC)
+        if self._progress >= 0.99 and t > self.MIN_SHOW_SEC:
+            out_t = t - self.MIN_SHOW_SEC
+            if out_t < self.FADE_OUT_SEC:
+                return 1.0 - self._ease_in(out_t / self.FADE_OUT_SEC)
+            return 0.0
+        return 1.0
+
+    @staticmethod
+    def _ease_out(x: float) -> float:
+        return 1.0 - (1.0 - x) ** 3
+
+    @staticmethod
+    def _ease_in(x: float) -> float:
+        return x * x * x
+
+    def _compose_image(self, alpha: float) -> np.ndarray:
+        w, h = self.width, self.height
+        img = Image.new("RGBA", (w, h), (0, 0, 0, 255))
+
+        if self._font:
+            overlay = Image.new("RGBA", (w, h), (0, 0, 0, 0))
+            draw = ImageDraw.Draw(overlay)
+
+            line1 = splash_line1()
+            line2 = splash_line2()
+            a = int(255 * max(0.0, min(1.0, alpha)))
+
+            # Slight slide-up like UE
+            slide = int((1.0 - min(1.0, alpha * 1.2)) * 28)
+
+            def tw(text, font):
+                bb = draw.textbbox((0, 0), text, font=font)
+                return bb[2] - bb[0], bb[3] - bb[1]
+
+            t1w, t1h = tw(line1, self._font)
+            t2w, t2h = tw(line2, self._font_small)
+            cy = h // 2 - slide
+
+            draw.text(((w - t1w) // 2, cy - t1h - 8), line1, font=self._font, fill=(255, 255, 255, a))
+            draw.text(((w - t2w) // 2, cy + 6), line2, font=self._font_small, fill=(230, 230, 230, a))
+
+            if self._status:
+                sw, sh = tw(self._status, self._font_small)
+                draw.text(
+                    ((w - sw) // 2, cy + t2h + 36),
+                    self._status,
+                    font=self._font_small,
+                    fill=(160, 160, 160, a),
+                )
+
+            # Progress bar
+            bar_w = min(420, int(w * 0.5))
+            bar_h = 4
+            bx = (w - bar_w) // 2
+            by = int(h * 0.62)
+            draw.rectangle([bx, by, bx + bar_w, by + bar_h], fill=(40, 40, 40, a))
+            fill = int(bar_w * self._progress)
+            if fill > 0:
+                draw.rectangle([bx, by, bx + fill, by + bar_h], fill=(255, 255, 255, a))
+
+            img = Image.alpha_composite(img, overlay)
+
+        return np.array(img, dtype=np.uint8)
+
+    def draw(self, progress: float, status: str = ""):
+        if not verify_token():
+            raise RuntimeError("Aether Engine identity verification failed")
+
+        self._progress = max(self._progress, progress)
+        self._status = status
+        alpha = self._fade_alpha()
+
+        glViewport(0, 0, self.width, self.height)
+        glClearColor(0, 0, 0, 1)
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+
+        data = self._compose_image(alpha)
+        glBindTexture(GL_TEXTURE_2D, self._tex)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, self.width, self.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data)
+
+        glDisable(GL_DEPTH_TEST)
+        glEnable(GL_BLEND)
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
+
+        self._shader.use()
+        self._shader.set_float("uAlpha", 1.0)
+        glActiveTexture(GL_TEXTURE0)
+        glBindTexture(GL_TEXTURE_2D, self._tex)
+        self._shader.set_int("uTex", 0)
+
+        glBindVertexArray(self._vao)
+        glDrawArrays(GL_TRIANGLES, 0, 6)
+        glBindVertexArray(0)
+
+        glDisable(GL_BLEND)
+        glEnable(GL_DEPTH_TEST)
+
+        self.window.swap_buffers()
+        glfw.poll_events()
+
+    def step(self, progress: float, status: str):
+        self.draw(progress, status)
+        time.sleep(0.016)
+
+    def finish(self):
+        # Fade-out animation
+        t0 = time.monotonic()
+        while time.monotonic() - t0 < self.FADE_OUT_SEC + 0.05:
+            self._progress = 1.0
+            self.draw(1.0, "Готово")
+        self.draw(1.0, "")
+
+
+import ctypes  # noqa: E402

aether_engine-1.4.0/aether/core/branding_guard.py

@@ -0,0 +1,32 @@
+"""Runtime integrity checks — no on-screen watermark during gameplay."""
+from __future__ import annotations
+
+from aether.core._identity import verify_token
+
+
+class BrandingGuard:
+    """Silent integrity guard. Branding is shown only on boot splash."""
+
+    _tamper_count = 0
+
+    def __init__(self, engine):
+        self.engine = engine
+        self._frame = 0
+
+    @classmethod
+    def assert_integrity(cls, engine) -> bool:
+        if not verify_token():
+            cls._tamper_count += 1
+            return False
+        if getattr(engine, "_brand_bypass", False):
+            cls._tamper_count += 1
+            engine._brand_bypass = False
+            return False
+        return True
+
+    def tick(self):
+        self._frame += 1
+        if self._frame % 120 == 0 and not verify_token():
+            raise RuntimeError(
+                "Aether Engine: integrity check failed. Reinstall: pip install -U aether-engine"
+            )

{aether_engine-1.3.0 → aether_engine-1.4.0}/aether/core/engine.py

@@ -276,7 +276,7 @@ class Engine:
                         traceback.print_exc()
 
                 if self._frame_count % 180 == 0 and not BrandingGuard.assert_integrity(self):
-                    self._branding._force_overlay = True
+                    raise RuntimeError("Aether Engine integrity check failed")
 
                 profiler.end_frame()
                 self._frame_count += 1
@@ -360,7 +360,8 @@ class Engine:
             self.renderer2d.begin_frame(clear=True)
             self.renderer2d.render()
             self.renderer2d.end_frame()
-            self._render_branding()
+            if hasattr(self, "_branding") and self._branding:
+                self._branding.tick()
             return
 
         self.renderer.begin_frame()
@@ -380,23 +381,6 @@ class Engine:
             self.renderer2d.render()
             self.renderer2d.end_frame()
 
-        self._render_branding()
-
-    def _render_branding(self):
-        """Mandatory watermark — always drawn."""
-        if not hasattr(self, "_branding") or self._branding is None:
-            return
-        try:
-            from OpenGL.GL import glDisable, glEnable, GL_BLEND, GL_DEPTH_TEST
-
-            glDisable(GL_DEPTH_TEST)
-            glEnable(GL_BLEND)
-            self._branding.draw_watermark()
-            self._branding.tick()
-            glEnable(GL_DEPTH_TEST)
-        except Exception:
-            pass
-
     def on_update(self, callback):
         """Регистрирует callback(dt), вызываемый каждый кадр."""
         self._update_callbacks.append(callback)

{aether_engine-1.3.0 → aether_engine-1.4.0}/aether/graphics/mesh.py

@@ -75,6 +75,27 @@ class Mesh:
         glBindBuffer(GL_ARRAY_BUFFER, 0)
         self._gpu_ready = True
 
+    def update_data(self, vertices, indices=None):
+        """Update GPU buffers in-place (fast path for voxel edits)."""
+        self.vertices = np.array(vertices, dtype=np.float32).reshape(-1)
+        if indices is not None:
+            self.indices = np.array(indices, dtype=np.uint32)
+        self.vertex_count = len(self.vertices) // 8
+        self.index_count = 0 if self.indices is None else len(self.indices)
+
+        if not self._gpu_ready:
+            self._create_gl_buffers()
+            return
+
+        glBindBuffer(GL_ARRAY_BUFFER, self.vbo)
+        glBufferData(GL_ARRAY_BUFFER, self.vertices.nbytes, self.vertices, GL_DYNAMIC_DRAW)
+        if self.indices is not None and self.index_count > 0:
+            if not self.ebo:
+                self.ebo = glGenBuffers(1)
+            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self.ebo)
+            glBufferData(GL_ELEMENT_ARRAY_BUFFER, self.indices.nbytes, self.indices, GL_DYNAMIC_DRAW)
+        glBindVertexArray(0)
+
     def draw(self):
         self.ensure_gpu()
         if not self.vao: