Attention: Here be dragons
This is the latest
(unstable) version of this documentation, which may document features
not available in or compatible with released stable versions of Godot.
Checking the stable version of the documentation...
BaseMaterial3D
Hérite de : Material < Resource < RefCounted < Object
Hérité par : ORMMaterial3D, StandardMaterial3D
Classe de base abstraite pour définir les propriétés de rendu 3D de maillages.
Description
Cette classe sert de matériau par défaut avec une grande variété de fonctionnalités et de propriétés de rendu sans avoir besoin d'écrire de code de shader. Voir le tutoriel ci-dessous pour plus de détails.
Tutoriels
Propriétés
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
Méthodes
get_feature(feature: Feature) const |
|
get_texture(param: TextureParam) const |
|
void |
set_feature(feature: Feature, enable: bool) |
void |
|
void |
set_texture(param: TextureParam, texture: Texture2D) |
Énumérations
enum TextureParam: 🔗
TextureParam TEXTURE_ALBEDO = 0
La texture spécifiant la couleur par pixel.
TextureParam TEXTURE_METALLIC = 1
La texture spécifiant la valeur métallique par pixel.
TextureParam TEXTURE_ROUGHNESS = 2
La texture spécifiant la valeur de rugosité par pixel.
TextureParam TEXTURE_EMISSION = 3
La texture spécifiant la couleur d’émission par pixel.
TextureParam TEXTURE_NORMAL = 4
La texture spécifiant le vecteur de normale par pixel.
TextureParam TEXTURE_BENT_NORMAL = 18
La texture spécifiant le vecteur de normale de courbure par pixel.
TextureParam TEXTURE_RIM = 5
La texture spécifiant la valeur du bord par pixel.
TextureParam TEXTURE_CLEARCOAT = 6
La texture spécifiant la valeur du vernis par pixel.
TextureParam TEXTURE_FLOWMAP = 7
Texture spécifiant la direction de la flowmap par pixel à utiliser avec anisotropy.
TextureParam TEXTURE_AMBIENT_OCCLUSION = 8
La texture spécifiant la valeur de l'occlusion ambiante par pixel.
TextureParam TEXTURE_HEIGHTMAP = 9
La texture spécifiant la hauteur par pixel.
TextureParam TEXTURE_SUBSURFACE_SCATTERING = 10
La texture spécifiant la transluminescence par pixel.
TextureParam TEXTURE_SUBSURFACE_TRANSMITTANCE = 11
Texture spécifiant par pixel la transmittance pour la transluminescence.
TextureParam TEXTURE_BACKLIGHT = 12
Texture spécifiant la couleur du rétroéclairage par pixel.
TextureParam TEXTURE_REFRACTION = 13
La texture spécifiant la force de réfraction par pixel.
TextureParam TEXTURE_DETAIL_MASK = 14
La texture spécifiant la valeur de mélange des masques de détail par pixel.
TextureParam TEXTURE_DETAIL_ALBEDO = 15
La texture spécifiant la couleur des détails par pixel.
TextureParam TEXTURE_DETAIL_NORMAL = 16
La texture spécifiant le détail de la normale par pixel.
TextureParam TEXTURE_ORM = 17
Texture contenant l'occlusion ambiante, la rugosité, et le métalisme.
TextureParam TEXTURE_MAX = 19
Représente la taille de l’enum TextureParam.
enum TextureFilter: 🔗
TextureFilter TEXTURE_FILTER_NEAREST = 0
Le filtrage de texture lit le pixel le plus proche seulement. Cela rend la texture pixelisée de loin, et granuleuse à une certaine distance (à cause des mipmaps qui ne sont pas échantillonnées).
TextureFilter TEXTURE_FILTER_LINEAR = 1
Le filtrage de texture mélange les 4 pixels les plus proches. Cela rend la texture lisse de près, et granuleuse à une certaine distance (à cause des mipmaps qui ne sont pas échantillonnées).
TextureFilter TEXTURE_FILTER_NEAREST_WITH_MIPMAPS = 2
Le filtre de texture lit le pixel le plus proche et mélange entre les 2 mipmaps les plus proches. (ou utilise la mipmap la plus proche si ProjectSettings.rendering/textures/default_filters/use_nearest_mipmap_filter vaut true). Cela rend la texture pixelisée de près, et lisse à une certaine distance.
TextureFilter TEXTURE_FILTER_LINEAR_WITH_MIPMAPS = 3
Le filtre de texture mélange les 4 pixels les plus proches et les 2 mipmaps les plus proches. (ou utilise la mipmap la plus proche si ProjectSettings.rendering/textures/default_filters/use_nearest_mipmap_filter vaut true). Cela rend la texture lisse de près, et lisse à une certaine distance.
TextureFilter TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC = 4
Le filtre de texture lit le pixel le plus proche et mélange entre 2 mipmaps (ou utilise la mipmap la plus proche si ProjectSettings.rendering/textures/default_filters/use_nearest_mipmap_filter vaut true) selon l'angle entre la surface et la vue de la caméra. Cela rend la texture pixelisée de près, et lisse à une certaine distance. Le filtrage anisotropique améliore la qualité de la texture sur les surfaces qui sont quasiment alignées avec la caméra, mais est légèrement plus lent. Le niveau du filtrage anisotropique peut être changé en ajustant ProjectSettings.rendering/textures/default_filters/anisotropic_filtering_level.
TextureFilter TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC = 5
Le filtre de texture lit les 4 pixels les plus proches et mélange entre 2 mipmaps (ou utilise la mipmap la plus proche si ProjectSettings.rendering/textures/default_filters/use_nearest_mipmap_filter vaut true) selon l'angle entre la surface et la vue de la caméra. Cela rend la texture lisse de près, et lisse à une certaine distance. Le filtrage anisotropique améliore la qualité de la texture sur les surfaces qui sont quasiment alignées avec la caméra, mais est légèrement plus lent. Le niveau du filtrage anisotropique peut être changé en ajustant ProjectSettings.rendering/textures/default_filters/anisotropic_filtering_level.
TextureFilter TEXTURE_FILTER_MAX = 6
Représente la taille de l’énumération TextureFilter.
enum DetailUV: 🔗
DetailUV DETAIL_UV_1 = 0
Utilise UV pour la texture des détails.
DetailUV DETAIL_UV_2 = 1
Utilise UV2 pour la texture des détails.
enum Transparency: 🔗
Transparency TRANSPARENCY_DISABLED = 0
Le matériau n'utilisera pas la transparence. C'est le plus rapide à rendre.
Transparency TRANSPARENCY_ALPHA = 1
Le matériau utilisera les valeurs alpha de la texture pour la transparence. C'est le plus lent à rendre, et désactive la projection d'ombres.
Transparency TRANSPARENCY_ALPHA_SCISSOR = 2
Le matériau coupera toutes les valeurs en dessous d'un seuil, le reste restera opaque. Les parties opaques seront rendues dans la pré-passe de profondeur. Ceci est plus rapide à rendre que le mélange alpha, mais plus lent que le rendu opaque. Cela supporte aussi la projection d'ombres.
Transparency TRANSPARENCY_ALPHA_HASH = 3
Le matériau coupera toutes les valeurs en dessous d'un seuil déterminé spatialement, le reste restera opaque. Ceci est plus rapide à rendre que le mélange alpha, mais plus lent que le rendu opaque. Cela prend également en charge la projection d'ombres. Le hachage Alpha est adapté pour le rendu des cheveux.
Transparency TRANSPARENCY_ALPHA_DEPTH_PRE_PASS = 4
Le matériau utilisera la valeur alpha de la texture pour la transparence, mais rejettera les fragments avec un alpha inférieur à 0,99 lors de la pré-passe de profondeur et les fragments avec un alpha inférieur à 0,1 pendant la passe d'ombre. Cela prend également en charge les projections d'ombres.
Transparency TRANSPARENCY_MAX = 5
Représente la taille de l'énumération Transparency.
enum ShadingMode: 🔗
ShadingMode SHADING_MODE_UNSHADED = 0
L'objet ne recevra pas d'ombres. C'est le plus rapide à rendre, mais cela désactive toutes les interactions avec les lumières.
ShadingMode SHADING_MODE_PER_PIXEL = 1
L'objet sera ombré par pixel. Utile pour des effets d'ombrage réalistes.
ShadingMode SHADING_MODE_PER_VERTEX = 2
L'objet sera ombré par sommet. Utile lorsque vous voulez des ombres moins chères et ne vous souciez pas de la qualité visuelle.
ShadingMode SHADING_MODE_MAX = 3
Représente la taille de l’énumération ShadingMode.
enum Feature: 🔗
Feature FEATURE_EMISSION = 0
Constante pour définir emission_enabled.
Feature FEATURE_NORMAL_MAPPING = 1
Constante pour définir normal_enabled.
Feature FEATURE_RIM = 2
Constante pour définir rim_enabled.
Feature FEATURE_CLEARCOAT = 3
Constante pour définir clearcoat_enabled.
Feature FEATURE_ANISOTROPY = 4
Constante pour définir anisotropy_enabled.
Feature FEATURE_AMBIENT_OCCLUSION = 5
Constante pour définir ao_enabled.
Feature FEATURE_HEIGHT_MAPPING = 6
Constante pour définir heightmap_enabled.
Feature FEATURE_SUBSURFACE_SCATTERING = 7
Constante pour définir subsurf_scatter_enabled.
Feature FEATURE_SUBSURFACE_TRANSMITTANCE = 8
Constante pour définir subsurf_scatter_transmittance_enabled.
Feature FEATURE_BACKLIGHT = 9
Constante pour définir backlight_enabled.
Feature FEATURE_REFRACTION = 10
Constante pour définir refraction_enabled.
Feature FEATURE_DETAIL = 11
Constante pour définir detail_enabled.
Feature FEATURE_BENT_NORMAL_MAPPING = 12
Constante pour définir bent_normal_enabled.
Feature FEATURE_MAX = 13
Représente la taille de l'énumération Feature.
enum BlendMode: 🔗
BlendMode BLEND_MODE_MIX = 0
Le mode de mélange par défaut. La couleur de l'objet est mélangée sur l'arrière-plan en fonction de l'opacité de l'objet.
BlendMode BLEND_MODE_ADD = 1
La couleur de l'objet est ajoutée à l'arrière-plan.
BlendMode BLEND_MODE_SUB = 2
La couleur de l'objet est soustraite à l'arrière-plan.
BlendMode BLEND_MODE_MUL = 3
La couleur de l'objet est multipliée par l'arrière-plan.
BlendMode BLEND_MODE_PREMULT_ALPHA = 4
La couleur de l'objet est ajoutée à l'arrière-plan et le canal alpha est utilisé pour masquer l'arrière-plan. Il s'agit d'un hybride des modes de mélange mix et add, utiles pour les effets comme le feu où vous voulez que la flamme s'ajoute mais la fumée se mixe. Par défaut, cela fonctionne avec des matériaux non ombragés utilisant des textures prémultipliées. Pour les matériaux ombragés, utilisez la constante intégrée PREMUL_ALPHA_FACTOR pour que l'éclairage puisse être aussi modulé.
enum AlphaAntiAliasing: 🔗
AlphaAntiAliasing ALPHA_ANTIALIASING_OFF = 0
Désactive l'anti-crénelage de l'alpha pour ce matériau.
AlphaAntiAliasing ALPHA_ANTIALIASING_ALPHA_TO_COVERAGE = 1
Active l'AlphaToCoverage (litt. alpha vers couverture). Les valeurs alpha dans le matériau sont transmises au masque d'échantillonnage d'anti-crénelage.
AlphaAntiAliasing ALPHA_ANTIALIASING_ALPHA_TO_COVERAGE_AND_TO_ONE = 2
Active AlphaToCoverage et force toutes les valeurs alpha non nulles à 1. Les valeurs alpha dans le matériau sont transmises au masque d'échantillonnage d'anti-crénelage.
enum DepthDrawMode: 🔗
DepthDrawMode DEPTH_DRAW_OPAQUE_ONLY = 0
Mode de dessin de profondeur par défaut. La profondeur n'est dessinée que pour les objets opaques pendant la pré-passe opaque (si présente) et pendant la passe opaque.
DepthDrawMode DEPTH_DRAW_ALWAYS = 1
Les objets écriront leur profondeur pendant les passes opaque et transparente. Les objets transparents proches de la caméra peuvent masquer d'autres objets transparents derrière eux.
Note : Cela n'influence pas si des objets transparents sont inclus dans la pré-passe de profondeur ou non. Pour cela, voir Transparency.
DepthDrawMode DEPTH_DRAW_DISABLED = 2
Les objets n'écriront pas leur profondeur dans le buffer de profondeur, même pendant la pré-passe de profondeur (si activée).
enum DepthTest: 🔗
DepthTest DEPTH_TEST_DEFAULT = 0
Le test de profondeur va défausser le pixel s'il est derrière d'autres pixels.
DepthTest DEPTH_TEST_INVERTED = 1
Le test de profondeur va défausser le pixel s'il est devant d'autres pixels. Utile pour les effets de pochoir.
enum CullMode: 🔗
CullMode CULL_BACK = 0
Mode de culling par défaut. L'arrière de l'objet est défaussé (culled) lorsqu'il n'est pas visible. Les triangles des faces arrières seront défaussés lorsqu'ils font face à la caméra. Cela fait que seuls les triangles des faces avant seront dessinés. Pour les maillages avec une surface fermée, cela signifie que seul l'extérieur du maillage sera visible.
CullMode CULL_FRONT = 1
Les triangles des faces avant seront défaussés lorsqu'ils font face à la caméra. Cela fait que seuls les triangles des faces arrières seront dessinés. Pour les maillages avec une surface fermée, cela signifie que seul l'intérieur du maillage sera dessiné au lieu de l'extérieur.
CullMode CULL_DISABLED = 2
Aucun culling de face n'est effectué, la face avant et arrière seront toutes deux visibles.
enum Flags: 🔗
Flags FLAG_DISABLE_DEPTH_TEST = 0
Désactive le test de profondeur, de sorte que cet objet sera dessiné au dessus de tous les objets dessinés avant lui. Cela place l'objet dans la passe de dessin transparente où il est trié selon sa distance à la caméra. Les objets dessinés après lui dans l'ordre de dessin peuvent le recouvrir. Cela désactive aussi l'écriture de sa profondeur.
Flags FLAG_ALBEDO_FROM_VERTEX_COLOR = 1
Définit ALBEDO par la couleur définie pour chaque sommet du maillage.
Flags FLAG_SRGB_VERTEX_COLOR = 2
Les couleurs de sommet sont considérées comme stockées dans un encodage sRGB et sont converties en encodage linéaire durant le rendu. Voir aussi vertex_color_is_srgb.
Note : Seulement effectif lors de l'utilisation des méthodes de rendu Forward+ et Mobile.
Flags FLAG_USE_POINT_SIZE = 3
Utilise la taille d'affichage des points pour modifier pour les primitives de points. Change également la projection des textures albedo en utilisant POINT_COORD au lieu de UV.
Flags FLAG_FIXED_SIZE = 4
L'objet est mise à l'échelle suivant sa profondeur pour qu'il apparaisse toujours la même taille à l'écran.
Flags FLAG_BILLBOARD_KEEP_SCALE = 5
Le shader gardera l'échelle du maillage. Sinon, la mise à l'échelle sera ignorée lors de l'affichage en billboard. Ne s'applique que quand billboard_mode vaut BILLBOARD_ENABLED.
Flags FLAG_UV1_USE_TRIPLANAR = 6
Utiliser la projection triplanaire pour les textures qui normalement utilisent UV.
Flags FLAG_UV2_USE_TRIPLANAR = 7
Utiliser la projection triplanaire pour les textures qui normalement utilisent UV2.
Flags FLAG_UV1_USE_WORLD_TRIPLANAR = 8
Utiliser la projection triplanaire pour les textures qui normalement utilisent UV.
Flags FLAG_UV2_USE_WORLD_TRIPLANAR = 9
Utiliser la projection triplanaire pour les textures qui normalement utilisent UV2.
Flags FLAG_AO_ON_UV2 = 10
Utiliser les coordonnées UV2 pour la projection de la ao_texture.
Flags FLAG_EMISSION_ON_UV2 = 11
Utiliser les coordonnées UV2 pour la projection de la emission_texture.
Flags FLAG_ALBEDO_TEXTURE_FORCE_SRGB = 12
Force le shader à convertir l'albedo d'un encodage sRGB en un encodage linéaire. Voir aussi albedo_texture_force_srgb.
Flags FLAG_DONT_RECEIVE_SHADOWS = 13
Désactive la réception des ombres venant des autres objets.
Flags FLAG_DISABLE_AMBIENT_LIGHT = 14
Désactive la réception de la lumière ambiante.
Flags FLAG_USE_SHADOW_TO_OPACITY = 15
Active la fonctionnalité de l'ombre vers opacité.
Flags FLAG_USE_TEXTURE_REPEAT = 16
Permet à la texture de se répéter lorsque les coordonnées UV sont à l'extérieur de l'intervalle 0-1. Si vous utilisez l'un des modes de filtrage linéaire, cela peut entraîner des artéfacts aux bords d'une texture lorsque l'échantillonneur filtre à travers les bords de la texture.
Flags FLAG_INVERT_HEIGHTMAP = 17
Inverse les valeurs lues d'une texture de profondeur pour les convertir en valeurs de hauteur (heightmap).
Flags FLAG_SUBSURFACE_MODE_SKIN = 18
Active le mode de peau pour la transluminescence, qui est utilisé pour améliorer l'aspect de la transluminescence lorsqu'elle est utilisée pour de la peau humaine.
Flags FLAG_PARTICLE_TRAILS_MODE = 19
Active les parties du shader nécessaires pour que les traînées de GPUParticles3D fonctionnent. Cela nécessite également l'utilisation d'un maillage avec un skinning approprié, comme RibbonTrailMesh ou TubeTrailMesh. L'activation de cette fonctionnalité en dehors des matériaux utilisés dans des maillages de GPUParticles3D cassera le rendu du matériau.
Flags FLAG_ALBEDO_TEXTURE_MSDF = 20
Active le shader de rendu de champ de distance signée multicanal.
Flags FLAG_DISABLE_FOG = 21
Désactive la réception de brouillard basé sur la profondeur ou volumétrique.
Flags FLAG_DISABLE_SPECULAR_OCCLUSION = 22
Désactive l'occlusion spéculaire.
Flags FLAG_USE_Z_CLIP_SCALE = 23
Active l'utilisation de z_clip_scale.
Flags FLAG_USE_FOV_OVERRIDE = 24
Active l'utilisation de fov_override.
Flags FLAG_MAX = 25
Représente la taille de l'énumération Flags.
enum DiffuseMode: 🔗
DiffuseMode DIFFUSE_BURLEY = 0
Algorithme de diffusion diffuse par défaut.
DiffuseMode DIFFUSE_LAMBERT = 1
La diffusion diffuse ignore la rugosité.
DiffuseMode DIFFUSE_LAMBERT_WRAP = 2
Étend le calcul Lambert pour couvrir plus de 90 degrés quand la rugosité augmente.
DiffuseMode DIFFUSE_TOON = 3
Utilise une transition abrupte pour les lumières, la rugosité permet d'ajuster cette transition.
enum SpecularMode: 🔗
SpecularMode SPECULAR_SCHLICK_GGX = 0
Blob spéculaire par défaut.
Note : Forward+ utilise de la multi-diffusion pour des réflexions plus précises, bien que l'impact de la multi-diffusion soit mieux visible sur des surfaces métalliques rugueuses que sur des surfaces lisses et non métalliques.
Note : Mobile et Compatibilité ne font pas de multi-diffusion pour des raisons de performance. Au lieu de cela, ils effectuent une diffusion unique, ce qui signifie que les surfaces métalliques rugueuses peuvent sembler légèrement plus foncées que prévu.
SpecularMode SPECULAR_TOON = 1
Le reflet en mode cartoon change de taille suivant la rugosité.
SpecularMode SPECULAR_DISABLED = 2
Pas de blob spéculaire. Ceci est légèrement plus rapide à rendre que les autres modes spéculaires.
enum BillboardMode: 🔗
BillboardMode BILLBOARD_DISABLED = 0
Le mode d'affichage est désactivé.
BillboardMode BILLBOARD_ENABLED = 1
L'axe Z de l'objet fera toujours face à la caméra.
BillboardMode BILLBOARD_FIXED_Y = 2
L'axe X de l'objet fera toujours face à la caméra.
BillboardMode BILLBOARD_PARTICLES = 3
Utilisé pour les systèmes de particules lorsqu'ils sont affectés aux nœuds GPUParticles3D et CPUParticles3D (animation flipbook). Active les propriétés particles_anim_*.
ParticleProcessMaterial.anim_speed_min ou CPUParticles3D.anim_speed_min devrait également être défini à une valeur supérieure à zéro pour que l'animation joue.
enum TextureChannel: 🔗
TextureChannel TEXTURE_CHANNEL_RED = 0
Utilisé pour lire la texture depuis le canal du rouge.
TextureChannel TEXTURE_CHANNEL_GREEN = 1
Utilisé pour lire la texture depuis le canal du vert.
TextureChannel TEXTURE_CHANNEL_BLUE = 2
Utilisé pour lire la texture depuis le canal du bleu.
TextureChannel TEXTURE_CHANNEL_ALPHA = 3
Utilisé pour lire la texture depuis le canal de l'alpha.
TextureChannel TEXTURE_CHANNEL_GRAYSCALE = 4
Utilisé pour lire la moyenne linéaire (non-perceptuelle) des canaux rouge, verts et bleus d'une texture.
enum EmissionOperator: 🔗
EmissionOperator EMISSION_OP_ADD = 0
Ajouter la couleur d'émission à la texture d'émission.
EmissionOperator EMISSION_OP_MULTIPLY = 1
Multiplie la couleur d'émission par la texture d'émission.
enum DistanceFadeMode: 🔗
DistanceFadeMode DISTANCE_FADE_DISABLED = 0
Ne pas utiliser de fondu de distance.
DistanceFadeMode DISTANCE_FADE_PIXEL_ALPHA = 1
Fait disparaitre doucement l'objet en fonction de la distance de chaque pixel par rapport à la caméra en utilisant l'opacité.
DistanceFadeMode DISTANCE_FADE_PIXEL_DITHER = 2
Fait disparaître l'objet par fondu de manière lisse selon la distance de chaque pixel par rapport à la caméra en utilisant une approche par dithering. Le dithering défausse des pixels selon sur un motif défini pour faire un fondu en douceur sans permettre la transparence. Sur certaines machines, cela peut être plus rapide que DISTANCE_FADE_PIXEL_ALPHA.
DistanceFadeMode DISTANCE_FADE_OBJECT_DITHER = 3
Fait disparaître l'objet par fondu de manière lisse selon la distance de l'objet par rapport à la caméra en utilisant une approche par dithering. Le dithering défausse des pixels selon sur un motif défini pour faire un fondu en douceur sans permettre la transparence. Sur certaines machines, cela peut être plus rapide que DISTANCE_FADE_PIXEL_ALPHA et DISTANCE_FADE_PIXEL_DITHER.
enum StencilMode: 🔗
StencilMode STENCIL_MODE_DISABLED = 0
Désactive les opérations de pochoir.
StencilMode STENCIL_MODE_OUTLINE = 1
Pré-réglage de pochoir qui applique un contour à l'objet.
Note : Nécessite un matériau Material.next_pass qui sera automatiquement appliqué. Tout changement manuel apporté à Material.next_pass sera perdu lorsque les propriétés du pochoir sont modifiées ou que la scène est rechargée. Pour appliquer en toute sécurité un matériau Material.next_pass sur un matériau qui utilise des pré-réglages de pochoir, utilisez GeometryInstance3D.material_overlay à la place.
StencilMode STENCIL_MODE_XRAY = 2
Pré-réglage de pochoir qui affiche une silhouette de l'objet derrière les murs.
Note : Nécessite un matériau Material.next_pass qui sera automatiquement appliqué. Tout changement manuel apporté à Material.next_pass sera perdu lorsque les propriétés du pochoir sont modifiées ou que la scène est rechargée. Pour appliquer en toute sécurité un matériau Material.next_pass sur un matériau qui utilise des pré-réglages de pochoir, utilisez GeometryInstance3D.material_overlay à la place.
StencilMode STENCIL_MODE_CUSTOM = 3
Active les opérations de pochoir sans un pré-réglage.
enum StencilFlags: 🔗
StencilFlags STENCIL_FLAG_READ = 1
The material will only be rendered where it passes a stencil comparison with existing stencil buffer values.
StencilFlags STENCIL_FLAG_WRITE = 2
Le matériau écrira la valeur de référence dans le buffer de pochoir la où il passe le test de profondeur.
StencilFlags STENCIL_FLAG_WRITE_DEPTH_FAIL = 4
Le matériau écrira la valeur de référence dans le buffer de pochoir la où il échoue au test de profondeur.
enum StencilCompare: 🔗
StencilCompare STENCIL_COMPARE_ALWAYS = 0
Passe toujours le test de pochoir.
StencilCompare STENCIL_COMPARE_LESS = 1
Passe le test du pochoir lorsque la valeur de référence est inférieure à la valeur existante du pochoir.
StencilCompare STENCIL_COMPARE_EQUAL = 2
Passe le test du pochoir lorsque la valeur de référence est égale à la valeur existante du pochoir.
StencilCompare STENCIL_COMPARE_LESS_OR_EQUAL = 3
Passe le test du pochoir lorsque la valeur de référence est inférieure ou égale à la valeur existante du pochoir.
StencilCompare STENCIL_COMPARE_GREATER = 4
Passe le test du pochoir lorsque la valeur de référence est supérieure à la valeur existante du pochoir.
StencilCompare STENCIL_COMPARE_NOT_EQUAL = 5
Passe le test du pochoir lorsque la valeur de référence n'est pas égale à la valeur existante du pochoir.
StencilCompare STENCIL_COMPARE_GREATER_OR_EQUAL = 6
Passe le test du pochoir lorsque la valeur de référence est supérieure ou égale à la valeur existante du pochoir.
Descriptions des propriétés
Color albedo_color = Color(1, 1, 1, 1) 🔗
La couleur de base du matériau.
Note : Si detail_enabled vaut true et qu'une texture detail_albedo est spécifiée, albedo_color ne modulera pas la texture des détails. Cela peut être utilisé pour colorer des zones partielles d'un matériau en ne spécifiant pas une texture albédo et en utilisant une texture detail_albedo transparente à la place.
void set_texture(param: TextureParam, texture: Texture2D)
Texture2D get_texture(param: TextureParam) const
La texture à multiplier par la couleur albedo_color. Utilisé pour l'habillage basique des objets.
Si la texture apparaît de façon inattendue trop foncée ou trop lumineuse, vérifiez albedo_texture_force_srgb.
bool albedo_texture_force_srgb = false 🔗
If true, forces a conversion of the albedo_texture from nonlinear sRGB encoding to linear encoding. See also vertex_color_is_srgb.
This should only be enabled when needed (typically when using a ViewportTexture as albedo_texture). If albedo_texture_force_srgb is true when it shouldn't be, the texture will appear to be too dark. If albedo_texture_force_srgb is false when it shouldn't be, the texture will appear to be too bright.
bool albedo_texture_msdf = false 🔗
Active le shader de rendu Champ de Distance Signé Multicanal (CDSM, ou MSDF en anglais). Utilisez msdf_pixel_range et msdf_outline_size pour configurer les paramètres CDSM.
float alpha_antialiasing_edge 🔗
Le seuil à partir duquel l'anticrénalage sera appliqué sur le canal alpha.
AlphaAntiAliasing alpha_antialiasing_mode 🔗
void set_alpha_antialiasing(value: AlphaAntiAliasing)
AlphaAntiAliasing get_alpha_antialiasing()
Le type d’anticrénelage alpha à appliquer.
L'échelle de hachage pour Alpha Hash. Valeurs recommandées entre 0 et 2.
float alpha_scissor_threshold 🔗
Seuil à partir duquel le ciseau alpha rejettera les valeurs. Des valeurs plus élevées entraîneront la suppression de plus de pixels. Si le matériau devient trop opaque à distance, essayez d'augmenter alpha_scissor_threshold. Si le matériau disparaît à distance, essayez de diminuer alpha_scissor_threshold.
La force de l'effet d'anisotropie. Ceci est multiplié par le canal alpha de anisotropy_flowmap si une texture y est définie et la texture contient un canal alpha.
bool anisotropy_enabled = false 🔗
Si true, l'anisotropie est activée. L'anisotropie modifie la forme du blob spéculaire et l'aligne à l'espace tangent. Ceci est utile pour l'aluminium brossé et les reflets capillaires.
Note : Les tangentes du maillage sont nécessaires pour que l'anisotropie fonctionne. Si le maillage ne contient pas de tangentes, l'effet anisotropie apparaîtra cassé.
Note : L'anisotropie du matériau ne doit pas être confondue avec le filtrage de texture anisotrope, qui peut être activé en définissant texture_filter à TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC.
Texture2D anisotropy_flowmap 🔗
void set_texture(param: TextureParam, texture: Texture2D)
Texture2D get_texture(param: TextureParam) const
Texture qui décale la tangent map pour les calculs d'anisotropie et contrôle optionnellement l'effet d'anisotropie (si un canal alpha est présent). La texture flowmap devrait être une texture des dérivées, le canal rouge représentant la distorsion sur l'axe X et le canal vert représentant la distorsion sur l'axe Y. Les valeurs inférieures à 0,5 entraîneront une distorsion négative, tandis que les valeurs supérieures à 0,5 entraîneront une distorsion positive.
S'il est présent, le canal alpha de la texture sera utilisé pour multiplier la force de l'effet anisotropy. Les pixels entièrement opaques garderont la force originale de l'effet anisotropie tandis que les pixels entièrement transparents désactiveront entièrement l'effet d'anisotropie. Le canal bleu de la flowmap est ignoré.
Si true, l'occlusion ambiante est activée. L'occlusion ambiante assombrit les zones basées sur ao_texture.
Montant de l'occlusion ambiante qui affecte l'éclairage des lumières. Si 0, l'occlusion ambiante n'affecte que la lumière ambiante. Si 1, l'occlusion ambiante affecte les lumières autant qu'elle affecte la lumière ambiante. Cela peut être utilisé pour influencer la force de l'effet d'occlusion ambiante, mais n'est généralement pas réaliste.
Si true, utilise les coordonnées UV2 pour la projection de ao_texture.
void set_texture(param: TextureParam, texture: Texture2D)
Texture2D get_texture(param: TextureParam) const
Texture qui définit la quantité d'occlusion ambiante pour un point donné sur l'objet.
TextureChannel ao_texture_channel = 0 🔗
void set_ao_texture_channel(value: TextureChannel)
TextureChannel get_ao_texture_channel()
Spécifie le canal de ao_texture dans lequel les informations d'occlusion ambiante sont stockées. Ceci est utile lorsque vous stockez l'information pour plusieurs effets dans une seule texture. Par exemple, si vous avez stocké le métal dans le canal rouge, la rugosité dans le bleu et l'occlusion ambiante dans le vert, vous pourriez réduire le nombre de textures que vous utilisez.
Color backlight = Color(0, 0, 0, 1) 🔗
La couleur utilisée par l'effet rétroéclairage. Représente la lumière passant par un objet.
bool backlight_enabled = false 🔗
Si true, l'effet rétroéclairage est activé. Voir aussi subsurf_scatter_transmittance_enabled.
void set_texture(param: TextureParam, texture: Texture2D)
Texture2D get_texture(param: TextureParam) const
Texture utilisée pour contrôler l'effet de rétroéclairage par pixel. Additionné à backlight.
bool bent_normal_enabled = false 🔗
Si true, la bent normal map est activée. Cela permet un éclairage indirect plus précis et de l'occlusion spéculaire.
Texture2D bent_normal_texture 🔗
void set_texture(param: TextureParam, texture: Texture2D)
Texture2D get_texture(param: TextureParam) const
Texture qui spécifie la direction moyenne de la lumière ambiante entrante à un pixel donné. La texture bent_normal_texture utilise seulement les canaux rouges et verts, les canaux bleu et alpha sont ignorés. La normale lue de bent_normal_texture est orientée autour de la normale de surface fournie par le Mesh.
Note : Une bent normal map est différente d'une normal map ordinaire. Lors du pré-calcul d'une bent normal map, assurez-vous d'utiliser une distribution en cosinus pour que la bend normal map fonctionne correctement.
Note : Le maillage doit avoir à la fois des normales et des tangents définis dans ses données de sommets. Sinon, l'ombrage produit par la bent normal map ne sera pas correct. Si vous créez une géométrie avec SurfaceTool, vous pouvez utiliser SurfaceTool.generate_normals() et SurfaceTool.generate_tangents() pour générer automatiquement des normales et des tangents respectivement.
Note : Godot s'attend à ce que la bent normal map utilise les coordonnées X+, Y+ et Z+. Voir cette page pour une comparaison des coordonnées de normal map attendues par les moteurs populaires.
bool billboard_keep_scale = false 🔗
Si true, le shader conservera l'échelle du maillage. Sinon, l'échelle est perdue lors du mode Billboard. S'applique seulement lorsque billboard_mode ne vaut pas BILLBOARD_DISABLED.
BillboardMode billboard_mode = 0 🔗
void set_billboard_mode(value: BillboardMode)
BillboardMode get_billboard_mode()
Contrôle comment l'objet fait face à la caméra.
Note : Le mode Billboard (litt. panneau d'affichage) n'est pas approprié pour la VR parce que le vecteur gauche-droite de la caméra n'est pas horizontal lorsque l'écran est fixé à votre tête au lieu d'être sur la table. Voir l'issue GitHub #41567 pour plus de détails.
Le mode de mélange du matériau.
Note : Les valeurs autres que Mix forcent l'objet dans le pipeline de transparence.
Définit la force de l'effet de vernis transparent (clearcoat). Le définir à 0 donne le même rendu que la désactivation de l'effet de vernis transparent.
bool clearcoat_enabled = false 🔗
Si true, le rendu de vernis transparent (clearcoat) est activé. Ajoute une passe transparent secondaire au calcul de l'éclairage résultant en un blob spéculaire ajouté. Cela fait apparaître des matériaux comme s'ils avaient une couche claire sur eux qui peuvent être brillante ou rugueuse.
Note : Le rendu de vernis transparent n'est pas visible si le shading_mode du matériau vaut SHADING_MODE_UNSHADED.
float clearcoat_roughness = 0.5 🔗
Définit la rugosité de la passe de vernis transparent. Une valeur élevée résulte en un vernis plus rugueux alors qu'une valeur plus faible résulte en un vernis plus lisse.
void set_texture(param: TextureParam, texture: Texture2D)
Texture2D get_texture(param: TextureParam) const
Texture qui définit la force de l'effet de vernis transparent et la brillance du vernis. La force est spécifiée dans le canal rouge tandis que la brillance est spécifiée dans le canal vert.
Détermine le côté du triangle à cull selon que le triangle fait face ou non à la caméra.
DepthDrawMode depth_draw_mode = 0 🔗
void set_depth_draw_mode(value: DepthDrawMode)
DepthDrawMode get_depth_draw_mode()
Détermine quand le rendu de la profondeur a lieu. Voir aussi transparency.
Expérimental : May be affected by future rendering pipeline changes.
Détermine quel opérateur de comparaison est utilisé lors des tests de profondeur.
Note : La modification de depth_test à une valeur qui n'est pas celle par défaut n'a qu'un effet visible que lorsqu'elle est utilisée sur un matériau transparent, ou un matériau qui a depth_draw_mode défini à DEPTH_DRAW_DISABLED.
void set_texture(param: TextureParam, texture: Texture2D)
Texture2D get_texture(param: TextureParam) const
Texture qui spécifie la couleur de la couche de détails. Le canal alpha de detail_albedo est utilisé comme masque, même lorsque le matériau est opaque. Pour utiliser une texture dédiée comme masque, voir detail_mask.
Note : detail_albedo n'est pas modulé par albedo_color.
BlendMode detail_blend_mode = 0 🔗
Spécifie comment detail_albedo devrait se mélanger avec l'actuel ALBEDO.
Si true, active la couche de détails. Le détail est une seconde texture qui se mélange avec la surface de l'objet en fonction de detail_mask et du canal alpha de detail_albedo. Cela peut être utilisé pour ajouter de la variation aux objets, ou pour mélanger entre deux textures albédo/normales différentes.
void set_texture(param: TextureParam, texture: Texture2D)
Texture2D get_texture(param: TextureParam) const
Texture utilisée pour spécifier comment les textures de détail se mélangent avec les textures de base. detail_mask peut être utilisé avec le canal alpha de detail_albedo (s'il existe).
void set_texture(param: TextureParam, texture: Texture2D)
Texture2D get_texture(param: TextureParam) const
Texture qui spécifie la normale par pixel de la couche de détails. La texture detail_normal utilise seulement les canaux rouges et verts, les canaux bleu et alpha sont ignorés. La normale lue de detail_normal est orientée autour de la normale de surface fournie par le Mesh.
Note : Godot s'attend à ce que la normal map utilise des coordonnées X+, Y+ et Z+. Voir cette page pour une comparaison des coordonnées de normal map attendues par les moteurs populaires.
DetailUV detail_uv_layer = 0 🔗
Spécifie s'il faut utiliser UV ou UV2 pour la couche de détail.
DiffuseMode diffuse_mode = 0 🔗
void set_diffuse_mode(value: DiffuseMode)
DiffuseMode get_diffuse_mode()
L'algorithme utilisé pour la diffusion de la lumière diffuse.
bool disable_ambient_light = false 🔗
Si trye, l'objet ne reçoit aucune lumière ambiante.
Si true, l'objet ne sera pas affecté par le brouillard (ni par le brouillard volumétrique et ni par le brouillard de profondeur). Cela est utile pour les matériaux non ombrés ou transparents (p. ex. les particules), qui, sans ce paramètre, seront affectés même s'ils sont entièrement transparents.
bool disable_receive_shadows = false 🔗
Si true, l'objet ne va pas recevoir les ombres qui seraient sinon projetées dessus.
bool disable_specular_occlusion = false 🔗
Si true, désactive l'occlusion spéculaire même si ProjectSettings.rendering/reflections/specular_occlusion/enabled vaut false.
float distance_fade_max_distance = 10.0 🔗
Distance à laquelle l'objet apparaît entièrement opaque.
Note : Si distance_fade_max_distance est inférieur à distance_fade_min_distance, le comportement sera inversé. L'objet va commencer à disparaître à distance_fade_max_distance et disparaîtra complètement une fois qu'il atteint distance_fade_min_distance.
float distance_fade_min_distance = 0.0 🔗
Distance à laquelle l'objet commence à être visible. Si l'objet plus proche que cette distance, il sera invisible.
Note : Si distance_fade_min_distance est supérieur à distance_fade_max_distance, le comportement sera inversé. L'objet va commencer à disparaître à distance_fade_max_distance et disparaîtra complètement une fois qu'il atteint distance_fade_min_distance.
DistanceFadeMode distance_fade_mode = 0 🔗
void set_distance_fade(value: DistanceFadeMode)
DistanceFadeMode get_distance_fade()
Spécifie quelle type de fondu utiliser. Peut être de n'importe quelle DistanceFadeMode.
Color emission = Color(0, 0, 0, 1) 🔗
La couleur de la lumière émise. Voir emission_enabled.
bool emission_enabled = false 🔗
Si true, le corps émet de la lumière. Émettre de la lumière rend l'objet plus lumineux. L'objet peut également projeter de la lumière sur d'autres objets si un VoxelGI, SDFGI ou LightmapGI est utilisé et cet objet est utilisé dans le pré-calcul des lumières.
float emission_energy_multiplier = 1.0 🔗
Multiplicateur la pour lumière émise. Voir emission_enabled.
Luminance de la lumière émise, mesurée en nits (candela par mètre carré). Seulement disponible lorsque ProjectSettings.rendering/lights_and_shadows/use_physical_light_units est activé. La valeur par défaut est à peu près équivalente à un une ampoule d'intérieur.
bool emission_on_uv2 = false 🔗
Utiliser UV2 pour lire depuis la emission_texture.
EmissionOperator emission_operator = 0 🔗
void set_emission_operator(value: EmissionOperator)
EmissionOperator get_emission_operator()
Définit comment emission interagit avec emission_texture. Peut soit être ajouté soit être multiplié.
void set_texture(param: TextureParam, texture: Texture2D)
Texture2D get_texture(param: TextureParam) const
La texture qui spécifie quelle quantité de lumière sera émise par la surface à un point donné.
Si true, l'objet est rendu à la même taille indépendamment de la distance. La taille de l'objet à l'écran est la même que si la caméra était éloignée de 1.0 unités de l'origine de l'objet, peu importe la distance réelle de la caméra. Le champ de vision de Camera3D (ou Camera3D.size en mode orthogonal/frustum) affecte toujours la taille à laquelle l'objet est dessiné.
Redéfinit l'angle du champ de vision de la Camera3D (en degrés).
Note : Cela se comporte comme si le champ de vision est défini sur une Camera3D avec Camera3D.keep_aspect défini à Camera3D.KEEP_HEIGHT. De plus, il peut ne pas avoir l'air correcte sur une caméra non-perspective où le paramètre du champ de vision est ignoré.
Si true, permet le réglage de l'agrandissement des sommets. Cela peut être utilisé pour créer des contours basés sur le maillage à l'aide d'un deuxième passe du matériau et son cull_mode défini à CULL_FRONT. Voir aussi grow_amount.
Note : L'agrandissement des sommets ne peut pas créer de nouveaux sommets, ce qui signifie que des écarts visibles peuvent se produire dans les coins tranchants. Cela peut être atténué en concevant le maillage pour qu'il utilise des normales lisses exclusivement en utilisant normales pondérées par les faces dans le logiciel de développent 3D. Dans ce cas, l'agrandissement sera en mesure de faire rejoindre tous les contours, comme dans le maillage original.
Agrandit les sommets des objets dans la direction de leurs normales. Effectif seulement si grow vaut true.
bool heightmap_deep_parallax = false 🔗
Si true, utilise le parallax occlusion mapping pour représenter la profondeur dans le matériau au lieu d'un simple mapping de décalage (voir heightmap_enabled). Cela résulte en un effet de profondeur plus convaincant, mais est beaucoup plus cher sur le GPU. N'activez ceci que sur les matériaux où cela fait une différence visuelle significative.
bool heightmap_enabled = false 🔗
Si true, le height mapping est actif (également appelé « parallax mapping » ou « depth mapping »). Voir aussi normal_enabled. Le height mapping est une fonctionnalité exigeante sur le GPU, donc il ne devrait être utilisé que sur les matériaux où cela fait une différence visuelle significative.
Note : Le height mapping n'est pas supporté si le triplanar mapping est utilisé sur le même matériau. La valeur de heightmap_enabled sera ignorée si uv1_triplanar est actif.
bool heightmap_flip_binormal = false 🔗
void set_heightmap_deep_parallax_flip_binormal(value: bool)
bool get_heightmap_deep_parallax_flip_binormal()
Si true, renvoie les vecteurs binormaux du maillage lors de l'interprétation de la heightmap. Si l'effet de la heightmap semble étrange lorsque la caméra se déplace (même avec une heightmap_scale raisonnable), essayez de définir ceci à true.
bool heightmap_flip_tangent = false 🔗
void set_heightmap_deep_parallax_flip_tangent(value: bool)
bool get_heightmap_deep_parallax_flip_tangent()
Si true, renvoie les vecteurs tangents du maillage lors de l'interprétation de la heightmap. Si l'effet de la heightmap semble étrange lorsque la caméra se déplace (même avec une heightmap_scale raisonnable), essayez de définir ceci à true.
bool heightmap_flip_texture = false 🔗
Si true, interprète la texture de heightmap comme une depth map, avec les valeurs plus lumineuses qui semblent être « plus basses » en altitude par rapport aux valeurs plus foncées.
Ceci peut être activé pour la compatibilité avec certains matériaux faits pour Godot 3.x. Cela n'est pas nécessaire si l'option d'import Inverser a été utilisée pour inverser la depth map dans Godot 3.x, auquel cas heightmap_flip_texture devrait rester à false.
void set_heightmap_deep_parallax_max_layers(value: int)
int get_heightmap_deep_parallax_max_layers()
Le nombre de couches à utiliser pour le parallax occlusion mapping lorsque la caméra est à proximité du matériau. Les valeurs plus élevées entraînent un effet de profondeur plus convaincant, surtout dans les matériaux qui ont des changements de hauteur raides. Les valeurs plus élevées ont un coût important sur le GPU, donc il ne devrait être augmenté que sur les matériaux où cela fait une différence visuelle significative.
Note : Seulement effectif si heightmap_deep_parallax vaut true.
void set_heightmap_deep_parallax_min_layers(value: int)
int get_heightmap_deep_parallax_min_layers()
Le nombre de couches à utiliser pour le parallax occlusion mapping lorsque la caméra est loin du matériau. Les valeurs plus élevées entraînent un effet de profondeur plus convaincant, surtout dans les matériaux qui ont des changements de hauteur raides. Les valeurs plus élevées ont un coût important sur le GPU, donc il ne devrait être augmenté que sur les matériaux où cela fait une différence visuelle significative.
Note : Seulement effectif si heightmap_deep_parallax vaut true.
L'échelle de la heightmap à utiliser pour l'effet parallaxe (voir heightmap_enabled). La valeur par défaut est réglée de sorte que le point le plus élevé (valeur = 255) semble être 5 cm plus haut que le point le plus bas (valeur = 0). Les valeurs plus élevées résultent en une apparence plus profonde, mais peuvent entraîner des artéfacts apparaissant lors de l'observation du matériau à partir d'angles obliques, surtout lorsque la caméra se déplace. Les valeurs négatives peuvent être utilisées pour inverser l'effet parallaxe, mais cela est différent de l'inversion de la texture en utilisant heightmap_flip_texture puisque le matériau apparaîtra également comme "plus proche" de la caméra. Dans la plupart des cas, heightmap_scale devrait être maintenu à une valeur positive.
Note : Si l'effet de la heightmap semble étrange indépendamment de cette valeur, essayez de régler heightmap_flip_binormal et heightmap_flip_tangent. Voir aussi heightmap_texture pour les recommandations sur l'écriture de textures de heightmap, car la façon dont la texture de heightmap est faite affecte comment heightmap_scale se comporte.
void set_texture(param: TextureParam, texture: Texture2D)
Texture2D get_texture(param: TextureParam) const
La texture à utiliser comme heightmap. Voir aussi heightmap_enabled.
Pour les meilleurs résultats, la texture doit être normalisée (avec heightmap_scale réduit pour compenser). Dans GIMP, cela peut être fait à l'aide de Couleurs > Auto > Égaliser. Si la texture n'utilise qu'une petite partie de sa gamme disponible, l'effet parallaxe peut paraître étrange, surtout lorsque la caméra se déplace.
Note : Pour réduire l'utilisation de la mémoire et améliorer les temps de chargement, vous pouvez utiliser une texture de heightmap à basse résolution, car la plupart des heightmaps ne contiennent que des données à faible fréquence.
Une valeur élevée fait apparaître le matériau plus comme un métal. Les non-métaux utilisent leur albédo comme couleur diffuse et ajoutent la couleur diffuse à la réflexion spéculaire. Avec des non-métaux, la réflexion apparaît sur la couleur albédo. Les métaux utilisent leur albédo comme multiplicateur à la réflexion spéculaire et définissent la couleur diffuse en noir, résultant en une réflexion teintée. Les matériaux fonctionnent mieux lorsqu'ils sont entièrement métalliques ou non métalliques, les valeurs entre 0 et 1 ne devraient être utilisées que pour du fondu entre les parties métalliques et non métalliques. Pour modifier la quantité de réflexion, utilisez roughness.
float metallic_specular = 0.5 🔗
Ajuste la force des réflexions spéculaires. Les réflexions spéculaires sont composés des réflexions de la scène et du lobe spéculaire qui est le point lumineux qui est reflété de sources lumineuses. Lorsqu'elle est définie à 0.0, aucune réflexion spéculaire ne sera visible. Cela diffère du mode SpecularMode SPECULAR_DISABLED car SPECULAR_DISABLED s'applique seulement au lobe spéculaire de la source lumineuse.
Note : Contrairement à metallic, cela ne conserve pas l'énergie, donc elle devrait être laissée à 0.5 dans la plupart des cas. Voir aussi roughness.
void set_texture(param: TextureParam, texture: Texture2D)
Texture2D get_texture(param: TextureParam) const
Texture utilisée pour spécifier le métal pour un objet. Ceci est multiplié par metallic.
TextureChannel metallic_texture_channel = 0 🔗
void set_metallic_texture_channel(value: TextureChannel)
TextureChannel get_metallic_texture_channel()
Spécifie le canal de metallic_texture dans lequel les informations métalliques sont stockées. Ceci est utile lorsque vous stockez l'information pour plusieurs effets dans une seule texture. Par exemple, si vous stockeriez le métallique dans le canal rouge, la rugosité dans le bleu et l'occlusion ambiante dans le vert, vous pourriez réduire le nombre de textures que vous utilisez.
float msdf_outline_size = 0.0 🔗
La largeur du contour de la forme.
float msdf_pixel_range = 4.0 🔗
La largeur de la plage autour de la forme entre la distance signée représentable minimale et maximale.
Si true, les tests de profondeur sont désactivés et l'objet sera dessiné suivant son ordre de rendu et non suivant sa distance.
Si true, la cartographie normale est activée. Cela a un léger coût de performance, en particulier sur les GPU mobiles.
L'intensité de l'effet de la carte normale.
void set_texture(param: TextureParam, texture: Texture2D)
Texture2D get_texture(param: TextureParam) const
Texture utilisée pour spécifier la normale en un pixel donné. La normal_texture utilise seulement les canaux rouges et verts, les canaux bleu et alpha sont ignorés. La lecture des normales de normal_texture est orientée autour de la normale de la surface fournie par le Mesh.
Note : Le maillage doit avoir à la fois des normales et des tangentes définis dans ses données de sommets. Sinon, la normal map ne rendra pas correctement et ne semblera qu'obscurcir toute la surface. Si vous créez une géométrie avec SurfaceTool, vous pouvez utiliser SurfaceTool.generate_normals() et SurfaceTool.generate_tangents() pour générer automatiquement des normales et des tangentes respectivement.
Note : Godot s'attend à ce que la normal map utilise des coordonnées X+, Y+ et Z+. Voir cette page pour une comparaison des coordonnées de normal map attendues par les moteurs populaires.
Note : Si detail_enabled vaut true, la texture detail_albedo est dessinée au-dessous de la normal_texture. Pour afficher une carte normale au-dessusde la texture detail_albedo, utilisez detail_normal à la place.
void set_texture(param: TextureParam, texture: Texture2D)
Texture2D get_texture(param: TextureParam) const
La texture Occlusion/Rugosité/Metallique à utiliser. Il s'agit d'un remplacement plus efficace de ao_texture, roughness_texture et metallic_texture dans ORMMaterial3D. L'occlusion ambiante est stockée dans le canal rouge. La rugosité est stockée dans le canal vert. Le métallique est stockée dans le canal bleu. Le canal alpha est ignoré.
Le nombre de trames horizontales dans la feuille de sprite de particules. Seulement activé lors de l'utilisation BILLBOARD_PARTICLES. Voir billboard_mode.
Si true, les animations de particules bouclent. Seulement activé lors de l'utilisation de BILLBOARD_PARTICLES. Voir billboard_mode.
Le nombre de trames verticales dans la feuille de sprite de particules. Seulement activé lors de l'utilisation de BILLBOARD_PARTICLES. Voir billboard_mode.
La taille de point en pixels. Voir use_point_size.
float proximity_fade_distance = 1.0 🔗
Distance sur laquelle l'effet de disparition se produit. Plus la distance est grande, plus l'objet disparait progressivement.
bool proximity_fade_enabled = false 🔗
Si true, l'effet de fondu de proximité est activé. Le fondu de proximité affecte chaque pixel basé sur sa distance par rapport à un autre objet.
bool refraction_enabled = false 🔗
Si true, l'effet de réfraction est activé. Distord la transparence selon la lumière de derrière l'objet.
Note : La réfraction est implémentée en utilisant la texture de l'écran. Seuls les matériaux opaques apparaîtront dans la réfraction, puisque les matériaux transparents ne figurent pas dans la texture de l'écran.
float refraction_scale = 0.05 🔗
L'intensité de l'effet de réfraction.
Texture2D refraction_texture 🔗
void set_texture(param: TextureParam, texture: Texture2D)
Texture2D get_texture(param: TextureParam) const
La texture qui contrôle l'intensité de la réfraction par pixel. Elle est multipliée par refraction_scale.
TextureChannel refraction_texture_channel = 0 🔗
void set_refraction_texture_channel(value: TextureChannel)
TextureChannel get_refraction_texture_channel()
Spécifie le canal de refraction_texture dans lequel les informations de réfraction sont stockées. Ceci est utile lorsque vous stockez l'information pour plusieurs effets dans une seule texture. Par exemple si vous avez stocké la réfraction dans le canal rouge, la rugosité dans le bleu et l'occlusion ambiante dans le vert, vous pourriez réduire le nombre de textures que vous utilisez.
Définit la force de l'effet d'éclairage du contour (rim lightning).
Si true, l'effet de contour est activé. L'éclairage du contour (rim lightning) augmente la luminosité aux angles rasants sur un objet.
Note : L'éclairage du contour n'est pas visible si le shading_mode du matériau vaut SHADING_MODE_UNSHADED.
void set_texture(param: TextureParam, texture: Texture2D)
Texture2D get_texture(param: TextureParam) const
Texture utilisée pour définir la force de l'effet d'éclairage du contour (rim lightning) par pixel. Multipliée par rim.
La quantité pour mélanger la lumière et la couleur albédo lors du rendu de l'effet de contour. Si 0, la couleur de la lumière est utilisée, alors que 1 signifie que la couleur de l'albédo est utilisée. Une valeur intermédiaire fonctionne généralement le mieux.
La réflexion de surface. Une valeur de 0 représente un miroir parfait alors qu'une valeur de 1 rend le reflet complètement flou. Voir aussi metallic.
void set_texture(param: TextureParam, texture: Texture2D)
Texture2D get_texture(param: TextureParam) const
La texture utilisée pour contrôler la rugosité par pixel. Multipliée par roughness.
TextureChannel roughness_texture_channel = 0 🔗
void set_roughness_texture_channel(value: TextureChannel)
TextureChannel get_roughness_texture_channel()
Spécifie le canal de roughness_texture dans lequel les informations de rugosité sont stockées. Ceci est utile lorsque vous stockez l'information pour plusieurs effets dans une seule texture. Par exemple, si vous stockeriez le métallique dans le canal rouge, la rugosité dans le bleu et l'occlusion ambiante dans le vert, vous pourriez réduire le nombre de textures que vous utilisez.
ShadingMode shading_mode = 1 🔗
void set_shading_mode(value: ShadingMode)
ShadingMode get_shading_mode()
Définit si l'ombrage a lieu, par pixel, par sommet ou pas du tout. L'éclairage par sommet est plus rapide, ce qui en fait le meilleur choix pour les applications mobiles, mais il a un aspect considérablement moins bien que l'ombrage par pixel. Le rendu sans ombrage est le plus rapide, mais désactive toutes les interactions avec les lumières.
bool shadow_to_opacity = false 🔗
Si true, permet le mode de rendu « ombre vers opacité » où l'éclairage modifie l'alpha de sorte que les zones ombragées sont opaques et les zones non ombragées sont transparentes. Utilise pour superposer des ombres sur un flux de caméra en RA.
SpecularMode specular_mode = 0 🔗
void set_specular_mode(value: SpecularMode)
SpecularMode get_specular_mode()
La méthode pour rendre le blob spéculaire.
Note : specular_mode s'applique seulement au blob spéculaire. Il n'affecte pas les réflexions spéculaires du ciel, les reflets de l'espace-écran, VoxelGI, SDFGI ou les ReflectionProbes. Pour désactiver les réflexions de ces sources, définissez metallic_specular à 0.0 à la place.
Color stencil_color = Color(0, 0, 0, 1) 🔗
Expérimental : May be affected by future rendering pipeline changes.
La couleur primaire de l'effet de pochoir.
StencilCompare stencil_compare = 0 🔗
void set_stencil_compare(value: StencilCompare)
StencilCompare get_stencil_compare()
Expérimental : May be affected by future rendering pipeline changes.
The comparison operator to use for stencil masking operations.
Expérimental : May be affected by future rendering pipeline changes.
The flags dictating how the stencil operation behaves.
StencilMode stencil_mode = 0 🔗
void set_stencil_mode(value: StencilMode)
StencilMode get_stencil_mode()
Expérimental : May be affected by future rendering pipeline changes.
The stencil effect mode.
float stencil_outline_thickness = 0.01 🔗
void set_stencil_effect_outline_thickness(value: float)
float get_stencil_effect_outline_thickness()
Expérimental : May be affected by future rendering pipeline changes.
L'épaisseur du contour pour STENCIL_MODE_OUTLINE.
Expérimental : May be affected by future rendering pipeline changes.
La valeur de référence du pochoir (0-255). Typiquement une puissance de 2.
bool subsurf_scatter_enabled = false 🔗
Si true, la transluminescence est activée. Émule la lumière qui pénètre la surface d'un objet, est dispersée, puis émerge. La qualité de la transluminescence est contrôlée par ProjectSettings.rendering/environment/subsurface_scattering/subsurface_scattering_quality.
Note : La transluminescence n'est pas pris en charge dans les viewports qui ont un fond transparent (où Viewport.transparent_bg vaut true).
bool subsurf_scatter_skin_mode = false 🔗
Si true, la transluminescence utilisera un mode spécial optimisé pour la couleur et la densité de la peau humaine, comme stimuler l'intensité du canal rouge dans la transluminescence.
float subsurf_scatter_strength = 0.0 🔗
La force de l'effet de transluminescence. La profondeur de l'effet est également contrôlée par ProjectSettings.rendering/environment/subsurface_scattering/subsurface_scattering_scale, qui est défini globalement.
Texture2D subsurf_scatter_texture 🔗
void set_texture(param: TextureParam, texture: Texture2D)
Texture2D get_texture(param: TextureParam) const
Texture utilisée pour contrôler la force transluminescence. Stocké dans le canal de texture rouge. Multiplié par subsurf_scatter_strength.
float subsurf_scatter_transmittance_boost = 0.0 🔗
L'intensité de l'effet de transmittance de la transluminescence.
Color subsurf_scatter_transmittance_color = Color(1, 1, 1, 1) 🔗
La couleur avec laquelle multiplier l'effet de transmittance de la transluminescence. Ignorée si subsurf_scatter_skin_mode vaut true.
float subsurf_scatter_transmittance_depth = 0.1 🔗
La profondeur de l'effet de transmission de la transluminescence.
bool subsurf_scatter_transmittance_enabled = false 🔗
Si true, active la transmittance de la transluminescence. Seulement effectif si subsurf_scatter_enabled vaut true. Voir aussi backlight_enabled.
Texture2D subsurf_scatter_transmittance_texture 🔗
void set_texture(param: TextureParam, texture: Texture2D)
Texture2D get_texture(param: TextureParam) const
La texture à utiliser pour multiplier l'intensité de l'intensité de la transluminescence. Voir aussi subsurf_scatter_texture. Ignoré si subsurf_scatter_skin_mode vaut true.
TextureFilter texture_filter = 3 🔗
void set_texture_filter(value: TextureFilter)
TextureFilter get_texture_filter()
Drapeaux de filtre pour la texture.
Note : heightmap_texture est toujours échantillonnée avec un filtrage linéaire, même si le filtrage par plus proche voisin est sélectionné ici. Cela est fait pour assurer que l'effet de heightmap apparaît comme prévu. Si vous avez besoin de transitions de hauteur plus nettes entre les pixels, redimensionnez la texture de la heightmap dans un éditeur d'image avec un filtrage par plus proche voisin.
Si true, la texture se répète lors du dépassement de la taille de la texture. Voir FLAG_USE_TEXTURE_REPEAT.
Transparency transparency = 0 🔗
void set_transparency(value: Transparency)
Transparency get_transparency()
Le mode de transparence du matériau. Certains modes de transparence désactiveront la projection d'ombres. Tout mode de transparence autre que TRANSPARENCY_DISABLED a un plus grand impact sur la performance comparé au rendu opaque. Voir aussi blend_mode.
bool use_fov_override = false 🔗
Si true, utilise fov_override pour redéfinir l'angle du champ de vision de la Camera3D.
bool use_particle_trails = false 🔗
Si true, active les parties du shader nécessaires pour que les traînées de GPUParticles3D fonctionnent. Cela nécessite également l'utilisation d'un maillage avec un skinning approprié, comme RibbonTrailMesh ou TubeTrailMesh. L'activation de cette fonctionnalité en dehors des matériaux utilisés dans des maillages de GPUParticles3D cassera le rendu du matériau.
Si true, la taille du point de rendu peut être modifiée.
Note : Ce n'est effectif que pour les objets dont la géométrie est basée sur des points plutôt que sur des triangles. Voir aussi point_size.
bool use_z_clip_scale = false 🔗
Si true, utilise z_clip_scale pour redimensionner l'objet rendu vers la caméra pour éviter le clipping dans des objets comme des murs.
Vector3 uv1_offset = Vector3(0, 0, 0) 🔗
De combien décaler les coordonnées UV. Cette quantité sera ajoutée à UV dans la fonction vertex. Cela peut être utilisé pour décaler une texture. La composante Z est utilisée lorsque uv1_triplanar est activé, mais n'est utilisée nulle part ailleurs.
Vector3 uv1_scale = Vector3(1, 1, 1) 🔗
De combien redimensionner les coordonnées UV. Ceci est multiplié par UV dans la fonction vertex. La composante Z est utilisée lorsque uv1_triplanar est activé, mais n'est utilisée nulle part ailleurs.
Si true, au lieu d'utiliser les textures UV, utilisera une recherche de texture tri-planaire pour déterminer comment appliquer les textures. Le tri-planaire utilise l'orientation de la surface de l'objet pour mélanger les coordonnées de texture. Il lit à partir de la texture source 3 fois, une fois pour chaque axe et puis mélange les résultats en fonction de la proximité du pixel avec chaque axe. Cela est souvent utilisé pour les caractéristiques naturelles pour obtenir un mélange réaliste des matériaux. Comme le texturage tri-planaire nécessite beaucoup plus de lectures de texture par-pixel, il est beaucoup plus lent que le texturage UV normal. De plus, comme il mélange la texture entre les trois axes, il est inapproprié lorsque vous essayez d'obtenir du texturage net.
float uv1_triplanar_sharpness = 1.0 🔗
Un nombre plus faible mélange la texture de manière plus douce alors qu'un nombre plus élevé mélange la texture de manière plus nette.
Note : uv1_triplanar_sharpness est borné entre 0.0 et 150.0 (inclusifs) car les valeurs hors de cette plage peuvent avoir l'air cassées selon le maillage.
bool uv1_world_triplanar = false 🔗
Si true, le mapping triplanaire pour UV est calculé dans l'espace global plutôt que dans l'espace local de l'objet. Voir aussi uv1_triplanar.
Vector3 uv2_offset = Vector3(0, 0, 0) 🔗
De combien décaler les coordonnées UV2. Cette quantité sera ajoutée à UV2 dans la fonction vertex. Cela peut être utilisé pour décaler une texture. La composante Z est utilisée lorsque uv2_triplanar est activé, mais n'est utilisée nulle part ailleurs.
Vector3 uv2_scale = Vector3(1, 1, 1) 🔗
De combien redimensionner les coordonnées UV2. Ceci est multiplié par UV2 dans la fonction vertex. La composante Z est utilisée lorsque uv2_triplanar est activé, mais n'est utilisée nulle part ailleurs.
Si true, au lieu d’utiliser UV2 les textures utiliseront une recherche de texture triplanaire pour déterminer comment appliquer des textures. Le triplanaire utilise l’orientation de la surface de l’objet pour mélanger les coordonnées de texture. Il lit à partir de la texture source 3 fois, une fois pour chaque axe, puis mélange les résultats en fonction de la façon dont le pixel s’aligne étroitement avec chaque axe. Ceci est souvent utilisé pour les caractéristiques naturelles pour obtenir un mélange réaliste de matériaux. Parce que la texturation triplanaire nécessite beaucoup plus de lectures de texture par pixel, il est beaucoup plus lent que la texturation UV normale. En outre, parce qu’il est le mélange de la texture entre les trois axes, il est inapproprié lorsque vous essayez d’atteindre texture croustillante.
float uv2_triplanar_sharpness = 1.0 🔗
Un nombre plus faible mélange la texture de manière plus douce alors qu'un nombre plus élevé mélange la texture de manière plus nette.
Note : uv2_triplanar_sharpness est borné entre 0.0 et 150.0 (inclusifs) car les valeurs hors de cette plage peuvent avoir l'air cassées selon le maillage.
bool uv2_world_triplanar = false 🔗
Si true, le mapping triplanaire pour UV2 est calculé dans l'espace global plutôt que dans l'espace local de l'objet. Voir aussi uv2_triplanar.
bool vertex_color_is_srgb = false 🔗
Si true, les couleurs des sommets sont considérées comme stockées dans un encodage sRGB non-linéaire et sont converties en encodage linéaire pendant le rendu. Si false, les couleurs des sommets sont considérées comme stockées dans un encodage linéaire et sont rendues telles quelles. Voir aussi albedo_texture_force_srgb.
Note : Seulement effectif lors de l'utilisation des méthodes de rendu Forward+ et Mobile, mais pas Compatibilité.
bool vertex_color_use_as_albedo = false 🔗
Si true, la couleur du sommet est utilisé pour la couleur de l'albedo.
Redimensionne l'objet rendu vers la caméra pour éviter le clipping dans des objets comme des murs. Ceci est destiné à être utilisé pour les objets qui sont fixés par rapport à la caméra comme les bras du joueur, les outils, etc. L'éclairage et les ombres continueront de fonctionner correctement lorsque ce paramètre est ajusté, mais les effets de l'espace-écran comme le SSAO et le SSR peuvent casser pour les échelles inférieures. Par conséquent, essayez de garder ce paramètre aussi près que possible de 1.0.
Descriptions des méthodes
bool get_feature(feature: Feature) const 🔗
Renvoie true si la fonctionnalité feature spécifiée est active.
bool get_flag(flag: Flags) const 🔗
Renvoie true si le drapeau flag spécifié est activé.
Texture2D get_texture(param: TextureParam) const 🔗
Returns the Texture2D associated with the specified texture param.
void set_feature(feature: Feature, enable: bool) 🔗
If enable is true, enables the specified feature. Many features that are available in BaseMaterial3D need to be enabled before use. This way, the cost for using the feature is only incurred when specified. Features can also be enabled by setting their corresponding property to true.
void set_flag(flag: Flags, enable: bool) 🔗
If enable is true, enables the specified flag. Flags are optional behavior that can be turned on and off. Only one flag can be enabled at a time with this function, the flag enumerators cannot be bit-masked together to enable or disable multiple flags at once. Flags can also be enabled by setting their corresponding property to true.
void set_texture(param: TextureParam, texture: Texture2D) 🔗
Définit la texture à l'emplacement spécifié par param.