Dorian Fevrier's blog - Mot-clé - mapJe m’appelle FEVRIER Dorian, je suis infographiste 3D passionné par mon métier, l’informatique en général, l’internet, la programmation et l’évolution de tout ce petit monde. Vous trouverez sur ce blog des tutoriaux, mes coups de cœurs, avis, etc.2024-01-02T23:48:05+01:00FEVRIER Dorianurn:md5:695d9c73474c33ce3dab043823509c4bDotclearLes maps mental ray (part 3): Fabriquer sa map de debugurn:md5:6dc26d3ecd617ba8cd524f38d3ffbfe72010-01-31T22:16:00+01:002013-07-26T22:34:32+02:00NarannInfographie 3D - Boulot3ds maxbatbatchbidouilledebugfrimf_copymapmayamental ray<p><img src="https://www.fevrierdorian.com/blog/public/billets/2010_creer_map_debug/map_mental_ray_create_tn.png" alt="map_mental_ray_create_tn.png" style="float:left; margin: 0 1em 1em 0;" title="map_mental_ray_create_tn.png, janv. 2010" height="150" width="150" />Pour clore ce chapitre sur les maps de mental ray je vais expliquer la démarche pour en créer une spécialement dédié au debug. Comme vu <a href="https://www.fevrierdorian.com/blog/post/2010/01/30/Les-maps-mental-ray-%28part-2.2%29%3A-Le-debug">précédemment</a>, l'idée est d'avoir une map avec différentes images à chaque niveaux. Ce qui permet de mieux régler les options de filtrage de texture lors d'un rendu et/ou de débugger le comportement des textures. Ce billet est le plus court des trois. :hehe:</p> <p>Une fois encore, tout le mérite revient à <a href="http://fr.linkedin.com/in/pierrelopes" hreflang="en">Pierre LOPES</a> qui m'a fait "découvrir" le principe de la "map de debug".</p>
<p>Pour générer une .map, comme d'habitude, il faut utiliser l'utilitaire <a href="https://www.fevrierdorian.com/blog/post/2009/01/14/Le-mappage-en-m%C3%A9moire-des-textures-dans-Mental-Ray-expliqu%C3%A9-%28Memory-mapped-textures%29.#imf_copy">imf_copy</a>.
Allez le chercher dans:</p>
<pre class="bash bash">C:\Program Files\Autodesk\Maya2010\bin\imf_copy.exe</pre>
<p>Comme vu dans l'aide <a href="https://www.fevrierdorian.com/blog/post/2009/01/14/Le-mappage-en-m%C3%A9moire-des-textures-dans-Mental-Ray-expliqu%C3%A9-%28Memory-mapped-textures%29.#imf_copy_traduction">précédemment</a>, il va falloir utiliser le flag "-c" suivi de la liste des images de la plus grande à la plus petite:</p>
<pre class="bash bash">imf_copy <span style="color: #660033;">-v</span> <span style="color: #660033;">-r</span> <span style="color: #660033;">-c</span> test.0.png test.1.png test.2.png ...etc... myDebugMap.map</pre>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/2010_creer_map_debug/.map_mental_ray_create001_m.jpg" alt="map_mental_ray_create001.png" style="display:block; margin:0 auto;" title="map_mental_ray_create001.png, janv. 2010" height="156" width="448" />
Important, pour éviter les problèmes du genre:</p>
<pre class="bash bash">MAIN <span style="color: #000000;">0.0</span> warn : C:\Program Files\Autodesk\Maya2010\bin\imf_copy.exe: smallest resolution is <span style="color: #000000;">4096</span> <span style="color: #000000;">4096</span>, expected <span style="color: #000000;">1</span> <span style="color: #000000;">1</span>
MAIN <span style="color: #000000;">0.0</span> warn : C:\Program Files\Autodesk\Maya2010\bin\imf_copy.exe: unexpected resolutions may cause nonoptimal filtering</pre>
<p>Veillez à ce que la dernière image donné dans votre liste soit une image de 1x1 pixels. Il faut donner toute les résolutions en puissance de deux entre votre résolution max jusqu'à 1 pixel.</p>
<pre class="bash bash">D:\3D\debugMap<span style="color: #000000; font-weight: bold;">></span><span style="color: #ff0000;">"C:\Program Files\Autodesk\Maya2010\bin\imf_copy.exe"</span> <span style="color: #660033;">-v</span> <span style="color: #660033;">-r</span> <span style="color: #660033;">-c</span> test.0.png test.1.png test.2.png test.3.png test.4.png test.5.png test.6.png test.7.png test.8.png test.9.png test.10.png test.11.png test.12.png test.13.png myTexture.map
MAIN .0 info : Copyright <span style="color: #000000;">1993</span>-<span style="color: #000000;">2009</span> mental images GmbH, Berlin, Germany. All rights reserved.
MAIN .0 info : imf_copy version 3.6.1
MAIN .0 info : version 3.7.52.14, Jan <span style="color: #000000;">6</span> <span style="color: #000000;">2009</span>, revision <span style="color: #000000;">30162</span>
IMG <span style="color: #000000;">0.0</span> info : opening <span style="color: #ff0000;">"test.0.png"</span> <span style="color: #000000; font-weight: bold;">for</span> reading
MAIN <span style="color: #000000;">0.0</span> info : C:\Program Files\Autodesk\Maya2010\bin\imf_copy.exe: <span style="color: #666666; font-style: italic;">#0: test.0.png (8192 x 8192) --> myTexture.map</span>
IMG <span style="color: #000000;">0.0</span> info : opening <span style="color: #ff0000;">"test.1.png"</span> <span style="color: #000000; font-weight: bold;">for</span> reading
MAIN <span style="color: #000000;">0.0</span> info : C:\Program Files\Autodesk\Maya2010\bin\imf_copy.exe: <span style="color: #666666; font-style: italic;">#1: test.1.png (4096 x 4096) --> myTexture.map</span>
IMG <span style="color: #000000;">0.0</span> info : opening <span style="color: #ff0000;">"test.2.png"</span> <span style="color: #000000; font-weight: bold;">for</span> reading
MAIN <span style="color: #000000;">0.0</span> info : C:\Program Files\Autodesk\Maya2010\bin\imf_copy.exe: <span style="color: #666666; font-style: italic;">#2: test.2.png (2048 x 2048) --> myTexture.map</span>
IMG <span style="color: #000000;">0.0</span> info : opening <span style="color: #ff0000;">"test.3.png"</span> <span style="color: #000000; font-weight: bold;">for</span> reading
MAIN <span style="color: #000000;">0.0</span> info : C:\Program Files\Autodesk\Maya2010\bin\imf_copy.exe: <span style="color: #666666; font-style: italic;">#3: test.3.png (1024 x 1024) --> myTexture.map</span>
IMG <span style="color: #000000;">0.0</span> info : opening <span style="color: #ff0000;">"test.4.png"</span> <span style="color: #000000; font-weight: bold;">for</span> reading
MAIN <span style="color: #000000;">0.0</span> info : C:\Program Files\Autodesk\Maya2010\bin\imf_copy.exe: <span style="color: #666666; font-style: italic;">#4: test.4.png (512 x 512) --> myTexture.map</span>
IMG <span style="color: #000000;">0.0</span> info : opening <span style="color: #ff0000;">"test.5.png"</span> <span style="color: #000000; font-weight: bold;">for</span> reading
MAIN <span style="color: #000000;">0.0</span> info : C:\Program Files\Autodesk\Maya2010\bin\imf_copy.exe: <span style="color: #666666; font-style: italic;">#5: test.5.png (256 x 256) --> myTexture.map</span>
IMG <span style="color: #000000;">0.0</span> info : opening <span style="color: #ff0000;">"test.6.png"</span> <span style="color: #000000; font-weight: bold;">for</span> reading
MAIN <span style="color: #000000;">0.0</span> info : C:\Program Files\Autodesk\Maya2010\bin\imf_copy.exe: <span style="color: #666666; font-style: italic;">#6: test.6.png (128 x 128) --> myTexture.map</span>
IMG <span style="color: #000000;">0.0</span> info : opening <span style="color: #ff0000;">"test.7.png"</span> <span style="color: #000000; font-weight: bold;">for</span> reading
MAIN <span style="color: #000000;">0.0</span> info : C:\Program Files\Autodesk\Maya2010\bin\imf_copy.exe: <span style="color: #666666; font-style: italic;">#7: test.7.png (64 x 64) --> myTexture.map</span>
IMG <span style="color: #000000;">0.0</span> info : opening <span style="color: #ff0000;">"test.8.png"</span> <span style="color: #000000; font-weight: bold;">for</span> reading
MAIN <span style="color: #000000;">0.0</span> info : C:\Program Files\Autodesk\Maya2010\bin\imf_copy.exe: <span style="color: #666666; font-style: italic;">#8: test.8.png (32 x 32) --> myTexture.map</span>
IMG <span style="color: #000000;">0.0</span> info : opening <span style="color: #ff0000;">"test.9.png"</span> <span style="color: #000000; font-weight: bold;">for</span> reading
MAIN <span style="color: #000000;">0.0</span> info : C:\Program Files\Autodesk\Maya2010\bin\imf_copy.exe: <span style="color: #666666; font-style: italic;">#9: test.9.png (16 x 16) --> myTexture.map</span>
IMG <span style="color: #000000;">0.0</span> info : opening <span style="color: #ff0000;">"test.10.png"</span> <span style="color: #000000; font-weight: bold;">for</span> reading
MAIN <span style="color: #000000;">0.0</span> info : C:\Program Files\Autodesk\Maya2010\bin\imf_copy.exe: <span style="color: #666666; font-style: italic;">#10: test.10.png (8 x 8) --> myTexture.map</span>
IMG <span style="color: #000000;">0.0</span> info : opening <span style="color: #ff0000;">"test.11.png"</span> <span style="color: #000000; font-weight: bold;">for</span> reading
MAIN <span style="color: #000000;">0.0</span> info : C:\Program Files\Autodesk\Maya2010\bin\imf_copy.exe: <span style="color: #666666; font-style: italic;">#11: test.11.png (4 x 4) --> myTexture.map</span>
IMG <span style="color: #000000;">0.0</span> info : opening <span style="color: #ff0000;">"test.12.png"</span> <span style="color: #000000; font-weight: bold;">for</span> reading
MAIN <span style="color: #000000;">0.0</span> info : C:\Program Files\Autodesk\Maya2010\bin\imf_copy.exe: <span style="color: #666666; font-style: italic;">#12: test.12.png (2 x 2) --> myTexture.map</span>
IMG <span style="color: #000000;">0.0</span> info : opening <span style="color: #ff0000;">"test.13.png"</span> <span style="color: #000000; font-weight: bold;">for</span> reading
MAIN <span style="color: #000000;">0.0</span> info : C:\Program Files\Autodesk\Maya2010\bin\imf_copy.exe: <span style="color: #666666; font-style: italic;">#13: test.13.png (1 x 1) --> myTexture.map</span></pre>
<p>Vous devriez vous retrouver avec un fichier assez gros (341 Mo pour moi) que vous pouvez maintenant utiliser dans vos scènes pour débugger vos textures.</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/2010_creer_map_debug/map_mental_ray_create002.png" alt="map_mental_ray_create002.png" style="display:block; margin:0 auto;" title="map_mental_ray_create002.png, janv. 2010" height="320" width="146" /></p>
<p>Notez que si l'application principalement utilisé ici est Maya, normalement, ont peut très bien utiliser cette map avec n'importe quel soft qui utilise mental ray.</p>
<p>En espérant que ce billet vous aura aider. :sourit:</p>
<p>N'hésitez pas à laisser un commentaire si vous avez des questions ou si je n'ai pas été assez clair quelque part.</p>
<p>A bientôt!</p>
<center>:marioCours:</center>
Les maps mental ray (part 2.2): Le debugurn:md5:fb7ac4999d9d421a89b046f7edaab3e62010-01-30T16:09:00+01:002013-07-26T22:34:42+02:00NarannInfographie 3D - Boulotdebugelliptiqueexplicationsfiltrefrmapmayamental raypyramidale<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/map_debug_tn.png" alt="map_debug_tn.png" style="float:left; margin: 0 1em 1em 0;" title="map_debug_tn.png, janv. 2010" height="150" width="150" />Voici la suite du billet précédent. Peut-être le billet le plus compliqué que je n'ai jamais écrit. Ça été très hardu pour moi de réussir à énoncer clairement les différents fonctionnements des filtres dans la mesure ou ils nécessitent d'avoir déjà emmagasiné un bon paquet de connaissance avant de pouvoir être compris :baffed: ... Technophobes passez votre chemin, les autres, armez vous de courage! Et surtout! Laissez moi un commentaire si vous voyez des choses à redire (et il y en a tellement c'est compliqué!). Si vous voyez que je peut m'être planté quelque part, n'hésitez pas à me le notifier. Bon courage et j'espere que vous apprendrez des choses intéressantes en lisant ce billet :sourit: .</p> <h5>Sommaire:</h5>
<ul>
<li><a href="https://www.fevrierdorian.com/blog/post/2010/01/30/Les-maps-mental-ray-%28part-2.2%29%3A-Le-debug#la_map_de_debug">La map de debug</a></li>
<li><a href="https://www.fevrierdorian.com/blog/post/2010/01/30/Les-maps-mental-ray-%28part-2.2%29%3A-Le-debug#premier_test">Premier test</a></li>
<li><a href="https://www.fevrierdorian.com/blog/post/2010/01/30/Les-maps-mental-ray-%28part-2.2%29%3A-Le-debug#sans_le_filtrage">Sans le filtrage</a></li>
<li><a href="https://www.fevrierdorian.com/blog/post/2010/01/30/Les-maps-mental-ray-%28part-2.2%29%3A-Le-debug#limite_diagnose_sample">Petite pause sur le diagnose sample dans le cas d'une map de debug</a></li>
<li><a href="https://www.fevrierdorian.com/blog/post/2010/01/30/Les-maps-mental-ray-%28part-2.2%29%3A-Le-debug#on_reprend">On reprend avec les filtres de base de Maya</a></li>
<li><a href="https://www.fevrierdorian.com/blog/post/2010/01/30/Les-maps-mental-ray-%28part-2.2%29%3A-Le-debug#filtre_elliptic">Le filtre Elliptique</a></li>
<li><a href="https://www.fevrierdorian.com/blog/post/2010/01/30/Les-maps-mental-ray-%28part-2.2%29%3A-Le-debug#attack_mental_ray">A l'attaque de mental ray, le vrai, pas l'autre!</a></li>
<li><a href="https://www.fevrierdorian.com/blog/post/2010/01/30/Les-maps-mental-ray-%28part-2.2%29%3A-Le-debug#le_filtrage_pyramidale">Le filtrage Pyramidale</a></li>
<li><a href="https://www.fevrierdorian.com/blog/post/2010/01/30/Les-maps-mental-ray-%28part-2.2%29%3A-Le-debug#optimisation_et_explications_plus_precises">Optimisation et explications plus précises</a></li>
<li><a href="https://www.fevrierdorian.com/blog/post/2010/01/30/Les-maps-mental-ray-%28part-2.2%29%3A-Le-debug#le_filtrage_elliptique_le_retour">Le filtre Elliptique (Le Retour!)</a></li>
</ul>
<p>Avant de commencer je voulais remercier la personne qui m'a fait "découvrir" le principe de la "map de debug": <a href="http://fr.linkedin.com/in/pierrelopes" hreflang="en">Pierre LOPES</a>.</p>
<p>C'est bête comme tout et je me suis senti idiot de ne pas avoir eu l'idée en premier tellement le principe est simple.</p>
<h5>La map de debug <a name="la_map_de_debug"></a></h5>
<p>Comme vue dans <a href="https://www.fevrierdorian.com/blog/post/2009/12/24/Les-maps-mental-ray-%28part-2.1%29%3A-Le-debug#le_choix">mon billet précédent</a>, pour pouvoir voir comment se comporte une mipmap, il faut créer des maps différentes pour chaque niveau et des les empaqueter dans une .map mental ray (ce sera l'objet de mon dernier billet la dessus). Voici ma map de debug. En ce qui me concerne, j'ai "écrit" la taille de la map en question sur chaque niveau (je vous conseille vivement de faire ça):</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/testMapProfil.png" alt="testMapProfil.png" style="display:block; margin:0 auto;" title="testMapProfil.png, janv. 2010" height="327" width="648" /></p>
<p>J'ai ainsi:</p>
<ul>
<li>Mon niveau principal, le plus grand: 8192 x 8192</li>
<li>Niveau 2: 4096 * 4096</li>
<li>Niveau 3: 2048 * 2048</li>
<li>Etc...</li>
</ul>
<p>Mais ne perdons pas de temps et testons cette map!</p>
<p>Vous pouvez la <a href="https://www.fevrierdorian.com/blog/public/billets/memorymap/debugMap.7z">télécharger ici</a> (24mo) au format <a href="http://www.7-zip.org/" hreflang="en">7-zip</a> (dsl pour le format mais Winrar, n'a atteint que 68mo... :mechantCrash: ).</p>
<h5>Premier test <a name="premier_test"></a></h5>
<p>Pour les paramètres de rendu, on fait simple et vite: J'utilise le preset Production, Anti-aliasing Contrast à 0.05, filtre Mitchel:</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/map_debug001.png" alt="map_debug001.png" style="display:block; margin:0 auto;" title="map_debug001.png, janv. 2010" height="172" width="470" /></p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/map_debug002.png" alt="map_debug002.png" style="display:block; margin:0 auto;" title="map_debug002.png, janv. 2010" height="236" width="367" /></p>
<p>N'oubliez pas de passer en rendu mental ray (Maya software supporte les .map mais pas le mipmaping :sourit: ).
<img src="https://www.fevrierdorian.com/blog/public/billets/sampling/map_debug003.png" alt="map_debug003.png" style="display:block; margin:0 auto;" title="map_debug003.png, janv. 2010" height="480" width="640" />
Et un diagnostique du sampling:</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/map_debug006.png" alt="map_debug006.png" style="display:block; margin:0 auto;" title="map_debug006.png, janv. 2010" height="198" width="480" /></p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/map_debug003Diagnose.png" alt="map_debug003Diagnose.png" style="display:block; margin:0 auto;" title="map_debug003Diagnose.png, janv. 2010" height="480" width="640" /></p>
<p>Vous l'aurez compris, il y a des options par défaut qui font déjà quelque chose. :hehe:</p>
<p>Ici, ont voit que mental ray à utiliser les niveau en 256*256 et 128*128. Donc mental ray utilise bien la mipmap avec des options de base. L'envois de sample est modéré et un bon compromis.</p>
<p>Vous pourrez le faire remarquer: 256 pixels, c'est peut être un peu léger (nous y reviendrons pour régler tout ça! :hehe: )</p>
<h5>Sans le filtrage <a name="sans_le_filtrage"></a></h5>
<p>Désactivons le filtrage:</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/map_debug004.png" alt="map_debug004.png" style="display:block; margin:0 auto;" title="map_debug004.png, janv. 2010" height="165" width="340" /></p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/map_debug005.png" alt="map_debug005.png" style="display:block; margin:0 auto;" title="map_debug005.png, janv. 2010" height="480" width="640" /></p>
<p>Si nous regardons de plus près nous voyons en effet qu'aucun filtre n'est appliqué sur la texture:</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/map_debug010.png" alt="map_debug010.png" style="display:block; margin:0 auto;" title="map_debug010.png, janv. 2010" height="480" width="640" /></p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/map_debug007.png" alt="map_debug007.png" style="display:block; margin:0 auto;" title="map_debug007.png, janv. 2010" height="480" width="640" />
Direct, ça lance beaucoup plus de samples... On peut même voir un effet de "vague" qui montre qu'il y a une sorte de "saturation".</p>
<h5>Petite pause sur le diagnose sample dans le cas d'une map de debug <a name="limite_diagnose_sample"></a></h5>
<p>Bon, je m'arrête un peu la dessus car ça mérite quelques précisions. :youplaBoum:</p>
<p>Utiliser le "diagnose samples" est conseillé car il permet de voir "ou les samples se perdent". Je vous ai montré deux exemples ici pour voir le principe. Cependant, <ins>il ne faut pas s'y arrêter</ins>. En effet, sur la map de debug, chaque niveau à sa propre texture, ses propres couleurs, son propre piquet. Comparer les passes de "diagnose" de différents paramètres entre elles n'a aucun intérêt avec une map de debug. Voici un exemple qui viens appuyer mes dires (j'ai utilisé un paramètre que nous verrons plus tard pour bien distinguer les deux résolutions):</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/map_debug009.png" alt="map_debug009.png" style="display:block; margin:0 auto;" title="map_debug009.png, janv. 2010" height="480" width="640" /></p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/map_debug008.png" alt="map_debug008.png" style="display:block; margin:0 auto;" title="map_debug008.png, janv. 2010" height="480" width="640" /></p>
<p>Nous voyons que la résolution de 2048 à nécessité plus de sample que la résolution 4096 car, encore une fois, chaque niveau à sa propre texture, ses propres couleurs, son propre piquet (rabâche :redface: ).</p>
<p>Je vous invite donc, à diagnostiquer vos samples quand vous êtes en condition réelle mais cette manipulation est inutile voir trompeuse avec une map de debug. :sourit:</p>
<p>Fin de la parenthèse.</p>
<h5>On reprend avec les filtres de base de Maya <a name="on_reprend"></a></h5>
<p>Passons en Mipmap:</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/map_debug011.png" alt="map_debug011.png" style="display:block; margin:0 auto;" title="map_debug011.png, janv. 2010" height="159" width="433" />
<img src="https://www.fevrierdorian.com/blog/public/billets/sampling/map_debug012.png" alt="map_debug012.png" style="display:block; margin:0 auto;" title="map_debug012.png, janv. 2010" height="480" width="640" /></p>
<p>Pour pouvoir faire varier la "vitesse" de changement entre les différents niveaux de la map, il suffit de jouer avec la valeur du filter (dans Effects).</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/map_debug016.png" alt="map_debug016.png" style="display:block; margin:0 auto;" title="map_debug016.png, janv. 2010" height="127" width="422" />
<img src="https://www.fevrierdorian.com/blog/public/billets/sampling/map_debug017.png" alt="map_debug017.png" style="display:block; margin:0 auto;" title="map_debug017.png, janv. 2010" height="480" width="640" />
Plus vous la diminuer, plus vous atténuez l'effet du filtre (on dit la compression) et plus vous vous rapprochez du niveau "zéro" (full résolution). Un filter à 0 et votre texture est en full résolution, comme si vous étiez en off (logique).</p>
<p>Vous pouvez changer de filtre (Quadratic, Quartic, Gaussian, oubliez le Box...), vous obtiendrez toujours cet espèce de dégradé que vous pourrez "contrôler" grâce a la valeur du filter (dans Effects).</p>
<p>Ça c'est pour les filters de "base" (vous verrez plus tard que ce n'est pas aussi simple).</p>
<p>Je vous présente brièvement le dernier (j'aurai l'occasion d'y revenir plus en détail): Le filtre Elliptique</p>
<h5>Le filtre Elliptique <a name="filtre_elliptic"></a></h5>
<p>C'est quoi ça? o_O</p>
<p>C'est un filtre un peu spécial de mental ray qui offre l'avantage d'avoir un excellent piquet sur la texture et diminue fortement le flou sur celle ci (comparé à l'utilisation d'autres filtres). Avant, il fallait bidouiller pour l'avoir (nous verrons ça plus tard :sourit: ). Maintenant, rien de plus simple:</p>
<p>Vous passez en Mipmap:</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/map_debug011.png" alt="map_debug011.png" style="display:block; margin:0 auto;" title="map_debug011.png, janv. 2010" height="159" width="433" /></p>
<p>Puis dans le frame mental ray, vous activez "Advanced Elliptical Filtering":</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/map_debug013.png" alt="map_debug013.png" style="display:block; margin:0 auto;" title="map_debug013.png, janv. 2010" height="84" width="433" /></p>
<p>Dans sa grande bonté (sarcasmes inside), Maya va automatiquement vous cocher les deux cases suivantes ("Override Global Auto-Conversion Settings" et "Convert File To Optimized Format").</p>
<p>Décochez la première suffira. Mais assurez vous surtout que la case "use optimized texture (auto-conversion)" est décoché dans "Preference/Rendering":</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/mentalRayPref001.png" alt="mentalRayPref001.png" style="display:block; margin:0 auto;" title="mentalRayPref001.png, janv. 2010" height="205" width="482" /></p>
<p>Revenons-en à notre filtre elliptique. En fait, l'utilisation de ce filtre n'est efficace que dans le cas d'une map pyramidale (petit rappel <a href="https://www.fevrierdorian.com/blog/post/2009/12/13/Les-maps-mental-ray-%28part-1%29%3A-Pratique#la_methode_new_age">ici</a> :sourit: ), d'où cette "gentille" façon de vous forcer la main des fois que vous serriez trop con pour faire vos maps tout seul... :baffed:</p>
<p>Le paramètre Anti-Aliasing Level est un peu comme la valeur du filter pour les autres filtres (mais en sens inverse). Il correspond (grosso modo, nous expliquerons mieux ça plus tard) au nombre de pixel de la texture (texels) qui seront utilisé par pixel. 8 est une bonne valeur. Plus vous la diminuez plus vous avancez dans les différents niveaux de la map (et donc une faible résolution). Testez par vous même:
<img src="https://www.fevrierdorian.com/blog/public/billets/sampling/mentalRayPref002.png" alt="mentalRayPref002.png" style="display:block; margin:0 auto;" title="mentalRayPref002.png, janv. 2010" height="480" width="640" />
PS: Sur <a href="http://download.autodesk.com/us/maya/2010help/index.html?url=mental_ray_for_Maya_rendering_Dynamic_Attributes.htm,topicNumber=d0e589888" hreflang="en">la documentation officielle</a> (à la fin) une option est donné pour ajouter des paramètres (qui sont au final les paramètres du node mental ray <a href="http://download.autodesk.com/us/maya/2010help/mr/shaders/node6.html#mi_shader__mib_texture_filter_lookup" hreflang="en">mib_texture_filter_lookup</a>):</p>
<pre class="mel mel">addAttr <span style="color: #339933;">-</span>longName <span style="color: #ff0000;">"miEllipticalBilinear"</span> <span style="color: #339933;">-</span>at bool <span style="color: #339933;">-</span>defaultValue <span style="color: #0000dd;">1</span> file1<span style="color: #339933;">;</span>
addAttr <span style="color: #339933;">-</span>longName <span style="color: #ff0000;">"miEllipticalEccMax"</span> <span style="color: #339933;">-</span>at <span style="color: #ff0000;">"float"</span> <span style="color: #339933;">-</span>defaultValue <span style="color:#800080;">4.0</span> <span style="color: #339933;">-</span>minValue <span style="color:#800080;">0.001</span> <span style="color: #339933;">-</span>maxValue <span style="color:#800080;">40.0</span> file1<span style="color: #339933;">;</span>
addAttr <span style="color: #339933;">-</span>longName <span style="color: #ff0000;">"miEllipticalDiscR"</span> <span style="color: #339933;">-</span>at <span style="color: #ff0000;">"float"</span> <span style="color: #339933;">-</span>defaultValue <span style="color:#800080;">0.3</span> <span style="color: #339933;">-</span>minValue <span style="color:#800080;">0.001</span> <span style="color: #339933;">-</span>maxValue <span style="color:#800080;">1.0</span> file1<span style="color: #339933;">;</span>
addAttr <span style="color: #339933;">-</span>longName <span style="color: #ff0000;">"miEllipticalCircleR"</span> <span style="color: #339933;">-</span>at <span style="color: #ff0000;">"float"</span> <span style="color: #339933;">-</span>defaultValue <span style="color:#800080;">0.8</span> <span style="color: #339933;">-</span>minValue <span style="color:#800080;">0.001</span> <span style="color: #339933;">-</span>maxValue <span style="color:#800080;">1.0</span> file1<span style="color: #339933;">;</span></pre>
<p>Je reviendrais sur ces options plus tard :sourit: .</p>
<h5>Arf! On voit la jonction entre les différents niveaux! C'est tout pourris! <a name="arf_on_voit_la_jonction"></a></h5>
<p>Héhé! :hehe: Vous êtes tombé dans le panneau. En effet, bien que ça puisse sembler surprenant, ce filtre est l'un des plus précis de tous. En effet, Les autres filtres font soit de l'aliasing (Off, Box) soit du flou (Mipmap, Quadratic, Quartic, Gaussian). Voici une image avec les différents filtres activés.
<img src="https://www.fevrierdorian.com/blog/public/billets/sampling/mentalRayFilters001.png" alt="mentalRayFilters001.png" style="display:block; margin:0 auto;" title="mentalRayFilters001.png, janv. 2010" height="495" width="640" /></p>
<p>On remarque les similitudes entre Quadratic, Quartic et Gaussian. Ils ont aussi cette tendance à finir en "gris" (l'effet "jeux vidéo"). Comparé au filtre Elliptique qui va beaucoup plus loin, et beaucoup plus précis. Après, ce n'est peut être pas le plus joli esthétiquement parlant mais c'est un autre débat. Il peut vraiment servir dans certains cas et le fait de savoir qu'il existe pourra vous aider.</p>
<h5>A l'attaque de mental ray, le vrai, pas l'autre! <a name="attack_mental_ray"></a></h5>
<p>Jusqu'à présent, tout ce qu'on a pu voir était "Maya thinked" et, comme tout ce qui est "Maya thinked", tout est caché pour pas traumatiser l'artiste en pleine folie créatrice... Nous, techniciens de base, on n'est pas trop susceptible vis-avis de ce genre de chose (si ont pouvais (re)faire de la 3D en console, on s'en plaindrait presque pas :baffed: ) et ce qui nous intéresse ici c'est justement de comprendre ce qui ce passe... :hehe:</p>
<h4>Les filtres mental ray <a name="les_filtres_mental_ray"></a></h4>
<p>Mental ray dispose, par défaut, de deux filtres de texture.</p>
<h5>Le filtrage Pyramidale <a name="le_filtrage_pyramidale"></a></h5>
<p>Je vais être franc, je n'ai jamais réussi à rendre de manière identique ce que me donne ce filtres de texture avec des rendus de filtre de type Maya (mipmap, quadratic, etc...). Je me demande si c'est possible en fait. ces derniers ont l'air de fonctionner dans mental ray comme avec Maya Software et donnent des résultats identiques. Je soupçonne que "mental ray for Maya" ait l'équivalent de ses filtres codé dans le plugins mais inutilisable en temps que node indépendant.</p>
<p>Pour revenir au filtre pyramidale, j'ai beaucoup de mal à comprendre la documentation (que je trouve presque contradictoire).</p>
<p>Je vous laisse juger:</p>
<p><a href="http://download.autodesk.com/us/maya/2010help/mr/manual/node23.html" hreflang="en">http://download.autodesk.com/us/maya/2010help/mr/manual/node23.html</a> << Doc mental ray</p>
<p><a href="http://download.autodesk.com/us/maya/2010help/Nodes/mentalrayTexture.html" hreflang="en">http://download.autodesk.com/us/maya/2010help/Nodes/mentalrayTexture.html</a> << Doc du node Maya</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/mentalrayTextureSetup001.png" alt="mentalrayTextureSetup001.png" style="display:block; margin:0 auto;" title="mentalrayTextureSetup001.png, janv. 2010" height="269" width="420" /></p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/mentalrayTexturePanel001.png" alt="mentalrayTexturePanel001.png" style="display:block; margin:0 auto;" title="mentalrayTexturePanel001.png, janv. 2010" height="294" width="428" /></p>
<p>Si je devais résumé de ce que j'en comprend, c'est que:</p>
<ul>
<li>Si votre map est une texture "normal" (non .map), il converti la texture en map pyramidale (tout ça dans la mémoire, ce qui nécessite environs 30% de mémoire supplémentaire) avant d'y utiliser sont filtre mipmap (pour determiner la couleur de chaque pixel).</li>
<li>Si votre map est déja "memory mapped", il ne la convertie pas et utilise directement le filtre mipmap.</li>
</ul>
<p>Si c'est réellement ça, c'est assez mal énoncé... :zinzin:</p>
<p>Concernant la valeur du "filter size" du node mentalrayTexture (on va faire simple ce coup ci), c'est exactement le même principe que la valeur du filter du node de file.
<img src="https://www.fevrierdorian.com/blog/public/billets/sampling/mentalrayTextureFilter001.png" alt="mentalrayTextureFilter001.png" style="display:block; margin:0 auto;" title="mentalrayTextureFilter001.png, janv. 2010" height="480" width="640" />
D'après mes tests, il me semble que cette méthode offre la "courbe de changement" la plus douce.</p>
<p>En effet:</p>
<p>Maya filter Box, 0.5:
<img src="https://www.fevrierdorian.com/blog/public/billets/sampling/testFiltersMentalray/mentalRayFilterCurve001.png" alt="mentalRayFilterCurve001.png" style="display:block; margin:0 auto;" title="mentalRayFilterCurve001.png, janv. 2010" height="480" width="640" />
Maya filter Quadratic 0.5:
<img src="https://www.fevrierdorian.com/blog/public/billets/sampling/testFiltersMentalray/mentalRayFilterCurve003.png" alt="mentalRayFilterCurve003.png" style="display:block; margin:0 auto;" title="mentalRayFilterCurve003.png, janv. 2010" height="480" width="640" />
Maya filter Quartic 0.5:
<img src="https://www.fevrierdorian.com/blog/public/billets/sampling/testFiltersMentalray/mentalRayFilterCurve004.png" alt="mentalRayFilterCurve004.png" style="display:block; margin:0 auto;" title="mentalRayFilterCurve004.png, janv. 2010" height="480" width="640" />
Maya filter Gaussian 0.5:
<img src="https://www.fevrierdorian.com/blog/public/billets/sampling/testFiltersMentalray/mentalRayFilterCurve005.png" alt="mentalRayFilterCurve005.png" style="display:block; margin:0 auto;" title="mentalRayFilterCurve005.png, janv. 2010" height="480" width="640" />
Quadratic, Quartic et Gaussian se ressemble énormément... Et même Box en fait... Ormis la précision, la "courbe de changement" est identique...</p>
<p>Maya filter Mipmap 0.5:
<img src="https://www.fevrierdorian.com/blog/public/billets/sampling/testFiltersMentalray/mentalRayFilterCurve002.png" alt="mentalRayFilterCurve002.png" style="display:block; margin:0 auto;" title="mentalRayFilterCurve002.png, janv. 2010" height="480" width="640" />
Filtre Pyramidale 1.0 (mentalrayTexture):
<img src="https://www.fevrierdorian.com/blog/public/billets/sampling/testFiltersMentalray/mentalRayFilterCurve006.png" alt="mentalRayFilterCurve006.png" style="display:block; margin:0 auto;" title="mentalRayFilterCurve006.png, janv. 2010" height="480" width="640" />
Mipmap (de Maya) et le filtre (Pyramidale de la mentalrayTexture) se ressemble beaucoup mais je n'ai pas réussi à trouver un bon rapport pour les faire coïncider... (Si quelqu'un à déjà réussi, je serai ravis qu'il me fasse partager sa trouvaille).</p>
<p>Je pense que nous avons fait le tour du filtre pyramidale de mental ray, passons au suivant! :sourit:</p>
<h5>Le filtre Elliptique (Le Retour!) <a name="le_filtrage_elliptique_le_retour"></a></h5>
<p>Ici nous allons voir "comment que c'est qu'on faisait avant que le bien aimé Autodesk ne nous fasse une checkbox: Elliptical Filtering"... :enerve:</p>
<p>Nous avons vu comment faire "simple-mais-on-comprend-rien" (<a href="https://www.fevrierdorian.com/blog/post/2010/01/30/Les-maps-mental-ray-%28part-2.2%29%3A-Le-debug#filtre_elliptic">Plus haut</a>). Maintenant nous allons voir comment faire "compliqué-et-ptete-que-si-t'est-pas-trop-con-tu-va-capter-un-truc" (Avant de venir spammer ma boite mail que je suis un sale petit branleur médisant, sachez que je n'ai pas réellement compris comment il fonctionnait, donc "ironie inside" :hehe: ).</p>
<p>Voici comment "monter" notre shader:</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/map_debug015.png" alt="map_debug015.png" style="display:block; margin:0 auto;" title="map_debug015.png, janv. 2010" /></p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/map_debug014.png" alt="map_debug014.png" style="display:block; margin:0 auto;" title="map_debug014.png, janv. 2010" height="285" width="419" /></p>
<p>Notez le coté indigeste du truc! ^^ (Et aussi les attributs qui étaient caché par Maya et ajoutable via un "addAttr", cf <a href="https://www.fevrierdorian.com/blog/post/2010/01/30/Les-maps-mental-ray-%28part-2.2%29%3A-Le-debug#filtre_elliptic">plus haut</a>).</p>
<p>La doc est ici:</p>
<p><a href="http://download.autodesk.com/us/maya/2010help/mr/manual/node24.html" hreflang="en">http://download.autodesk.com/us/maya/2010help/mr/manual/node24.html</a> << Doc mental ray</p>
<p><a href="http://download.autodesk.com/us/maya/2010help/mr/shaders/node6.html#mi_shader__mib_texture_filter_lookup" hreflang="en">http://download.autodesk.com/us/maya/2010help/mr/shaders/node6.html#mi_shader__mib_texture_filter_lookup</a> << Doc du node Maya</p>
<p>Et maintenant, l'explication. Accrochez vous car:</p>
<ul>
<li>D'une je ne suis pas sûr de moi</li>
<li>De deux c'est assez complexe à imaginer...</li>
</ul>
<p>J'ai donc fais quelques shema pour tenter d'expliquer tout ça:</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/schemaExplicationFilters/shemaProjection01_normal.png" alt="shemaProjection01_normal.png" style="display:block; margin:0 auto;" title="shemaProjection01_normal.png, janv. 2010" height="480" width="640" /></p>
<p>Le framebuffer est une zone mémoire ou sont stocké les couleurs (RVBA) des pixels à la queue leu leu <a href="http://tony-mena.chez-alice.fr/a-la-queue-leu-leu.jpg">tout le monde s'éclaaaaate!...</a>. Ici, nous nous concentrons sur les méthodes utilisés pour déterminer la couleur d'un seul pixel (suivant les filtres utilisés).</p>
<p>Pour vous faire une idée simple, on a un plan avec un material surface shader avec une texture dessus.</p>
<h5>Cas de filter sur Off</h5>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/schemaExplicationFilters/shemaProjection01_filterOff.png" alt="shemaProjection01_filterOff.png" style="display:block; margin:0 auto;" title="shemaProjection01_filterOff.png, janv. 2010" height="480" width="640" /></p>
<p>En désactivant le filter, ce seront les samples "classiques" qui détermineront la couleur du pixel.</p>
<p>C'est un petit peut plus complexe que ça mais dans l'idée:</p>
<ul>
<li>Le moteur lance des samples depuis la camera dans le pixel.</li>
<li>Ces samples se "cognent" à un pixel d'une texture (texel).</li>
<li>Chaque sample renvoit la couleur de se texel au moteur.</li>
<li>Le moteur fait la moyenne des couleurs des samples en fonction du filtre de rendu des samples utilisés (Pour simplifier l'explication, on prend le cas d'un filtre de rendu de type "box" à 1x1 qui fait, pour chaque pixel, la moyenne de la couleur des samples).</li>
<li>La valeur RVBA de la couleur résultante est placé dans le pixel du framebuffer.</li>
<li>On passe au pixel suivant.</li>
</ul>
<p>Le problème de cette méthode (nous l'avons vue dans le <a href="https://www.fevrierdorian.com/blog/post/2009/12/24/Les-maps-mental-ray-%28part-2.1%29%3A-Le-debug">billet précédent</a>) est qu'elle créé beaucoups d'aliasing et est donc très sensible au mouvement.</p>
<p>Ce n'est pas mon habitude mais je trouve que ce shema est très parlant. Il est tiré du livre "mental ray Handbooks Vol. 1 : Rendering with mental ray" (<a href="http://www.amazon.com/Rendering-mental-ray%C2%AE-Handbooks/dp/3211228756" hreflang="en">lien Amazon</a>):</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/texture_sampling_locationOff.jpg" alt="texture_sampling_locationOff.jpg" style="display:block; margin:0 auto;" title="texture_sampling_locationOff.jpg, janv. 2010" height="600" width="600" /></p>
<p>Nous voyons que les informations récupérées sont indépendantes de la distance (la camera étant supposé être situé en bas du schéma) ce qui fait qu'au moindre mouvement, les informations récupérées sont totalement différentes.</p>
<h5>Cas de filter sur mipmap (Box, Mipmap, Quadratic, Quartic, Gaussian)</h5>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/schemaExplicationFilters/shemaProjection01_filterMipmap.png" alt="shemaProjection01_filterMipmap.png" style="display:block; margin:0 auto;" title="shemaProjection01_filterMipmap.png, janv. 2010" height="480" width="640" /></p>
<p>Comme expliqué dans le dessin, l'idée est que le moteur va descende dans les niveaux de la mipmap jusqu'à avoir un texel suffisamment grand pour englober toute le pixel. Il suffit donc de récupérer la couleur de se textel.</p>
<p>Voici l'idée (Ici un pixel qui cible un plan texturé):</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/schemaExplicationFilters/projectionMipmap01.png" alt="projectionMipmap01.png" style="display:block; margin:0 auto;" title="projectionMipmap01.png, janv. 2010" height="413" width="386" /></p>
<p style="font-style:italic; text-align:center;">Non</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/schemaExplicationFilters/projectionMipmap02.png" alt="projectionMipmap02.png" style="display:block; margin:0 auto;" title="projectionMipmap02.png, janv. 2010" height="413" width="386" /></p>
<p style="font-style:italic; text-align:center;">Non</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/schemaExplicationFilters/projectionMipmap03.png" alt="projectionMipmap03.png" style="display:block; margin:0 auto;" title="projectionMipmap03.png, janv. 2010" height="413" width="386" /></p>
<p style="font-style:italic; text-align:center;">Non</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/schemaExplicationFilters/projectionMipmap04.png" alt="projectionMipmap04.png" style="display:block; margin:0 auto;" title="projectionMipmap04.png, janv. 2010" height="413" width="386" /></p>
<p style="font-style:italic; text-align:center;">Non</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/schemaExplicationFilters/projectionMipmap05.png" alt="projectionMipmap05.png" style="display:block; margin:0 auto;" title="projectionMipmap05.png, janv. 2010" height="413" width="386" /></p>
<p style="font-style:italic; text-align:center;">Non</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/schemaExplicationFilters/projectionMipmap06.png" alt="projectionMipmap06.png" style="display:block; margin:0 auto;" title="projectionMipmap06.png, janv. 2010" height="413" width="386" /></p>
<p style="font-style:italic; text-align:center;">Ok! :banaeyouhou: </p>
<p>Et le schema de ce qui est récupéré dans le pixel:</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/texture_sampling_locationMipmap.jpg" alt="texture_sampling_locationMipmap.jpg" style="display:block; margin:0 auto;" title="texture_sampling_locationMipmap.jpg, janv. 2010" height="554" width="600" /></p>
<p>Ici, plus les points sont éloignés, plus les zones récupérées pour l'approximation sont grandes.</p>
<h5>Optimisation et explications plus précises <a name="optimisation_et_explications_plus_precises"></a></h5>
<p>Bon, dans les faits c'est très couteux de faire ça. Les gars de mental image, plutot que de calculer à chaque fois si un seul texel rentre dans le pixel, ont décidé de faire "moins complexe" (uniquement en terme de calcul parce que j'ai mis un peu de temps avant de capter ^^).</p>
<p>En gros, l'idée est de calculer un "facteur de compression" qui servira "d'index" pour se déplacer entre les différents niveaux de la mipmap (1=niveau0, 0.5=niveau1, 0.25=niveau2, etc...). Pour calculer ce facteur, voici la méthode (accrochez vous, ça va aller très vite):</p>
<ul>
<li>Le pixel (du framebuffer) projette un rectangle sur la texture (pour alléger l'algo, il projette en fait un carré).</li>
<li>On récupère la taille (en texel) d'un des cotés du carré (qui a été projeté dans l'espace de la texture: UV)</li>
<li>On fait l'inverse de cette valeur (inv(x) = 1/x)</li>
</ul>
<p>Ça y est, nous avons notre facteur de compression :baffed: .</p>
<p>Pour comprendre un peu mieux "le coup de l'inverse", je vais prendre un exemple: Si notre carré projeté avait fait 4 pixels de coté, le facteur de compression aurait été 1/4, autrement dit, il aurait fallu déscendre de 4 niveaux pour récupérer la valeur du pixel.</p>
<p>Imaginez la mipmap comme un building: Tout en haut est la map la plus grande (le niveau0). Et plus on descend plus on avance dans les niveau des maps. Mais dans la mesure ou le facteur de compression est un chiffre à virgule, il se peut qu'il soit entre deux niveaux de la mipmap. Ni précisément sur l'un, ni précisément sur l'autre.</p>
<p>Si c'est le cas, le moteur récupère les deux texels (juste en haut et juste en bas). Ceux ci sont (saucisson haha trop bonne celle là! :hehe:), dans un premier temps, interpolés de manière bilinéaire (pas flouté, ce n'est pas pareille, nous le verrons <a href="https://www.fevrierdorian.com/blog/post/2010/01/30/Les-maps-mental-ray-%28part-2.2%29%3A-Le-debug#le_cas_du_filtrage_bilineaire">plus bas</a>). Les valeurs de couleurs du pixel de chaque niveau respectif sont ensuite interpolés de manière linéaire. (En gros de chez gros, il fait la moyenne. Encore une fois, <a href="http://download.autodesk.com/us/maya/2010help/mr/manual/node23.html">la doc est votre amis</a>).</p>
<p>Malgré le coté indigeste de mes explications <del>foireuses</del> modestes :baffed: , gardez mon exemple précédent à l'esprit: Grosso modo, il va chercher le texel de la taille de mon pixel.</p>
<p>Comme vous pouvez vous en douter, cette méthode à la fâcheuse tendance à "flouter rapidement" (voir <a href="https://www.fevrierdorian.com/blog/post/2010/01/30/Les-maps-mental-ray-%28part-2.2%29%3A-Le-debug#arf_on_voit_la_jonction">plus haut</a>). Imaginez le cas d'un plan quasi-horizontal par rapport à la caméra (comme le schéma mais en plus prononcé). La distance physique (comprenez "dans l'espace 3D"), sur le plan, qu'il peut y avoir entre le bas du pixel et le haut peut être importante et le moteur doit descendre "profondément" dans la mipmap pour avoir un texel qui recouvre tout le pixel. C'est ce qui nous donne des pixels complètement gris dans le cas d'un damier noir et blanc répétitif. On peut cepandant faire varier la taille du filter pour tenter de grappiller un peu (pas trop sinon c'est l'aliasing assuré). Cette technique est surement le meilleur rapport qualité/vitesse.</p>
<p>Il y a un exemple que je trouve très parlant dans <a href="http://download.autodesk.com/us/maya/2010help/mr/manual/node23.html">la doc officiel</a>:</p>
<blockquote><p>If the pixel has a projected size of four texels in texture space, then one texel is compressed to 1/4 in the focal plane.</p></blockquote>
<p>Comprenez: Si un pixel (framebuffer) à une taille projeté (sur le plan) de quatre texels, et bien un texel est "compressé à 1/4" dans ce pixel(et il faudra descendre de 4 niveau dans la mipmap pour obtenir sa couleur).</p>
<h5>Cas de filter elliptique</h5>
<p>Pour le filtre elliptic, je vais devoir passer à un schema 3D:</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/schemaExplicationFilters/shemaProjection01_filterElliptic.png" alt="shemaProjection01_filterElliptic.png" style="display:block; margin:0 auto;" title="shemaProjection01_filterElliptic.png, janv. 2010" height="480" width="640" /></p>
<p>Soyez indulgent, ce n'est pas facile de représenter ça. Ormis le gros cercle blanc dont je vais expliquer la présence, nous avons tout les éléments déja présents dans les schemas 2D:</p>
<ul>
<li>Le framebuffer (en rouge et la plaque transparente)</li>
<li>Le plan et sa texture</li>
<li>Les rayons de projection (en bleu)</li>
</ul>
<p>Une fois encore, n'oubliez pas l'echelle (même si elle n'est pas bien retranscrite sur mon schéma, c'est justment pour ça que je me permet de faire un rappel): On cherche à savoir comment est calculé un pixel. Dans un cas plus "réel", la camera serait beaucoup plus loin, et le plan et sa texture aussi).</p>
<p>Alors, comment ça marche. :sourit:</p>
<p>En fait, un cercle ("ellipse" serait plus aproprié) est projeté dans le pixel du framebuffer:</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/schemaExplicationFilters/shemaProjection02_filterElliptic.png" alt="shemaProjection02_filterElliptic.png" style="display:block; margin:0 auto;" title="shemaProjection02_filterElliptic.png, janv. 2010" height="480" width="640" /></p>
<p>Une fois ce cercle projeté:</p>
<ul>
<li>On mesure son rayon minimum (minor radius) dans "l'espace 3D" (ici, le rayon minimum sera quasiment horizontal).</li>
<li>On compte le nombre de texel que traverse le minor radius</li>
<li>Si celui ci est plus élevé que la valeur de maxminor (Anti-aliasing Level dans <a href="https://www.fevrierdorian.com/blog/post/2010/01/30/Les-maps-mental-ray-%28part-2.2%29%3A-Le-debug#filtre_elliptic">l'UI Maya thinked</a>, 8 par défaut), on "avance" d'un niveau dans la mipmap puis on recommence jusqu'à ce que ce soit le cas.</li>
</ul>
<p>Si vous avez bien compris, vous devriez être en mesure de comprendre pourquoi, ducoup, la coupure est aussi "net" entre les différents niveaux de la mipmap avec le filtre elliptic.
<img src="https://www.fevrierdorian.com/blog/public/billets/sampling/map_debug018.png" alt="map_debug018.png" style="display:block; margin:0 auto;" title="map_debug018.png, janv. 2010" height="480" width="640" />
Vous comprendrez aussi le dernier schema:</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/texture_sampling_locationElliptical.jpg" alt="texture_sampling_locationElliptical.jpg" style="display:block; margin:0 auto;" title="texture_sampling_locationElliptical.jpg, janv. 2010" height="600" width="585" /></p>
<p>Nous avons fini pour l'explication des différents filtres mental ray. (ouf)</p>
<p>N'hésitez pas à laisser un commentaire si vous ne comprennez pas des choses, si je n'ai pas été assez clair quelque part ou si, tout simplement, je me suis planté... :sourit:</p>
<p>A très bientôt pour la dernière partie qui expliquera comment fabriquer la map de debug utilisé durant ses exercices.</p>
<p>Dorian</p>Les maps mental ray (part 2.1): Le debugurn:md5:407bed1b8bbc5e815082bc9b8bacc1f12009-12-26T23:48:00+01:002013-07-26T22:35:34+02:00NarannInfographie 3D - Boulot3ddebugfiltrefrmapmappage en memoiremayamayatomrmental raymipmaprendu<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/sampling_002_th.png" alt="sampling_002_th.png" style="float:left; margin: 0 1em 1em 0;" title="sampling_002_th.png, janv. 2010" height="150" width="150" /> Cette seconde partie se décompose en deux sous parties. Celle ci est la première: Un rappel afin de bien comprendre comment fonctionne le sampling et les mipmap de manière général. Il n'est pas indispensable d'avoir lu mes billets précédents (<a href="https://www.fevrierdorian.com/blog/post/2009/01/14/Le-mappage-en-m%C3%A9moire-des-textures-dans-Mental-Ray-expliqu%C3%A9-%28Memory-mapped-textures%29.">traduction de la doc</a> et <a href="https://www.fevrierdorian.com/blog/post/2009/12/13/Les-maps-mental-ray-%28part-1%29%3A-Pratique">pratique</a>). Cependant, si vous êtes 100% débutant avec les maps mental ray, je vous y invite fortement :sourit: . A la fin de se billet, vous aurez un idée plus précise de comment Maya détermine les couleurs de ses pixels et comprendrez l'intérêt d'utiliser des map "pyramidales" (mipmap).</p> <h5>Sommaire:</h5>
<ul>
<li><a href="https://www.fevrierdorian.com/blog/post/2009/12/24/Les-maps-mental-ray-%28part-2.1%29%3A-Le-debug#les_maps_mental_ray">Les maps mental ray</a></li>
<li><a href="https://www.fevrierdorian.com/blog/post/2009/12/24/Les-maps-mental-ray-%28part-2.1%29%3A-Le-debug#soucis_de_sampling">Soucis de sampling</a></li>
<li><a href="https://www.fevrierdorian.com/blog/post/2009/12/24/Les-maps-mental-ray-%28part-2.1%29%3A-Le-debug#des_techniques_de_jeux_video">Des techniques de jeux vidéo</a></li>
<li><a href="https://www.fevrierdorian.com/blog/post/2009/12/24/Les-maps-mental-ray-%28part-2.1%29%3A-Le-debug#le_mipmaping">Le mipmaping</a></li>
<li><a href="https://www.fevrierdorian.com/blog/post/2009/12/24/Les-maps-mental-ray-%28part-2.1%29%3A-Le-debug#le_choix">Le choix</a></li>
<li><a href="https://www.fevrierdorian.com/blog/post/2009/12/24/Les-maps-mental-ray-%28part-2.1%29%3A-Le-debug#et_maya">Et Maya</a></li>
</ul>
<h5>Les maps mental ray <a name="les_maps_mental_ray"></a></h5>
<p>Comme vous le savez, la raison d'être d'une .map de mental ray est d'être lu directement depuis le disque, sans avoir à être chargé dans la mémoire. cette méthode permet d'une part de libérer de la mémoire et d'autre part, d'obtenir des images de taille quasi illimitée.</p>
<center>:sauteJoie:</center>
<h5>Soucis de sampling <a name="soucis_de_sampling"></a></h5>
<p>Seulement voila, si les map mental ray nous libèrent de la contrainte de la taille, utiliser de grosses maps pose un autre problème:</p>
<p>Dans le cas où vous voulez afficher une texture qui est en très haute résolution sur une petite surface (dans l'écran), vous vous retrouvez avec un grand nombre d'information possible par pixel et mental ray, suivant votre sampling, va devoir faire un choix. Si votre sampling est 0-2, et que votre texture est très contrasté et/ou granuleuse, il attendra sa valeur maximum ("2") soit 16 rayons lancés par pixel (ce qui est déjà énorme). Si la résolution de la texture est un peu trop élevé et contrasté, cela peut se révéler insuffisant.</p>
<p>Je pense que des images parlent d'elles même:</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/sampling_001.png" alt="sampling_001.png" style="display:block; margin:0 auto;" title="sampling_001.png, janv. 2010" height="275" width="275" /></p>
<ul>
<li>Les barres rouges sont les limites entre chaque pixel</li>
<li>Les points rouges sont les rayons lancé dans le pixel (samples)</li>
<li>Et derrière, un plan avec notre texture</li>
</ul>
<p>Afin de bien illustrer mes propos, j'ai choisi d'afficher les pixel de la texture "sans filtre". Maya peut (et le fait par défaut) appliquer un filtre sur chacune des textures mais ça ne change pas grand chose sachant que la texture est en haute résolution, les variations de couleurs au sein même du pixel, restent importantes (on y reviendra, l'idée ici est de montrer ce qui ce passe :sourit: ).</p>
<p>Il est important de bien considérer l'échelle: Un carré = Un pixel. Donc, même si la résolution de ma texture est (volontairement) faible (environs 32*20), le nombre de couleur présent dans le pixel est important (environ 20*20 pixels) :zinzin: . Oui, je sais je ne l'explique pas très bien mais en gros, j'essaie de dire qu'il y a pleins de couleurs dans un notre seul pixel et que mental ray va "piocher" parmi ces valeurs.</p>
<p>Si on prend la valeur de chaque rayon, nous voyons que mental ray récupère ça:</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/sampling_002.png" alt="sampling_002.png" style="display:block; margin:0 auto;" title="sampling_002.png, janv. 2010" height="275" width="275" /></p>
<p>C'est à partir de ses 16 couleurs et de votre filtre que mental ray va évaluer la couleur total du pixel. Dans le cas d'un filtre de type "box" à 1 pixel il calcul la moyenne des couleur de chaque pixel, indépendamment des pixels aux alentours.</p>
<p>Bon, je comprend qu'on ne puisse pas directement voir ou se situe le problème (ormis une image granuleuse mais sur une image fixe on s'en rend pas compte).</p>
<p>Là ou c'est vraiment problématique c'est dans le cas d'une animation, démonstration:</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/sampling_003.png" alt="sampling_003.png" style="display:block; margin:0 auto;" title="sampling_003.png, janv. 2010" height="275" width="275" /></p>
<p>Ici, j'ai déplacé très (très) légèrement l'objet (rappeler vous de l'échelle: Nous regardons ce qui ce passe dans un seul pixel). Voici le résultat pour chaque sample:</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/sampling_004.png" alt="sampling_004.png" style="display:block; margin:0 auto;" title="sampling_004.png, janv. 2010" height="275" width="275" /></p>
<p>Si nous comparons avec l'image précédente, nous voyons que, bien que nous ayons bougé le plan d'un chouilla, les valeurs récupéré sont assez différentes de l'image du dessus. Le pixel qui sera calculé ici sera donc teinté différemment de l'ancien.</p>
<p>Si on réfléchie au fait que le phénomène que l'on vient d'observer s'applique à chaque pixel de l'image (et pour chaque image de l'animation), vous l'aurez compris, ça "flick" ou "granule" dès qu'on bouge un peu... :gne2:</p>
<h5>Des techniques de jeux vidéo <a name="des_techniques_de_jeux_video"></a></h5>
<p>En jeux vidéo le problème est encore plus présent dans la mesure où, dans la plupart des cas, un pixel n'est calculé qu'une fois (oui je sais, depuis quelques années on peut sampler mais malgrès les avancés impressionnantes dans le sampling temps réel, ce procédé reste assez lourd et, de toute façon, est beaucoup moins précis qu'un sampling de précal).</p>
<p>Voici une image (méchamment prise de <a href="http://www.tomshardware.com/reviews/ati,819-2.html" hreflang="en">tom's hardware guide</a>) qui je pense, montre bien le problème (ne regardez que l'image de gauche):</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/mipmapping-egz_1_.png" alt="mipmapping-egz_1_.png" style="display:block; margin:0 auto;" title="mipmapping-egz_1_.png, janv. 2010" height="317" width="540" /></p>
<p>Chaque pixel renvoit la couleur exact qui est dans son axe. Maintenant regardez celle de droite et hop je rebondis vers ce sur quoi je voulais venir: Le mipmap! :hehe:</p>
<h5>Le mipmaping <a name="le_mipmaping"></a></h5>
<p>Le principe est le suivant: Puisqu'il y a trop d'informations dans un pixel, nous allons flouter la map (en fait on lui diminue ça taille) de façon à ce que, quel que soit la couleur que on décide d'afficher, elle sera "dans la moyenne" des pixels voisins.</p>
<p>C'est exactement le principe d'une réduction: Vous récupérer un certain nombre de pixel que vous groupez entre eux pour en obtenir un nouveau qui est la "moyenne" (suivant l'algorithme utilisé) de couleurs des pixels qu'il est sensé contenir.</p>
<p>Pour le cas d'une mipmap, une texture contient plusieurs textures, la siennes (taille normal) plus des version redimensionné (divisé par deux à chaque itérations).</p>
<p>Concrètement ça donne ça:</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/pic03_1_.jpg" alt="pic03_1_.jpg" style="display:block; margin:0 auto;" title="pic03_1_.jpg, janv. 2010" height="375" width="553" /></p>
<p>Le tout empaqueté dans un seul fichier: le .map.</p>
<p>Dans notre cas:</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/sampling_005.png" alt="sampling_005.png" style="display:block; margin:0 auto;" title="sampling_005.png, janv. 2010" height="146" width="200" /></p>
<center>La texture de base, haute def</center>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/sampling_006.png" alt="sampling_006.png" style="display:block; margin:0 auto;" title="sampling_006.png, janv. 2010" height="160" width="200" /></p>
<p>Voila, vous avez ce que mental ray voit! Si on reprend le cas de tout à l'heure et qu'on lance 16 pixels sur la seconde map, même si on la bouge, on aura un résultat quasi identique.</p>
<h5>Pas si extra ordinaire que ça... <a name="pas_si_extra_ordinaire_que_ca"></a></h5>
<p>Bon, ça vous le saviez si vous avez lu mes billets précédents sur les .map:</p>
<ul>
<li><a href="https://www.fevrierdorian.com/blog/post/2009/01/14/Le-mappage-en-m%C3%A9moire-des-textures-dans-Mental-Ray-expliqu%C3%A9-%28Memory-mapped-textures%29.">Le mappage en mémoire des textures dans Mental Ray expliqué (Memory-mapped textures)</a></li>
<li><a href="https://www.fevrierdorian.com/blog/post/2009/12/13/Les-maps-mental-ray-%28part-1%29%3A-Pratique">Les maps mental ray (part 1): Pratique</a></li>
</ul>
<p>Mais il y a une chose que je n'ai pas abordé. :siffle:</p>
<h5>Le choix <a name="le_choix"></a></h5>
<p>Maintenant, le problème c'est le choix. Mental ray connait la coordonné UV de l'information de couleur qu'il cherche à obtenir. Le problème est de savoir sur quel résolution (ou map) se caler pour récupérer le pixel... Le niveau 0 (taille max), 1, 2, 3? etc...</p>
<p>Laissez moi vous montrer une image et vous expliquer:</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/pic02_1_.jpg" alt="pic02_1_.jpg" style="display:block; margin:0 auto;" title="pic02_1_.jpg, janv. 2010" height="325" width="425" /></p>
<p>Ici, nous voyons les différents niveaux, chacun affiché par une couleur différente:</p>
<ul>
<li>Le niveau 0 est de couleur normal</li>
<li>Le niveau 1 est rouge</li>
<li>Le niveau 2 est vert</li>
<li>Le niveau 3 est bleu</li>
<li>etc...</li>
</ul>
<p>Ceci permet d'avoir un retour "visuel" de quel niveau le moteur choisit d'utiliser.</p>
<p>Le filtrage est de type linéaire. Avec d'autres type de filtrage vous aurez un dégradé plus atténué (mais qui demande plus de calcul):</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/sampling/pic11_1_.jpg" alt="pic11_1_.jpg" style="display:block; margin:0 auto;" title="pic11_1_.jpg, janv. 2010" height="317" width="540" /></p>
<h5>Et Maya <a name="et_maya"></a></h5>
<p>Et bien c'est exactement comme ça que nous allons savoir comment Maya se comporte avec les .map que nous lui donnons. :hehe:</p>
<p>Nous allons utilisé une map spéciale (sorte de "map de debug") qui nous affichera plus ou moins ce que vous avez pu voir sur les images de jeux vidéo.</p>
<p>Mais je n'en dis pas plus pour l'instant! Vous verrez ça dans la seconde partie!</p>
<p>Je pense que déjà, avec ça dans la tête vous avez une bonne base sur le fonctionnement des mipmaps.</p>
<p>N'hésitez pas à réagir si vous avez des questions/suggestions ou si je suis resté un peu trop flou sur certains points.</p>
<p>A très bientôt!</p>
<p>Dorian</p>
<center>:marioCours:</center>
<p>Liens intéressants:</p>
<ul>
<li><a href="http://www.tomshardware.com/reviews/ati,819-2.html" hreflang="en">http://www.tomshardware.com/reviews/ati,819-2.html</a></li>
<li><a href="http://www.tomshardware.com/reviews/ati,819-5.html" hreflang="en">http://www.tomshardware.com/reviews/ati,819-5.html</a></li>
<li><a href="http://www.impresszio.hu/szabolcs/MentalRay/MentalRaySampling.htm" hreflang="en">http://www.impresszio.hu/szabolcs/MentalRay/MentalRaySampling.htm</a></li>
</ul>Les maps mental ray (part 1): Pratiqueurn:md5:9097340c202dfe6b5d9ea0444e3dd3ab2009-12-13T14:21:00+01:002013-07-26T22:35:46+02:00NarannInfographie 3D - Boulot3dfrgobelinmapmappage en memoiremayamental raypyramidalerenduscript<p><img src="https://www.fevrierdorian.com/blog/public/billets/maps_mental_ray_part_1_Pratique/maps_mental_ray_part_1_Pratique_th.png" alt="maps_mental_ray_part_1_Pratique_th.png" style="float:left; margin: 0 1em 1em 0;" title="maps_mental_ray_part_1_Pratique_th.png, déc. 2009" height="150" width="150" />Ce billet est le premier d'un chapitre qui concerne les .map dans mental ray. Ici je vais expliquer les différentes méthodes pour en créer une. Il s'agit plus d'une introduction aux billets qui suivront où nous expliqueront exactement comment réagit Maya à l'utilisation des options de .map. Vous pouvez considérer ce tuto comme une solution clef en mains. Pour illustrer mes propos, j'ai décidé de racoler un peu en utilisant le modèle dont nous nous somme servi durant notre production de fin d'année 2007 (<a href="http://mauvais-role.com/" hreflang="fr">Mauvais Rôle</a>): Le gobelin. Le modèle ainsi que la texture ont été fait par <a href="http://www.linkedin.com/pub/j%C3%A9r%C3%A9mie-rousseau/5/434/77b" hreflang="en">Jérémie Rousseau</a>. :bravo:</p> <p>Avant de commencer, je vous invite fortement à lire <a href="https://www.fevrierdorian.com/blog/post/2009/01/14/Le-mappage-en-m%C3%A9moire-des-textures-dans-Mental-Ray-expliqu%C3%A9-%28Memory-mapped-textures%29." hreflang="fr">la partie "théorique"</a> sur le principe de memory-mapping (mappage en mémoire) des textures.</p>
<h4>Sommaire</h4>
<ul>
<li><a href="https://www.fevrierdorian.com/blog/post/2009/12/13/Les-maps-mental-ray-%28part-1%29%3A-Pratique#start">Start!</a></li>
<li><a href="https://www.fevrierdorian.com/blog/post/2009/12/13/Les-maps-mental-ray-%28part-1%29%3A-Pratique#la_methode_old_school">La méthode "Old school"</a></li>
<li><a href="https://www.fevrierdorian.com/blog/post/2009/12/13/Les-maps-mental-ray-%28part-1%29%3A-Pratique#la_methode_new_age">La méthode "New age"</a></li>
<li><a href="https://www.fevrierdorian.com/blog/post/2009/12/13/Les-maps-mental-ray-%28part-1%29%3A-Pratique#comparaison_des_deux_methodes">Comparaison des deux méthodes</a></li>
<li><a href="https://www.fevrierdorian.com/blog/post/2009/12/13/Les-maps-mental-ray-%28part-1%29%3A-Pratique#conclusion">Conclusion</a></li>
</ul>
<h4>Start! <a name="start"></a></h4>
<p>Voici notre texture:</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/maps_mental_ray_part_1_Pratique/gobelin_color_512.jpg" alt="gobelin_color_512.jpg" style="display:block; margin:0 auto;" title="gobelin_color_512.jpg, déc. 2009" height="512" width="512" /></p>
<p>Elle a fait 4096x4096. :sourit:</p>
<p>Il y a deux façons de travailler avec des .map dans Maya. Nous allons les voir l'une après l'autres puis nous comparerons leurs avantages/inconvénients.</p>
<p>Commençons par "l'ancienne".</p>
<h5>La méthode "Old school" <a name="la_methode_old_school"></a></h5>
<p>Pour convertir notre texture en .map nous utilisons le programme imf_copy placé dans:</p>
<pre class="bash bash">C:\Program Files\Autodesk\Maya2010\bin\imf_copy.exe</pre>
<p>Soit la commande (Pour les options, <a href="https://www.fevrierdorian.com/blog/post/2009/01/14/Le-mappage-en-m%C3%A9moire-des-textures-dans-Mental-Ray-expliqu%C3%A9-%28Memory-mapped-textures%29.#imf_copy_traduction">voir ici</a>):</p>
<pre class="bash bash">imf_copy <span style="color: #660033;">-p</span> <span style="color: #660033;">-r</span> <span style="color: #660033;">-v</span> gobelin_color.png gobelin_color.map</pre>
<p>Nous venons de créer une map pyramidale!</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/maps_mental_ray_part_1_Pratique/maps_mental_ray_part_1_Pratique_001.png" alt="maps_mental_ray_part_1_Pratique_001.png" style="display:block; margin:0 auto;" title="maps_mental_ray_part_1_Pratique_001.png, déc. 2009" height="59" width="511" /></p>
<p>Notez la taille de la .map: 87Mo.</p>
<p>Si nous l'avions généré sans l'option "-p" elle aurait fait 65Mo, la même taille que sa version bmp non compressé. (Logique vu qu'en format .map, tout est décompressé et écrit tel qu'elle serait lu dans la ram, une dernière fois: Lisez <a href="https://www.fevrierdorian.com/blog/post/2009/01/14/Le-mappage-en-m%C3%A9moire-des-textures-dans-Mental-Ray-expliqu%C3%A9-%28Memory-mapped-textures%29." hreflang="fr">la partie "théorique"</a>).</p>
<p>Comme je suis bon prince, je vous donne un petit script qui nous a beaucoup servit à l'époque pour convertir automatiquement nos images en .map (convertDirectoryToMap.bat) :joue:</p>
<pre class="bash bash"><span style="color: #000000; font-weight: bold;">for</span> <span style="color: #000000; font-weight: bold;">%%</span>f <span style="color: #000000; font-weight: bold;">in</span> <span style="color: #7a0874; font-weight: bold;">(</span><span style="color: #000000; font-weight: bold;">*</span>.jpg <span style="color: #000000; font-weight: bold;">*</span>.tif, <span style="color: #000000; font-weight: bold;">*</span>.tga,<span style="color: #000000; font-weight: bold;">*</span>.bmp, <span style="color: #000000; font-weight: bold;">*</span>.png<span style="color: #7a0874; font-weight: bold;">)</span> <span style="color: #000000; font-weight: bold;">do</span> imf_copy <span style="color: #660033;">-p</span> <span style="color: #660033;">-r</span> <span style="color: #660033;">-v</span> <span style="color: #ff0000;">"%%f"</span> <span style="color: #ff0000;">"%%~nf.map"</span></pre>
<p>(Un de ses quatre je ferais peut être un petit tuto Python pour convertir des textures en map en fonction de sa date)... :sourit:</p>
<p>Nous allons donc appliquer notre .map au modèle de <a href="http://www.linkedin.com/pub/j%C3%A9r%C3%A9mie-rousseau/5/434/77b" hreflang="en">Jérémie</a>:</p>
<p><a href="https://www.fevrierdorian.com/blog/public/billets/maps_mental_ray_part_1_Pratique/face_gobelin001.png" title="face_gobelin001.png"><img src="https://www.fevrierdorian.com/blog/public/billets/maps_mental_ray_part_1_Pratique/.face_gobelin001_m.jpg" alt="face_gobelin001.png" style="display:block; margin:0 auto;" title="face_gobelin001.png, déc. 2009" height="325" width="448" /></a></p>
<p style="font-style:italic; text-align:center;">PS: J'en profite pour regarder le modèle, il avait bien bossé dis donc! o_O</p>
<p>Hop hop quelques area lights, un lambert avec la map en color (on avait fait 4-5 maps à l'époque pour le SSS, bump etc... Mais là, on se concentre sur l'utilisation des .map ^^).</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/maps_mental_ray_part_1_Pratique/maps_mental_ray_part_1_Pratique_002.png" alt="maps_mental_ray_part_1_Pratique_002.png" style="display:block; margin:0 auto;" title="maps_mental_ray_part_1_Pratique_002.png, déc. 2009" height="342" width="473" /></p>
<p style="font-style:italic; text-align:center;">Rien de plus simple...</p>
<p>J'ajoute un peu de DOF, pour le fun!</p>
<p><a href="https://www.fevrierdorian.com/blog/public/billets/maps_mental_ray_part_1_Pratique/face_gobelin002dof.jpg" title="face_gobelin002dof.jpg"><img src="https://www.fevrierdorian.com/blog/public/billets/maps_mental_ray_part_1_Pratique/.face_gobelin002dof_m.jpg" alt="face_gobelin002dof.jpg" style="display:block; margin:0 auto;" title="face_gobelin002dof.jpg, déc. 2009" height="336" width="448" /></a></p>
<p style="font-style:italic; text-align:center;">Ça fait longtemps que j'ai pas fait un peu de rendu moi, ça me manquait! :banaeyouhou:</p>
<p>Comme dis dans <a href="https://www.fevrierdorian.com/blog/post/2009/01/14/Le-mappage-en-m%C3%A9moire-des-textures-dans-Mental-Ray-expliqu%C3%A9-%28Memory-mapped-textures%29." hreflang="fr">la partie "théorique"</a>, mental ray reconnait automatiquement les textures au format .map. Il va donc l'utiliser sans autres manipulations de votre part.</p>
<p>Nous avons fini pour la première méthode.</p>
<h5>La méthode "New age" <a name="la_methode_new_age"></a></h5>
<p>Depuis Maya 2008 (je crois...), on peut convertir les textures en .map "a la volé", au moment du rendu. Pour cela, rien de plus simple, on va dans:</p>
<pre class="bash bash">Windows -<span style="color: #000000; font-weight: bold;">></span> Settings<span style="color: #000000; font-weight: bold;">/</span>Preferences -<span style="color: #000000; font-weight: bold;">></span> Preferences</pre>
<p>Puis dans:</p>
<pre class="bash bash">Settings -<span style="color: #000000; font-weight: bold;">></span> Rendering</pre>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/maps_mental_ray_part_1_Pratique/maps_mental_ray_part_1_Pratique_003.png" alt="maps_mental_ray_part_1_Pratique_003.png" style="display:block; margin:0 auto;" title="maps_mental_ray_part_1_Pratique_003.png, déc. 2009" height="442" width="621" /></p>
<p>Ici, il faut cocher la case: "Use optimized textures (auto-conversion)".</p>
<p>Vous pouvez également choisir où vous souhaitez que les textures converties aillent ("Optimized textures location"):</p>
<ul>
<li>Soit dans le "sourceimages/cache" de votre projet maya</li>
<li>Soit dans un répertoire personnalisé. Notez que si vous choisissez "Custom Location" et que vous entrez "<scene>/map", les textures .map généré iront dans le répertoire de votre scène, dans un sous dossier "map". Le champ de saisi supporte également les variables d'environnement. Si par exemple, vous avez une variable d'environnement:</li>
</ul>
<pre class="bash bash"><span style="color: #007800;">$MYCACHE</span>=C:\mycache</pre>
<p>Et bien:</p>
<pre class="bash bash"><span style="color: #007800;">$MYCACHE</span><span style="color: #000000; font-weight: bold;">/<</span>scene<span style="color: #000000; font-weight: bold;">></span></pre>
<p>Vous créera un dossier du nom de votre scène dans votre répertoire de cache. Si le chemin entré n'existe pas, Maya en créé un automatiquement. (Copie de la doc :sourit: )</p>
<p>"Conversion Mode" peut prendre deux valeurs:</p>
<ul>
<li>Assigned textures only.</li>
<li>All textures.</li>
</ul>
<p>"Assigned textures only" peut vous permettre de gagner un peu de temps en ne convertissant uniquement les textures qui appartiennent à un shader assigné.</p>
<p>Si vous avez pleins de shaders mais que vous ne vous en servez que de deux ou trois, il vaut mieux laisser cette option.</p>
<p>Voila, j'active donc "Use optimized textures (auto-conversion)":</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/maps_mental_ray_part_1_Pratique/maps_mental_ray_part_1_Pratique_004.png" alt="maps_mental_ray_part_1_Pratique_004.png" style="display:block; margin:0 auto;" title="maps_mental_ray_part_1_Pratique_004.png, déc. 2009" height="93" width="420" /></p>
<p>Je met mon image originale dans le node de file:</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/maps_mental_ray_part_1_Pratique/maps_mental_ray_part_1_Pratique_005.png" alt="maps_mental_ray_part_1_Pratique_005.png" style="display:block; margin:0 auto;" title="maps_mental_ray_part_1_Pratique_005.png, déc. 2009" height="110" width="301" /></p>
<p>Je lance mon rendu puis je vais voir dans:</p>
<pre class="bash bash">Documents\maya\projects\default\sourceimages\cache</pre>
<p><img src="https://www.fevrierdorian.com/blog/public/billets/maps_mental_ray_part_1_Pratique/maps_mental_ray_part_1_Pratique_006.png" alt="maps_mental_ray_part_1_Pratique_006.png" style="display:block; margin:0 auto;" title="maps_mental_ray_part_1_Pratique_006.png, déc. 2009" height="147" width="487" />
On vois déja un premier défaut: Il faut faire attention à la nomenclature de ses textures. Si vous utilisez deux textures portant le même nom mais dans un dossier différent il génèrera l'une, ou l'autre (je ne sais pas trop comment il fait son choix). Méfiance donc... :redface:</p>
<h4>Comparaison des deux méthodes <a name="comparaison_des_deux_methodes"></a></h4>
<p>Maintenant que nous avons fait le tour de ses deux méthodes, je vous proprose de les comparer rapidement :hehe:</p>
<h5>La méthode "Old school"</h5>
<ul>
<li>Cette méthode offre l'avantage de "voir ce qu'on fait": Un fichier image, et son .map... Elle est plus "logique" en quelque sorte car "ce qu'on voit c'est ce qu'on lui donne".</li>
<li>Si vous êtes un peu scripteur, vous pouvez rapidement faire un système qui compare les dates des fichiers d'image original et régénère le .map. Le tout combiné avec un script de pre-render qui change les extensions des images si la version .map existe. (Refaire la méthode New Age en gros ^^ ) Sauf que vous contrôlez exactement ce qui ce passe au moment du rendu.</li>
<li>Si vous n'êtes pas scripteur cette méthode vous gonflera rapidement ^^.</li>
</ul>
<h5>La méthode "New age"</h5>
<ul>
<li>Le gros intérêt de cette méthode est que cela ne change rien à l'intérieur de vos scènes et vous évite d'avoir à jongler avec les extensions de fichier.</li>
<li>Tout est généré tous seul au moment du rendu. Les textures .map se mettent à jour toutes seules.</li>
<li>Cette technique semble assez pratique dans le cas ou vous travaillez en local.</li>
<li>En revanche, comme toute méthode dites "automatique", il est nécessaire de bien comprendre comment elle fonctionne si on souhaite l'intégrer à un pipeline. Mais c'est tout à fait possible.</li>
</ul>
<h4>Conclusion <a name="conclusion"></a></h4>
<p>En ce qui me concerne, j'ai un penchant pour la méthode "Old School". Surtout pour le coté "pipeline". La conversion des images en .map, combiné à un script pour les comparaisons de date, si fait régulièrement, n'est pas particulièrement dérangeant.</p>
<p>De plus, passer par une "génération de .map" permet de faire une étape (un breakpoint) dans le pipeline, ce qui peut être intéressant et diminue les risques de fausses manipulations. :youplaBoum:</p>
<p>Généraliser la technique "New age" à tout un pipeline peut être dangereux si un/des graphistes utilise des textures persos pour faire des tests d'uv par exemple, ou dans le cas d'un graphiste qui texture un personnage avec 36 versions d'une image. On peut vite se retrouver avec des gigas de .map inutiles... :baffed:</p>
<p>En revanche, je pense que c'est une très bonne idée d'utiliser cette technique sur certains postes de travail, en local (comprenez hors renderfarm/rendu/pipeline) peut faire gagner du temps (l'exemple de notre graphiste qui test ses textures).</p>
<p>De même, si vous travaillez chez vous, je vous conseille cette technique!</p>
<p>J'espère que ce "mini-tuto" Vous aura aidé un peu (notamment la seconde méthode qui n'est pas encore démocratisé).</p>
<p>Dans le prochain billet, nous utiliseront une map spécial (je l'appel la map de debug) et nous verrons comment réagit Maya avec une map pyramidale.</p>
<p>A bientôt!</p>Le mappage en mémoire des textures dans Mental Ray expliqué (Memory-mapped textures).urn:md5:a9ad63140fec02161a0a503754acb6c72009-11-27T23:22:00+01:002013-07-26T22:38:53+02:00NarannInfographie 3D - Boulot3dfrimf_copymapmappage en memoiremayamental raytexture<p><img src="https://www.fevrierdorian.com/blog/public/billets/memorymap/memorymapped_mentalray_doc.png" alt="memorymapped_mentalray_doc.png" style="float:left; margin: 0 1em 1em 0;" title="memorymapped_mentalray_doc.png, nov. 2009" height="150" width="150" />Bonjours à tous. Dans ce billet je vais vous parler d'une spécificité de mental ray à savoir le mappage en mémoire des textures (ou, en anglais, textures memory mapped). Nous parlerons du fonctionnement de ses maps ainsi que des différentes façons de les utiliser. Cette technique permet de ne pas mettre en mémoire les textures de vos scènes mais de les lires directement sur le disque dur. Permettant ainsi d'économiser de la RAM et de diminuer les limitations de taille de texture.</p> <h5>Sommaire</h5>
<ul>
<li><a href="https://www.fevrierdorian.com/blog/post/2009/01/14/Le-mappage-en-m%C3%A9moire-des-textures-dans-Mental-Ray-expliqu%C3%A9-%28Memory-mapped-textures%29.#memory_mapped_textures_traduction">Memory-Mapped Textures: Traduction de la documentation officiel</a></li>
<li><a href="https://www.fevrierdorian.com/blog/post/2009/01/14/Le-mappage-en-m%C3%A9moire-des-textures-dans-Mental-Ray-expliqu%C3%A9-%28Memory-mapped-textures%29.#mais_comment_quon_fait">Mais comment qu'on fait?</a></li>
<li><a href="https://www.fevrierdorian.com/blog/post/2009/01/14/Le-mappage-en-m%C3%A9moire-des-textures-dans-Mental-Ray-expliqu%C3%A9-%28Memory-mapped-textures%29.#imf_copy">imf_copy</a></li>
<li><a href="https://www.fevrierdorian.com/blog/post/2009/01/14/Le-mappage-en-m%C3%A9moire-des-textures-dans-Mental-Ray-expliqu%C3%A9-%28Memory-mapped-textures%29.#imf_copy_traduction">imf_copy: Traduction de la documentation officiel</a></li>
<li><a href="https://www.fevrierdorian.com/blog/post/2009/01/14/Le-mappage-en-m%C3%A9moire-des-textures-dans-Mental-Ray-expliqu%C3%A9-%28Memory-mapped-textures%29.#convertir_nos_textures_en_map">Convertir nos textures en .map</a></li>
<li><a href="https://www.fevrierdorian.com/blog/post/2009/01/14/Le-mappage-en-m%C3%A9moire-des-textures-dans-Mental-Ray-expliqu%C3%A9-%28Memory-mapped-textures%29.#suite">Suite?</a></li>
</ul>
<h5>Memory-Mapped Textures: Traduction de la documentation officiel <a name="memory_mapped_textures_traduction"></a></h5>
<p>Avant de commencer, je me suis "amusé" à traduire la documentation mental ray qui y fait référence...</p>
<blockquote><p>Memory-Mapped Textures</p>
<p>
Mental Ray supporte le mappage en mémoire des textures sur les systèmes UNIX et NT.</p>
<p>
Le mappage des textures consiste à ne pas charger la texture en mémoire mais à y accéder directement depuis le disque quand le shader en a besoin.</p>
<p>
Il n'y a pas d'options spéciales pour en profiter: Si une texture est "mappable en mémoire", mental ray la reconnaîtra et l'utilisera automatiquement.</p>
<p>
Seul les fichiers images peuvent être converti en textures "mappable en mémoire" (l'extension de base est .map. Cela dis, les fichiers "mappable en mémoire" sont reconnu même si ils ont une extension différente de .map). Voir la liste des "Output Shaders" (Ndt: dans la doc mental ray) pour une liste des formats de fichier supporté.</p>
<p>
Remarquez que le mappage en mémoire est basé sur le principe que les informations sur le disque ne demande pas de décodage ou de conversion, mais sont accessibles dans le format exact que mental ray utilise en interne durant le rendu.</p>
<p>
Normalement, mental ray essai de convertir automatiquement les fichiers images qu'il lit en son format d'image interne; Par exemple, si un fichier image est utilisé dans un shader, mental ray va silencieusement convertir les pixels de couleurs en valeur scalaire (0-1).</p>
<p>
Du coup, une grande quantité de données (pixel) est converti en un autres type de données (scalaire).</p>
<p>
Cela n'est pas le cas pour textures mappé en mémoire, et ce n'est pas le but. Cela s'applique également à l'ordre des octets (Ndt: Dernière phrase technique propre à l'organisation des octets dans la mémoire "Big et Little Endian", pour dire qu'une map converti sur une machine utilisant du big endian ne sera pas compatible avec une machine utilisant du little endian. Mais dans la mesure ou on travail pratiquement que sur station x86 et x64, on s'en fout).</p>
<p>
Le mappage en mémoire nécessite plusieurs étapes de préparation:</p>
<p>
- La texture doit être convertit au format .map en utilisant un utilitaire comme le imf_copy de mental image. Les chemins de fichier de la scène doit être changé pour aller chercher la nouvelle texture. Remarquez que mental ray reconnait les textures memory mapped mêmé si elles ont une extension différente de .map. Ceci peut être utile pour utiliser les anciens noms de fichiers images avec la "mauvaise" extension, et ce, afin d'éviter à ouvrir et modifier les chemin des fichiers images de la scène. (Ndt: Personnellement, je ne vous conseil pas cette technique)</p>
<p>
Lors de l'utilisation de imf_copy, l'option -p est fortement recommandé pour créer une texture en pyramide dans le fichier .map.</p>
<p>
- les textures mappé en mémoire sont automatiquement considéré comme étant en local par mental ray, comme si l'option "local" avait été utilisé dans le fichier scène. Cela signifie que si la scène est rendu sur plusieurs machine, chacune d'elle va essayer d'accéder au chemin de l'image donné au lieu de transférer la texture a travers le réseau, ce qui irait à l'encontre du but du mappage en mémoire des textures. Le chemin donné doit être valide sur toute les machine qui participe au rendu. Mental ray support également les textures mappé en "non local": La texture (mappé) est sur le serveur, mais récupérés à travers le réseau par les "esclaves", ce qui simplifie la distribution des scène (Ndt: En rendu) mais peu induire des surcharges réseau inacceptable. (Ndt: En gros, vu que mental ray fait des accès aussi fréquent que si la texture était en mémoire, il pas très conseillé de pointer vers des textures placé en réseau mais plutôt de les avoirs en local, sur chaque machine dédié au rendu. Pour avoir pratiqué le rendu "via le réseau", cela ne pose en fait pas trop de soucis si le réseau en un peu robuste et que le serveur est capable d'encaisser beaucoups d'entrées-sorties.)</p>
<p>
- La texture ne dois pas être sur la partition d'un disque utilisant un système de fichier de type <a href="http://fr.wikipedia.org/wiki/Network_file_system" hreflang="fr">NFS</a> (en réseau). Bien que cela évite que les textures doivent exister sur toute les machines, les transferts réseaux réduisent l'efficacité et peuvent facilement rendre le mappage en mémoire plus lent que l'utilisation de textures "tel quel".</p>
<p>
- Le mappage en mémoire fonctionne mieux si il s'agit de textures très grandes qui contiennent beaucoup de pixels non utilisés car le fichier de la texture n'est jamais chargé en entier dans la mémoire.</p>
<p>
- Une texture mappé en mémoire doit être créé sur une machine avec le même "byte order" que sur la machine qui sera utilisé, où il sera utilisé. Mental ray ne "memorymapera" pas les textures utilisant un byte order incompatible, au lieu de ça, il lira la totalité de la texture placé en mémoire et la convertira. Ce n'est pas efficace et doit être évitée (Ndt: Encore une histoire de little endian et de big endian).
Si les textures et la scène sont grandes au point qu'elles ne rentrent pas dans la mémoire physique, et bien le fait de charger une texture revient à:</p>
<p>
- Charger le fichier en mémoire<br />
- Le décompresser<br />
- Le copier dans le swap ((Ndt: Sur Unix) Le swap est une partition de disque qui agit comme une extension de la mémoire physique mais sur le disque dur. La vitesse de transfère y est ridicule). (Ndt: Sur windows, c'est le pagefile, la mémoire virtuelle)<br /></p>
<p>
Dès lors, l'accès à une texture signifie l'accès au swap, et donc, au disque dur, ce qui fait "ramer" l'ordinateur.</p>
<p>
Le mappage en mémoire élimine les étapes de "lecture-décompression-écriture-dans-la-mémoire" et accède à la texture depuis le système de fichiers au lieu du swap.</p>
<p>
Cela a pour effet que moins d'espace de swap est nécessaire.</p>
<p>
Si la texture et la scène ne sont pas énorme et "rentre" dans la mémoire, et si la texture est fréquemment consultée, les textures memory mapped se révèles légèrement plus lentes que les textures "classiques" (Lire sur le disque est plus long que de lire directement dans la mémoire). Mais pour les grandes textures, le memory mapping est une manière bien plus efficace de charger des textures.
Ceci est particulièrement important pour mental ray, qui gère la mémoire comme un cache.
Les textures qui ne sont pas memory mapped sont une perte énorme sur le cache, car ils ont tendance à prendre une grandes partie de la mémoire cache. Mental ray a un gestionnaire de cache virtuel séparé qui charge et décharge les textures memory-mapped de manière efficace sans bloquer le cache principal.</p></blockquote>
<p>Je vous accorde que balancé comme ça, c'est un peu indigeste... :baffed: Mais si j'ai fait cette traduction, c'est parce que j'ai du passer sur cette documentation une bonne dizaine de fois et que malgré qu'elle soit imbuvable, elle est nécessaire à la compréhension du memory mapping dans mental ray...</p>
<p>Donc lisez bien cette version traduite puis lisez ensuite la version anglaise (si vous voulez comprendre les quelques subtilités que j'ai eu du mal à traduire):</p>
<p>Vous connaissez maintenant le principe des "map" (c'est comme ça qu'on les appellera). Avec cette technique, Mental Ray est techniquement capable de manger des textures de taille infini (j'ai essayé 80000x80000, ça passe! :aupoil: ).</p>
<h5>Mais comment qu'on fait? <a name="mais_comment_quon_fait"></a></h5>
<p>En gros le principe va être de convertir les textures de votre projet en .map et de pointer les textures de vos scène vers ses fichiers nouvellement créés. Et pis c'est tout! En effet, une fois cela fait, mental ray se débrouille très bien tout seul et va reconnaitre les .map et les utiliser comme il se doit. C'est transparent pour l'utilisateur. Sauf que vos barrettes de mémoires vous diront merci (et vos disques dur vont faire la gueule :septic: ).</p>
<h5>imf_copy <a name="imf_copy"></a></h5>
<p>Comme expliqué dans la documentation, il faut utiliser un utilitaire en ligne de commande: imf_copy. :RTFM:</p>
<p>Il est situé dans:</p>
<pre>
C:\Program Files\Autodesk\Maya2010\bin\imf_copy.exe</pre>
<p>Pour avoir la documentation de ce petit outil, dans Maya, tapez F1 puis naviguez dans:</p>
<pre>
mental ray -> mental ray for Maya reference -> Apendix (en bas de la page) -> Command Line Interface -> Image Copy: imf_copy</pre>
<p>Sinon, le lien complet:</p>
<pre>
C:\Program Files\Autodesk\Maya2010\docs\Maya2010\en_US\mr\manual\node249.html</pre>
<p>C'est le genre de page que je vous invite à placer en favoris :sourit:</p>
<h5>imf_copy: Traduction de la documentation officiel <a name="imf_copy_traduction"></a></h5>
<p>Une fois de plus, je me suis "amusé" à traduire la documentation de cet utilitaire: :baffed:</p>
<blockquote><p>Image Copy: imf_copy</p>
<p>
L'utilitaire de copie et de conversion d'image imf_copy s'utilise de la façon suivante:</p>
<p>
imf_copy [options] fichierSource fichierSorti [type de fichier de sorti]</p>
<p>
Le fichier "fichierSource" sera copié vers "fichierSorti". Le "type de fichier de sorti" spécifie le format de fichier de "fichierSorti". Si aucun type n'est indiqué, il sera choisi en fonction de l'extension de "fichierSorti". Voir la page "picformats" (Ndt: Dans la documentation mental ray) pour une list des formats supportés. Le format "map" est particulièrement utilisé pour créer des textures "mappable en mémoire". Les options suivantes sont supportés:</p>
<p>
-h</p>
<p>
Affiche un bref résumé des options.</p>
<p>
-p</p>
<p>
Créé une texture pyramidale contenant différentes "versions" de la texture. Chaque version est en fait la texture de la version précédente divisé par deux. Le tout est contenu dans un seul fichier. Cette technique (Ndt: très utilisé dans le jeu vidéo, cf: <a href="http://fr.wikipedia.org/wiki/MIP_mapping" hreflang="fr">Mipmapping</a>) permet d'obtenir un meilleur anti-aliasing. Voir la page "imfcopyp" (Ndt: Dans la documentation mental ray) pour plus d'informations. Une version de plus en plus petite de l'image est créé a partir de la version précédente (plus grande) en utilsant un filtre de type "box" sur environs 4 pixels.</p>
<p>
-v</p>
<p>
Verbose. Affiche ce que fait imf_copy quand il est exécuté ainsi que sa version.</p>
<p>
-g gamma</p>
<p>
Effectue une correction du gamma avec le facteur donné. La valeur par défaut est 1.0.</p>
<p>
-q quality</p>
<p>
Quand on écrit un fichier JPEG, ce paramettre défini la qualité sur un écart de 1 à 100. La valeur par défaut est 75.</p>
<p>
-f filter</p>
<p>
Utile uniquement si le fichier de sorti est un .map. La valeur du filter est sauvé dans la texture. Les fichiers de textures "mappable en mémoire" utiliseront cette valeur même si une autre valeur est déclaré dans le .mi ou avec la fonction mi_api_texture_set_filter. (Ndt: Compris que la moitié mais on s'en fout, on ne l'utilise jamais)</p>
<p>
-e</p>
<p>
Si on souhaite redimensionner une image d'un certain format à un autre format avec moins de bit par pixel, cette option effectue une erreur de diffusion au lieu d'une "troncature" (Ndt: Pas bien compris non plus mais je suppose que c'est quelque chose qui à été ajouté à la suite pour éviter les arrêts du programme sur un problème de conversion de format de pixel. Je ne l'ai jamais utilisé).</p>
<p>
-L</p>
<p>
Quand on écrit un fichier .map "memorymapped", cette option utilise ordre de byte "little-endian". Pour être efficace le fichiers .map doivent avoir l'ordre des bytes identique à la machine qui les utiliseront (Ndt: sinon elle passeront par l'étape d'ouverture, lecture, écriture sur le swap). Les processeurs de type Alpha et x86 sont de type "little-endian"; La plupart des autres sont de type "big-endian".</p>
<p>
-B</p>
<p>
Quand on écrit un fichier .map "memorymapped", cette option utilise l'ordre de byte "big-endian".</p>
<p>
-r</p>
<p>
Quand on écrit un fichier .map "memorymapped", cette option organise les pixels en rectangle au lieu de l'ordre habituel "a la queu-leu-leu". Ceci augmente l'efficacité du cache et réduit l'utilisation de la mémoire pendant le rendu. Les fichiers créés de cette façon ne peuvent être rendu qu'avec mental ray 3.2 et suivant, c'est pourquoi cette option n'est pas activé par défaut. (Ndt: A la lecture de la documentation, on comprend bien que si c'était possible, cette option serait activé par défaut. Utilisez la donc par défaut.)</p>
<p>
-c</p>
<p>
Quand on écrit un fichier .map "memorymapped", cette option rassemble jusqu'à 20 fichiers donnés pour former une pyramide d'images, mipmap (Ndt: Nous verrons dans <a href="https://www.fevrierdorian.com/blog/post/2010/01/31/Les-maps-mental-ray-%28part-3%29%3A-Fabriquer-sa-map-de-debug">un futur billet</a> l'intérêt de cette commande qui nous permettra de fabriquer une "map de debug"). Cette option permet donc de "contrôler" la création de notre .map d'images pyramidales comparé à l'option -p qui créé automatiquement chaque niveau de la pyramide à la moitié de la résolution du niveau précédent en utilisant un filtre de type "box". La première image donnée devra avoir la plus haute résolution, la seconde environs la moitié, la suivante le quart, etc... Les fichiers créés avec cette option peuvent être lu avec n'importe quelle version de mental ray 3.x.</p>
<p>
-x N</p>
<p>
Extrait le niveau N du .map pyramidale. Le premier (et plus grand) niveau est 0; Le plus élevé est le 19. Cette opération peut être considéré comme l'inverse de l'option -c, mais elle marche également avec des .map pyramidales créés avec -p.</p>
<p>
-k K</p>
<p>
Quand on écrit un fichier OpenEXR, K définie la methode de compression, ou K peut prendre les valeurs suivantes: none, piz, zip, rle, pxr24. La valeur par défaut est rle.</p></blockquote>
<h5>Convertir nos textures en .map <a name="convertir_nos_textures_en_map"></a></h5>
<p>A la suite de cette traduction, nous somme capable de trouver facilement la ligne de commande à utiliser pour convertir nos textures:</p>
<pre>
imf_copy -p -r myTexture.png myTexture.map</pre>
<p>"easy as one-two-three" :laClasse:
Il ne vous reste plus qu'a ouvrir votre scènes et à pointer vers vos nouvelles textures ".map" et mental ray se chargera tout seul du reste.</p>
<h5>Suite? <a name="suite"></a></h5>
<p>Ce billet introduit quelques autres billets que je compte faire (un jour :siffle2: ). Voici un aperçu:</p>
<ul>
<li>Script qui génère automatiquement les versions .map des fichiers images en comparant leurs ages. Et ce, dans toute la hiérarchie d'un dossier donné (récursif).</li>
<li>Création d'un fichier .map de debug qui affiche une image différente à chaque niveau de la texture pyramidale.</li>
<li>Analyse et optimisation du fonctionnement de "mental ray for Maya" grâce à la map de debug que nous auront créé.</li>
<li>Surement d'autres trucs...</li>
</ul>
<p>Voila, j'espère que ce billet en aidera quelques uns d'entre vous. N'hésitez pas à me faire remarqué si je n'ai pas été assez clair ou si vous pensez que certains points méritent quelques éclaircissements.</p>
<p>A bientôt!</p>Un max de textures dans le viewport Maya: La Solution!urn:md5:54865e3606837979c0c49f6830aa609b2009-01-18T18:24:00+01:002013-07-26T22:43:40+02:00NarannInfographie 3D - Boulot3dcompressionddsDirectDraw Surfacefrmapmayanconvertnvdxtnvidiaphotoshops3texturexnview<p><a href="http://img262.imageshack.us/img262/9154/2281134222bd559a34e61dw7.jpg"><img src="http://img262.imageshack.us/img262/9154/2281134222bd559a34e61dw7.th.jpg" alt="" style="float:left; margin: 0 1em 1em 0;" /></a>Il arrive sur certains projets que les animateurs ou le réalisateur veuillent voir les textures dans le viewport Maya. Le réflexe est d'appuyer sur la touche "6" du pavé numérique pour les afficher. Ce genre de manipulation est souvent imprévisible dans la mesure oû les textures peuvent être de très grandes tailles (ce qui prend du temps à mettre dans la ram, sans garantie de succès) et faire minablement planter Maya. Ne reste alors qu'une seule alternative:</p>
<ul>
<li>Pleurer</li>
</ul> <p>Nan je déconne! :D Il existe une solution alternative et intéressante : les textures <a href="http://en.wikipedia.org/wiki/DirectDraw_Surface">DirectDraw Surface</a> (ou DDS). Sans rentrer dans les détails, je vous explique déjà comment Maya fait quand on lui donne, par exemple, un BMP (on rit pas, je prends un cas simple).</p>
<h5>Forcément, si tu prends un BMP, c'est lourd!</h5>
<p>Héhé... Sachez que, que ce soit un JPG, un TGA, un BMP, Maya ouvre la texture, la décompresse, la lit et place tous les pixels dans la mémoire de la carte graphique pour l'afficher. C'est énorme et très lourd à supporter pour la-dite carte qui dans un logiciel de 3D fonctionne très différemment que dans un jeux vidéo où le calcul des tailles des textures est millimétré. L'astuce que je vous propose consiste à utiliser un format de fichier texture que la carte graphique connait... le format DDS !</p>
<h5>Dintendo DS!</h5>
<p>Le format DDS, c'est quoi ? Pour faire simple disons que c'est un peu le JPG de la carte graphique. C'est la société <a href="http://en.wikipedia.org/wiki/S3_Graphics">S3 Graphics</a> qui a développé les premières cartes supportant la compression-décompression des textures en hardware (la <a href="http://en.wikipedia.org/wiki/Savage_3D">Savage 3D</a>). Cette technologie fut ensuite implémentée dans Directx (6.0) et se propagea très rapidement (les possibilités offertes pour l'époque étaient révolutionnaire pour le jeux vidéo). La compression est destructive (on s'en fout pour un viewport vous me direz), mais l'image est stockée compressée dans la mémoire et décompressée "à la volée". Il y a plusieurs façons de créer une image dds à partir d'un autre format. La plus simple (mais vous allez voir qu'on est limité par cette simplicité) étant selon moi d'utiliser <a href="http://pierre.g.pagesperso-orange.fr/xnview/frxnview.html">XnView</a> : On ouvre, "Outils/Convertir" puis DDS (Il ne génère cependant pas les <a href="http://fr.wikipedia.org/wiki/MIP_mapping">mipmap</a>). J'ajouterai une dernière chose, c'est que ce que XnView fait, <a href="http://pierre.g.pagesperso-orange.fr/xnview/fr_nconvert.html">nconvert</a> le fait aussi :D . Il est donc possible de convertir ses images en ligne de commande (pratique en production).</p>
<p>Voici la ligne de commande BAT:</p>
<pre>
nconvert.exe -out dds -o "monFichier.dds" "monFichier.bmp"
</pre>
<p>Simpliste non? Et bien en fait pas tout à fait ! Il faut savoir une chose quand on fait ce genre de manipulation, c'est que les images doivent avoir des tailles puissance de 2 (512x512, 1024x256 est possible aussi). En jeux vidéo, cette contrainte est primordiale et est donc prise en compte dès le début du projet. En précal', les softs gérant assez bien ce genre de problèmes, on se fout un peu de savoir si les textures sont carrées et (ou) puissance de quoi que ce soit. Il faut donc être rigoureux là-dessus. Si vous ne le faîtes pas, Nconvert va prendre automatiquement la première puissance de 2 (128, 256, 512 etc...) supérieure à la résolution de l'image et remplir le reste de noir. Ce qui rend la position de l'image par rapport à ses uvs faussée. La technique consiste donc à déformer l'image (ça peut sembler paradoxal mais quand on y réfléchit et qu'on teste un peu, c'est logique) en la resizant manuellement dans la taille du "bloc multiple" le plus proche. Personnellement et dans un souci de simplifier le tout, je mets toutes les images en 1024 par 1024 qui est un bon compromis (Cela dit, si vous avez le luxe de pouvoir resizer les maps au cas par cas ne vous gênez pas (C'est vrai que c'est dommage de resizer une map 1310x100 en 1024x1024, c'est vous qui voyez, faut pas se brosser non plus, c'est de la préviz). Voila donc une ligne de BAT possible:</p>
<pre>
nconvert.exe -rflag orient -resize 1024 1024 -rtype lanczos -out dds -o "monFichier.dds" "monFichier.bmp"
</pre>
<p><a href="https://www.fevrierdorian.com/blog/public/billet_dds/image01.jpg"><img src="https://www.fevrierdorian.com/blog/public/billet_dds/.image01_m.jpg" alt="image01.jpg" style="display:block; margin:0 auto;" title="image01.jpg, janv. 2009" height="448" width="448" /></a>
Bon, vous connaissez maintenant les grandes lignes de la manipulation.</p>
<h5>Pas d'alpha, pas de chocolat</h5>
<p>Si vous avez testé avec une image contenant un canal alpha, vous aurez peut-être remarqué que Maya l'interprète différemment (dans mon cas, l'alpha de mon image est censé être son inverse).
<a href="https://www.fevrierdorian.com/blog/public/billet_dds/image02.jpg"><img src="https://www.fevrierdorian.com/blog/public/billet_dds/.image02_m.jpg" alt="image02.jpg" style="display:block; margin:0 auto;" title="image02.jpg, janv. 2009" height="295" width="448" /></a>
L'alpha semble être interprété sur les bords. Je ne sais pas si le problème vient de Maya ou XnView mais il est bien présent. Il y a cependant plusieurs façons de le contourner.</p>
<h5>Nvidia Pawa</h5>
<p><a href="https://www.fevrierdorian.com/blog/public/logos/nvidia_logo_1_.jpg"><img src="https://www.fevrierdorian.com/blog/public/logos/.nvidia_logo_1__s.jpg" alt="logo nvidia" style="float:left; margin: 0 1em 1em 0;" title="logo nvidia, janv. 2009" height="186" width="240" /></a>
Heureusement qu'ils sont là ceux là. En effet, <a href="http://fr.wikipedia.org/wiki/Nvidia">Nvidia</a> propose pas mal d'outils destinés aux développeurs. Ceux qui nous intéressent sont les <a href="http://developer.nvidia.com/object/nv_texture_tools.html">textures tools</a> et plus précisément les <a href="http://developer.nvidia.com/object/dds_utilities_legacy.html">DDS Utilities</a>. Téléchargez les, installez les et allez récupérer le fichier "nvDXT.exe" qui est un convertisseur en ligne de commande (il est placé dans le dossier d'installation). Ce programme à bon nombre d'options que je ne vous expliquerai pas ici (je me contente de laisser les paramètres par défaut), je préfère rester concis (vous pouvez toutefois, si le cœur vous en dit, lire le PDF inclut).</p>
<p>Grosso modo, la ligne de commande est la même que pour nconvert:</p>
<pre>
nvdxt.exe -file maMap.tga -output maMap.dds
</pre>
<p><a href="https://www.fevrierdorian.com/blog/public/billet_dds/image03.jpg"><img src="https://www.fevrierdorian.com/blog/public/billet_dds/.image03_m.jpg" alt="image03.jpg" style="display:block; margin:0 auto;" title="image03.jpg, janv. 2009" height="448" width="448" /></a></p>
<p>Sympa n'est-ce pas? ;)</p>
<p>Je viens aussi (en direct live!) de me rendre compte que les images ayant des tailles qui ne sont pas des puissances de 2 passent très bien ! (Un petit warning mais la conversion se fait)</p>
<p><img src="https://www.fevrierdorian.com/blog/public/billet_dds/image04.gif" alt="image04.gif" style="display:block; margin:0 auto;" title="image04.gif, janv. 2009" height="69" width="352" />
<a href="https://www.fevrierdorian.com/blog/public/billet_dds/image05.jpg"><img src="https://www.fevrierdorian.com/blog/public/billet_dds/.image05_m.jpg" alt="image05.jpg" style="display:block; margin:0 auto;" title="image05.jpg, janv. 2009" height="338" width="448" /></a></p>
<p>Bon, je suis pas sûr que ce soit très propre tout ça, je vous donne aussi la commande qui resize l'image en 1024 par 1024:</p>
<pre>
nvdxt.exe -prescale 1024 1024 -RescaleKaiser -file maMap.tga -output maMap.dds
</pre>
<p>Encore une fois, pour une explication des options, lisez le PDF. J'ai aussi l'impression que l'option -prescale ne fonctionne pas sur des images de grandes tailles (8192 par 8192 par exemple).</p>
<h5>Houai, mais n'empêche que ça pue tes lignes de commande toutes noires!</h5>
<p>Ne vous inquiétez pas! Nvidia a pensé aux <del>attardés</del> personnes n'étant pas à l'aise avec les applications en ligne de commande (Je rigolais hein? Je me sers beaucoup de l'outil qui va suivre car il est plus pratique pour visualiser ce qui se passe dans l'image). Ainsi, ils ont sorti un <a href="http://developer.nvidia.com/object/photoshop_dds_plugins.html">plug-ins Photoshop</a> qui permet également de créer des normal maps à partir de maps de bump (en niveau de gris).</p>
<p><a href="http://developer.nvidia.com/object/photoshop_dds_plugins.html"><img src="http://developer.nvidia.com/docs/IO/20926/TextureCompression.jpg" alt="" style="display:block; margin:0 auto;" /></a></p>
<p>Une fois de plus, je ne vais pas m'étaler (l'objectif étant de sortir des dds, pas de tout vous expliquer, la documentation Nvidia est d'ailleurs très bien faite et je vous invite à la lire si le sujet vous intéresse).</p>
<p>J'espère que ce billet vous aura servi ou vous servira à l'avenir. N'hésitez pas à tester chez vous et à laisser un commentaire si vous avez rencontré des problèmes, si vous pensez que je suis trop vague dans mes explications ou que vous avez la conviction que j'ai écris une énormité.</p>
<p>Pour ceux qui ont déjà utilisé les dds en production, je serai également intéressé de connaitre les limites de ce format ou les contraintes qu'il peut générer.</p>
<p>A bientôt!</p>
<p>Dorian</p>
<h5>MAJ 2011 - 09 - 11 <a name="maj_20110911"></a></h5>
<p>Bon, ça fait un moment que ce billet est écrit mais je fait une MAJ car j'ai pas mal potassé le sujet depuis et j'ai fait deux vidéos.</p>
<p>La première (septembre 2010) présente Maya affichant 4 maps dds de 8k. Mais pour être honnête, je soupçonne que ce n'était la bonne solution car c'est Maya qui envoi les maps dans le GPU:</p>
<iframe width="580" height="356" src="http://www.youtube.com/embed/aVghteicCGM?hd=1" frameborder="0" allowfullscreen></iframe>
<p>Après <a href="http://area.autodesk.com/forum/autodesk-maya/autodesk-maya-2012/cgfx-and-dds-textures-in-gpu-memory/">m'être acharné</a> à trouver de l'aide sur Area, j'ai finalement obtenu une réponse.</p>
<p>Mais il fallait que je test pour être sur. C'est donc chose faite: Pour profiter correctement du format dds, il faut utiliser un shader cgfx. Dans l'exemple qui suite, Maya peut afficher, sans broncher, 9 maps dds de 8k.</p>
<iframe src="http://player.vimeo.com/video/28788662" width="579" height="315" frameborder="0" webkitAllowFullScreen allowFullScreen></iframe>
<p>Et encore, là j’utilisai une compression DXT5 (qui prends le double de place que la DXT1). Donc à priori (il faut que je retest), je dois pouvoir afficher 18 maps dds de 8k dans le viewport Maya :baffed: .</p>
<p>La grande classe! :laClasse:</p>