Maison

• Nous allons maintenant commencer à créer des petits objets « architecturaux ».
• Commençons par une magnifique petite maison de style Monopoly !
• Créons un nouveau fichier texte architectures.py
• 💡 En cas de blocage sur ce projet, essayer la Maison alternative

Module

• Nous allons nous servir de notre fonction Cube qui se trouve dans le fichier volumes.py
• Pour cela, ajoutons une nouvelle ligne pour charger ce fichier en tant que Volumes

import bpy
Pygram = bpy.data.texts["pygram.py"].as_module()
Volumes = bpy.data.texts["volumes.py"].as_module()
Pygram.cleanup()

Test

• Faisons un petit test :

import bpy
Pygram = bpy.data.texts["pygram.py"].as_module()
Volumes = bpy.data.texts["volumes.py"].as_module()
Pygram.cleanup()
 
a = Pygram.Point(0,0,0)
b = Pygram.Point(10,0,0)
l = Pygram.Line(a,b)
v = Pygram.Vector(0,10,0)
j = Pygram.Vector(0,0,10)
 
f = Volumes.extrude(l,v)
c = Volumes.cube(f,j)
print(c)

• Parfait !
• Ah oui mais le print(c) « renvoie » None dans la console.
• Mais oui, notre fonction cube() dans volumes.py ne renvoie rien,
• … None !

• Corrigeons cela :
• Ouvrir volumes.py et ajouter l'opérateur de renvoi return obj dans la fonction cube()
• Et maintenant :

📢 Object: cube
📢 Face: a 📢 Point:(0,0,0) b 📢 Point:(10,0,0) c 📢 Point:(10.0,10.0,0.0) d 📢 Point:(0.0,10.0,0.0)
📢 Face: a 📢 Point:(10.0,10.0,0.0) b 📢 Point:(0.0,10.0,0.0) c 📢 Point:(0.0,10.0,10.0) d 📢 Point:(10.0,10.0,10.0)
📢 Face: a 📢 Point:(10,0,0) b 📢 Point:(10.0,10.0,0.0) c 📢 Point:(10.0,10.0,10.0) d 📢 Point:(10.0,0.0,10.0)
📢 Face: a 📢 Point:(0,0,0) b 📢 Point:(0.0,10.0,0.0) c 📢 Point:(0.0,10.0,10.0) d 📢 Point:(0.0,0.0,10.0)
📢 Face: a 📢 Point:(0,0,0) b 📢 Point:(10,0,0) c 📢 Point:(10.0,0.0,10.0) d 📢 Point:(0.0,0.0,10.0)

Fonction

• Regroupons les variables qui permettent de générer un cube dans une nouvelle fonction que nous appelons house(x,y,z) qui prendra 3 arguments nous permettant de positionner cette « maison » dans l'espace.
• Utiliser la fonction rename() pour renommer l'objet en house

def house(x,y,z):
    a = Pygram.Point(0,0,0)
    b = Pygram.Point(10,0,0)
    l = Pygram.Line(a,b)
    v = Pygram.Vector(0,10,0)
    j = Pygram.Vector(0,0,10)
    f = Volumes.extrude(l,v)
    c = Volumes.cube(f,j)
    c.rename("house")

• Vérifions que nous obtenons toujours notre cube

house(0,0,0)

• À présent :
• Changer les valeurs des variables présentes dans la fonction house() pour produire un cube aux dimensions suivantes : 5m x 5m en plan et 2.5m de hauteur
• Renommer la variable j en h pour plus de lisibilité (h pour height)
• Évidemment, il faut aussi renommer j en h dans l'appel de la fonction cube() …

Toit

• Nous allons maintenant progressivement modifier la fonction cube() pour y ajouter un toit.
• Commençons par copier/coller la fonction cube() dans notre fichier architectures.py

import bpy
Pygram = bpy.data.texts["pygram.py"].as_module()
Volumes = bpy.data.texts["volumes.py"].as_module()
Pygram.cleanup()
 
def cube(f,v):
  ...
 
 
def house(x,y,z):
    a = Pygram.Point(0,0,0)
    b = Pygram.Point(5,0,0)
    l = Pygram.Line(a,b)
    v = Pygram.Vector(0,5,0)
    h = Pygram.Vector(0,0,2.5)
    f = Volumes.extrude(l,v)
    c = cube(f,h)
    c.rename("house")
 
house(0,0,0)

• Maintenant, il s'agit de modifier la fonction cube() pour y ajouter les 4 nouvelles faces du toit.
• Pour construire les deux pans inclinés et les deux pignons, il nous faut trouver le centre du segment (a1,b1) qui correspond à la ligne supérieure du cube, et nous aurons également besoin de (c1,d1).
• Pour ce faire, nous allons utiliser la fonction center() de l'objet Line
• Dans notre fonction cube() nous avons commencer par créer les points a1, b1, … en créant des copies par déplacement des point a, b. Voici la démarche pour créer les points de construction de la toiture à l'aide de ces points :

• Créer une ligne line_1 à l'aide des points a1 et b1
• Puis trouver le point au milieu de la ligne avec la fonction center()
• Enfin, créer le point de la ligne de faîtage en utilisant la fonction move() de l'objet Point :

    # Line 1
    line_1 = Pygram.Line(a1,b1)
    center_1 = line_1.center()
    p1 = center_1.move(v) # move vertically

• Il y a de grandes chances que vous fassiez des erreurs…
• Il faut afficher certaines informations pour vérifier les coordonnées :

    print("This is my Line #1")
    print(line_1)

• Réaliser la même opération sur l'autre façade à partir des points (c1,d1) pour créer une ligne line_2 et un point p2
• Ensuite il s'agit de créer un premier pan incliné à partir des points que nous venons de créer avec la fonction face() de l'objet Pygram.

• Puis nous ajoutons le deuxième pan.

• Dernière étape : ajouter les pignons
• Ici, il s'agit d'ajouter des faces triangulaires
• Utiliser la fonction tri(a,b,c) de l'objet Pygram

• Et voilà !
• Pour terminer, nous pouvons créer trois petites maisons en modifiant la fonction house(x,y,z):
• Ajouter une variable w pour la largeur de la maison qui correspond à la longeur de la Ligne l, et modifier la création des points a et b pour qu'ils prennent en compte les coordonnées x,y,z de la fonction.
• Ajoutons maintenant les trois appels de fonction house() aux trois coordonnées (0,0,0), (5,0,0) et (10,0,0).
• Pour terminer, renommer la fonction cube() en house_volume()
• 👏

Maison alternative

• Cet exercice comporte un certain nombre de difficultés.
• En cas de blocage, il est bon de prendre un chemin détourné.
• Il s'agit d'essayer de faire les mêmes choses, mais plus simplement.

• 1) Ne pas utiliser les fonctions importées du fichier volumes.py
  • Il peut devenir compliqué de travailler avec des données dispersées dans deux fichiers
  • Alors, faire un copier/coller des données et/ou des fonctions du fichiers volumes.py vers le fichier architectures.py, ou « recoder » les données et/ou les fonctions directement dans le fichier architectures.py (c'est encore mieux, car vous pouvez mieux corriger vos erreurs).

• 2) Ne pas repartir de la fonction cube()
  • Il est parfois (souvent) plus clair de repartir à zéro.
  • Commencer par écrire une fonction roof() qui génère les deux pans inclinés du toit.
  • Puis ajouter les deux pignons (avec la fonction tri() au lieu de face(), voir plus haut)
  • Enfin, terminer par le corps du volume, c'est la partie identique à celle de la fonction cube()

• 3) Pour terminer, renommer roof() en house()
• 4) Votre fonction est maintenant identique à la maison « non-alternative », telle qu'elle est décrite plus haut. Pour terminer, il faut donc générer 3 petites maisons comme l'exercice le demande. Relire l'énoncé depuis le début, si nécessaire.
• Et voilà :)