Comment installer des shaders sur Minecraft ? Que sont les shaders et comment installer des shaders sur minecraft Des shaders sont nécessaires

introduction

Le monde des graphismes 3D, y compris les jeux, est rempli de termes. Des termes qui n'ont pas toujours la seule définition correcte. Parfois, les mêmes choses sont appelées différemment, et vice versa, le même effet peut être appelé "HDR", puis "Bloom", puis "Glow", puis "Post-processing" dans les paramètres du jeu. La plupart des gens, à part les développeurs qui se vantent de ce qu'ils ont intégré à leur moteur graphique, sont confus quant à ce qu'ils veulent vraiment dire.

L'article est destiné à vous aider à comprendre ce que signifient certains de ces mots, le plus souvent utilisés dans de tels cas. Dans le cadre de cet article, nous ne parlerons pas de tous les termes des graphismes 3D, mais uniquement de ceux qui se sont généralisés ces dernières années en tant que traits distinctifs et technologies utilisés dans les moteurs graphiques de jeux et en tant que noms pour les paramètres graphiques des jeux modernes. . Pour commencer, je vous recommande fortement de vous familiariser avec.

Si quelque chose dans cet article et dans les articles d'Alexandre n'est pas clair pour vous, alors il est logique de commencer par le plus tôt, p. Ces articles sont déjà un peu dépassés, certes, mais les données de base, les plus initiales et les plus importantes sont là. Nous discuterons avec vous de termes plus « de plus haut niveau ». Vous devez avoir une compréhension de base des graphiques 3D en temps réel et du pipeline graphique. D'un autre côté, ne vous attendez pas à des formules mathématiques, à une précision académique et à des exemples de code - ce n'est pas du tout le sujet de cet article. termes

Liste des termes décrits dans l'article :

Ombrage

Un shader au sens large est un programme permettant de définir visuellement la surface d'un objet. Cela peut être une description de l'éclairage, de la texturation, du post-traitement, etc. Les shaders ont évolué à partir des arbres d'ombrage de Cook et du langage de flux de pixels de Perlin. RenderMan Shading Language est maintenant le plus célèbre. Les shaders programmables ont d'abord été introduits dans RenderMan de Pixar, qui définit plusieurs types de shaders : shaders de source lumineuse, shaders de surface, shaders de déplacement, shaders de volume, shaders imageurs. Ces shaders sont le plus souvent exécutés de manière logicielle par des processeurs universels et n'ont pas une implémentation matérielle complète. Plus tard, de nombreux chercheurs ont décrit des langages similaires à RenderMan, mais ils étaient déjà conçus pour l'accélération matérielle : système PixelFlow (Olano et Lastra ), Quake Shader Language (utilisé par id Software dans le moteur graphique du jeu Quake III, qui décrivait le rendu multi-passes), etc. Peercy et ses collègues ont développé une technique pour exécuter des programmes avec des boucles et des conditions sur des architectures matérielles traditionnelles utilisant plusieurs passes de rendu. Les shaders RenderMan se sont divisés en plusieurs Le nombre de passes qui ont été combinées dans le framebuffer. Plus tard, il y a eu des langages que nous voyons accélérés matériellement dans DirectX et OpenGL. C'est ainsi que les shaders ont été adaptés pour les applications graphiques en temps réel.

Les premières puces vidéo n'étaient pas programmables et n'effectuaient que des actions préprogrammées (fonction fixe), par exemple, l'algorithme d'éclairage était rigidement fixé dans le matériel et rien ne pouvait être modifié. Ensuite, les fabricants de puces vidéo ont progressivement introduit des éléments de programmabilité dans leurs puces, au début, il s'agissait de capacités très faibles (NV10, connu sous le nom de NVIDIA GeForce 256, était déjà capable de certains programmes primitifs), qui ne recevaient pas de support logiciel dans l'API Microsoft DirectX, mais depuis au fil du temps, les possibilités n'ont cessé de s'élargir. L'étape suivante concernait à la fois le NV20 (GeForce 3) et le NV2A (la puce vidéo utilisée dans la console de jeu Microsoft Xbox), qui sont devenus les premières puces avec prise en charge matérielle des shaders d'API DirectX. La version Shader Model 1.0 / 1.1, apparue dans DirectX 8, était très limitée, chaque shader (en particulier pour les pixels) pouvait être relativement court et combiner un ensemble d'instructions très limité. Plus tard, le Shader Model 1 (SM1 en abrégé) a été amélioré avec les Pixel Shaders 1.4 (ATI R200), qui offraient plus de flexibilité, mais avaient également des capacités trop limitées. Les shaders de l'époque étaient écrits dans le langage dit assembleur shader, qui est proche du langage assembleur pour les processeurs à usage général. Son faible niveau apporte certaines difficultés pour la compréhension du code et la programmation, surtout lorsque le code du programme est volumineux, car il est loin de l'élégance et de la structuration des langages de programmation modernes.

La version Shader Model 2.0 (SM2), qui est apparue dans DirectX 9 (qui était prise en charge par la puce vidéo ATI R300, qui est devenue le premier GPU prenant en charge la version 2.0 du modèle de shader), a considérablement étendu les capacités des shaders en temps réel, offrant des shaders plus longs et plus complexes et un ensemble d'instructions considérablement étendu. La possibilité de calculer la virgule flottante dans les shaders de pixels a été ajoutée, ce qui était également une amélioration majeure. DirectX 9, face aux capacités de SM2, a également introduit le langage de shader de haut niveau (HLSL), qui est très similaire au langage C. Et un compilateur efficace qui traduit les programmes HLSL en code de bas niveau et convivial pour le matériel. De plus, plusieurs profils sont disponibles pour différentes architectures matérielles. Désormais, le développeur peut écrire un code de shader HLSL et le compiler à l'aide de DirectX dans le programme optimal pour la puce vidéo installée par l'utilisateur. Après cela, les puces de NVIDIA, NV30 et NV40 ont été publiées, ce qui a amélioré les capacités des shaders matériels un peu plus loin, en ajoutant des shaders encore plus longs, la possibilité de transitions dynamiques dans les shaders de vertex et de pixels, la possibilité de récupérer des textures à partir de shaders de vertex, etc. . n'étaient pas, ils sont attendus vers la fin 2006 en DirectX 10...

En général, les shaders ont ajouté de nombreuses nouvelles possibilités au pipeline graphique pour transformer et éclairer les sommets et traiter individuellement les pixels comme le souhaitent les développeurs de chaque application spécifique. Et pourtant, les capacités des shaders matériels n'ont pas encore été entièrement divulguées dans les applications, et à mesure que leurs capacités augmentent dans chaque nouvelle génération de matériel, nous verrons bientôt le niveau de ces shaders RenderMan qui semblaient autrefois inaccessibles pour les accélérateurs vidéo de jeu. Jusqu'à présent, dans les modèles de shaders en temps réel pris en charge par les accélérateurs vidéo matériels, seuls deux types de shaders sont définis : et (dans la définition de l'API DirectX 9). À l'avenir, DirectX 10 promet d'en ajouter de plus en plus.

Ombrage de sommet

Les vertex shaders sont des programmes exécutés par des puces vidéo qui effectuent des opérations mathématiques avec les vertex (vertex, ils constituent des objets 3D dans les jeux), en d'autres termes, ils offrent la possibilité d'exécuter des algorithmes programmables pour changer les paramètres des vertex et leur éclairage (T&L - Transformer et éclairer) ... Chaque sommet est défini par plusieurs variables, par exemple, la position d'un sommet dans l'espace 3D est déterminée par des coordonnées : x, y et z. Les sommets peuvent également être décrits par des caractéristiques de couleur, des coordonnées de texture, etc. Les vertex shaders, selon les algorithmes, modifient ces données au cours de leur travail, par exemple en calculant et en écrivant de nouvelles coordonnées et/ou couleur. C'est-à-dire que les données d'entrée du vertex shader sont des données concernant un sommet du modèle géométrique en cours de traitement. Il s'agit généralement des coordonnées spatiales, des normales, des composants de couleur et des coordonnées de texture. Les données résultantes du programme exécuté servent d'entrée pour l'autre partie du pipeline, le rastériseur effectue une interpolation linéaire des données d'entrée pour la surface du triangle et pour chaque pixel exécute le pixel shader correspondant. Un exemple très simple et grossier (mais clair, j'espère) : un vertex shader vous permet de prendre un objet sphère 3D et d'utiliser un vertex shader pour en faire un cube vert :).

Avant l'avènement de la puce vidéo NV20, les développeurs avaient deux moyens, soit d'utiliser leurs propres programmes et algorithmes qui modifient les paramètres des sommets, mais alors tous les calculs seraient effectués par le CPU (logiciel T&L), soit de s'appuyer sur des algorithmes dans les puces vidéo, avec prise en charge de la transformation matérielle et de l'éclairage (hardware T&L ). Le tout premier modèle de shader DirectX a marqué un grand pas en avant, passant des fonctions fixes de transformation et d'éclairage des sommets à des algorithmes entièrement programmables. Il est devenu possible, par exemple, d'exécuter l'algorithme de skinning entièrement sur des puces vidéo, et avant cela, la seule possibilité était leur exécution sur des processeurs centraux universels. Maintenant, avec les capacités grandement améliorées depuis la puce NVIDIA susmentionnée, vous pouvez faire beaucoup de choses avec les vertex en utilisant les vertex shaders (sauf pour leur création, peut-être) ...

Exemples de comment et où les vertex shaders sont appliqués :

Ombrage de pixels

Les shaders de pixels sont des programmes exécutés par la puce vidéo lors de la rastérisation pour chaque pixel d'une image ; ils effectuent un échantillonnage de texture et/ou des opérations mathématiques sur la valeur de couleur et de profondeur (Z-buffer) des pixels. Toutes les instructions du pixel shader sont exécutées pixel par pixel une fois la transformation de la géométrie et les opérations d'éclairage terminées. À la suite de son travail, le pixel shader produit la valeur finale de la couleur du pixel et la valeur Z pour la prochaine étape du pipeline graphique, le mélange. L'exemple le plus simple de pixel shader que l'on puisse citer : le multitexturing banal, mélangeant simplement deux textures (diffuse et lightmap, par exemple) et imposant le résultat du calcul sur un pixel.

Avant l'avènement des puces vidéo avec prise en charge matérielle des pixel shaders, les développeurs n'avaient que des possibilités de multitexturation et de mélange alpha conventionnels, ce qui limitait considérablement les possibilités de nombreux effets visuels et ne permettait pas de faire beaucoup de ce qui est maintenant disponible. Et si avec la géométrie quelque chose d'autre pouvait être fait par programmation, alors avec des pixels - non. Les premières versions de DirectX (jusqu'à 7.0 inclus) effectuaient toujours tous les calculs verticalement et offraient des fonctionnalités extrêmement limitées pour l'éclairage par pixel (rappelez-vous EMBM - l'environnement bump mapping et DOT3) dans les dernières versions. Les shaders de pixels ont permis d'éclairer n'importe quelle surface pixel par pixel à l'aide de matériaux programmés par le développeur. Les pixel shaders version 1.1 (au sens DirectX) qui sont apparus dans le NV20 pouvaient non seulement faire du multitexturing, mais aussi bien plus, bien que la plupart des jeux utilisant SM1 utilisaient simplement le multitexturing traditionnel sur la plupart des surfaces, exécutant des pixel shaders plus complexes uniquement sur une partie de les surfaces, pour créer une variété d'effets spéciaux (tout le monde sait que l'eau reste l'exemple le plus courant d'utilisation de pixel shaders dans les jeux). Maintenant, après l'avènement du SM3 et des puces vidéo qui les prennent en charge, les capacités des shaders de pixels se sont développées pour permettre même le lancer de rayons, bien qu'avec certaines limitations.

Exemples d'utilisation de pixel shaders :

Textures procédurales

Les textures procédurales sont des textures décrites par des formules mathématiques. De telles textures ne prennent pas de place dans la mémoire vidéo, elles sont créées par le pixel shader "à la volée", chacun de leurs éléments (texel) est obtenu suite à l'exécution des commandes de shader correspondantes. Les textures procédurales les plus courantes : différents types de bruit (par exemple, bruit fractal), bois, eau, lave, fumée, marbre, feu, etc., c'est-à-dire ceux qui peuvent être décrits mathématiquement de manière relativement simple. Les textures procédurales vous permettent également d'utiliser des textures animées avec juste une légère modification des formules mathématiques. Par exemple, les nuages ​​créés de cette manière semblent assez décents à la fois en dynamique et en statique.

Les avantages des textures procédurales incluent également un niveau de détail illimité pour chaque texture, il n'y aura tout simplement pas de pixellisation, la texture est toujours générée en fonction de la taille requise pour l'afficher. L'animation est également d'un grand intérêt, avec son aide, vous pouvez faire des vagues sur l'eau, sans utiliser de textures animées pré-calculées. Un autre avantage de ces textures est que plus elles sont utilisées dans un produit, moins les artistes (bien que plus pour les programmeurs) travaillent pour créer des textures régulières.

Malheureusement, les textures procédurales n'ont pas encore été correctement utilisées dans les jeux, dans les applications réelles, il est encore souvent plus facile de charger une texture régulière, les volumes de mémoire vidéo augmentent à pas de géant, dans les accélérateurs les plus modernes, ils installent déjà 512 mégaoctets de vidéo dédiée mémoire, qui est plus nécessaire que pour emprunter quelque chose. De plus, ils font encore souvent le contraire - pour accélérer les mathématiques dans les pixel shaders, des tables de recherche (LUT) sont utilisées - des textures spéciales contenant des valeurs pré-calculées obtenues à la suite de calculs. Afin de ne pas compter quelques instructions mathématiques pour chaque pixel, ils lisent simplement les valeurs pré-calculées à partir de la texture. Mais plus loin, plus l'accent doit être mis sur les calculs mathématiques, prenez les mêmes puces vidéo ATI de nouvelle génération : RV530 et R580, qui ont respectivement des processeurs de 12 et 48 pixels pour 4 et 16 unités de texture. De plus, si l'on parle de textures 3D, car si des textures bidimensionnelles peuvent être placées dans la mémoire locale de l'accélérateur sans aucun problème, alors les textures 3D en nécessitent beaucoup plus.

Exemples de textures procédurales :

Cartographie des bosses / Cartographie des bosses spéculaires

Le bumpmapping est une technique permettant de simuler des irrégularités (ou de modéliser un microrelief, comme vous le souhaitez) sur une surface plane sans coûts de calcul ni changements de géométrie importants. Pour chaque pixel de la surface, un calcul d'éclairage est effectué sur la base des valeurs d'une carte de hauteur spéciale appelée bumpmap. Il s'agit généralement d'une texture noir et blanc 8 bits et les valeurs de couleur de texture ne sont pas superposées comme des textures normales, mais sont utilisées pour décrire la rugosité d'une surface. La couleur de chaque texel détermine la hauteur du point de relief correspondant, des valeurs plus élevées signifient une hauteur plus élevée au-dessus de la surface d'origine et des valeurs plus faibles, respectivement, plus basses. Ou vice versa.

Le degré d'éclairement d'un point dépend de l'angle d'incidence des rayons lumineux. Plus l'angle entre la normale et le rayon lumineux est petit, plus l'éclairement d'un point de la surface est important. Autrement dit, si vous prenez une surface plane, les normales à chaque point seront les mêmes et l'éclairage sera également le même. Et si la surface est inégale (en fait, presque toutes les surfaces le sont en réalité), alors les normales à chaque point seront différentes. Et l'éclairage est différent, à un moment ce sera plus, à un autre - moins. D'où le principe du bumpmapping - pour simuler des irrégularités pour différents points du polygone, des normales de surface sont définies, qui sont prises en compte lors du calcul de l'éclairage par pixel. De ce fait, on obtient une image plus naturelle de la surface, le bumpmapping donne plus de détails aux surfaces, comme les bosses sur les briques, les pores sur la peau, etc., sans augmenter la complexité géométrique du modèle, puisque les calculs sont effectués à le niveau de pixels. De plus, lorsque la position de la source lumineuse change, l'éclairement de ces irrégularités change correctement.

Bien sûr, l'éclairage des sommets est beaucoup plus simple en calcul, mais il semble trop irréaliste, en particulier avec une géométrie relativement low-poly, l'interpolation des couleurs pour chaque pixel ne peut pas reproduire des valeurs plus grandes que les valeurs calculées pour les sommets. C'est-à-dire que les pixels au milieu du triangle ne peuvent pas être plus brillants que les fragments près du sommet. Par conséquent, les zones présentant des changements brusques d'éclairage, telles que l'éblouissement et les sources lumineuses très proches de la surface, s'afficheront physiquement de manière incorrecte, ce qui sera particulièrement visible en dynamique. Bien sûr, le problème peut être partiellement résolu en augmentant la complexité géométrique du modèle, en le divisant en plusieurs sommets et triangles, mais l'éclairage pixel par pixel est la meilleure option.

Pour continuer, vous devez rappeler les composants de l'éclairage. La couleur d'un point de surface est calculée comme la somme des composantes ambiantes, diffuses et spéculaires de toutes les sources lumineuses de la scène (idéalement de toutes, souvent négligées par beaucoup). La contribution à cette valeur de chaque source lumineuse dépend de la distance entre la source lumineuse et un point de la surface.

Composants d'éclairage :

Ajoutons maintenant du bump mapping à ceci :

La composante uniforme (ambiante) de l'éclairage est une approximation, l'éclairage « initial » pour chaque point de la scène, auquel tous les points sont éclairés de manière égale et l'éclairage ne dépend pas d'autres facteurs.
La composante diffuse de la lumière dépend de la position de la source lumineuse et de la normale à la surface. Cette composante d'éclairage est différente pour chaque sommet de l'objet, ce qui leur donne du volume. La lumière ne remplit plus la surface de la même teinte.
La composante spéculaire de l'éclairage apparaît comme une réflexion des rayons lumineux d'une surface. Pour son calcul, en plus du vecteur de la position de la source lumineuse et de la normale, deux autres vecteurs sont utilisés : le vecteur de la direction du regard et le vecteur de réflexion. Le modèle d'éclairage spéculaire a été proposé pour la première fois par Phong Bui-Tong. Ces flares augmentent considérablement le réalisme de l'image, car de rares surfaces réelles ne réfléchissent pas la lumière, la composante spéculaire est donc très importante. Surtout en mouvement, car l'éblouissement montre immédiatement le changement de position de la caméra ou de l'objet lui-même. Plus tard, les chercheurs ont proposé d'autres moyens de calculer cette composante, plus complexes (Blinn, Cook-Torrance, Ward), prenant en compte la répartition de l'énergie lumineuse, son absorption par les matériaux et sa diffusion sous forme de composante diffuse.

Ainsi, la cartographie spéculaire des bosses est obtenue de cette manière :

Et voyons la même chose avec l'exemple du jeu, Call of Duty 2 :

Le premier fragment de l'image est rendu sans bumpmapping (), le second (en haut à droite) est un bumpmapping sans composante spéculaire, le troisième est avec une composante spéculaire de magnitude normale, qui est utilisée dans le jeu, et le dernier , en partant du bas à droite, avec la composante spéculaire maximale possible.

Comme pour la première application matérielle, certains types de bumpmapping (Emboss Bump Mapping) ont commencé à être utilisés à l'époque des cartes vidéo basées sur des puces NVIDIA Riva TNT, mais les techniques de l'époque étaient extrêmement primitives et peu utilisées. Le prochain type connu était l'EMBM (Environment Mapped Bump Mapping), mais seules les cartes vidéo Matrox avaient une prise en charge matérielle dans DirectX à l'époque, et encore une fois, l'utilisation était sévèrement limitée. Puis le Dot3 Bump Mapping est apparu et les puces vidéo de l'époque (GeForce 256 et GeForce 2) nécessitaient trois passages pour exécuter complètement un tel algorithme mathématique, puisqu'elles sont limitées par deux textures utilisées simultanément. A partir du NV20 (GeForce3), il est devenu possible de faire la même chose en un seul passage grâce aux pixel shaders. En outre. Ils ont commencé à utiliser des techniques plus efficaces telles que.

Exemples d'utilisation du bumpmapping dans les jeux :

La cartographie de déplacement est une méthode d'ajout de détails aux objets 3D. Contrairement au bumpmapping et autres méthodes par pixel, lorsque seule l'illumination d'un point est correctement modélisée par les cartes de hauteur, mais que sa position dans l'espace ne change pas, ce qui ne donne que l'illusion d'une augmentation de la complexité de la surface, les cartes de déplacement permettent d'obtenir de vrais objets 3D complexes à partir de sommets et de polygones, sans restrictions inhérentes aux méthodes par pixel. Cette méthode repositionne les sommets des triangles en les normalisant d'un montant basé sur les valeurs des cartes de déplacement. Une carte de déplacement est généralement une texture en noir et blanc et les valeurs sont utilisées pour déterminer la hauteur de chaque point sur la surface d'un objet (les valeurs peuvent être stockées sous forme de nombres 8 bits ou 16 bits), comme une bumpmap. Les cartes de déplacement sont souvent utilisées (auquel cas elles sont également appelées cartes de hauteur) pour créer un terrain avec des collines et des vallées. Le terrain étant décrit par une carte de déplacement en deux dimensions, il est relativement facile de le déformer si nécessaire, car il suffirait de modifier la carte de déplacement et de rendre la surface basée sur celle-ci dans l'image suivante.

La création d'un paysage à l'aide de la superposition de cartes de déplacement est clairement illustrée sur l'image. Initialement, 4 sommets et 2 polygones ont été utilisés, en conséquence, un morceau à part entière du paysage s'est avéré.

Le gros avantage de la superposition de cartes de déplacement n'est pas seulement la possibilité d'ajouter des détails à la surface, mais la création presque complète de l'objet. Un objet low-poly est pris, divisé (pavage) en plusieurs sommets et polygones. Les sommets produits par la tessellation sont alors déplacés le long de la normale en fonction de la valeur lue dans la carte de déplacement. Nous nous retrouvons avec un objet 3D complexe à partir d'un objet simple en utilisant la carte de déplacement appropriée :

Le nombre de triangles créés par la tessellation doit être suffisamment grand pour capturer tous les détails définis par la carte de déplacement. Parfois, des triangles supplémentaires sont créés automatiquement à l'aide de N-patchs ou d'autres méthodes. Les cartes de déplacement sont mieux utilisées en conjonction avec le mappage de relief pour créer des détails fins là où un éclairage pixel par pixel approprié est suffisant.

Le mappage de déplacement a été pris en charge pour la première fois dans DirectX 9.0. Il s'agissait de la première version de cette API à prendre en charge la technique de mappage de déplacement. DX9 prend en charge deux types de mappage de déplacement, filtré et pré-échantillonné. La première méthode était prise en charge par la puce vidéo oubliée MATROX Parhelia, et la seconde - par l'ATI RADEON 9700. La méthode filtrée diffère en ce qu'elle permet d'utiliser des niveaux mip pour les cartes de déplacement et d'appliquer un filtrage trilinéaire pour celles-ci. Dans cette méthode, le niveau mip de la carte de déplacement est sélectionné pour chaque sommet en fonction de la distance entre le sommet et la caméra, c'est-à-dire que le niveau de détail est automatiquement sélectionné. Cela permet d'obtenir une division presque uniforme de la scène lorsque les triangles ont approximativement la même taille.

La cartographie de déplacement peut essentiellement être considérée comme une technique de compression de la géométrie ; l'utilisation de cartes de déplacement réduit la quantité de mémoire requise pour un certain niveau de détail dans un modèle 3D. Les données géométriques volumineuses sont remplacées par de simples textures de déplacement 2D, généralement 8 bits ou 16 bits. Cela réduit la quantité de mémoire et de bande passante nécessaires pour fournir des données géométriques à la puce vidéo, et ces contraintes sont parmi les principales contraintes des systèmes actuels. Alternativement, avec des exigences de bande passante et de stockage égales, la cartographie de déplacement permet des modèles 3D géométriques beaucoup plus complexes. L'utilisation de modèles de bien moindre complexité, lorsqu'au lieu de dizaines ou centaines de milliers de triangles, on utilise des unités de milliers, elle permet aussi d'accélérer leur animation. Ou améliorez-le en appliquant des algorithmes et des techniques plus complexes, tels que la simulation de tissu.

Un autre avantage est que l'utilisation de cartes de déplacement transforme des maillages 3D polygonaux complexes en plusieurs textures 2D plus faciles à manipuler. Par exemple, pour l'organisation, vous pouvez utiliser un mappage mip régulier pour superposer des cartes de déplacement. De plus, au lieu d'algorithmes relativement complexes pour compresser des maillages tridimensionnels, vous pouvez utiliser les méthodes habituelles de compression de textures, même de type JPEG. Et pour la création procédurale d'objets 3D, vous pouvez utiliser les algorithmes habituels pour les textures 2D.

Mais les cartes de déplacement ont aussi quelques limitations, elles ne peuvent pas être appliquées dans toutes les situations. Par exemple, les objets lisses qui ne contiennent pas beaucoup de détails fins seront mieux représentés sous forme de maillages standard ou d'autres surfaces de niveau supérieur telles que les courbes de Bézier. D'autre part, des modèles très complexes tels que des arbres ou des plantes ne sont pas non plus faciles à représenter avec des cartes de déplacement. Il y a aussi des problèmes avec la commodité de leur utilisation, cela nécessite presque toujours des utilitaires spécialisés, car il est très difficile de créer directement des cartes de déplacement (si l'on ne parle pas d'objets simples, comme un paysage). Bon nombre des problèmes et limitations inhérents aux cartes de déplacement sont les mêmes que ceux de, puisque les deux méthodes sont essentiellement deux représentations différentes d'une idée similaire.

Comme exemple de jeux réels, je citerai un jeu qui utilise l'échantillonnage de texture à partir d'un vertex shader, une fonctionnalité qui est apparue dans les puces vidéo NVIDIA NV40 et Shader Model 3.0. La texturation de sommet peut être appliquée à une méthode simple de superposition de cartes de déplacement entièrement réalisée par le GPU, sans tessellation (séparation en plusieurs triangles). L'utilisation d'un tel algorithme est limitée, ils n'ont de sens que si les cartes sont dynamiques, c'est-à-dire qu'elles changeront au cours du processus. Par exemple, il s'agit d'un rendu de grandes surfaces d'eau, qui est réalisé dans le jeu Pacific Fighters :

Normalmapping est une version améliorée de la technique de bumpmapping décrite précédemment, une version étendue de celle-ci. Le bumpmapping a été développé par Blinn en 1978, où les normales de surface sont modifiées avec cette méthode de cartographie du terrain basée sur les informations des bump maps. Alors que le bumpmapping ne modifie que la normale existante pour les points de surface, le normalmapping remplace complètement les normales en récupérant leurs valeurs à partir d'une normal map spécialement préparée. Ces cartes sont généralement des textures contenant des valeurs normales précalculées, représentées sous forme de composants de couleur RVB (cependant, il existe également des formats spéciaux pour les cartes normales, y compris celles avec compression), contrairement à la hauteur noir et blanc 8 bits cartes en bumpmapping.

En général, comme le bumpmapping, c'est aussi une méthode "pas chère" pour ajouter des détails à des modèles de complexité géométrique relativement faible, sans utiliser une géométrie plus réelle, juste plus avancée. L'une des utilisations les plus intéressantes de la technique est d'augmenter considérablement le détail des modèles low-poly en utilisant des cartes normales obtenues en traitant le même modèle de haute complexité géométrique. Les cartes normales fournissent une description plus détaillée de la surface que le bumpmapping et vous permettent de représenter des formes plus complexes. Des idées pour obtenir des informations à partir d'objets très détaillés ont été exprimées au milieu des années 90 du siècle dernier, mais il s'agissait ensuite d'utiliser pour. Plus tard, en 1998, des idées ont été présentées pour transférer des détails sous la forme de cartes normales des modèles high-poly aux modèles low-poly.

Les cartes normales offrent un moyen plus efficace de stocker des données de surface détaillées que d'utiliser simplement un grand nombre de polygones. Leur seule limitation sérieuse est qu'ils ne sont pas très bien adaptés pour les gros détails, car le mappage normal n'ajoute pas réellement de polygones ou ne modifie pas la forme de l'objet, il en crée seulement l'apparence. Il s'agit simplement d'une simulation de détails basée sur des calculs d'éclairage au niveau des pixels. Aux polygones extrêmes de l'objet et aux grands angles d'inclinaison de la surface, cela est très perceptible. Par conséquent, le moyen le plus raisonnable d'appliquer un mappage normal est de rendre le modèle low poly suffisamment détaillé pour conserver la forme de base de l'objet et d'utiliser des mappages normaux pour ajouter des détails plus fins.

Les cartes normales sont généralement générées à partir de deux versions du modèle, low poly et high poly. Le modèle low poly se compose d'un minimum de géométrie, des formes de base de l'objet, et le modèle high poly contient tout ce dont vous avez besoin pour un maximum de détails. Ensuite, à l'aide d'utilitaires spéciaux, ils sont comparés les uns aux autres, la différence est calculée et stockée dans une texture appelée carte normale. Lors de sa création, vous pouvez également utiliser une map bump pour de très petits détails qui ne peuvent pas être modélisés même dans un modèle high-poly (pores de la peau, autres petites dépressions).

Les cartes normales étaient à l'origine représentées comme des textures RVB régulières, où les composants de couleur R, V et B (0 à 1) sont interprétés comme des coordonnées X, Y et Z. Chaque texel de la carte normale est représenté comme la normale d'un point de surface. Les cartes normales peuvent être de deux types : avec des coordonnées dans l'espace modèle (système de coordonnées général) ou dans l'espace tangent (le terme en russe est « espace tangent », le système de coordonnées local d'un triangle). La deuxième option est plus souvent utilisée. Lorsque des cartes normales sont présentées dans l'espace modèle, elles doivent avoir trois composants, car toutes les directions peuvent être représentées, et dans le système de coordonnées local, l'espace tangent, vous pouvez vous débrouiller avec deux composants et obtenir le troisième dans un pixel shader .

Les applications temps réel modernes surpassent encore largement l'animation pré-rendue en termes de qualité d'image, cela concerne tout d'abord la qualité de l'éclairage et la complexité géométrique des scènes. Le nombre de sommets et de triangles calculés en temps réel est limité. Par conséquent, les méthodes pour réduire la quantité de géométrie sont très importantes. Avant le mappage normal, plusieurs de ces méthodes ont été développées, mais les modèles low poly, même avec le bumpmapping, sont bien pires que les modèles plus complexes. Bien que le mappage normal présente plusieurs inconvénients (le plus évident - puisque le modèle reste low-poly, cela se voit facilement à partir de ses limites angulaires), la qualité du rendu final est sensiblement améliorée, laissant la complexité géométrique des modèles faible. Récemment, une augmentation de la popularité de cette technique et de son utilisation dans tous les moteurs de jeux populaires a été clairement visible. Ceci est dû à la combinaison d'une excellente qualité résultante et d'une réduction simultanée des exigences de complexité géométrique des modèles. La technique de mappage normale est maintenant utilisée presque partout, tous les nouveaux jeux l'utilisent aussi largement que possible. Voici juste une courte liste de jeux PC célèbres utilisant la cartographie normale : Far Cry, Doom 3, Half-Life 2, Call of Duty 2, FEAR, Quake 4. Ils ont tous l'air bien mieux que les jeux du passé, y compris en raison de la utilisation des normales de cartes.

L'utilisation de cette technique n'a qu'une seule conséquence négative : l'augmentation du volume des textures. Après tout, une carte normale affecte fortement l'apparence d'un objet, et sa résolution doit être suffisamment grande, de sorte que les besoins en mémoire vidéo et sa bande passante sont doublés (dans le cas des cartes normales non compressées). Mais maintenant, des cartes vidéo avec 512 mégaoctets de mémoire locale sont déjà produites, sa bande passante ne cesse de croître, des méthodes de compression ont été développées spécifiquement pour les cartes normales, ces petites restrictions ne sont donc pas très importantes, en fait. L'effet du mappage normal est beaucoup plus important, permettant d'utiliser des modèles de poly relativement faible, réduisant les besoins en mémoire pour stocker les données géométriques, améliorant les performances et donnant un résultat visuel très décent.

Mappage de parallaxe / Mappage de décalage

Le mappage normal, développé en 1984, a été suivi du mappage de texture en relief, introduit par Olivera et Bishop en 1999. Il s'agit d'une technique de mappage de texture basée sur des informations de profondeur. La méthode n'a pas trouvé d'application dans les jeux, mais son idée a contribué à la poursuite des travaux sur la cartographie de parallaxe et son amélioration. Kaneko a introduit le mappage de parallaxe en 2001, qui était la première méthode efficace pour rendre l'effet de parallaxe par pixel. En 2004, Welsh a démontré l'utilisation du mappage de parallaxe sur des puces vidéo programmables.

Cette méthode a peut-être les noms les plus différents. Je vais lister ceux que j'ai rencontrés : Parallax Mapping, Offset Mapping, Virtual Displacement Mapping, Per-Pixel Displacement Mapping. Le premier titre est utilisé dans l'article par souci de concision.
Le mappage de parallaxe est une autre alternative aux techniques de mappage de relief et de mappage normal, qui vous donne encore plus d'informations sur les détails de la surface, un affichage plus naturel des surfaces 3D, également sans trop de pénalité de performance. Cette technique est similaire à la fois à la cartographie de déplacement et à la cartographie normale, elle se situe quelque part entre les deux. La méthode est également conçue pour afficher plus de détails de surface que le modèle géométrique d'origine. C'est similaire au mappage normal, mais la différence est que la méthode déforme le mappage de texture en changeant les coordonnées de texture de sorte que lorsque vous regardez la surface sous différents angles, elle semble convexe, bien qu'en réalité la surface soit plate et ne change pas . En d'autres termes, le mappage de parallaxe est une technique d'approximation de l'effet du déplacement des points de surface en fonction d'un changement de point de vue.

La technique décale les coordonnées de la texture (d'où la technique est parfois appelée mappage décalé) de sorte que la surface semble plus volumineuse. L'idée derrière la méthode est de renvoyer les coordonnées de texture du point où le vecteur de vue coupe la surface. Cela nécessite un lancer de rayons (ray tracing) pour la carte de hauteur, mais si elle n'a pas trop de valeurs changeantes ("lisse" ou "lisse"), alors l'approximation peut être supprimée. Cette méthode est bonne pour les surfaces dont les hauteurs varient en douceur, sans erreur de calcul des intersections et des valeurs de décalage importantes. Un algorithme aussi simple diffère du mappage normal avec seulement trois instructions de pixel shader : deux instructions mathématiques et une extraction supplémentaire à partir de la texture. Une fois la nouvelle coordonnée de texture calculée, elle est ensuite utilisée pour lire d'autres couches de texture : texture de base, normal map, etc. Cette méthode de mappage de parallaxe sur les puces vidéo modernes est presque aussi efficace que le mappage de texture conventionnel, et son résultat est un affichage de surface plus réaliste que le simple mappage normal.

Mais l'utilisation de la cartographie de parallaxe conventionnelle est limitée aux cartes de hauteur avec peu de différence de valeurs. Les irrégularités "raides" sont traitées par l'algorithme de manière incorrecte, divers artefacts apparaissent, des textures "flottantes", etc. Plusieurs méthodes modifiées ont été développées pour améliorer la technique de mappage de parallaxe. Plusieurs chercheurs (Yerex, Donnelly, Tatarchuk, Policarpo) ont décrit de nouvelles méthodes qui améliorent l'algorithme initial. Presque toutes les idées sont basées sur le lancer de rayons dans un pixel shader pour déterminer l'intersection des détails de surface les uns avec les autres. Les techniques modifiées ont reçu plusieurs noms différents : Parallax Mapping with Occlusion, Parallax Mapping with Distance Functions, Parallax Occlusion Mapping. Par souci de concision, nous les appellerons tous Mapping d'occlusion de parallaxe.

Les méthodes de cartographie d'occlusion de parallaxe incluent également le lancer de rayons pour déterminer les hauteurs et tenir compte de la visibilité des texels. En effet, vus sous un angle par rapport à la surface, les texels se bloquent, et dans cet esprit, vous pouvez ajouter plus de profondeur à l'effet de parallaxe. L'image résultante devient plus réaliste et de telles méthodes améliorées peuvent être utilisées pour un relief plus profond, elle est idéale pour représenter les murs de briques et de pierre, les trottoirs, etc. Il convient en particulier de noter que la principale différence entre la cartographie de parallaxe et la cartographie de déplacement est que les calculs sont tous par pixel, et non superficiels. C'est pourquoi la méthode porte des noms tels que Virtual Displacement Mapping et Per-Pixel Displacement Mapping. Regardez la photo, c'est difficile à croire, mais les pierres du trottoir ici ne sont qu'un effet pixel par pixel :

La méthode vous permet d'afficher efficacement des surfaces détaillées sans les millions de sommets et de triangles qui seraient nécessaires lors de la mise en œuvre de cette géométrie. Dans le même temps, les détails élevés sont préservés (sauf pour les silhouettes/bords) et les calculs d'animation sont grandement simplifiés. Cette technique est moins chère que l'utilisation de la géométrie réelle, et beaucoup moins de polygones sont utilisés, en particulier dans les cas avec de très petits détails. Il existe de nombreuses applications pour l'algorithme, et il convient mieux aux pierres, briques, etc.

En outre, un avantage supplémentaire est que les cartes de hauteur peuvent changer de manière dynamique (surface de l'eau avec des vagues, trous de balle dans les murs, etc.). L'inconvénient de cette méthode est le manque de silhouettes géométriquement correctes (bords de l'objet), car l'algorithme est pixel par pixel et n'est pas une véritable cartographie de déplacement. Mais cela permet d'économiser des performances sous la forme d'une réduction de la charge de transformation, d'éclairage et d'animation de la géométrie. Enregistre la mémoire vidéo requise pour stocker de gros volumes de données géométriques. La technologie bénéficie également d'une intégration relativement simple dans les applications existantes et de l'utilisation d'utilitaires familiers utilisés pour la cartographie normale dans le processus.

La technique a déjà été utilisée dans des jeux réels récemment. Jusqu'à présent, ils se débrouillent avec une simple cartographie de parallaxe basée sur des cartes de hauteur statiques, sans lancer de rayons et sans calculer les intersections. Voici quelques exemples d'utilisation du mappage de parallaxe dans les jeux :

Post-traitement

Au sens large, le post-traitement est tout ce qui se passe après les principales étapes d'imagerie. En d'autres termes, le post-traitement est toute modification apportée à une image après son rendu. Le post-traitement est un ensemble d'outils permettant de créer des effets visuels spéciaux, et leur création est effectuée une fois le travail principal de rendu de la scène terminé, c'est-à-dire que lors de la création d'effets de post-traitement, une image raster prête à l'emploi est utilisée.

Un exemple simple tiré d'une photographie : vous avez photographié un beau lac avec de la verdure par temps clair. Le ciel est très lumineux et les arbres sont trop sombres. Vous chargez la photo dans un éditeur graphique et commencez à modifier la luminosité, le contraste et d'autres paramètres pour les zones de l'image ou pour l'ensemble de l'image. Mais vous n'avez plus la possibilité de modifier les paramètres de l'appareil photo, vous faites le traitement de l'image finie. Il s'agit du post-traitement. Ou un autre exemple : sélectionner un arrière-plan en photographie de portrait et appliquer un filtre de flou à cette zone pour un effet de profondeur de champ avec une plus grande profondeur. C'est-à-dire que lorsque vous modifiez ou corrigez une image dans un éditeur graphique, vous effectuez un post-traitement. La même chose peut être faite dans le jeu, en temps réel.

Il existe de nombreuses possibilités différentes pour le traitement d'image post-rendu. Tout le monde a probablement vu beaucoup de soi-disant filtres graphiques dans les éditeurs graphiques. C'est exactement ce qu'on appelle les post-filtres : flou, détection des contours, netteté, bruit, lissage, gaufrage, etc. Lorsqu'il est appliqué au rendu 3D en temps réel, cela se fait comme suit - la scène entière est rendue dans une zone spéciale, le rendu cible, et après le rendu principal, cette image est en outre traitée à l'aide de pixel shaders et ensuite seulement affichée à l'écran. Parmi les effets de post-traitement dans les jeux, les plus couramment utilisés sont,,. Il existe de nombreux autres post-effets : bruit, flare, distorsion, sépia, etc.

Voici quelques exemples de post-traitement dans les applications de jeu :

Plage dynamique élevée (HDR)

La plage dynamique élevée (HDR) appliquée aux graphiques 3D est un rendu à plage dynamique élevée. L'essence du HDR est de décrire l'intensité et la couleur avec des quantités physiques réelles. Le modèle habituel pour décrire une image est le RVB, lorsque toutes les couleurs sont représentées comme la somme des couleurs primaires : rouge, vert et bleu, avec des intensités différentes sous forme de valeurs entières possibles de 0 à 255 pour chacune, encodées avec huit bits par couleur. Le rapport de l'intensité maximale au minimum pouvant être affiché par un modèle ou un appareil particulier est appelé plage dynamique. Ainsi, la plage dynamique du modèle RVB est de 256:1 ou 100:1 cd/m2 (deux ordres de grandeur). Ce modèle pour décrire la couleur et l'intensité est communément appelé Low Dynamic Range (LDR).

Les valeurs LDR possibles pour tous les cas ne sont clairement pas suffisantes, une personne est capable de voir une plage beaucoup plus large, en particulier à faible intensité lumineuse, et le modèle RVB est trop limité dans de tels cas (et à des intensités élevées également). La plage dynamique de la vision humaine est de 10 -6 à 10 8 cd/m 2 , soit 10 000 000 000 000 : 1 (14 ordres de grandeur). Nous ne pouvons pas voir toute la plage en même temps, mais la plage visible à l'œil nu à un moment donné est d'environ 10 000:1 (quatre ordres de grandeur). La vision s'adapte progressivement aux valeurs d'une autre partie de la plage d'éclairage, en utilisant ce qu'on appelle l'adaptation, qui peut être facilement décrite par une situation d'extinction de la lumière dans une pièce la nuit - au début, les yeux voient très peu, mais au fil du temps, ils s'adaptent aux conditions d'éclairage modifiées et voient beaucoup plus. ... La même chose se produit lorsque vous remplacez l'environnement sombre par un environnement clair.

Ainsi, la plage dynamique du modèle de description RVB n'est pas suffisante pour représenter des images qu'une personne est capable de voir dans la réalité, ce modèle réduit considérablement les valeurs possibles d'intensité lumineuse dans les parties supérieure et inférieure de la plage. L'exemple le plus courant cité dans les séquences HDR est une image d'une pièce sombre avec une fenêtre donnant sur une rue lumineuse par une journée ensoleillée. Avec le modèle RVB, vous pouvez obtenir soit un affichage normal de ce qui se trouve à l'extérieur de la fenêtre, soit uniquement ce qui se trouve à l'intérieur de la pièce. Les valeurs supérieures à 100 cd/m2 en LDR sont généralement recadrées, c'est pourquoi il est difficile de rendre des sources lumineuses vives directement dans la caméra en rendu 3D.

Jusqu'à présent, les dispositifs d'affichage de données eux-mêmes ne peuvent pas être sérieusement améliorés, et il est logique d'abandonner le LDR dans les calculs, vous pouvez utiliser de vraies valeurs physiques d'intensité et de couleur (ou linéairement proportionnelles), et afficher le maximum possible sur le surveiller. L'essence de la représentation HDR est d'utiliser des valeurs d'intensité et de couleur en quantités physiques réelles ou linéairement proportionnelles et d'utiliser non pas des nombres entiers, mais des nombres à virgule flottante avec une grande précision (par exemple, 16 ou 32 bits). Cela supprime les limitations du modèle RVB et augmente considérablement la plage dynamique de l'image. Mais alors, n'importe quelle image HDR peut être affichée sur n'importe quel support d'affichage (le même moniteur RVB), avec la meilleure qualité possible en utilisant des algorithmes spéciaux.

Le rendu HDR vous permet de modifier l'exposition après avoir rendu l'image. Il permet de simuler l'effet d'adaptation de la vision humaine (passage d'espaces clairs à des pièces sombres et vice versa), permet un éclairage physiquement correct, et est également une solution unifiée pour appliquer des effets de post-traitement (éblouissement, flares, floraison, flou de mouvement). Les algorithmes de traitement d'image, la correction des couleurs, la correction gamma, le flou de mouvement, le bloom et d'autres méthodes de post-traitement sont mieux exécutés dans la représentation HDR.

Dans les applications de rendu 3D en temps réel (les jeux, principalement), le rendu HDR a commencé à être utilisé il n'y a pas si longtemps, car il nécessite des calculs et la prise en charge d'une cible de rendu dans des formats à virgule flottante, qui ne sont d'abord disponibles que sur les puces vidéo prenant en charge DirectX 9. Le chemin de rendu HDR habituel dans les jeux : rendu d'une scène dans un tampon à virgule flottante, post-traitement d'une image dans une gamme de couleurs étendue (modification du contraste et de la luminosité, de la balance des couleurs, des effets d'éblouissement et de flou de mouvement, de la lumière parasite et du comme), en appliquant le mappage des tons pour produire l'image HDR finale sur le périphérique d'affichage LDR. Parfois, les cartes d'environnement sont utilisées aux formats HDR, pour les réflexions statiques sur les objets, l'utilisation du HDR pour simuler des réfractions et des réflexions dynamiques est très intéressante, pour cela, des cartes dynamiques aux formats à virgule flottante peuvent également être utilisées. A cela vous pouvez ajouter plus de light maps, calculées à l'avance et enregistrées au format HDR. Une grande partie de ce qui précède a été fait, par exemple, dans Half-Life 2: Lost Coast.

Le rendu HDR est très utile pour un post-traitement complexe de meilleure qualité que les méthodes conventionnelles. Le même bloom semblera plus réaliste lorsqu'il est calculé dans le modèle de vue HDR. Par exemple, comme c'est le cas dans le jeu Far Cry de Crytek, il utilise des techniques de rendu HDR standard : l'application de filtres de bloom fournis par Kawase et l'opérateur de mappage de tons Reinhard.

Malheureusement, dans certains cas, les développeurs de jeux peuvent cacher sous le nom HDR juste un filtre bloom calculé dans la plage LDR habituelle. Et bien que la plupart de ce qui est fait actuellement dans les jeux avec rendu HDR soit une floraison de meilleure qualité, les avantages du rendu HDR ne se limitent pas à ce post-effet, c'est juste le plus simple à faire.

Autres exemples de rendu HDR dans des applications temps réel :

Le mappage des tons est le processus de conversion d'une plage de luminance HDR en plage LDR affichée par un périphérique de sortie tel qu'un moniteur ou une imprimante, car la sortie d'images HDR vers eux nécessitera la conversion de la plage dynamique et de la gamme du modèle HDR en dynamique LDR correspondante plage, le plus souvent RVB. Après tout, la plage de luminosité présentée en HDR est très large, il s'agit de plusieurs ordres de grandeur de la plage dynamique absolue à la fois, dans une scène. Et la plage qui peut être reproduite sur les appareils de sortie conventionnels (moniteurs, téléviseurs) n'est que d'environ deux ordres de grandeur de plage dynamique.

La conversion HDR en LDR est appelée mappage de tons, et elle est avec perte et imite les propriétés de la vision humaine. Ces algorithmes sont communément appelés déclarations de mappage de tons. Les opérateurs classent toutes les valeurs de luminosité de l'image en trois types différents : sombre, moyen et lumineux. Sur la base de l'évaluation de la luminosité des tons moyens, l'éclairage global est corrigé, les valeurs de luminosité des pixels de la scène sont redistribuées afin d'entrer dans la plage de sortie, les pixels sombres sont éclaircis et les pixels clairs sont assombris. Ensuite, les pixels les plus lumineux de l'image sont mis à l'échelle de la plage du périphérique de sortie ou du modèle de vue de sortie. L'image suivante montre la conversion la plus simple d'une image HDR vers la plage LDR, une transformation linéaire et un opérateur de mappage de tons plus complexe est appliqué au fragment au centre, qui fonctionne comme décrit ci-dessus :

On peut voir que ce n'est qu'avec l'utilisation d'un mappage de tons non linéaire que vous pouvez obtenir le maximum de détails dans l'image, et si vous convertissez linéairement HDR en LDR, de nombreuses petites choses sont tout simplement perdues. Il n'y a pas un seul algorithme de mappage de tons correct ; il existe plusieurs opérateurs qui donnent de bons résultats dans différentes situations. Voici un bon exemple de deux déclarations de mappage de tons différentes :

Avec le rendu HDR, le mappage de tons a récemment été utilisé dans les jeux. Il est devenu possible de simuler éventuellement les propriétés de la vision humaine : perte de netteté dans les scènes sombres, adaptation aux nouvelles conditions d'éclairage lors des transitions de zones très lumineuses à zones sombres et inversement, sensibilité aux changements de contraste, de couleur... C'est ainsi que le ressemble à l'imitation de la capacité de la vision à s'adapter dans Far Cry. La première capture d'écran montre l'image que le joueur voit passer d'une pièce sombre à un espace ouvert très éclairé, et la seconde montre la même image quelques secondes après l'adaptation.

floraison

Bloom est l'un des effets de post-traitement cinématographiques qui éclaircit les parties les plus lumineuses d'une image. C'est l'effet d'une lumière très vive, qui se manifeste sous la forme d'une lueur autour des surfaces lumineuses, après l'application du filtre anti-efflorescence, ces surfaces ne reçoivent pas seulement une luminosité supplémentaire, leur lumière (halo) affecte partiellement les zones plus sombres adjacentes aux surfaces lumineuses du cadre. La façon la plus simple de le montrer est avec un exemple :

Dans les graphiques 3D Bloom, le filtre est créé à l'aide d'un post-traitement supplémentaire - mélangeant une image floue par le filtre de flou (l'image entière ou ses zones lumineuses individuelles, le filtre est généralement appliqué plusieurs fois) et l'image d'origine. L'un des algorithmes de post-filtre Bloom les plus couramment utilisés dans les jeux et autres applications en temps réel :

• La scène est rendue dans un framebuffer, l'intensité de la lueur des objets est écrite dans le canal alpha du buffer.
• Le framebuffer est copié dans une texture spéciale pour le traitement.
• La résolution de la texture est par exemple réduite d'un facteur 4.
• Des filtres anti-aliasing (flou) sont appliqués à l'image plusieurs fois, en fonction des données d'intensité enregistrées dans le canal alpha.
• L'image résultante est mélangée avec l'image d'origine dans le framebuffer et le résultat est affiché à l'écran.

Comme d'autres types de post-traitement, bloom est mieux utilisé lors du rendu dans une plage dynamique élevée (HDR). Exemples supplémentaires de traitement de l'image finale par un filtre bloom à partir d'applications 3D temps réel :

Flou de mouvement

Le flou de mouvement se produit dans les photographies et les films en raison du mouvement des objets dans le cadre pendant le temps d'exposition du cadre, lorsque l'obturateur de l'objectif est ouvert. Une image prise par un appareil photo (photo, film) ne montre pas un instantané pris instantanément avec une durée nulle. En raison de limitations technologiques, le cadre montre une certaine période de temps, pendant ce temps les objets dans le cadre peuvent se déplacer sur une certaine distance, et si cela se produit, alors toutes les positions de l'objet en mouvement pendant l'obturateur ouvert de l'objectif seront présenté sur le cadre comme une image floue le long du vecteur de mouvement ... Cela se produit si l'objet se déplace par rapport à la caméra ou si la caméra est relative à l'objet, et la quantité de flou nous donne une idée de l'ampleur de la vitesse de l'objet.

Dans l'animation tridimensionnelle, à un moment donné (frame), les objets sont situés à certaines coordonnées dans l'espace tridimensionnel, semblable à une caméra virtuelle avec une vitesse d'obturation infiniment rapide. En conséquence, il n'y a pas de flou similaire à celui obtenu par un appareil photo et l'œil humain en regardant des objets en mouvement rapide. Cela semble contre nature et irréaliste. Prenons un exemple simple : plusieurs sphères tournent autour d'un axe. Voici une image de ce à quoi ressemblerait ce mouvement avec et sans flou :

A partir d'une image sans flou, on ne peut même pas dire si les sphères bougent ou non, alors que le flou de mouvement donne une idée précise de la vitesse et de la direction de mouvement des objets. Soit dit en passant, l'absence de flou de mouvement est également la raison pour laquelle le mouvement dans les jeux à 25-30 images par seconde semble saccadé, bien que les films et les vidéos soient superbes avec les mêmes paramètres de fréquence d'images. Pour compenser l'absence de flou de mouvement, une fréquence d'images élevée (60 images par seconde ou plus) ou l'utilisation de méthodes de traitement d'image supplémentaires pour émuler l'effet du flou de mouvement est souhaitable. Ceci est utilisé pour améliorer la fluidité de l'animation et pour l'effet de réalisme photographique et cinématographique en même temps.

L'algorithme de flou de mouvement le plus simple pour les applications en temps réel consiste à utiliser les données des images d'animation précédentes pour restituer l'image actuelle. Mais il existe également des méthodes de flou de mouvement plus efficaces et plus modernes, qui n'utilisent pas les images précédentes, mais sont basées sur les vecteurs de mouvement des objets dans l'image, ajoutant également une seule étape de post-traitement supplémentaire au processus de rendu. L'effet de flou peut être soit en plein écran (généralement effectué en post-traitement), soit pour des objets individuels se déplaçant le plus rapidement.

Applications possibles de l'effet de flou de mouvement dans les jeux : tous les jeux de course (pour créer un effet de très grande vitesse de mouvement et à utiliser pour regarder des rediffusions de type télé), jeux de sport (les mêmes rediffusions et dans le jeu lui-même, le flou peut être appliqué à des objets se déplaçant très rapidement, comme une balle ou une rondelle), des jeux de combat (mouvements rapides des armes de mêlée, des bras et des jambes), de nombreux autres jeux (lors des cinématiques 3D en jeu sur le moteur). Voici quelques exemples d'effets post-flou de mouvement issus de jeux :

Profondeur de champ (DOF)

La profondeur de champ, en bref, est le flou des objets en fonction de leur position par rapport à la mise au point de la caméra. Dans la vraie vie, dans les photographies et dans les films, nous ne voyons pas tous les objets de la même manière, cela est dû à la particularité de la structure de l'œil et de la structure de l'optique des appareils photo et des caméras de cinéma. Les optiques photo et cinématographiques ont une certaine distance, les objets situés à une telle distance de la caméra sont nets et semblent nets dans l'image, et les objets plus éloignés ou proches de la caméra, au contraire, semblent flous, la netteté diminue progressivement avec une distance croissante ou décroissante ...

Comme vous l'avez deviné, il s'agit d'une photographie, pas d'un rendu. En infographie, chaque objet de l'image rendue est parfaitement clair, puisque les lentilles et les optiques ne sont pas imitées dans les calculs. Par conséquent, afin d'atteindre le réalisme des photos et des films, des algorithmes spéciaux doivent être utilisés pour faire quelque chose de similaire pour l'infographie. Ces techniques simulent l'effet d'une mise au point différente sur des objets à différentes distances.

L'une des techniques courantes de rendu en temps réel consiste à mélanger l'image d'origine et sa version floue (passages multiples du filtre de flou) en fonction des données de profondeur des pixels de l'image. Dans les jeux, il existe plusieurs utilisations de l'effet DOF, par exemple, ce sont des vidéos de jeux sur le moteur de jeu, des replays dans des jeux de sport et de course. Exemples de profondeur de champ en temps réel :

Niveau de détail (LOD)

Le niveau de détail dans les applications 3D est une méthode permettant de réduire la complexité du rendu d'une image, de réduire le nombre total de polygones, de textures et d'autres ressources dans une scène, et généralement de réduire sa complexité. Un exemple simple : le modèle du personnage principal se compose de 10 000 polygones. Dans les cas où il est situé à proximité de la caméra dans la scène traitée, il est important que tous les polygones soient utilisés, mais à une très grande distance de la caméra dans l'image finale, il ne prendra que quelques pixels, et il n'y a pas de point dans le traitement des 10 000 polygones. Peut-être, dans ce cas, des centaines de polygones, voire quelques polygones et une texture spécialement préparée suffiront pour approximativement le même affichage du modèle. En conséquence, à des distances moyennes, il est logique d'utiliser un modèle composé de plus de triangles que le modèle le plus simple et moins que le plus complexe.

La méthode LOD est généralement utilisée lors de la modélisation et du rendu de scènes 3D, en utilisant plusieurs niveaux de complexité (géométrique ou autre) pour les objets, proportionnellement à la distance qui les sépare de la caméra. La technique est souvent utilisée par les développeurs de jeux pour réduire le nombre de polygones dans une scène et améliorer les performances. Lorsqu'ils sont situés à proximité de la caméra, des modèles avec un maximum de détails (le nombre de triangles, la taille de la texture, la complexité de la texturation) sont utilisés, pour la meilleure qualité d'image possible et vice versa, lorsque les modèles sont retirés de la caméra, des modèles avec moins de triangles sont utilisés pour augmenter la vitesse de rendu. La modification de la complexité, en particulier du nombre de triangles dans le modèle, peut se produire automatiquement sur la base d'un modèle 3D de complexité maximale, ou peut-être sur la base de plusieurs modèles pré-préparés avec différents niveaux de détail. En utilisant des modèles avec moins de détails pour différentes distances, la complexité de rendu estimée est réduite, avec presque aucune dégradation du détail global de l'image.

La méthode est particulièrement efficace si le nombre d'objets dans la scène est grand et qu'ils sont situés à différentes distances de la caméra. Par exemple, prenez un jeu de sport comme un simulateur de hockey ou de soccer. Les modèles de caractères low poly sont utilisés lorsqu'ils sont éloignés de la caméra, et lors d'un zoom avant, les modèles sont remplacés par d'autres avec un grand nombre de polygones. Cet exemple est très simple et il montre l'essence de la méthode basée sur deux niveaux de détail du modèle, mais personne ne prend la peine de créer plusieurs niveaux de détail afin que l'effet du changement du niveau LOD ne soit pas trop perceptible, de sorte que les détails progressivement « grandir » à mesure que l'objet s'approche.

En plus de la distance de la caméra, d'autres facteurs peuvent également être importants pour le LOD - le nombre total d'objets à l'écran (lorsqu'un ou deux caractères sont dans le cadre, des modèles complexes sont utilisés, et lorsque 10-20, ils passer à des plus simples) ou le nombre d'images par seconde (les limites des valeurs FPS sont définies, auxquelles le niveau de détail change, par exemple, à FPS inférieur à 30, nous réduisons la complexité des modèles à l'écran, et à 60, au contraire, augmenter). D'autres facteurs possibles affectant le niveau de détail sont la vitesse de déplacement de l'objet (vous aurez à peine le temps d'envisager une fusée en mouvement, mais vous pouvez facilement voir un escargot), l'importance d'un personnage d'un point de vue du jeu ( prenez le même ballon de football - pour un modèle de joueur que vous contrôlez, vous pouvez utiliser une géométrie et des textures plus complexes, vous le voyez le plus près et le plus souvent). Tout dépend des désirs et des capacités d'un développeur particulier. L'essentiel est de ne pas en faire trop, les changements fréquents et notables du niveau de détail sont ennuyeux.

Je rappelle que le niveau de détail ne concerne pas forcément que la géométrie, la méthode peut aussi être utilisée pour économiser d'autres ressources : lors de la texturation (bien que les puces vidéo utilisent déjà le mipmapping, il est parfois judicieux de changer de texture à la volée pour d'autres avec différents détails), techniques d'éclairage (les objets proches sont illuminés à l'aide d'un algorithme complexe et les objets distants - en utilisant un simple), technique de texturation (le mappage de parallaxe complexe est utilisé sur les surfaces proches et le mappage normal est utilisé sur les surfaces éloignées), etc. .

Il n'est pas si facile de montrer un exemple du jeu, d'une part, dans une certaine mesure, le LOD est utilisé dans presque tous les jeux, d'autre part, il n'est pas toujours possible de le montrer clairement, sinon cela ne servirait à rien en LOD lui-même.

Mais dans cet exemple, il est toujours clair que le modèle de voiture le plus proche a un maximum de détails, les deux ou trois voitures suivantes sont également très proches de ce niveau, et toutes les plus éloignées ont des simplifications visibles, voici les plus significatives : il y a pas de rétroviseurs, plaques d'immatriculation, essuie-glaces, etc. équipement d'éclairage supplémentaire. Et du modèle le plus éloigné, il n'y a même pas une ombre sur la route. C'est l'algorithme de niveau de détail en action.

Illumination globale

Il est difficile de simuler un éclairage réaliste d'une scène, chaque rayon lumineux étant en réalité réfléchi et réfracté de manière répétée, le nombre de ces réflexions n'est pas limité. Et dans le rendu 3D, le nombre de réflexions dépend fortement des capacités de conception, tout calcul de scène est un modèle physique simplifié, et l'image résultante n'est que proche du réalisme.

Les algorithmes d'éclairage peuvent être divisés en deux modèles : illumination directe ou locale et illumination globale (illumination directe ou locale et illumination globale). Le modèle d'éclairage local utilise le calcul de l'éclairage direct, de la lumière des sources lumineuses à la première intersection de la lumière avec une surface opaque, l'interaction des objets entre eux n'est pas prise en compte. Bien qu'un tel modèle essaie de compenser cela en ajoutant un éclairage de fond ou un éclairage (ambiant) uniforme, c'est l'approximation la plus simple, un éclairage très simplifié de tous les rayons indirects de sources lumineuses, qui spécifie la couleur et l'intensité d'éclairage des objets en l'absence de sources lumineuses directes.

Le même lancer de rayons calcule l'éclairage des surfaces uniquement par les rayons directs des sources lumineuses et toute surface, pour être visible, doit être directement éclairée par une source lumineuse. Cela ne suffit pas pour obtenir des résultats photoréalistes ; en plus de l'éclairage direct, il faut prendre en compte l'éclairage secondaire par les rayons réfléchis par d'autres surfaces. Dans le monde réel, les rayons lumineux sont réfléchis plusieurs fois sur les surfaces jusqu'à ce qu'ils soient complètement éteints. La lumière du soleil passant à travers une fenêtre illumine toute la pièce, bien que les rayons ne puissent pas atteindre directement toutes les surfaces. Plus la source lumineuse est lumineuse, plus elle sera réfléchie. La couleur de la surface réfléchissante affecte également la couleur de la lumière réfléchie, par exemple un mur rouge provoquera une tache rouge sur un objet blanc adjacent. Voici une nette différence, calcul sans et en tenant compte de l'éclairage secondaire :

Dans le modèle d'éclairage global, l'éclairage global, l'éclairage est calculé en tenant compte de l'influence des objets les uns sur les autres, les réflexions et réfractions multiples des rayons lumineux provenant des surfaces des objets, les caustiques et la diffusion souterraine sont prises en compte. Ce modèle vous permet d'obtenir une image plus réaliste, mais complique le processus, nécessitant beaucoup plus de ressources. Il existe plusieurs algorithmes d'illumination globale, nous aborderons rapidement la radiosité (calcul d'illumination indirecte) et le mappage de photons (calcul d'illumination globale basé sur des cartes de photons pré-calculées à l'aide du traçage). Il existe également des méthodes simplifiées pour simuler l'éclairage indirect, telles que la modification de la luminosité globale d'une scène en fonction du nombre et de la luminosité des sources lumineuses, ou l'utilisation d'un grand nombre de lumières ponctuelles placées autour de la scène pour simuler la lumière réfléchie, mais toujours c'est loin d'être un vrai algorithme.GI.

L'algorithme de radiosité est le processus de calcul des réflexions secondaires des rayons lumineux d'une surface à une autre, ainsi que de l'environnement aux objets. Les rayons des sources lumineuses sont tracés jusqu'à ce que leur intensité tombe en dessous d'un certain niveau ou que les rayons atteignent un certain nombre de réflexions. Il s'agit d'une technique GI courante, les calculs sont généralement effectués avant le rendu et les résultats du calcul peuvent être utilisés pour le rendu en temps réel. Les idées de base de la radiosité sont basées sur la physique du transfert de chaleur. Les surfaces des objets sont divisées en petites zones appelées patchs, et on suppose que la lumière réfléchie est diffusée uniformément dans toutes les directions. Au lieu de calculer chaque faisceau pour les lumières, une technique de moyenne est utilisée, divisant les lumières en patchs en fonction des niveaux d'énergie qu'elles produisent. Cette énergie est répartie proportionnellement entre les plaques de surface.

Une autre méthode de calcul de l'illumination globale, proposée par Henrik Wann Jensen, est la méthode de cartographie des photons. La cartographie photonique est un autre algorithme d'éclairage global par lancer de rayons utilisé pour simuler la façon dont les rayons lumineux interagissent avec les objets d'une scène. L'algorithme calcule les réflexions secondaires des rayons, la réfraction de la lumière à travers les surfaces transparentes, les réflexions diffusées. Cette méthode consiste à calculer l'éclairement des points de la surface en deux passes. Le premier est le traçage direct des rayons lumineux avec des réflexions secondaires, c'est un processus préliminaire qui est effectué avant le rendu principal. Cette méthode calcule l'énergie des photons allant de la source lumineuse aux objets de la scène. Lorsque les photons atteignent la surface, le point d'intersection, la direction et l'énergie du photon sont stockés dans un cache appelé photon map. Les cartes photoniques peuvent être enregistrées sur disque pour une utilisation ultérieure afin qu'elles n'aient pas à être rendues à chaque image. Les réflexions des photons sont calculées jusqu'à ce que le travail s'arrête après un certain nombre de réflexions ou lorsqu'une certaine énergie est atteinte. Dans la deuxième passe de rendu, l'éclairement des pixels de la scène avec des rayons directs est calculé, en tenant compte des données stockées dans les cartes photoniques, l'énergie photonique est ajoutée à l'énergie de l'éclairement direct.

Les calculs d'illumination globale qui utilisent un grand nombre de réflexions secondaires prennent beaucoup plus de temps que les calculs d'illumination directe. Il existe des techniques de calcul matériel d'une ville radio en temps réel, qui utilisent les capacités des dernières générations de puces vidéo programmables, mais pour l'instant les scènes pour lesquelles l'illumination globale est calculée en temps réel devraient être assez simples et de nombreuses simplifications sont fait dans les algorithmes.

Mais ce qui est utilisé depuis longtemps, c'est l'éclairage global statique pré-calculé, ce qui est acceptable pour les scènes sans changer la position des sources lumineuses et des gros objets qui affectent fortement l'éclairage. Après tout, le calcul de l'éclairage global ne dépend pas de la position de l'observateur, et si la position de ces objets dans la scène et les paramètres des sources d'éclairage ne changent pas dans la scène, alors les valeurs d'éclairage précédemment calculées peut être utilisé. Ceci est utilisé dans de nombreux jeux, stockant les données de calcul de l'IG sous forme de lightmaps.

Il existe également des algorithmes acceptables pour simuler un éclairage global dynamique. Par exemple, il existe une méthode si simple à utiliser dans les applications en temps réel pour calculer l'éclairage indirect d'un objet dans une scène : un rendu simplifié de tous les objets avec des détails réduits (à l'exception de celui pour lequel l'éclairage est calculé) en un carte de cube basse résolution (elle peut également être utilisée pour afficher des réflexions dynamiques sur la surface d'un objet), puis filtrer cette texture (plusieurs passages du filtre de flou) et appliquer les données de la texture calculée pour éclairer cet objet comme un complément à l'éclairage direct. Dans les cas où le calcul dynamique est trop lourd, vous pouvez vous en tirer avec des cartes de radiosité statiques. Un exemple tiré du jeu MotoGP 2, qui montre clairement l'effet bénéfique d'une imitation aussi simple de GI :

Cette instruction vous aidera à installer des shaders dans Minecraft et ainsi à améliorer le monde du jeu en ajoutant des ombres dynamiques, des bruits de vent et d'herbe, de l'eau réaliste et bien plus encore.

A noter tout de suite que les shaders chargent assez lourdement le système, et si vous avez une carte vidéo faible ou intégrée, nous vous recommandons de ne pas installer ce mod.

L'installation se compose de deux étapes, vous devez d'abord installer le mod sur les shaders, puis des shaderpacks supplémentaires.

ÉTAPE #1 - Installation du mod pour les shaders

1. Télécharger et installer Java
2. Installer OptiFine HD
   ou Shadersmod;
3. Nous décompressons l'archive résultante à n'importe quel endroit ;
4. Exécutez le fichier jar, car il est installateur ;
5. Le programme vous montrera le chemin vers le jeu, si tout est correct, cliquez sur Oui, Ok, Ok ;
6. Aller à .Minecraft et créer un dossier là-bas shaderpacks;
7. Nous allons dans le lanceur et voyons dans la ligne un nouveau profil avec le nom "ShadersMod", sinon, sélectionnez-le manuellement.
8. Ensuite, vous devez télécharger les shaderpacks

ÉTAPE #2 - Installation du shaderpack

1. Téléchargez le shaderpack qui vous intéresse (liste en fin d'article)
2. Appuyez sur les touches GAGNER + R
3. Aller à .minecraft / shaderpacks... S'il n'y a pas de tel dossier, créez-le.
4. Déplacez ou extrayez l'archive du shader vers .minecraft / shaderpacks... Le chemin devrait ressembler à ceci : .minecraft / shaderpacks / SHADER_FOLDER_NAME / shaders / [fichiers .fsh et .vsh à l'intérieur]
5. Démarrez Minecraft et partez Paramètres> Ombrages... Ici, vous verrez une liste des shaders disponibles. Sélectionnez le requis
6. Dans les paramètres du shader, activez "tweakBlockDamage", désactivez "CloudShadow" et "OldLighting"

Les incroyables shaders de Sonic Ether
Les shaders de Sildur
Shaders Chocapic13"
Sensi277 "s yShaders
MrMeep_x3 "s Shaders
Cel Shaders de Naelego
Shaders RRe36"
Shaders CUDA de DeDelner
Bruceatsr44 "s Acid Shaders
Shaders de Beed28"
Pack de shaders de Ziipzaap
robobo1221 "s Shaders
dvv16 "s Shaders
Super shaders Stazza85
hoo00 "s Shaders pack B
Plantes ondulantes de Regi24
Pack d'ombrage MrButternuss
Des graphismes impressionnants de DethRaid sur les shaders Nitro
Edi "s Shader ForALLPc" s
Shaders TME de CrankerMan
Kadir Nck Shader (pour skate702)
Shaders de Werrus
Shaders Nexus de la vie de Knewtonwako
Shaderpack CYBOX
CrapDeShoes CloudShade Alpha
Shader AirLoocke42
Shaders BSL de CaptTatsu
Les shaders de Triliton
ShadersMcOfficial "s Bloominx Shaders (Shaders Chocapic13")
Shaders continus dotModded "s
Shaders lunaires Qwqx71 "s (shader chocapic13")

- Igor (Administrateur)

Dans le cadre de cet article, je vais vous dire en termes simples ce que sont les shaders, ainsi que pourquoi ils sont nécessaires.

Les exigences de qualité de l'infographie grandissent de jour en jour. Auparavant, les graphismes 2D étaient considérés comme suffisants et suffisants pour émerveiller l'imagination de millions de personnes. À l'heure actuelle, beaucoup plus d'attention est accordée à la visualisation.

Cependant, lors de la formation des graphiques 3D actuels, beaucoup ont été confrontés au problème du manque de filtres et de gadgets intégrés pour les cartes vidéo (GPU). Par exemple, il y avait souvent besoin de leurs propres effets. Par conséquent, beaucoup de choses devaient être faites manuellement et effectuer des calculs dans le processeur principal de l'ordinateur (CPU), ce qui a sans aucun doute affecté les performances (malgré le fait que le vidyuha, comme on dit, était "inactif" au ralenti).

Ainsi, au fil du temps, différentes technologies ont vu le jour, comme les shaders, qui permettent d'utiliser la puissance du GPU pour des besoins spécifiques.

Que sont les shaders et pourquoi sont-ils nécessaires ?

Ombrage- un programme informatique (code) qui peut être exécuté dans les processeurs de la carte vidéo sans gaspiller inutilement la puissance du processeur central. De plus, des pipelines peuvent être construits à partir de ces shaders (leur utilisation séquentielle). C'est-à-dire que le même shader peut être appliqué à différents types d'objets graphiques, ce qui simplifie grandement le processus de création d'animation.

Initialement, les cartes vidéo signifiaient trois types - sommet (pour les effets de sommets individuels ; par exemple, pour créer l'effet de vagues, dessiner de l'herbe, etc.), géométrique (pour les petites primitives ; par exemple, pour créer des silhouettes) et pixel ( pour les filtres d'une certaine zone de l'image ; par exemple, le brouillard). Et, par conséquent, il y avait trois types de processeurs spécialisés dans le conseil d'administration. Plus tard, cette division a été abandonnée et tous les processeurs de carte vidéo sont devenus universels (ils prennent en charge les trois types).

Réduire la charge CPU globale n'est pas tout l'intérêt de pouvoir créer vos propres shaders. Il faut comprendre que de nombreux jeux et vidéos réutilisent les mêmes fonctionnalités. Par exemple, pourquoi écrire, par exemple, des effets pour l'eau dans des dizaines de programmes d'animation similaires à partir de zéro, si vous pouvez utiliser des bibliothèques prêtes à l'emploi telles que OpenGL ou DirectX ? Ces derniers contiennent de nombreux shaders déjà implémentés et offrent une méthode plus pratique pour écrire le vôtre (pas besoin d'écrire des instructions de bas niveau pour le GPU).

C'est-à-dire que si auparavant, pour créer l'animation ou le jeu le plus simple, il fallait avoir des connaissances importantes, dans les réalités d'aujourd'hui, c'est une tâche réalisable pour beaucoup.

A quoi sert l'approche shader ?

Il existe une certaine confusion avec les shaders, car il existe différentes normes de langage de programmation pour différentes bibliothèques (GLSL - OpenGL, HLSL - DirectX, etc.), et cela sans compter le fait que les fabricants de cartes vidéo eux-mêmes peuvent prendre en charge diverses fonctionnalités. Cependant, le plus de leur utilisation peut être facilement évalué en regardant l'image ci-dessus avec un exemple de la différence d'affichage entre DirectX 9 et DirectX 10.

Ainsi, si vous utilisez des shaders d'une bibliothèque bien connue, alors la sortie de la prochaine version suffit pour que la qualité augmente d'elle-même. Bien sûr, il y a des nuances ici, telles que la compatibilité, la prise en charge des commandes spécialisées qui sont apparues, etc., mais quand même.

En plus des graphiques, l'approche des shaders est utile pour les utilisateurs ordinaires des manières suivantes :

1. La vitesse et les performances de l'ordinateur augmentent (après tout, le processeur central n'a pas besoin de calculer les graphiques à la place du GPU).

Une question assez courante pour les joueurs curieux et les créateurs de jeux débutants.

Shader (shader anglais - programme d'ombrage) est un programme pour une carte vidéo, qui est utilisé dans les graphiques 3D pour comprendre les caractéristiques finales d'un objet ou d'une image, peut inclure la présentation de l'absorption et de la diffusion de la lumière, le mappage de texture, l'affichage et la réfraction , ombrage, déplacement de surface, etc. un grand nombre d'autres caractéristiques.

Les shaders sont de petits, pour ainsi dire, des "scripts pour une carte vidéo". Permettez-en assez pour simplement incarner ces divers effets spéciaux et effets.

Parfois pixelisé (travail avec des images - c'est-à-dire avec un plein écran ou avec des textures) et vertex (travail avec des objets 3D). Par exemple, en utilisant des pixel shaders, des effets tels que des textures 3D (bump), des textures de parallaxe, des rayons de soleil (sunshafts) à la Crisis, range blur, simplement motion blur, textures animées (eau, lave, ... ), HDR, anti -aliasing, shadows (basé sur le workflow ShadowMaps), et plus encore. Les shaders de vertex font des animations d'herbe, de héros, d'arbres, font des vagues sur l'eau (telles que grandes), etc. Plus l'effet est difficile (qualité supérieure, plus moderne), plus il a besoin de commandes dans le code du shader. Mais les shaders de différentes versions (1.1 - 5.0) prennent en charge un nombre différent de commandes : plus la version est élevée, plus vous pouvez utiliser de commandes. Pour cette raison, il n'est pas réaliste d'implémenter certains processus technologiques sur les shaders les plus bas. Par exemple, pour cette raison particulière, le plus récent Dead Space 2 demande la 3e version des shaders (à la fois en pixels et en vertex) - car il a un tel modèle d'éclairage qui ne peut être implémenté que sur la 3e version et les versions supérieures des shaders.

Options d'ombrage

Selon l'étape du pipeline, les shaders sont divisés en un certain nombre de types : vertex, fragment (pixel) et géométrique. Eh bien, les nouveaux types de pipelines ont toujours des shaders de tessellation. Nous ne discuterons pas en détail du pipeline graphique, je pense toujours à ne pas écrire d'article séparé à ce sujet, pour ceux qui décident d'étudier les shaders et la programmation graphique. Écrivez dans les commentaires si vous êtes curieux, j'aurai des informations, ça vaut la peine de perdre du temps.

Ombrage de sommet :
Les shaders Vertex font des animations de héros, d'herbe, d'arbres, font des vagues sur l'eau et presque toutes les autres choses. Dans le vertex shader, le programmeur a accès aux données relatives aux sommets, par exemple : les coordonnées d'un sommet dans l'espace, ses coordonnées de texture, sa couleur et un vecteur normal.

Ombrage géométrique :
Les shaders géométriques sont prêts à créer la dernière géométrie et peuvent être utilisés pour créer des particules, configurer les détails du modèle à la volée, façonner des silhouettes, etc. Contrairement au sommet précédent, nous sommes prêts à traiter non seulement un sommet, mais aussi toute une primitive. La primitive peut être un segment (2 sommets) et un triangle (3 sommets), et s'il existe des informations sur les sommets adjacents (adjacence en anglais) pour une primitive triangulaire, jusqu'à 6 sommets peuvent être traités.

Ombrage de pixels :
Les shaders de pixels effectuent le mappage de texture, l'éclairage et divers effets de texture tels que la réflexion, la réfraction, le brouillard, le mappage de bosses, etc. Les shaders de pixels sont également utilisés pour les post-effets. Le pixel shader fonctionne avec les moments et les textures bitmap - il traite les données associées aux pixels (par exemple, la couleur, la profondeur, les coordonnées de texture). Le pixel shader est utilisé à l'étape finale du pipeline graphique pour former un fragment d'image.

Conclusion : un shader est une variété d'effets sur une image, tout comme vous traitez votre photo sur votre téléphone dans différents tons ou motifs.

"itemprop =" image ">

« Qu'est-ce que les shaders ? » C'est une question très courante des joueurs curieux et des développeurs de jeux novices. Dans cet article je vais vous parler de ces terribles shaders de manière lucide et compréhensible.

Je considère les jeux informatiques comme le moteur du progrès vers des images photoréalistes en infographie, parlons donc de ce que sont les « shaders » dans le contexte des jeux vidéo.

Avant l'apparition des premiers accélérateurs graphiques, tout le travail de rendu des images d'un jeu vidéo était effectué par le pauvre processeur central.

Dessiner un cadre est en fait un travail assez routinier : vous devez prendre de la "géométrie" - des modèles polygonaux (monde, personnage, arme, etc.) et le pixelliser. Qu'est-ce que la rastérisation ? L'ensemble du modèle 3D se compose des plus petits triangles, que le rastériseur transforme en pixels (c'est-à-dire que "rasteriser" signifie transformer en pixels). Après la rastérisation, prenez les données de texture, les paramètres d'éclairage, le brouillard, etc. et calculez chaque pixel résultant du cadre de jeu, qui sera affiché au joueur.

Ainsi, l'unité centrale de traitement (CPU - Central Processing Unit) est un gars trop intelligent pour lui faire faire une telle routine. Au lieu de cela, il est logique d'allouer une sorte de module matériel qui décharge le processeur afin qu'il puisse effectuer un travail intellectuel plus important.

Un tel module matériel est un accélérateur graphique ou une carte vidéo (GPU - Graphics Processing Unit). Maintenant, la CPU prépare les données et charge un collègue de travail de routine. Considérant que le GPU n'est plus qu'un seul collègue, c'est une foule de minions-cores, alors il fait face à un tel travail à la fois.

Mais nous n'avons pas encore reçu de réponse à la question principale : que sont les shaders ? Attends, j'y arrive.

Des graphismes agréables, intéressants et proches du photo-réalisme, ont obligé les développeurs de cartes vidéo à implémenter de nombreux algorithmes au niveau matériel. Ombres, lumières, reflets et ainsi de suite. Cette approche - avec la mise en œuvre d'algorithmes dans le matériel est appelée "pipeline ou pipeline fixe" et où des graphiques de haute qualité sont requis, elle n'est plus trouvée. Sa place a été prise par le Pipeline Programmable.

Demandes des joueurs « Allez, apportez un bon graphonium ! surprise ! », a poussé les développeurs de jeux (et les fabricants de cartes vidéo, respectivement) à des algorithmes de plus en plus complexes. Jusqu'à présent, à un moment donné, il n'y a pas assez d'algorithmes matériels câblés pour eux.

Il est maintenant temps que les cartes graphiques deviennent plus intelligentes. La décision a été prise de permettre aux développeurs de programmer des blocs GPU dans des pipelines arbitraires qui implémentent différents algorithmes. C'est-à-dire que les développeurs de jeux, les programmeurs graphiques ont maintenant été capables d'écrire des programmes pour les cartes vidéo.

Et maintenant, enfin, nous sommes arrivés à la réponse à notre question principale.

« Qu'est-ce que les shaders ? »

Shader (shader anglais - programme d'ombrage) est un programme pour une carte vidéo qui est utilisé dans les graphiques en trois dimensions pour déterminer les paramètres finaux d'un objet ou d'une image, peut inclure la description de l'absorption et de la diffusion de la lumière, le mappage de texture, la réflexion et réfraction, ombrage, déplacement de surface, etc. de nombreux autres paramètres.

Que sont les shaders ? Par exemple, vous pouvez obtenir cet effet, il s'agit d'un shader d'eau appliqué à une sphère.

Pipeline graphique

L'avantage du pipeline programmable par rapport à son prédécesseur est que les programmeurs peuvent désormais créer leurs propres algorithmes et ne pas utiliser un ensemble d'options câblées.

Au début, les cartes vidéo étaient équipées de plusieurs processeurs spécialisés prenant en charge différents ensembles d'instructions. Les shaders ont été divisés en trois types, selon le processeur qui les exécutera. Mais ensuite, les cartes vidéo ont commencé à être équipées de processeurs universels prenant en charge les jeux d'instructions pour les trois types de shaders. La division des shaders en types a été conservée pour décrire le but du shader.

En plus des tâches graphiques avec de telles cartes vidéo intelligentes, il est devenu possible d'effectuer des calculs à usage général (non liés à l'infographie) sur le GPU.

Pour la première fois, une prise en charge à part entière des shaders est apparue dans les cartes vidéo de la série GeForce 3, mais les débuts ont été implémentés dans la GeForce256 (sous la forme de Register Combiners).

Types de shaders

Selon l'étape du pipeline, les shaders sont divisés en plusieurs types : vertex, fragment (pixel) et géométrique. Et dans les derniers types de pipelines, il existe également des shaders de tessellation. Nous ne discuterons pas du pipeline graphique en détail, je pense toujours à écrire un article séparé à ce sujet, pour ceux qui décident d'étudier les shaders et la programmation graphique. Écrivez dans les commentaires si vous êtes intéressé, je saurai si cela vaut la peine de perdre du temps.

Ombrage de sommet

Les vertex shaders font des animations de personnages, d'herbe, d'arbres, créent des vagues sur l'eau et bien d'autres choses. Dans un vertex shader, le programmeur a accès aux données relatives aux sommets, par exemple : les coordonnées d'un sommet dans l'espace, ses coordonnées de texture, sa couleur et un vecteur normal.

Ombrage géométrique

Les shaders géométriques sont capables de créer une nouvelle géométrie et peuvent être utilisés pour créer des particules, modifier les détails du modèle à la volée, créer des silhouettes, etc. Contrairement au sommet précédent, ils sont capables de traiter non seulement un sommet, mais également toute une primitive. La primitive peut être un segment (deux sommets) et un triangle (trois sommets), et s'il existe des informations sur les sommets adjacents (adjacence en anglais) pour une primitive triangulaire, jusqu'à six sommets peuvent être traités.

Ombrage de pixels

Les shaders de pixels effectuent le mappage de texture, l'éclairage et divers effets de texture tels que la réflexion, la réfraction, le brouillard, le mappage de bosses, etc. Les shaders de pixels sont également utilisés pour les post-effets.

Le pixel shader fonctionne avec des tranches et des textures bitmap - il traite les données associées aux pixels (par exemple, la couleur, la profondeur, les coordonnées de texture). Le pixel shader est utilisé à la dernière étape du pipeline graphique pour former un fragment d'image.

Sur quoi les shaders écrivent-ils ?

Initialement, les shaders pouvaient être écrits dans un langage de type assembleur, mais plus tard, il y avait des langages de shaders de haut niveau similaires au langage C, tels que Cg, GLSL et HLSL.

De tels langages sont beaucoup plus simples que C, car les tâches résolues avec leur aide sont beaucoup plus simples. Le système de types dans ces langages reflète les besoins des programmeurs graphiques. Par conséquent, ils fournissent au programmeur des types de données spéciaux : matrices, échantillonneurs, vecteurs, etc.

RenduHomme

Tout ce que nous avons discuté ci-dessus est lié aux graphiques en temps réel. Mais il y a des graphiques non temps réel. Quelle est la différence - temps réel - temps réel, c'est-à-dire ici et maintenant - pour donner 60 images par seconde dans le jeu, c'est un processus en temps réel. Mais le rendu d'une image complexe pour une animation de pointe pendant quelques minutes n'est pas en temps réel. L'essentiel est dans le temps.

Par exemple, on ne peut pas obtenir des graphismes d'une telle qualité que dans les derniers films d'animation du studio Pixar en temps réel. De très grandes fermes de rendu calculent des simulations de lumière en utilisant des algorithmes complètement différents, très coûteux, mais donnant des images presque photoréalistes.

Graphismes super réalistes dans Sand Piper

Par exemple, regardez ce dessin animé mignon, des grains de sable, des plumes d'oiseaux, des vagues, tout a l'air incroyablement réel.

* Les vidéos peuvent être interdites de Youtube, si elles ne s'ouvrent pas, google Pixar sandpiper - le court dessin animé sur le brave bécasseau est très mignon et moelleux. Touchera et démontrera à quel point l'infographie peut être cool.

Voici donc RenderMan de Pixar. Il est devenu le premier langage de programmation de shader. L'API RenderMan est la norme de facto pour le rendu professionnel et est utilisée dans tous les travaux Pixar et au-delà.

Informations utiles

Vous savez maintenant ce que sont les shaders, mais en plus des shaders, il y a d'autres sujets très intéressants dans le développement de jeux et l'infographie qui vous intéresseront certainement :

• est une technique pour créer des effets étonnants dans les jeux vidéo modernes. Article de présentation et vidéo avec des tutoriels sur la création d'effets dans Unity3d
• - Si vous envisagez de développer des jeux vidéo dans le cadre d'une carrière professionnelle ou d'un passe-temps, cet article contient un excellent ensemble de recommandations "par où commencer", "quels livres lire", etc.

Si vous avez des questions

Comme d'habitude, si vous avez encore des questions, posez-les dans les commentaires, j'y répondrai toujours. Pour tout mot aimable ou correction d'erreurs, je vous serais très reconnaissant.