on installe un shader de control buffer.
télécharger ici le control buffer
Le mia_materialX est fait pour stocker différentes couches, il est donc parfait pour utiliser le control buffer.
Cette méthode de control buffer ne s'utilise qu'avec les mia_X. Le buffer fonctionne en fonction de la camera et du shader.
1) le buffer store
pour l'installer, les dll et le .mi sont à mettre dans le répertoire mentalray, les .mel dans le répertoire script de maya (situé généralement dans mes documents) et les .xpm, dans préférences
=> icons.
Dans les shaders mental ray on a maintenant le
buffer store, le
buffer api et le
buffer write.

pour utiliser le render buffer, on applique le buffer store à l'objet. On peut ensuite
connecter le shader. On connecte le mia_X au store en utilisant le
connection editor. On choisi les canaux que l'on veut pour le rendu et on les connect en instore, par exemple le diffuse,
le spécular, la réflexion...
Le but du render buffer est de décortiquer l'image dans le moindre détail pour pouvoir intervenir sur ces détails individuellement au compositing.
Pour avoir le résultat, on connecte le résult du mia_x au
primary buffer du store, c'est pour avoir l'image complète, sinon il ne va rendre que les couches.
et pour le reste, on connecte chaque cannal à un
inbuffer. Exemple : le
diffuse_resut (on connect que les trucs qui ont "result" dedans) au
inbuffer_1, le
specular_result au
inbuffer_2 ....
Le inbuffer_0 est réservé au glow !
il ne faut pas oublier de cocher la case store dans le bufferstore, pour que le moteur de rendu le rende, sinon il ne le fera pas. Penser aussi à nommer les
couches !
2) le buffer read
On va lui dire combien de couche on va sortir.
On va dans le panneau de rendu, sous l'onglet mentalray => framebuffer => primary framebuffer. On choisi le data type. Pour du .iff avec la couche alpha c'est RGBA (float) 4x32
Bit
On clique ensuite en dessous sur user framebuffer => open editor.
Dans le nouveau panneau qui s'ouvre on clique sur framebuffer => create. un autre panneau s'ouvre. On resselectionne le RGBA (float) 4x32 Bit dans le user buffer attributes. On pense bien à renommer le buffer.
Attention !! le logiciel crée les buffers dans l'ordre. Alors ce premier buffer correspond au canal 0 (même si vous n'avez rien mit dans ce cannal), le suivant
au 1 etc... prenez bien garde à avoir bien nommé vos buffers au préalable dans le store et rappelez vous de l'ordre sinon vous allez avoir des surprises.
3) le buffer write
Dans la camera => mentalray => primary output Passes => Secondary Output pass
on fait create. On arrive dans une nouvelle fenetre : mentalray Output pass. On pense à la renommer pareil que pour les précédentes. Donc dans cette fentêtre, il faut biensûr cocher
renderable, remettre le framebuffer type. On coche use User Buffer, on peut sélectionner les buffers reads que l'on vient juste de créer. On coche file mode et on
donne un nom de sortie dans file name postfix.
et une fois tout cela paramétré, y a plus qu'à appuyer sur le bouton rendu, pour qu'il sorte les différentes passes.
4) le buffer store avec un blin, un lambert ou tout autre shader qui n'est pas un mia_X
La méthode est la même, on crée un store qu'on applique à l'objet. On va prendre l'exemple d'un blinn. On le fait glisser sur le store et on dupplique autant de shader blinn qu'on veut de pass, car
on ne peut connecter qu'un seul cannal du blinn à la fois sur le store.
Il y a donc une possibilité d'assigner plusieurs shaders différents avec différentes textures pour qu'il rende les pass.
Par Ed
-
Publié dans : Tutoriaux
0
-
Recommander
On copie colle le script dans
animation => expression editor
Pour les matheux qui comprendraient quelque chose à ce charabia, voici quelques formules mathématiques pour (mieux ?) comprendre.
Calcul de la distance parcourue
//Le code du calcul de D, la distance parcouru
//on commence par déclarer les variables
float $old_tX;
float $old_tZ;
float $DX;
float $DZ;
//1. je note mes coords actuelle
float $new_tX = abs(Voiture.translateX);
float $new_tZ = abs(Voiture.translateZ);
//2. je soustrait
float $tX = $old_tX - $new_tX;
float $tZ = $old_tZ - $new_tZ;
//3. je garde au chaud mes coord actuelle pour les utiliser dans la prochaine boucle
$old_tX = $new_tX;
$old_tZ = $new_tZ;
//4. j'additionne mes résultats de soustraction
$DX = $DX + $tX;
$DZ = $DZ + $tZ;
// on place un IF au cas ou la machine s emballe et ne tende vers l'infini
// ca arrive ...
if ($DX > 9999999) $DX = 0;
if ($DZ > 9999999) $DZ = 0;
// on applique enfin pythagore pour avoir notre distance reel et notre vitesse
//
//la fonction sqrt($var) correspond a racine carré
//la fonction pow($var, 2) correspond a puissance 2, c'est a dire le carré
float $distance = sqrt(pow($DX, 2) + pow($DZ, 2));
float $vitesse = sqrt(pow(abs($tX), 2) + pow(abs($tZ), 2));
|
On calcule ensuite la rotation des roues :
// On déclare nos variables, ici le diamètre précédemment trouvé et pi
float $diametre = 2.33;
float $pi = 3.14159;
// on calcul la rotation de la roue suivant la formule TR = (D / (DM / Pi)) * 360
//TR = NB de tour ; D = distance parcourue ; DM = Diamètre de roue ; Pi = valeur de pi
//Pour faire rouler une roue nous avons en fait besoin de connaître combien de tours TR fait cette roue
//pour parcourir une distance D au sol. Ce nombre de tour est facile a connaître, il faut tout simplement
//diviser la distance D parcouru par le périmètre P de la roue.
//encore une fois le périmètre de notre roue s'obtiens de manière élémentaire; il faut multiplier le
//diamètre DM de notre roue par Pi. comme vous le savez (j'espère) un tour est égale a 360 degrés, il
//faut donc multiplier le résultat par 360 et on obtiens la rotation approprié de notre roue pour sa distance
//parcouru.
float $rotation = ( $distance / ($diametre * $pi) ) * 360;
// on connecte le rotateZ des roues sur notre variable nouvellement cree.
// théoriquement, ça tourne rond...
roueAvD.rotateZ = $rotation;
roueAvG.rotateZ = $rotation;
roueArD.rotateZ = $rotation;
roueArG.rotateZ = $rotation;
|
et on peut pousser le vice jusqu'à animer le volant. On crée d'abord un locator sur chaque roue avant pour qu'elle puisse pivoter.
//Première Partie du code
//je déclare les variables
float $oldVoitureX;
float $oldVoitureZ;
//je bouge le Volant avec les coordonnée de la boucle précédente
Volant.translateX = $oldVoitureX;
Volant.translateZ = $oldVoitureZ;
//je prend garde a ce que Volant soit exactement a la même hauteur que la voiture,
//ça évite les problèmes avec le Aim constraint
Volant.translateY = Voiture.translateY;
//je garde au chaud les coordonné de la voiture pour la prochaine boucle
float $oldVoitureX = Voiture.translateX;
float $oldVoitureZ = Voiture.translateZ;
//Seconde Partie du code
//On récupère la variable d'amplification sur l'attribut créé
float $ampli = Voiture.hydraulique;
//je soustrait mes rotations absolus
float $direction = Volant.rotateY - Voiture.rotateY;
//J'applique l'inverse multiplié de ma rotation a mes axes de direction
AxeDirectionD.rotateY = - $direction * $ampli;
AxeDirectionG.rotateY = - $direction * $ampli;
|
Si les roues tournent peu, on peut mettre un amplificateur : attributs à rajouter sur la voiture dans objet => add attribute et le mettre en float.
Par Ed
-
Publié dans : Tutoriaux
0
-
Recommander