Open Shading Language (OSL) : définition, activation dans Blender et premier shader

Les menus, cités en anglais, sont vérifiés dans le manuel et le code source de Blender 5.2. Le shader d’exemple a été compilé et rendu dans Blender 5.2 LTS avant publication.

Qu’est-ce que l’Open Shading Language (OSL) ?

L’Open Shading Language, abrégé OSL, est un petit langage de programmation consacré au shading, le calcul de l’aspect des surfaces dans un moteur de rendu. Selon la présentation officielle du projet, il sert à décrire des matériaux, des lumières, du déplacement de surface et des motifs procéduraux. Sa syntaxe ressemble à celle du C : des variables typées, des fonctions, des accolades et des points-virgules.

OSL a été développé à l’origine par Sony Pictures Imageworks pour le moteur de rendu interne du studio, utilisé sur ses films d’animation et d’effets visuels, puis publié en open source pour que d’autres studios et éditeurs de logiciels puissent l’adopter. Le code est distribué sous licence BSD à trois clauses et le projet est aujourd’hui hébergé par l’Academy Software Foundation. En 2017, ce travail a reçu un prix de l’Académie des Oscars, l’Academy Award for Technical Achievement.

La liste tenue par le projet cite, parmi les moteurs qui acceptent OSL, Arnold, V-Ray, RenderMan, Redshift, 3Delight, Clarisse, appleseed et Cycles, le moteur de Blender, ainsi que 3ds Max dans sa version 2019. Côté cinéma, elle mentionne entre autres The Amazing Spider-Man et Finding Dory. Le manuel de Blender en tire un argument : un shader OSL peut se partager entre applications compatibles avec le standard.

Ce qui distingue OSL des autres langages de shaders

Dans d’autres langages, un shader de surface calcule le plus souvent une couleur finale, vue depuis une direction donnée. Le manuel de Blender souligne qu’OSL, contrairement à GLSL ou au RenderMan Shading Language (RSL), n’a pas de boucle sur les lumières : un shader de surface ne voit pas les lampes de la scène et ne lance pas de rayons d’éclairage. Il renvoie une closure, une description de la façon dont la surface diffuse la lumière, et c’est le moteur qui l’évalue, choisit les directions à échantillonner et calcule l’éclairage. Le manuel y voit une contrainte, mais aussi ce qui permet au moteur d’optimiser les shaders et de tous les échantillonner correctement.

Le code source, un fichier .osl, est traduit par le compilateur oslc en code intermédiaire, un fichier .oso. Au rendu, selon le projet, la bibliothèque OSL transforme ce code en code machine à la volée avec LLVM, en tenant compte des valeurs réelles des paramètres. Dans Blender, ces étapes sont automatiques : vous écrivez le .osl, Blender produit le .oso.

OSL dans Blender : où il fonctionne

Dans Blender, OSL sert dans Cycles à écrire des shaders de surface, de volume et de déplacement sur mesure. Le manuel cite les textures procédurales, des modèles de réflexion (BRDF) particuliers et des prototypes issus de la recherche. Le code s’écrit dans le Text Editor de Blender ou dans un fichier externe, et entre dans le matériau par un nœud Script, dont les entrées et les sorties sont les paramètres du code.

Le code source de Blender 5.2 ne déclare la prise en charge d’OSL que pour le processeur et pour OptiX. Le guide OptiX ou CUDA dans Blender explique comment sélectionner OptiX dans les préférences et quelles cartes NVIDIA sont concernées.

Depuis Blender 4.5, OSL sert aussi à programmer des caméras : dans les propriétés de la caméra, panneau Lens, réglez Type sur Custom. Ces caméras ne dépendent pas de la case Open Shading Language, mais demandent elles aussi le processeur ou OptiX.

Activer Open Shading Language dans Cycles

1. Dans Render Properties, réglez Render Engine sur Cycles.
2. Réglez Device sur CPU. Pour rendre sur une carte NVIDIA, choisissez plutôt GPU Compute, après avoir sélectionné l’onglet OptiX dans Edit > Preferences > System > Cycles Render Devices.
3. Cochez Open Shading Language, juste sous Device. Le réglage appartient à la scène et s’enregistre dans le fichier .blend.

Si la case n’apparaît pas, regardez Device : Blender ne l’affiche que lorsque le rendu se fait sur le processeur ou avec OptiX. Avec CUDA, HIP, oneAPI ou Metal en GPU Compute, elle disparaît du panneau. Un fichier où elle est cochée, rendu sur l’un de ces appareils, repasse sur le système de nœuds intégré de Cycles : les nœuds Script sont ignorés. Le manuel ajoute que le rendu avec OSL est en général plus lent qu’avec les nœuds intégrés : ne cochez la case que dans les scènes qui en ont besoin.

Le nœud Script : code interne ou fichier externe

Dans le Shader Editor, Shift+A > Utilities > Script ajoute le nœud (Blender 5.0 et suivants ; en 4.x, Add > Script > Script). Il n’apparaît dans le menu que si le moteur est Cycles, et n’est évalué que si la case Open Shading Language est cochée. Son champ Mode propose deux façons de fournir le code.

• Internal : le code est un bloc de texte du fichier .blend, écrit dans le Text Editor, et le bytecode .oso est stocké dans le nœud. Tout voyage avec le fichier : c’est le mode à choisir pour transmettre une scène.
• External : le nœud pointe vers un fichier .osl sur le disque, que Blender compile en .oso dans le même dossier ; un .oso déjà compilé est utilisé tel quel. On peut aussi indiquer un simple nom de module, cherché dans le dossier shaders de la configuration, sous Windows C:\Users\<nom>\AppData\Roaming\Blender Foundation\Blender\5.2\shaders\. L’option Auto Update, dans la barre latérale du Shader Editor, recompile le shader quand le fichier .osl change.

Le bouton à l’icône de rafraîchissement, à droite du nom du script, est Script Node Update : il recompile le code et crée ou supprime les entrées et sorties selon les paramètres. En mode Internal, le rendu utilise le bytecode enregistré dans le nœud : une modification du texte ne compte qu’après ce clic. Pour la production, le manuel conseille d’envelopper les nœuds Script dans un groupe de nœuds lié dans les autres fichiers : quand des entrées changent, il n’y a qu’un groupe à mettre à jour.

Écrire le code dans le Text Editor

Le Text Editor s’ouvre avec Shift+F11 ou dans l’espace de travail Scripting. Son menu Templates > Open Shading Language propose neuf modèles dans Blender 5.2 : six shaders, dont empty_shader (un shader vide), basic_shader (des entrées et sorties float et color), noise (les fonctions de bruit) et ramp_closure (des closures), et trois caméras. Donnez au texte un nom qui finit par .osl : l’en-tête de l’éditeur remplace alors le bouton Run Script par un bouton Shader Update, qui met à jour tous les nœuds Script utilisant ce texte.

Un premier shader OSL, ligne par ligne

Ce shader dessine des rayures de deux couleurs. Il a deux sorties : une couleur à brancher où vous voulez, par exemple sur la Base Color d’un Principled BSDF, et un shader diffus complet. Les textures procédurales déjà intégrées à Blender (Noise, Voronoi, Wave) sont présentées dans le guide des textures dans Blender : OSL prend le relais quand aucune ne convient.

// rayures.osl : des rayures procédurales pour la Base Color.
shader rayures(
    color Couleur_A = color(0.8, 0.1, 0.1),  // première couleur
    color Couleur_B = color(0.9, 0.9, 0.9),  // seconde couleur
    float Echelle = 10.0,                    // périodes par unité
    point Position = P,                      // non reliée : P
    output color Couleur = 0.0,              // sortie couleur
    output closure color BSDF = 0)           // sortie shader
{
    // x multiplié par l'échelle, ramené entre 0 et 1.
    float t = mod(Position[0] * Echelle, 1.0);
    // step() vaut 0 sur la première moitié de la période, 1 ensuite.
    Couleur = mix(Couleur_A, Couleur_B, step(0.5, t));
    BSDF = Couleur * diffuse(N);
}

1. Ouvrez le Text Editor, cliquez sur New, renommez le texte rayures.osl et collez le code.
2. Dans le Shader Editor du matériau, ajoutez un nœud Script, laissez Mode sur Internal et choisissez rayures.osl.
3. Cliquez sur le bouton Update. Les entrées Couleur_A, Couleur_B, Echelle et Position apparaissent, ainsi que les sorties Couleur et BSDF.
4. Reliez Couleur à la Base Color d’un Principled BSDF, ou BSDF directement à l’entrée Surface de Material Output.
5. Passez la vue 3D en mode d’affichage Rendered, ou lancez un rendu avec F12 (voir le guide du rendu dans Blender).

Ce que fait chaque ligne

• shader rayures(...) déclare le shader et ses paramètres. La spécification d’OSL impose une valeur par défaut à chaque paramètre. Blender crée une entrée de nœud par paramètre, et une sortie pour chaque paramètre précédé de output.
• color, float et point sont des types d’OSL ; closure color est celui d’un shader de surface. Les commentaires s’écrivent comme en C++, après // ou entre /* et */.
• point Position = P : P est la position du point en cours de calcul, une variable globale qu’OSL fournit sans déclaration. Cette valeur par défaut n’étant pas une constante, l’entrée laissée libre prend P. Dans Cycles, P est exprimé dans l’espace du monde : les rayures restent fixes quand l’objet se déplace. Reliez la sortie Object d’un nœud Texture Coordinate à l’entrée Position pour qu’elles le suivent.
• mod(a, b) renvoie a - b × floor(a / b), toujours positif ou nul, contrairement à fmod() : les rayures restent régulières de part et d’autre de l’origine. Position[0] lit la composante x (Position.x fonctionne aussi).
• step(0.5, t) vaut 0 si t est inférieur à 0,5 et 1 sinon ; mix(a, b, f) renvoie a × (1 - f) + b × f. Ensemble, ils choisissent l’une ou l’autre couleur.
• diffuse(N) est la closure de réflexion diffuse de Lambert, N la normale de la surface. Multipliée par une couleur, elle donne un matériau diffus de cette couleur.

Les métadonnées, entre doubles crochets après la valeur par défaut, règlent l’affichage dans le nœud : [[ string label = "Échelle" ]] donne un nom lisible à l’entrée, [[ string widget = "null" ]] la masque, et [[ string widget = "checkBox" ]] (ou "boolean") affiche un paramètre entier sous forme de case à cocher.

Les closures disponibles dans Cycles

Les closures de Cycles correspondent à ses nœuds de shader. On y trouve notamment diffuse(), oren_nayar(), translucent(), reflection(), refraction(), transparent(), emission(), holdout() et background(), absorption() et henyey_greenstein() pour les volumes, et bssrdf() pour le subsurface scattering. Depuis Blender 4.0, les reflets passent par la closure standard d’OSL microfacet(), avec les distributions ggx, multi_ggx, beckmann, sharp, ashikhmin_shirley et clearcoat. Par exemple, microfacet("ggx", N, 0.2, 1.5, 0) donne un reflet GGX de paramètre alpha 0,2 et d’indice 1,5, sans réfraction (1 pour la seule réfraction, 2 pour les deux). Les closures MaterialX dielectric_bsdf(), conductor_bsdf() et generalized_schlick_bsdf() sont aussi fournies.

Les attributs de la géométrie se lisent avec getattribute() : cartes UV, attributs de couleur, attributs créés par les Geometry Nodes, et des valeurs intégrées comme geom:uv, object:index ou object:random, un nombre aléatoire propre à chaque instance d’objet. Deux lignes suffisent pour faire varier une teinte d’un objet dupliqué à l’autre : float r = 0.0; puis getattribute("object:random", r);.

Limites d’OSL et coût en temps de rendu

• Vitesse. Le manuel prévient que le rendu est en général plus lent qu’avec les nœuds intégrés, à cause de la compilation et de l’interprétation des shaders. Gardez OSL pour ce que les nœuds ne savent pas faire.
• Bake et volumes. Toujours selon le manuel, certaines fonctions, comme le bake et certains shaders de volume, peuvent ne pas fonctionner avec OSL.
• Pas d’accès aux lumières. Un shader OSL ne remplace pas l’éclairage. La fonction trace() lance bien des rayons depuis le shader, mais sur le processeur seulement, et pour sonder la géométrie voisine : projeter une texture que des objets peuvent masquer, user davantage les zones exposées, imiter une occlusion ambiante.
• Limites sous OptiX. Chaque appel de texture doit pouvoir déterminer un chemin d’image constant ; certaines fonctions de bruit manquent, dont Cell, Simplex et Gabor ; trace() ne fonctionne pas, si bien que les nœuds Ambient Occlusion et Bevel ne marchent pas non plus quand OSL est activé. Le guide de l’occlusion ambiante présente d’autres façons d’obtenir cet assombrissement.
• Textures dans Blender 5.2. Les textures lues par OSL passent désormais par le cache de textures de Cycles au lieu d’OpenImageIO : selon les notes de version, de meilleures performances et une meilleure prise en charge du GPU, mais certaines options avancées de texture() et gettextureinfo() ont disparu.

Pour un shader lourd, le plus sûr reste de comparer : rendez la même image avec le script puis avec un réseau de nœuds équivalent, et gardez le plus rapide. Les autres réglages qui pèsent sur la durée d’un rendu sont réunis dans le guide pour accélérer un rendu Blender.

Erreurs courantes avec OSL

Le matériau sort noir

Le nœud Script n’a pas été évalué. Trois causes possibles : la case Open Shading Language est décochée ; le rendu se fait avec CUDA, HIP, oneAPI ou Metal ; ou la compilation a échoué, et le nœud n’a alors ni entrée ni sortie. Relié directement à Surface, un nœud ignoré laisse un matériau noir ; relié à une entrée de couleur, celle-ci reprend sa propre valeur.

Le matériau sort rose

Un appel texture() vers un fichier absent renvoie du magenta, qui ressort rose au rendu, et la console affiche « Image file … does not exist ». Vérifiez le chemin de l’image dans le code.

« OSL script compilation failed, see console for errors »

Ce message apparaît au clic sur Update quand le code ne compile pas. Le détail est dans la console système : sous Windows, Window > Toggle System Console ; sous Linux et macOS, lancez Blender depuis un terminal. Chaque erreur donne un numéro de ligne, sous la forme fichier.osl:4: error: Syntax error: syntax error. Pour un script interne, le nom de fichier est celui d’un fichier temporaire : seul le numéro compte. Un point-virgule oublié est signalé à la ligne suivante, là où le compilateur bute.

« function 'microfacet_ggx' was not declared in this scope »

Le code vient d’un tutoriel antérieur à Blender 4.0, version qui a retiré les closures propres à Cycles comme microfacet_ggx() ou microfacet_beckmann(). Remplacez-les par microfacet("ggx", ...) ou microfacet("beckmann", ...). La page OSL du manuel de Blender 5.2 liste encore ces anciennes closures, mais le compilateur les refuse.

Les entrées du nœud ne changent pas

En mode Internal, Blender ne relit pas le code de lui-même : cliquez sur Update dans le nœud, ou sur Shader Update dans le Text Editor si le texte porte l’extension .osl. Un clic sur Update sans texte choisi affiche « No text or file specified in node, nothing to compile ». En mode External, le fichier doit finir par .osl ou .oso, et Blender doit pouvoir écrire le .oso dans le même dossier.