Motif

Les Motifs

Ils permettent de travailler plus facilement avec les partitions.

Ce sont des groupes de notes (ou même une note seule) qu'on peut définir plus précisément grâce à toutes les méthodes que les motifs possèdent, ou qu'on peut dupliquer en les modifiant.

Création d'un motif

@usage simple :

instance_motif = Motif::new <donnees>

@exemple :

mon_motif = Motif::new "c d e"

@usage complexe :

instance_motif = Motif::new(
                            :motif  => <motif>, 
                            :octave => <octave>, 
                            :duree  => <duree>
                          )

<motif>, ci-dessus, est une suite de notes, au format ou non LilyPond, en note anglo-saxonnes ou italienne.

Par exemple :

Motif::new "ré mi fa# sib"
Motif::new "d e fis bes"

<octave> est l'indication de l'octave à laquelle, par défaut, le motif doit être joué. Mais il peut être facilement modifié à l'écriture.

La valeur par défaut de l'octave (i.e. quand on ne la précise pas) est de 3.

<durée>, qu'on peut aussi définir à l'aide de la clé :duration est la durée du motif (donc de chaque note), au format LilyPond (1 pour la ronde, 2 pour la blanche, 4 pour la noire, etc.).

Ajouter le motif à la partition

En supposant que PAUL est un musicien défini dans l'ORCHESTRE :

def score
  ...
  motif_pour_paul = Motif::new "ré8( fa la sib la2)"
  PAUL << motif_pour_paul
  ..
end

ou

def score
  ...
  PAUL.add motif_pour_paul
  ...

Créer un nouveau motif à partir d'un autre motif

Joindre deux motifs

On peut joindre un motif à un autre motif :

<motif>.join(<autre motif>)

Le motif <motif> contiendra alors les notes des deux motifs.

Mais on peut également créer un nouveau motif (pour préserver le premier) avec la directive :

<nouveau motif>.join(<autre motif>, :new => false)

Par exemple :

motif_un = Motif::new( :motif => "d f a r", :octave => 3)
motif_de = Motif::new( :motif => "r d a f", :octave => 3)

nouveau_motif = motif_un.join(motif_de, :new => true)
# =>  motif_un contiendra toujours "d f a r"
#     nouveau_motif contiendra "d f a r r d, a f"

Tandis que :

motif_un.join(motif_de, :new => false)
# ou simplement :
motif_un.join motif_de
# =>  motif_un contiendra à présent : "d f a r r d, a f"

Modification de la hauteur du motif

mon_motif_do = Motif::new "c e g"
mon_motif_re = mon_motif_do.plus(2)
# => Motif contenant "d fis a"
mon_motif_sibemol = mon_motif_do.moins(2)
puts mon_motif_sibemol.class
# => <#Motif xxxxx @motif="bes d f" @octave=2 @duration=4...>

Le nombre en paramètre de plus et moins correspond au nombre de demi-tons dont il faut baisser au augmenter le motif.

Noter un point très important ici : pour ces méthodes, un NOUVEL OBJET motif est créé. Le motif mon_motif_do ci-dessus est laissé intact, contrairement à d'autres méthodes qui agissent directement sur le motif lui-même.

On peut néanmoins contourner ce comportement en utilisant en second paramètres : :new => false :

motif_do = Motif::new "c e g"
motif_re = motif_do.plus(2)
# motif_do.to_s => "c e g"   -- il est inchangé
# motif_re.to_s => "d fis a" -- un nouveau motif a été créé
motif_re = motif_do.plus(2, :new => false)
# motif_do.to_s => "d fis a" -- cette fois, le motif_do a été modifié

Méthodes transformant (par défaut) l'objet lui-même

Les méthodes suivantes transforment l'objet lui-même, SAUF si le second argument contient :new => true (c'est le contraire de ce que nous venons de voir avec moins et plus).

<motif>.legato

Ajoute une liaison d'expression (pas de durée) du début à la fin des notes du motif.

mo = Motif::new "a b c d e"
mo.legato
# mo.to_s => "a( b c d e)"

<motif>.surlegato

Ajoute une "sur-liaison d'expression" du début à la fin des notes du motif. Cette deuxième méthode permet de lier expressivement des notes qui contiennent déjà des liaisons d'expression.

Par exemple :

motif_avec_liaisons = Motif::new "a b( c d) e( f g)"
motif_avec_liaisons.surlegato
# .to_s => "a\( b( c d) e( f g)\)"

L'utilisation de legato ci-dessus produirait une erreur lilypond.

Méthodes produisant (par défaut) un nouvel objet

(note : sauf si le second argument contient :new => false)

<motif>.plus(<demi-tons>[, <params>])

Hausse du nombre de demi-tons voulus toutes les notes du motif, en renvoyant par défaut une nouvelle instance de Motif.

<motif>.moins(<demi-tons>[, <params>])

Baisse du nombre de demi-tons voulus toutes les notes du motif, en renvoyant par défaut une nouvelle instance de Motif.

<motif>.crescendo([<params>])

Crée un crescendo depuis la première note du motif jusqu'à la dernière.

<params> peut contenir :

    :start => '<dynamique>' # valeur dynamique de départ, p.e. 'mf', 'ffff', 'pp', etc.
    :end   => '<dynamique>' # valeur dynamique de fin du crescendo, p.e. idem
    :new   => false         # Modifie l'objet lui-même

<motif>.decrescendo([<params>])

Crée un decrescendo depuis la première note du motif jusqu'à la dernière.

<params> peut contenir les mêmes valeurs que crescendo ci-dessus.