AI 游戏资产生成：纹理/模型/动画的 AI 方案

class TextureGenerator:
    """AI PBR 纹理生成器"""
    
    def __init__(self):
        self.sd_pipe = StableDiffusionPipeline.from_pretrained(
            "stabilityai/stable-diffusion-xl-4"
        )
    
    async def generate_pbr_set(self, material_description, 
                                resolution=2048):
        """生成完整 PBR 纹理集"""
        
        textures = {}
        
        # 1. 基础色
        textures["base_color"] = await self._generate_texture(
            prompt=f"{material_description}, base color, "
                   f"seamless tileable, PBR texture",
            resolution=resolution
        )
        
        # 2. 法线贴图
        textures["normal"] = await self._generate_texture(
            prompt=f"{material_description}, normal map, "
                   f"seamless tileable, PBR texture",
            resolution=resolution,
            controlnet="normal"
        )
        
        # 3. 粗糙度
        textures["roughness"] = await self._generate_texture(
            prompt=f"{material_description}, roughness map, "
                   f"grayscale, PBR texture",
            resolution=resolution
        )
        
        # 4. 金属度
        textures["metallic"] = await self._generate_texture(
            prompt=f"{material_description}, metallic map, "
                   f"grayscale, PBR texture",
            resolution=resolution
        )
        
        # 5. AO
        textures["ao"] = await self._generate_texture(
            prompt=f"{material_description}, ambient occlusion, "
                   f"grayscale, PBR texture",
            resolution=resolution
        )
        
        return textures

def make_seamless(image):
    """使纹理可平铺"""
    import numpy as np
    from PIL import Image
    
    arr = np.array(image)
    h, w = arr.shape[:2]
    
    # 中心裁剪
    ch, cw = h // 2, w // 2
    cropped = arr[:ch, :cw]
    
    # 四象限拼接
    seamless = np.zeros_like(arr)
    seamless[:ch, :cw] = cropped  # 左上
    seamless[ch:, :cw] = arr[ch:h, cw:w]  # 左下
    seamless[:ch, cw:] = arr[ch:h, :cw]  # 右上
    seamless[ch:, cw:] = arr[:ch, cw:w]  # 右下
    
    # 边缘混合
    seamless = cv2.GaussianBlur(seamless, (5, 5), 0)
    
    return Image.fromarray(seamless)

class TextureStyleKeeper:
    """保持游戏纹理风格一致"""
    
    def __init__(self, style_reference):
        self.style_ref = style_reference
        self.style_embedding = self._extract_style(style_reference)
    
    def generate_consistent(self, material_description):
        """生成风格一致的纹理"""
        # 使用 IP-Adapter 注入风格
        image = self.sd_pipe(
            prompt=material_description,
            ip_adapter_image=self.style_ref,
            ip_adapter_scale=0.6,
            num_inference_steps=30
        ).images[0]
        
        return image

class GamePropGenerator:
    """游戏道具批量生成"""
    
    PROP_CATEGORIES = {
        "weapons": [
            "iron sword with leather grip",
            "wooden bow with string",
            "steel battle axe",
            "magical staff with crystal orb"
        ],
        "furniture": [
            "wooden chair, medieval style",
            "oak table with carved legs",
            "stone throne with armrests"
        ],
        "containers": [
            "wooden chest with iron bands",
            "ceramic vase with painted design",
            "leather pouch with drawstring"
        ],
        "environment": [
            "stone wall section, weathered",
            "wooden door with iron hinges",
            "torch bracket with flame"
        ]
    }
    
    async def batch_generate(self, category, art_style="stylized"):
        """批量生成道具"""
        prompts = self.PROP_CATEGORIES[category]
        
        tasks = []
        for prompt in prompts:
            task = self._generate_single(prompt, art_style)
            tasks.append(task)
        
        models = await asyncio.gather(*tasks)
        return models
    
    async def _generate_single(self, prompt, art_style):
        # Meshy 生成
        model = await self.meshy.create_model_from_text(
            prompt=f"{prompt}, {art_style} style, game asset",
            mode="fast",
            art_style=art_style,
            enable_pbr=True
        )
        
        # 后处理
        model = self._optimize_for_game(model)
        
        return {
            "prompt": prompt,
            "model": model,
            "lod_levels": self._generate_lods(model)
        }

def generate_lods(mesh, levels=3):
    """自动生成 LOD 层级"""
    lods = {}
    face_counts = [10000, 5000, 2000, 500]  # LOD0-LOD3
    
    for i, target in enumerate(face_counts[:levels+1]):
        lod = mesh.simplify_quadric_decimation(target)
        lods[f"LOD{i}"] = lod
    
    return lods

class AnimationGenerator:
    """AI 角色动画生成"""
    
    ANIMATION_TYPES = {
        "idle": "character idle, subtle breathing, slight weight shift",
        "walk": "character walking forward, natural gait, 4km/h",
        "run": "character running, athletic, 12km/h",
        "attack": "character melee attack, overhead swing",
        "cast": "character casting spell, hands raised, magical effect",
        "death": "character death animation, fall to ground",
        "jump": "character jumping, takeoff to landing"
    }
    
    async def generate(self, animation_type, duration=2.0):
        """生成角色动画"""
        prompt = self.ANIMATION_TYPES[animation_type]
        
        # MotionGPT 生成 BVH 动画
        bvh_data = await self.motion_gpt.generate(
            prompt=prompt,
            duration=duration,
            fps=30,
            skeleton_type="metahuman"
        )
        
        return bvh_data
    
    async def generate_locomotion_blend(self):
        """生成移动混合空间"""
        animations = {}
        
        # 生成不同速度的行走动画
        for speed in [0, 2, 4, 6, 8, 12]:  # km/h
            anim = await self.generate(
                "walk" if speed <= 6 else "run",
                duration=3.0
            )
            animations[speed] = anim
        
        return animations  # 用于引擎中的 Blend Space

class AIMotionCapture:
    """基于视频的 AI 动作捕捉"""
    
    def __init__(self):
        self.pose_estimator = PoseEstimator("motionbert_v2")
    
    def capture_from_video(self, video_path):
        """从视频提取动作"""
        # 1. 逐帧姿态估计
        poses = self.pose_estimator.estimate(video_path)
        
        # 2. 3D 姿态重建
        poses_3d = self._lift_to_3d(poses)
        
        # 3. 重定向到游戏骨骼
        bvh_data = self._retarget(poses_3d, 
                                   target_skeleton="metahuman")
        
        return bvh_data
    
    def _retarget(self, motion_data, target_skeleton):
        """重定向到目标骨骼"""
        # 自动骨骼对应
        mapping = self._auto_bind(
            motion_data.skeleton,
            target_skeleton
        )
        
        # 应用动作
        retargeted = self._apply_mapping(motion_data, mapping)
        
        # 平滑处理
        retargeted = self._smooth(retargeted)
        
        return retargeted

class TerrainGenerator:
    """AI 地形生成"""
    
    async def generate_terrain(self, description, size=1024):
        """生成地形高度图"""
        
        # 1. GPT-4o 生成地形描述
        terrain_desc = await self.llm.generate(
            f"描述一个{description}的地形特征，"
            f"包括海拔、坡度、水域、植被分布"
        )
        
        # 2. 生成高度图
        heightmap = await self._generate_heightmap(
            terrain_desc, size
        )
        
        # 3. 生成权重图（草地/岩石/雪地等）
        splatmap = await self._generate_splatmap(
            heightmap, terrain_desc
        )
        
        return {
            "heightmap": heightmap,
            "splatmap": splatmap,
            "description": terrain_desc
        }
    
    async def _generate_heightmap(self, desc, size):
        """使用 AI 生成高度图"""
        # 使用条件扩散模型
        heightmap = self.terrain_model.generate(
            prompt=desc,
            size=(size, size),
            seed=42
        )
        
        # 后处理：平滑 + 归一化
        heightmap = self._smooth_terrain(heightmap)
        heightmap = self._normalize(heightmap, min_h=0, max_h=1000)
        
        return heightmap

class VegetationPlacer:
    """AI 植被分布"""
    
    def place(self, heightmap, splatmap, density="medium"):
        """根据地形自动放置植被"""
        vegetation = []
        
        for y in range(0, heightmap.shape[0], 5):
            for x in range(0, heightmap.shape[1], 5):
                # 根据坡度、海拔、土壤类型决定植被
                slope = self._calculate_slope(heightmap, x, y)
                altitude = heightmap[y, x]
                soil = splatmap[y, x]
                
                plant_type = self._select_plant(
                    slope, altitude, soil
                )
                
                if plant_type:
                    # 随机偏移
                    offset_x = np.random.uniform(-2, 2)
                    offset_y = np.random.uniform(-2, 2)
                    scale = np.random.uniform(0.8, 1.2)
                    rotation = np.random.uniform(0, 360)
                    
                    vegetation.append({
                        "type": plant_type,
                        "position": (x + offset_x, y + offset_y),
                        "scale": scale,
                        "rotation": rotation
                    })
        
        return vegetation

class SFXGenerator:
    """AI 游戏音效生成"""
    
    def __init__(self):
        self.client = OpenAI()
    
    async def generate_sfx(self, description, duration=2.0):
        """生成游戏音效"""
        
        # 方式一：ElevenLabs SFX
        sfx = await self.elevenlabs.generate_sfx(
            prompt=description,
            duration=duration
        )
        
        # 方式二：AudioGen
        sfx = await self.audiogen.generate(
            prompt=description,
            duration=duration
        )
        
        return sfx
    
    async def generate_sfx_set(self):
        """生成完整音效集"""
        sfx_list = {
            "footstep_grass": "footsteps on grass, soft, walking",
            "footstep_stone": "footsteps on stone, hard surface",
            "sword_swing": "sword swing through air, whoosh",
            "sword_hit": "sword hitting metal shield, clang",
            "door_open": "wooden door opening, creaky",
            "chest_open": "treasure chest opening, creaky wood",
            "coin_pickup": "coin pickup, metallic ching",
            "potion_drink": "drinking potion, liquid gulping",
            "fire_burning": "campfire burning, crackling",
            "wind_outdoor": "outdoor wind, gentle breeze"
        }
        
        sfx_set = {}
        for name, desc in sfx_list.items():
            sfx_set[name] = await self.generate_sfx(desc)
        
        return sfx_set

class UE5AIPipeline:
    """UE5 AI 资产生成管线"""
    
    async def import_generated_assets(self, assets):
        """将 AI 生成的资产导入 UE5"""
        
        for asset in assets:
            if asset["type"] == "texture":
                self._import_texture(asset)
            elif asset["type"] == "mesh":
                self._import_mesh(asset)
            elif asset["type"] == "animation":
                self._import_animation(asset)
            elif asset["type"] == "sfx":
                self._import_sound(asset)
    
    def _import_mesh(self, asset):
        """导入 3D 模型"""
        # 使用 UE5 Python API
        import unreal
        
        # 导入 FBX
        task = unreal.AssetImportTask()
        task.set_editor_property('filename', asset["fbx_path"])
        task.set_editor_property('destination_path', 
                                  f"/Game/Props/{asset['category']}")
        task.set_editor_property('replace_existing', True)
        
        unreal.AssetToolsHelpers.get_asset_tools().import_asset_tasks([task])

class AssetQualityChecker:
    """资产质量检查"""
    
    def check_mesh(self, mesh):
        """检查 3D 模型质量"""
        issues = []
        
        # 1. 面数检查
        if len(mesh.faces) > 50000:
            issues.append("面数过多，需要简化")
        
        # 2. UV 检查
        if not mesh.visual.uv.any():
            issues.append("缺少 UV 映射")
        
        # 3. 流形检查
        if not mesh.is_watertight:
            issues.append("非水密网格")
        
        # 4. 法线检查
        if len(mesh.face_normals) != len(mesh.faces):
            issues.append("法线缺失")
        
        return issues
    
    def check_texture(self, texture):
        """检查纹理质量"""
        issues = []
        
        # 分辨率
        if texture.size[0] < 1024:
            issues.append("分辨率过低")
        
        # 可平铺性
        if not self._is_tileable(texture):
            issues.append("不可平铺")
        
        return issues

# 为游戏建立统一的视觉风格参考
style_references = {
    "characters": "style_ref/character_style.png",
    "environments": "style_ref/env_style.png",
    "props": "style_ref/prop_style.png",
    "ui": "style_ref/ui_style.png"
}

# 所有生成都使用对应的风格参考
generator = TextureGenerator(style_ref=style_references["props"])

AI 生成初稿 → 人工审核 → AI 修正 → 人工微调 → 最终版本
     ↑                                        ↓
     └──────────── 不通过 ←────────────────────┘

# 使用 Git LFS 管理 AI 生成资产
# .gitattributes
"""
*.obj filter=lfs diff=lfs merge=lfs -text
*.fbx filter=lfs diff=lfs merge=lfs -text
*.glb filter=lfs diff=lfs merge=lfs -text
*.png filter=lfs diff=lfs merge=lfs -text
"""