fractex 0.1.0__py3-none-any.whl

fractex/examples/custom_pattern.py

@@ -0,0 +1,114 @@
+# Создание собственных паттернов
+import sys
+from pathlib import Path
+from dataclasses import dataclass
+import numpy as np
+import argparse
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+EXAMPLES_DIR = Path(__file__).resolve().parent
+if str(EXAMPLES_DIR) not in sys.path:
+    sys.path.insert(0, str(EXAMPLES_DIR))
+
+from _output import save_volume_slice
+from fractex.interactive import add_interactive_args, InteractiveConfig, run_interactive
+
+
+@dataclass
+class CustomPatternParams:
+    scale: float = 10.0
+    surface_threshold: float = 0.5
+
+
+class CustomPatternGenerator:
+    def generate_custom_pattern(self, dimensions, params: CustomPatternParams):
+        depth, height, width = dimensions
+        texture = np.zeros((depth, height, width, 4), dtype=np.float32)
+        
+        # Пользовательская логика
+        for i in range(depth):
+            for j in range(height):
+                for k in range(width):
+                    value = self.custom_math_function(i, j, k, params)
+                    
+                    if self.is_on_surface(value, params):
+                        color = self.calculate_color(i, j, k, value)
+                        texture[i, j, k] = color
+        
+        return texture
+    
+    def custom_math_function(self, x, y, z, params: CustomPatternParams):
+        # Пример: гиперболический параболоид
+        return (x / params.scale) ** 2 - (y / params.scale) ** 2 - z / params.scale
+    
+    def is_on_surface(self, value: float, params: CustomPatternParams) -> bool:
+        return abs(value) < params.surface_threshold
+    
+    def calculate_color(self, x, y, z, value: float) -> np.ndarray:
+        return np.array([
+            0.4 + 0.6 * np.clip(value, -1, 1),
+            0.6,
+            0.8,
+            1.0,
+        ], dtype=np.float32)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Custom pattern example")
+    add_interactive_args(parser)
+    parser.add_argument("--speed", type=float, default=1.0)
+    args = parser.parse_args()
+    
+    generator = CustomPatternGenerator()
+    params = CustomPatternParams(scale=8.0, surface_threshold=0.4)
+    texture = generator.generate_custom_pattern((16, 16, 16), params)
+    print("Custom pattern:", texture.shape, texture.min(), texture.max())
+    save_volume_slice(
+        texture,
+        EXAMPLES_DIR / "output" / "custom_pattern_slice.ppm",
+        stretch=True,
+    )
+    
+    if args.interactive:
+        config = InteractiveConfig.from_args(args, title="Custom Pattern (interactive)")
+        
+        def render_frame(t, w, h):
+            speed = max(0.1, args.speed)
+            tt = t * speed * 3.0
+            zoom = np.exp(tt * 0.03)
+            zoom = min(zoom, 200.0)
+            depth = (tt * 1.5) % (params.scale * 6.0)
+            drift = np.exp(-tt * 0.02)
+            x0 = np.sin(tt * 0.4) * 3.0 * drift
+            y0 = np.cos(tt * 0.35) * 3.0 * drift
+            
+            x = np.linspace(-1.0, 1.0, w) / zoom + x0
+            y = np.linspace(-1.0, 1.0, h) / zoom + y0
+            xx, yy = np.meshgrid(x, y)
+            
+            angle = t * 0.02
+            cos_a, sin_a = np.cos(angle), np.sin(angle)
+            xr = xx * cos_a - yy * sin_a
+            yr = xx * sin_a + yy * cos_a
+            
+            value = (xr / params.scale) ** 2 - (yr / params.scale) ** 2 - depth / params.scale
+            value2 = np.sin(xr * 3.0 + t * 0.5) + np.cos(yr * 2.0 - t * 0.3)
+            combined = value + 0.35 * value2
+            mask = 0.1 + 0.9 * np.exp(-np.abs(combined) * 1.6)
+            
+            radius = np.sqrt(xr * xr + yr * yr)
+            vignette = np.clip(1.2 - radius * 0.8, 0.0, 1.0)
+            
+            rgb = np.zeros((h, w, 3), dtype=np.float32)
+            color = np.clip(0.4 + 0.6 * np.tanh(combined), 0, 1)
+            ripple = 0.5 + 0.5 * np.sin(t * 0.6 + (xr + yr) * 2.0)
+            palette_shift = 0.5 + 0.5 * np.sin(t * 0.12)
+            rgb[..., 0] = (color * 0.7 + ripple * 0.3) * mask
+            rgb[..., 1] = (0.45 + 0.45 * ripple + 0.1 * palette_shift) * mask
+            rgb[..., 2] = (0.65 + 0.3 * np.cos(t * 0.4) + 0.1 * palette_shift) * mask
+            rgb = np.clip(rgb * vignette[..., None], 0, 1)
+            return rgb
+        
+        run_interactive(render_frame, config)

fractex/examples/game_integration.py

@@ -0,0 +1,86 @@
+# Полная интеграция с Unity/Unreal
+import sys
+from pathlib import Path
+import math
+from typing import Tuple, List
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from fractex.dynamic_textures_3d import StreamingDynamicTextures, DynamicTextureType
+
+
+class GameDynamicTexturesManager:
+    def __init__(self, world_size: Tuple[int, int, int]):
+        # Разделяем мир на чанки
+        self.chunk_size = (32, 32, 32)
+        self.num_chunks = (
+            world_size[0] // self.chunk_size[0],
+            world_size[1] // self.chunk_size[1],
+            world_size[2] // self.chunk_size[2],
+        )
+        
+        self.streamer = StreamingDynamicTextures(
+            chunk_size=self.chunk_size,
+            max_active_chunks=8
+        )
+        
+        self.render_cache = {}
+    
+    def update(self, dt: float, player_position: Tuple[float, float, float]):
+        visible_chunks = self._get_visible_chunks(player_position)
+        
+        for chunk_coords in visible_chunks:
+            distance = self._distance_to_chunk(player_position, chunk_coords)
+            priority = 1.0 / (distance + 1.0)
+            
+            state = self.streamer.request_chunk(
+                chunk_coords,
+                DynamicTextureType.WATER_FLOW,
+                priority
+            )
+            
+            if state:
+                self._render_or_update_chunk(chunk_coords, state)
+        
+        try:
+            self.streamer.update_all(dt)
+        except Exception as exc:
+            print(f"Simulation update skipped: {exc}")
+    
+    def _get_visible_chunks(self, player_position: Tuple[float, float, float]) -> List[Tuple[int, int, int]]:
+        """Получение чанков в поле зрения игрока (упрощенно)"""
+        px, py, pz = player_position
+        cx = int(px // self.chunk_size[0])
+        cy = int(py // self.chunk_size[1])
+        cz = int(pz // self.chunk_size[2])
+        
+        visible = []
+        for dx in [-1, 0, 1]:
+            for dy in [-1, 0, 1]:
+                for dz in [-1, 0, 1]:
+                    nx, ny, nz = cx + dx, cy + dy, cz + dz
+                    if 0 <= nx < self.num_chunks[0] and 0 <= ny < self.num_chunks[1] and 0 <= nz < self.num_chunks[2]:
+                        visible.append((nx, ny, nz))
+        
+        return visible
+    
+    def _distance_to_chunk(self, player_position: Tuple[float, float, float], chunk_coords: Tuple[int, int, int]) -> float:
+        px, py, pz = player_position
+        cx, cy, cz = chunk_coords
+        center = (
+            (cx + 0.5) * self.chunk_size[0],
+            (cy + 0.5) * self.chunk_size[1],
+            (cz + 0.5) * self.chunk_size[2],
+        )
+        return math.dist(player_position, center)
+    
+    def _render_or_update_chunk(self, chunk_coords: Tuple[int, int, int], state):
+        self.render_cache[chunk_coords] = state.data.mean()
+
+
+if __name__ == "__main__":
+    manager = GameDynamicTexturesManager(world_size=(96, 96, 96))
+    manager.update(dt=0.016, player_position=(48.0, 48.0, 48.0))
+    print("Render cache size:", len(manager.render_cache))

fractex/examples/game_texture.py

@@ -0,0 +1,178 @@
+# fractex/examples/game_texture.py
+"""
+Пример интеграции в игровой движок
+"""
+
+import sys
+from pathlib import Path
+from queue import Queue
+import threading
+import argparse
+import numpy as np
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+EXAMPLES_DIR = Path(__file__).resolve().parent
+if str(EXAMPLES_DIR) not in sys.path:
+    sys.path.insert(0, str(EXAMPLES_DIR))
+
+from fractex import FractalParams, FractalGenerator, InfiniteTexture, TextureStreamer
+from _output import save_ppm
+from fractex.interactive import add_interactive_args, InteractiveConfig, run_interactive
+
+
+class GameTextureSystem:
+    """Система текстур для игры с бесконечной детализацией"""
+    
+    def __init__(self):
+        self.textures = {}
+        self.streamers = {}
+        self.worker_threads = []
+        self.task_queue = Queue()
+        
+        # Запускаем рабочие потоки для генерации текстур
+        for i in range(4):  # 4 потока
+            thread = threading.Thread(target=self._texture_worker)
+            thread.daemon = True
+            thread.start()
+            self.worker_threads.append(thread)
+    
+    def register_texture(self, name, params, texture_type="procedural"):
+        """Регистрация новой текстуры"""
+        generator = FractalGenerator(params)
+        texture = InfiniteTexture(generator, texture_type)
+        streamer = TextureStreamer(texture)
+        
+        self.textures[name] = texture
+        self.streamers[name] = streamer
+        
+        return texture
+    
+    def request_texture_tiles(self, name, viewport, camera_zoom):
+        """Запрос тайлов текстуры для вьюпорта"""
+        streamer = self.streamers[name]
+        
+        # Определяем необходимые тайлы и уровни детализации
+        tiles_needed = self._calculate_tiles_needed(viewport, camera_zoom)
+        
+        # Запрашиваем все необходимые тайлы
+        results = {}
+        for tile_info in tiles_needed:
+            tile_x, tile_y, lod = tile_info
+            
+            # Проверяем кэш
+            tile = streamer.request_tile(tile_x, tile_y, lod)
+            results[(tile_x, tile_y, lod)] = tile
+        
+        return results
+    
+    def _calculate_tiles_needed(self, viewport, zoom):
+        """Расчет необходимых тайлов на основе положения камеры"""
+        tiles = []
+        
+        # Преобразуем вьюпорт в тайловые координаты
+        min_x, min_y = viewport['min']
+        max_x, max_y = viewport['max']
+        
+        # Разные LOD для разных расстояний (MIP-маппинг)
+        base_tile_size = 256
+        for lod in range(4):  # 4 уровня детализации
+            tile_scale = 2 ** lod
+            effective_tile_size = base_tile_size / tile_scale
+            
+            start_tile_x = int(min_x // effective_tile_size)
+            start_tile_y = int(min_y // effective_tile_size)
+            end_tile_x = int(max_x // effective_tile_size) + 1
+            end_tile_y = int(max_y // effective_tile_size) + 1
+            
+            for tx in range(start_tile_x, end_tile_x):
+                for ty in range(start_tile_y, end_tile_y):
+                    tiles.append((tx, ty, lod))
+        
+        return tiles
+    
+    def _texture_worker(self):
+        """Рабочий поток для генерации текстур"""
+        while True:
+            try:
+                task = self.task_queue.get()
+                if task is None:
+                    break
+                
+                texture_name, tile_x, tile_y, lod = task
+                streamer = self.streamers[texture_name]
+                streamer.request_tile(tile_x, tile_y, lod)
+                
+                self.task_queue.task_done()
+            except:
+                pass
+
+# Демонстрация
+def demo_terrain_texture():
+    """Создание бесконечно детализируемой текстуры terrain"""
+    
+    # Параметры для terrain текстуры
+    terrain_params = FractalParams(
+        seed=42,
+        base_scale=0.005,
+        detail_level=4.0,
+        persistence=0.55,
+        lacunarity=2.1,
+        octaves=16,
+        fractal_dimension=2.7
+    )
+    
+    # Создаем систему текстур
+    texture_system = GameTextureSystem()
+    
+    # Регистрируем различные текстуры
+    texture_system.register_texture("terrain", terrain_params, "stone")
+    texture_system.register_texture("clouds", 
+        FractalParams(seed=123, persistence=0.7, octaves=8), "clouds")
+    texture_system.register_texture("water",
+        FractalParams(seed=456, base_scale=0.002, persistence=0.4), "water")
+    
+    # Имитация запросов от игрового движка
+    viewport = {'min': (0, 0), 'max': (1024, 1024)}
+    zoom_levels = [1.0, 2.0, 4.0, 8.0]
+    
+    for zoom in zoom_levels:
+        print(f"\nGenerating texture tiles at zoom {zoom}x...")
+        
+        terrain_tiles = texture_system.request_texture_tiles(
+            "terrain", viewport, zoom
+        )
+        
+        print(f"Generated {len(terrain_tiles)} terrain tiles")
+        
+        # Здесь можно визуализировать или сохранить тайлы
+        for (tx, ty, lod), tile in list(terrain_tiles.items())[:3]:
+            print(f"  Tile ({tx},{ty}) LOD {lod}: {tile.shape}")
+        
+        if terrain_tiles:
+            first_tile = next(iter(terrain_tiles.values()))
+            save_ppm(first_tile, EXAMPLES_DIR / "output" / f"game_texture_tile_{zoom:.1f}x.ppm")
+    
+    return texture_system
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Game texture example")
+    add_interactive_args(parser)
+    args = parser.parse_args()
+    
+    # Запускаем демо
+    system = demo_terrain_texture()
+    print("\nTexture system ready!")
+    
+    if args.interactive:
+        config = InteractiveConfig.from_args(args, title="Game Texture (interactive)")
+        terrain_params = FractalParams(seed=42, base_scale=0.005, detail_level=3.0)
+        generator = FractalGenerator(terrain_params)
+        texture = InfiniteTexture(generator, "stone")
+        
+        def render_frame(t, w, h):
+            zoom = 1.0 + 0.5 * (1 + np.sin(t * 0.2))
+            return texture.generate_tile(0, 0, w, h, zoom=zoom)[..., :3]
+        
+        run_interactive(render_frame, config)

fractex/examples/integration.py

@@ -0,0 +1,102 @@
+import sys
+from pathlib import Path
+import numpy as np
+import argparse
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+EXAMPLES_DIR = Path(__file__).resolve().parent
+if str(EXAMPLES_DIR) not in sys.path:
+    sys.path.insert(0, str(EXAMPLES_DIR))
+
+from fractex.simplex_noise import SimplexTextureGenerator
+from fractex.texture_blending import TextureBlender
+from _output import save_ppm
+from fractex.interactive import add_interactive_args, InteractiveConfig, run_interactive
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Texture blending example")
+    add_interactive_args(parser)
+    args = parser.parse_args()
+    # Генерация текстур
+    tex_gen = SimplexTextureGenerator(seed=42)
+    size = 256
+    clouds = tex_gen.generate_clouds(size, size)
+    rock = tex_gen.generate_marble(size, size)
+    grass = tex_gen.generate_grass(size, size)
+    
+    height_map = rock[..., 0]
+    cloud_mask = clouds[..., 3]
+    
+    blender = TextureBlender()
+    result = blender.blend_layer_stack(
+        base_texture=rock,
+        layers=[
+            {
+                "texture": grass,
+                "blend_mode": "overlay",
+                "opacity": 0.7,
+                "mask_params": {
+                    "mask_type": "height_based",
+                    "parameters": {
+                        "height_map": height_map,
+                        "min_height": 0.3,
+                        "max_height": 0.6,
+                    },
+                },
+            },
+            {
+                "texture": clouds,
+                "blend_mode": "screen",
+                "opacity": 0.3,
+                "mask": cloud_mask,
+            },
+        ],
+    )
+    
+    print("Blended texture:", result.shape, result.min(), result.max())
+    save_ppm(result, EXAMPLES_DIR / "output" / "integration_blend.ppm")
+    
+    if args.interactive:
+        config = InteractiveConfig.from_args(args, title="Integration Blend (interactive)")
+        
+        def render_frame(t, w, h):
+            tex_gen = SimplexTextureGenerator(seed=42)
+            clouds = tex_gen.generate_clouds(w, h, scale=0.01 + 0.003 * np.sin(t * 0.1))
+            rock = tex_gen.generate_marble(w, h, scale=0.005 + 0.002 * np.cos(t * 0.07))
+            grass = tex_gen.generate_grass(w, h, scale=0.02 + 0.01 * np.sin(t * 0.08))
+            height_map = rock[..., 0]
+            cloud_mask = clouds[..., 3]
+            blender = TextureBlender()
+            return blender.blend_layer_stack(
+                base_texture=rock,
+                layers=[
+                    {
+                        "texture": grass,
+                        "blend_mode": "overlay",
+                        "opacity": 0.7,
+                        "mask_params": {
+                            "mask_type": "height_based",
+                            "parameters": {
+                                "height_map": height_map,
+                                "min_height": 0.3,
+                                "max_height": 0.6,
+                            },
+                        },
+                    },
+                    {
+                        "texture": clouds,
+                        "blend_mode": "screen",
+                        "opacity": 0.3,
+                        "mask": cloud_mask,
+                    },
+                ],
+            )[..., :3]
+        
+        run_interactive(render_frame, config)
+
+
+if __name__ == "__main__":
+    main()

fractex/examples/physic_integration.py

@@ -0,0 +1,70 @@
+# Геометрические паттерны для разрушаемых материалов
+import sys
+from pathlib import Path
+import numpy as np
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from fractex.geometric_patterns_3d import GeometricPatternGenerator3D, GeometricPattern3D, PatternParameters
+
+
+class DestructibleMaterial:
+    def __init__(self, pattern_type, params):
+        self.pattern_generator = GeometricPatternGenerator3D()
+        self.base_pattern = self.pattern_generator.generate_pattern(
+            pattern_type, (32, 32, 32), params
+        )
+        self.stress_field = np.zeros((32, 32, 32), dtype=np.float32)
+    
+    def apply_stress(self, position, force):
+        stress_point = self.world_to_voxel(position)
+        self.propagate_stress(stress_point, force)
+        fracture_points = self.find_fracture_points()
+        self.modify_pattern_for_fractures(fracture_points)
+    
+    def propagate_stress(self, point, force, depth: int = 0):
+        if depth > 6 or force < 0.5:
+            return
+        for direction in self.get_structure_directions(point):
+            self.stress_field[tuple(point)] += force
+            next_point = point + direction
+            if self.is_connected(point, next_point):
+                self.propagate_stress(next_point, force * 0.7, depth + 1)
+    
+    def world_to_voxel(self, position):
+        pos = np.clip(np.array(position, dtype=int), 0, 31)
+        return pos
+    
+    def get_structure_directions(self, point):
+        return [
+            np.array([1, 0, 0]),
+            np.array([-1, 0, 0]),
+            np.array([0, 1, 0]),
+            np.array([0, -1, 0]),
+            np.array([0, 0, 1]),
+            np.array([0, 0, -1]),
+        ]
+    
+    def is_connected(self, point_a, point_b):
+        if np.any(point_b < 0) or np.any(point_b >= 32):
+            return False
+        return True
+    
+    def find_fracture_points(self):
+        threshold = self.stress_field.mean() + self.stress_field.std()
+        return np.argwhere(self.stress_field > threshold)
+    
+    def modify_pattern_for_fractures(self, fracture_points):
+        for p in fracture_points[:50]:
+            self.base_pattern[tuple(p)] = 0
+
+
+if __name__ == "__main__":
+    material = DestructibleMaterial(
+        GeometricPattern3D.CRYSTAL_LATTICE,
+        PatternParameters(scale=1.0, thickness=0.05),
+    )
+    material.apply_stress((10, 10, 10), force=5.0)
+    print("Fracture points:", material.find_fracture_points().shape[0])