Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-mini-2024-07-18· OpenAIAi2 WildChat-4.8M (AI2)

Sous blender en python, ajoute un custom property dans les objets rond pour indiqué s'il…

  1. User

    Sous blender en python, ajoute un custom property dans les objets rond pour indiqué s'il y a eu ou pas collision, et dans le tableau d'initialisé ne prend que ceux qui n'ont pas eu de collision, il faut pouvoir passé à lélément suivant : import bpy from mathutils import Vector

    Configuration

    COLLISION_DISTANCE = 0.1 X_OFFSET = 7.554 # Décalage spécifique en mètres PROJECTILE_NAME = "Projectile" ROND_PREFIX = "Rond1"

    class CollisionSystem: def init(self): self.sorted_ronds = [] self.current_target_index = 0

    def initialize(self):
        # Tri par coordonnée X mondiale des ronds
        self.sorted_ronds = sorted(
            [o for o in bpy.data.objects if ROND_PREFIX in o.name],
            key=lambda x: x.matrix_world.translation.x
        )
        self.current_target_index = 0
        print("=== Liste des ronds triés ===")
        for i, rond in enumerate(self.sorted_ronds):
            pos = rond.matrix_world.translation
            print(f"{i+1}. {rond.name} - X: {pos.x:.3f}m")
    
    def update(self, scene, depsgraph):
        projectile = bpy.data.objects.get(PROJECTILE_NAME)
        if not projectile or not self.sorted_ronds:
            return
    
        # Position mondiale du projectile avec décalage
        projectile_pos = projectile.matrix_world.translation.copy()
        projectile_pos.x += X_OFFSET  # Application du décalage
    
        if self.current_target_index >= len(self.sorted_ronds):
            print("🏁 Tous les ronds traités")
            return
    
        current_rond = self.sorted_ronds[self.current_target_index]
        rond_pos = current_rond.matrix_world.translation
    
        # Calcul de la distance sur l'axe X seulement
        distance_x = abs(projectile_pos.x - rond_pos.x)
        real_distance = (projectile_pos - rond_pos).length
    
        print(f"\n=== Frame {scene.frame_current} ===")
        print(f"Projectile (monde): {projectile.matrix_world.translation.x:.3f}m")
        print(f"Projectile (ajusté): {projectile_pos.x:.3f}m (+{X_OFFSET})")
        print(f"Cible: {current_rond.name} - X: {rond_pos.x:.3f}m")
        print(f"Distance X: {distance_x:.3f}m | Totale: {real_distance:.3f}m")
    
        if real_distance <= COLLISION_DISTANCE:
            print("💥 COLLISION DETECTEE !")
            self._handle_collision(scene, current_rond)
            self.current_target_index += 1
    
    def _handle_collision(self, scene, rond):
        current_frame = scene.frame_current
        
        # Création de la propriété si nécessaire
        if "EmissionValue" not in rond:
            rond["EmissionValue"] = 0.0
            rond.id_properties_ensure()
        
        # Animation
        rond["EmissionValue"] = 0.0
        rond.keyframe_insert('["EmissionValue"]', frame=current_frame - 1)
        
        rond["EmissionValue"] = 1.0
        rond.keyframe_insert('["EmissionValue"]', frame=current_frame)
        
        print(f"✅ {rond.name} animé aux frames {current_frame-1} et {current_frame}")
    

    Initialisation

    collision_system = CollisionSystem() collision_system.initialize()

    Gestionnaires

    bpy.app.handlers.frame_change_post.clear() bpy.app.handlers.frame_change_post.append(collision_system.update)

  2. Assistant

    Le code que vous avez fourni configure un système de collision dans Blender en Python, où l'on détecte les collisions entre un projectile et des objets appelés "Rond1" (ou d'autres objets en fonction du préfixe). Pour incorporer un "custom property" qui indique si une collision a eu lieu, vous pouvez suivre ces étapes :

    1. Ajoutez une propriété personnalisée pour chaque objet Rond1 pour indiquer s'une collision a eu lieu ou non.
    2. Modifiez votre initialisation pour ne récupérer que les objets qui n'ont pas eu de collision.

    Voici comment vous pouvez modifier votre code en conséquence :

    import bpy
    from mathutils import Vector
    
    # Configuration
    COLLISION_DISTANCE = 0.1
    X_OFFSET = 7.554  # Décalage spécifique en mètres
    PROJECTILE_NAME = "Projectile"
    ROND_PREFIX = "Rond1"
    
    class CollisionSystem:
        def __init__(self):
            self.sorted_ronds = []
            self.current_target_index = 0
    
        def initialize(self):
            # Tri par coordonnées X mondiale des ronds qui n'ont pas eu de collision
            self.sorted_ronds = sorted(
                [o for o in bpy.data.objects if ROND_PREFIX in o.name and "CollisionDetected" not in o],
                key=lambda x: x.matrix_world.translation.x
            )
            self.current_target_index = 0
            print("=== Liste des ronds triés (sans collision) ===")
            for i, rond in enumerate(self.sorted_ronds):
                pos = rond.matrix_world.translation
                print(f"{i+1}. {rond.name} - X: {pos.x:.3f}m")
    
        def update(self, scene, depsgraph):
            projectile = bpy.data.objects.get(PROJECTILE_NAME)
            if not projectile or not self.sorted_ronds:
                return
    
            # Position mondiale du projectile avec décalage
            projectile_pos = projectile.matrix_world.translation.copy()
            projectile_pos.x += X_OFFSET  # Application du décalage
    
            if self.current_target_index >= len(self.sorted_ronds):
                print("🏁 Tous les ronds traités")
                return
    
            current_rond = self.sorted_ronds[self.current_target_index]
            rond_pos = current_rond.matrix_world.translation
    
            # Calcul de la distance sur l'axe X seulement
            distance_x = abs(projectile_pos.x - rond_pos.x)
            real_distance = (projectile_pos - rond_pos).length
    
            print(f"\n=== Frame {scene.frame_current} ===")
            print(f"Projectile (monde): {projectile.matrix_world.translation.x:.3f}m")
            print(f"Projectile (ajusté): {projectile_pos.x:.3f}m (+{X_OFFSET})")
            print(f"Cible: {current_rond.name} - X: {rond_pos.x:.3f}m")
            print(f"Distance X: {distance_x:.3f}m | Totale: {real_distance:.3f}m")
    
            if real_distance <= COLLISION_DISTANCE:
                print("💥 COLLISION DETECTEE !")
                self._handle_collision(scene, current_rond)
                self.current_target_index += 1
    
        def _handle_collision(self, scene, rond):
            current_frame = scene.frame_current
            
            # Création de la propriété si nécessaire
            if "CollisionDetected" not in rond:
                rond["CollisionDetected"] = False
                rond.id_properties_ensure()
            
            # Animation (vous pouvez aussi définir l'émission comme dans votre code si nécessaire)
            rond["CollisionDetected"] = True  # Indique que la collision a eu lieu
            rond.keyframe_insert('["CollisionDetected"]', frame=current_frame)
    
            print(f"✅ {rond.name} a eu une collision au frame {current_frame}")
    
    # Initialisation
    collision_system = CollisionSystem()
    collision_system.initialize()
    
    # Gestionnaires
    bpy.app.handlers.frame_change_post.clear()
    bpy.app.handlers.frame_change_post.append(collision_system.update)
    

    Ce que fait ce code modifié :

    1. Un "custom property" nommé CollisionDetected est ajouté à chaque objet Rond1 dès qu'il est initialisé. Si ce "property" n'est pas présent, il est créé avec une valeur initiale de False.
    2. Lorsque le projectile détecte une collision, CollisionDetected est modifié pour True, indiquant que cet objet a déjà eu une collision.
    3. Lors de l'initialisation des ronds, seuls ceux qui n'ont pas eu de collision (c'est-à-dire ceux qui n'ont pas la propriété CollisionDetected) sont ajoutés à la liste sorted_ronds.

    Cela garantit que vous ne traitez que les objets qui n'ont pas encore été touchés par le projectile, et que chaque objet peut être identifié pour savoir s'il a déjà subi une collision.

  3. User

    garde mon emission

  4. Assistant

    Pour conserver la fonctionnalité d'émission tout en ajoutant la gestion des collisions avec un custom property, vous pouvez simplement intégrer le code de gestion des collisions à votre logique d'animation d'émission. Voici comment vous pouvez modifier votre code afin de maintenir l'animation de l'émission tout en ajoutant le custom property "CollisionDetected".

    Code Modifié

    import bpy
    from mathutils import Vector
    
    # Configuration
    COLLISION_DISTANCE = 0.1
    X_OFFSET = 7.554  # Décalage spécifique en mètres
    PROJECTILE_NAME = "Projectile"
    ROND_PREFIX = "Rond1"
    
    class CollisionSystem:
        def __init__(self):
            self.sorted_ronds = []
            self.current_target_index = 0
    
        def initialize(self):
            # Tri par coordonnées X mondiale des ronds qui n'ont pas eu de collision
            self.sorted_ronds = sorted(
                [o for o in bpy.data.objects if ROND_PREFIX in o.name and "CollisionDetected" not in o],
                key=lambda x: x.matrix_world.translation.x
            )
            self.current_target_index = 0
            print("=== Liste des ronds triés (sans collision) ===")
            for i, rond in enumerate(self.sorted_ronds):
                pos = rond.matrix_world.translation
                print(f"{i+1}. {rond.name} - X: {pos.x:.3f}m")
    
        def update(self, scene, depsgraph):
            projectile = bpy.data.objects.get(PROJECTILE_NAME)
            if not projectile or not self.sorted_ronds:
                return
    
            # Position mondiale du projectile avec décalage
            projectile_pos = projectile.matrix_world.translation.copy()
            projectile_pos.x += X_OFFSET  # Application du décalage
    
            if self.current_target_index >= len(self.sorted_ronds):
                print("🏁 Tous les ronds traités")
                return
    
            current_rond = self.sorted_ronds[self.current_target_index]
            rond_pos = current_rond.matrix_world.translation
    
            # Calcul de la distance sur l'axe X seulement
            distance_x = abs(projectile_pos.x - rond_pos.x)
            real_distance = (projectile_pos - rond_pos).length
    
            print(f"\n=== Frame {scene.frame_current} ===")
            print(f"Projectile (monde): {projectile.matrix_world.translation.x:.3f}m")
            print(f"Projectile (ajusté): {projectile_pos.x:.3f}m (+{X_OFFSET})")
            print(f"Cible: {current_rond.name} - X: {rond_pos.x:.3f}m")
            print(f"Distance X: {distance_x:.3f}m | Totale: {real_distance:.3f}m")
    
            if real_distance <= COLLISION_DISTANCE:
                print("💥 COLLISION DETECTEE !")
                self._handle_collision(scene, current_rond)
                self.current_target_index += 1
    
        def _handle_collision(self, scene, rond):
            current_frame = scene.frame_current
            
            # Création de la propriété si nécessaire
            if "CollisionDetected" not in rond:
                rond["CollisionDetected"] = False
                rond.id_properties_ensure()
            
            # Animation de l'émission
            rond["EmissionValue"] = 0.0  # État de départ
            rond.keyframe_insert('["EmissionValue"]', frame=current_frame - 1)
            
            rond["EmissionValue"] = 1.0  # État en collision
            rond.keyframe_insert('["EmissionValue"]', frame=current_frame)
            
            # Mise à jour de la propriété de collision
            rond["CollisionDetected"] = True  # Indique que la collision a eu lieu
            rond.keyframe_insert('["CollisionDetected"]', frame=current_frame)
    
            print(f"✅ {rond.name} animé aux frames {current_frame-1} et {current_frame}, collision détectée.")
    
    # Initialisation
    collision_system = CollisionSystem()
    collision_system.initialize()
    
    # Gestionnaires
    bpy.app.handlers.frame_change_post.clear()
    bpy.app.handlers.frame_change_post.append(collision_system.update)
    

    Ce qui a changé :

    1. EmissionValue : Conserve le fonctionnement de l'émission en insérant des keyframes pour EmissionValue chaque fois qu'une collision est détectée.

    2. CollisionDetected : Le code gère maintenant cette propriété tout en respectant l'animation de l'émission. La propriété CollisionDetected est mise à True lors de la détection d'une collision, et elle est également enregistrée dans les keyframes.

    Résumé

    Dans ce code, lorsque le projectile détecte une collision, il met à jour à la fois la propriété d'émission et la propriété CollisionDetected. Cela conserve la logique d'animation de votre code d'origine tout en ajoutant une fonctionnalité pour suivre les collisions.