Soya/Python base 6
import sys, os, os.path, soya, soya.sdlconst
soya.init()
soya.path.append(os.path.join(os.path.dirname(sys.argv[0]), "data"))
scene = soya.World()
class CaterpillarHead(soya.Body):
 def __init__(self, parent):
 soya.Body.__init__(self, parent, soya.Model.get("caterpillar_head"))
 self.speed = soya.Vector(self, 0.0, 0.0, 0.0)
 self.rotation_y_speed = 0.0
 self.mouse_x = 0
 self.mouse_y = 0
 def begin_round(self):
 soya.Body.begin_round(self)
 # Boucle pour tous les évenements Soya / SDL.
 for event in soya.process_event():
 # Verification des évenements de la souris, et conservation des coordonnées X et Y du curseur.
 if event[0] == soya.sdlconst.MOUSEMOTION:
 self.mouse_x = event[1]
 self.mouse_y = event[2]
 # Le calcul des coordonnées de la souris est en 3D, Camera.coord2d_to_3d renvoie les coordonnées X et Y d'une souris en 2D
 # et une coordonnée optionnel Z (puisqu'il ne peut pas bien le gérer, la valeur de Z par défaut est -1.0).
 # Maintenant, nous utilisons pour Z les coordonnées Z de la chenille dans les coordonnées du système de la caméra :
 # nous considérons que le curseur est à la même hauteur que la chenille.
 # l'opérateur % est utilisé pour la conversion des coordonnées :
 # position % coordinate_system
 # retourne la position convertie dans coordinate_system (possibly position itself if it
 # is already in the right coordinate system).
 mouse_pos = camera.coord2d_to_3d(self.mouse_x, self.mouse_y, (self % camera).z)
 # Alors ca convertit la position de la souris en système de coordonnées pour la scène, et met les 
 # coordonnées de Y à 0.0, car nous ne voulons pas d'une chenille qui vole
 # (souvenez vous que Y est l'axe de la hauteur).
 mouse_pos.convert_to(scene)
 mouse_pos.y = 0.0
 # Calcul de la vitesse de coordonnée Z ; nous ne voulons pas une vitesse constante : plus le curseur est loin
 # et plus la chenille va vite.
 # Ainsi, la vitesse de coordonnée Z est la distance entre la chenille et la souris, et doit être négative
 # (car -Z est vers le haut).
 self.speed.z = -self.distance_to(mouse_pos)
 # Rotations vers la souris.
 self.look_at(mouse_pos)
 def advance_time(self, proportion):
 soya.Body.advance_time(self, proportion)
 self.add_mul_vector(proportion, self.speed)
class CaterpillarPiece(soya.Body):
 def __init__(self, parent, previous):
 soya.Body.__init__(self, parent, soya.Model.get("caterpillar"))
 self.previous = previous
 self.speed = soya.Vector(self, 0.0, 0.0, -0.2)
 def begin_round(self):
 soya.Body.begin_round(self)
 # Comme la vitesse peut être très élevée, nous avons besoin de prendre en compte
 # la vitesse précédente (celle que l'on avait lors du mouvement).
 # On calcule ensuite la future position de la pièce par la translation de la piece 
 # par le vecteur vitesse de cette même pièce.
 previous_next_pos = self.previous + self.previous.speed
 # La chenille regarde vers la futur position de la pièce.
 self.look_at(previous_next_pos)
 # Calcul de la coordonnée Z de vitesse. Nous utilisons un espace entre une pièce et 
 # sa prochaine position, et nous supprimons 1.5 car nous avons besoin que chaque piece
 # soit séparé par une distance de 1.5 unités.
 self.speed.z = -(self.distance_to(previous_next_pos) - 1.5)
 def advance_time(self, proportion):
 soya.Body.advance_time(self, proportion)
 self.add_mul_vector(proportion, self.speed)
caterpillar_head = CaterpillarHead(scene)
caterpillar_head.rotate_y(90.0)
previous_caterpillar_piece = caterpillar_head
for i in range(10):
 previous_caterpillar_piece = CaterpillarPiece(scene, previous_caterpillar_piece)
 previous_caterpillar_piece.x = i + 1
light = soya.Light(scene)
light.set_xyz(2.0, 5.0, 1.0)
camera = soya.Camera(scene)
camera.set_xyz(0.0, 15.0, 15.0)
camera.look_at(caterpillar_head)
soya.set_root_widget(camera)
soya.MainLoop(scene).main_loop()

Néerlandais/Pour traducteurs/Dissertation

Soya/Python base de chargement de fichier 1

Photographie/Fabricants/Sigma/Sigma APO 200-500 mm f/2,8 EX DG

Commentaires.
Le premier télé-zoom offrant une ouverture de f/2,8 à 500 mm est aussi le plus gros jamais construit.

Soya/Python sauvegarde avec cerealizer
import sys, os, os.path, soya
import cerealizer
class RotatingBody(soya.Body):
 def advance_time(self, proportion):
 soya.Body.advance_time(self, proportion)
 self.rotate_y(proportion * 5.0)
cerealizer.register(RotatingBody)
if sys.argv[0].endswith("basic-savingfile-cerealizer-1.py"):
 # Inits Soya and sets the data directory.
 soya.init()
 soya.path.append(os.path.join(os.path.dirname(sys.argv[0]), "data"))
 # Sets the file format soya uses for saving file.
 # The default configuration is to use cPickle for saving files, and to support loading
 # files saved either by cPickle or Cerealizer (if available).
 # The complete syntax is set_file_format(saving_format, loading_format), where loading_format
 # is optional and can be either a single format, or a list of format.
 # There are currently 2 supported formats: cPickle and Cerealizer.
 # See set_file_format's __doc__ for more information.
 soya.set_file_format(cerealizer)
 # Creates the scene.
 scene = soya.World()
 # Loads the sword model.
 sword_model = soya.Model.get("sword")
 # Creates a rotating body in the scene, using the sword model.
 sword = RotatingBody(scene, sword_model)
 # Creates a light.
 light = soya.Light(scene)
 light.set_xyz(0.5, 0.0, 2.0)
 # Set the scene filename. It is just the name of the file, soya adds automatically
 # a directory path as well as a ".data" extention.
 scene.filename = "a_scene_with_a_rotating_body"
 # Saves the scene. The file is created in the <soya.path[0]>/worlds/ directory, here:
 # tutorial/data/worlds/a_scene_with_a_rotating_body.data
 # The file is ALWAYS saved in the FIRST path listed in soya.path (which is, as sys.path,
 # a list of path).
 # Soya separates the "set filename" and the "save" step, because it allows you to set the
 # filename once, and then to save the object several times without having to remind its
 # filename.
 # Notice that, while saving the scene, Soya will save a reference to the "sword" Model we
 # have used above. However, the data of this Model are NOT dupplicated.
 scene.save()
 # Creates a camera.
 # For technical reasons, camera are not saveable yet. This is not really a problem since the
 # camera is not really scene-dependent by rather configuration-dependent.
 # We thus add the camera AFTER saving the scene.
 camera = soya.Camera(scene)
 camera.z = 3.0
 soya.set_root_widget(camera)
 soya.MainLoop(scene).main_loop()
 # That's all -- after running this tutorial, you should have a
 # tutorial/data/worlds/a_scene_with_a_rotating_body.data file. The easiest way to verify
 # that this file is REALLY a Cerealizer file, is to open the file and check if it begins
 # by the magic string "cereal1".