Énumération D3DTEXTUREOP

Article
06/13/2023

Définit les opérations de fusion de textures par étape.

Syntaxe

typedef enum D3DTEXTUREOP { 
  D3DTOP_DISABLE                    = 1,
  D3DTOP_SELECTARG1                 = 2,
  D3DTOP_SELECTARG2                 = 3,
  D3DTOP_MODULATE                   = 4,
  D3DTOP_MODULATE2X                 = 5,
  D3DTOP_MODULATE4X                 = 6,
  D3DTOP_ADD                        = 7,
  D3DTOP_ADDSIGNED                  = 8,
  D3DTOP_ADDSIGNED2X                = 9,
  D3DTOP_SUBTRACT                   = 10,
  D3DTOP_ADDSMOOTH                  = 11,
  D3DTOP_BLENDDIFFUSEALPHA          = 12,
  D3DTOP_BLENDTEXTUREALPHA          = 13,
  D3DTOP_BLENDFACTORALPHA           = 14,
  D3DTOP_BLENDTEXTUREALPHAPM        = 15,
  D3DTOP_BLENDCURRENTALPHA          = 16,
  D3DTOP_PREMODULATE                = 17,
  D3DTOP_MODULATEALPHA_ADDCOLOR     = 18,
  D3DTOP_MODULATECOLOR_ADDALPHA     = 19,
  D3DTOP_MODULATEINVALPHA_ADDCOLOR  = 20,
  D3DTOP_MODULATEINVCOLOR_ADDALPHA  = 21,
  D3DTOP_BUMPENVMAP                 = 22,
  D3DTOP_BUMPENVMAPLUMINANCE        = 23,
  D3DTOP_DOTPRODUCT3                = 24,
  D3DTOP_MULTIPLYADD                = 25,
  D3DTOP_LERP                       = 26,
  D3DTOP_FORCE_DWORD                = 0x7fffffff
} D3DTEXTUREOP, *LPD3DTEXTUREOP;

Constantes

D3DTOP_DISABLE

Désactive la sortie de cette étape de texture et de toutes les phases avec un index supérieur. Pour désactiver le mappage de texture, définissez-le comme opération de couleur pour la première étape de texture (étape 0). Les opérations alpha ne peuvent pas être désactivées lorsque les opérations de couleur sont activées. La définition de l’opération alpha sur D3DTOP_DISABLE lorsque le mélange de couleurs est activé entraîne un comportement non défini.

D3DTOP_SELECTARG1

Utilisez la première couleur ou l’argument alpha de cette étape de texture, non modifié, comme sortie. Cette opération affecte l’argument de couleur lorsqu’il est utilisé avec l’état D3DTSS_COLOROP de l’étape de texture, et l’argument alpha lorsqu’il est utilisé avec D3DTSS_ALPHAOP.

équation de cet argument (s(rgba) = arg1)

D3DTOP_SELECTARG2

Utilisez la deuxième couleur ou l’argument alpha de cette étape de texture, non modifié, comme sortie. Cette opération affecte l’argument de couleur lorsqu’il est utilisé avec l’état de l’étape de texture D3DTSS_COLOROP et l’argument alpha lorsqu’il est utilisé avec D3DTSS_ALPHAOP.

équation de cet argument (s(rgba) = arg2)

D3DTOP_MODULATE

Multipliez les composants des arguments.

équation de l’opération de module (s(rgba) = arg1 x arg 2)

D3DTOP_MODULATE2X

Multipliez les composants des arguments et déplacez les produits sur le 1 bit gauche (en les multipliant par 2) à des fins d’éclaircissement.

équation de l’opération module2x (s(rgba) = (arg1 x arg 2) puis décaler vers la gauche 1)

D3DTOP_MODULATE4X

Multipliez les composants des arguments et déplacez les produits sur les 2 bits de gauche (en les multipliant par 4) pour l’éclaircissage.

équation de l’opération module4x (s(rgba) = (arg1 x arg 2) puis décaler vers la gauche 2)

D3DTOP_ADD

Ajoutez les composants des arguments.

équation de l’opération d’ajout (s(rgba) = arg1 + arg 2)

D3DTOP_ADDSIGNED

Ajoutez les composants des arguments avec un biais - 0,5, en faisant la plage effective de valeurs comprises entre - 0,5 et 0,5.

équation de l’opération d’ajout signé (s(rgba) = arg1 + arg 2 – 0,5)

D3DTOP_ADDSIGNED2X

Ajoutez les composants des arguments avec un biais - 0,5, puis déplacez les produits vers le bit 1 gauche.

équation de l’opération 2x d’ajout signé ((s(rgba) = arg1 + arg 2 - 0,5) puis décaler vers la gauche 1)

D3DTOP_SUBTRACT

Soustrayez les composants du deuxième argument de ceux du premier argument.

équation de l’opération de soustraction (s(rgba) = arg1 - arg 2)

D3DTOP_ADDSMOOTH

Ajoutez les premier et deuxième arguments ; puis soustraire leur produit de la somme.

équation de l’opération add smooth (s(rgba) = arg1 + arg 2 x (1 - arg1))

D3DTOP_BLENDDIFFUSEALPHA

Mélangez linéairement cette étape de texture, à l’aide de l’alpha interpolée de chaque sommet.

équation de l’opération de fusion alpha diffuse (s(rgba) = arg1 x alpha + arg 2 x (1 - alpha))

D3DTOP_BLENDTEXTUREALPHA

Mélangez linéairement cette étape de texture en utilisant l’alpha de la texture de cette étape.

équation de l’opération alpha de texture de fusion (s(rgba) = arg1 x alpha + arg 2 x (1 - alpha))

D3DTOP_BLENDFACTORALPHA

Mélangez linéairement cette étape de texture, à l’aide d’un jeu alpha scalaire avec l’état de rendu D3DRS_TEXTUREFACTOR.

équation de l’opération de facteur de fusion alpha (s(rgba) = arg1 x alpha + arg 2 x (1 - alpha))

D3DTOP_BLENDTEXTUREALPHAPM

Mélanger linéairement une étape de texture qui utilise une alpha prémultipliée.

équation de l’opération blend texture alpha pm (s(rgba) = arg1 + arg 2 x (1 - alpha))

D3DTOP_BLENDCURRENTALPHA

Mélangez linéairement cette étape de texture, à l’aide de l’alpha extraite de l’étape de texture précédente.

équation de l’opération alpha actuelle de fusion (s(rgba) = arg1 x alpha + arg2 x (1 - alpha))

D3DTOP_PREMODULATE

D3DTOP_PREMODULATE est défini à l’étape n. La sortie de la phase n est arg1. En outre, s’il existe une texture à l’étape n + 1, toute D3DTA_CURRENT de l’étape n + 1 est prémultipliée par la texture à l’étape n + 1.

D3DTOP_MODULATEALPHA_ADDCOLOR

Moduler la couleur du deuxième argument en utilisant l’alpha du premier argument ; ajoutez ensuite le résultat à l’argument 1. Cette opération est prise en charge uniquement pour les opérations de couleur (D3DTSS_COLOROP).

équation de l’opération alpha add color module (s(rgba) = arg1(rgb) + arg1(a) x arg2(rgb))

D3DTOP_MODULATECOLOR_ADDALPHA

Moduler les arguments ; ajoutez ensuite l’alpha du premier argument. Cette opération est prise en charge uniquement pour les opérations de couleur (D3DTSS_COLOROP).

équation de l’opération add alpha module color (s(rgba) = arg1(rgb) x arg2(rgb) + arg1(a))

D3DTOP_MODULATEINVALPHA_ADDCOLOR

Semblable à D3DTOP_MODULATEALPHA_ADDCOLOR, mais utilisez l’inverse de l’alpha du premier argument. Cette opération est prise en charge uniquement pour les opérations de couleur (D3DTSS_COLOROP).

équation de l’opération alpha inverse add color module (s(rgba) = (1 - arg1(a)) x arg2(rgb) + arg1(rgb))

D3DTOP_MODULATEINVCOLOR_ADDALPHA

Semblable à D3DTOP_MODULATECOLOR_ADDALPHA, mais utilisez l’inverse de la couleur du premier argument. Cette opération est prise en charge uniquement pour les opérations de couleur (D3DTSS_COLOROP).

équation de l’opération add alpha module inverse color (s(rgba) = (1 - arg1(rgb)) x arg2(rgb) + arg1(a))

D3DTOP_BUMPENVMAP

Effectuez un mappage de bosses par pixel, à l’aide de la carte d’environnement à l’étape de texture suivante, sans luminance. Cette opération est prise en charge uniquement pour les opérations de couleur (D3DTSS_COLOROP).

D3DTOP_BUMPENVMAPLUMINANCE

Effectuez un mappage de bosses par pixel, à l’aide de la carte d’environnement à l’étape de texture suivante, avec la luminosité. Cette opération est prise en charge uniquement pour les opérations de couleur (D3DTSS_COLOROP).

D3DTOP_DOTPRODUCT3

Moduler les composants de chaque argument en tant que composants signés, ajouter leurs produits; répliquez ensuite la somme sur tous les canaux de couleur, y compris alpha. Cette opération est prise en charge pour les opérations de couleur et alpha.

équation de l’opération dot product 3 (s(rgba) = arg1(r) x arg2(r) + arg1(g) x arg2(g) + arg1(b) x arg2(b))

Dans DirectX 6 et DirectX 7, les opérations multitexture les entrées ci-dessus sont toutes décalées de moitié (y = x - 0,5) avant d’être utilisées pour simuler les données signées, et le résultat scalaire est automatiquement limité aux valeurs positives et répliqué sur les trois canaux de sortie. Notez également qu’en tant qu’opération de couleur, cette opération ne met pas à jour l’alpha, elle met simplement à jour les composants RVB.

Toutefois, dans les nuanceurs DirectX 8.1, vous pouvez spécifier que la sortie doit être routée vers les composants .rgb ou .a ou les deux (valeur par défaut). Vous pouvez également spécifier une opération scalaire distincte sur le canal alpha.

D3DTOP_MULTIPLYADD

Effectue une opération de multiplication-accumulation. Il prend les deux derniers arguments, les multiplie, les ajoute à l’argument d’entrée/source restant et le place dans le résultat.

S_RGBA = Arg1 + Arg2 * Arg3

D3DTOP_LERP

Interpole linéairement entre les deuxième et troisième arguments sources selon une proportion spécifiée dans le premier argument source.

S_RGBA = (Arg1) * Arg2 + (1- Arg1) * Arg3.

D3DTOP_FORCE_DWORD

Force cette énumération à compiler à 32 bits. Sans cette valeur, certains compilateurs autoriseraient cette énumération à compiler à une taille autre que 32 bits. Cette valeur n'est pas utilisée.

Notes

Les membres de ce type sont utilisés lors de la définition d’opérations de couleur ou alpha à l’aide des valeurs D3DTSS_COLOROP ou D3DTSS_ALPHAOP avec la méthode IDirect3DDevice9::SetTextureStageState .

Dans les formules ci-dessus, S_RGBA est la couleur RGBA produite par une opération de texture, et Arg1, Arg2 et Arg3 représentent la couleur RVBA complète des arguments de texture. Les composants individuels d’un argument sont affichés avec des indices. Par exemple, le composant alpha de l’argument 1 s’affiche sous la forme Arg1_A.

Spécifications

Condition requise	Valeur
En-tête	D3D9Types.h

Voir aussi

Énumérations Direct3D
D3DTEXTURESTAGESTATETYPE

Partager via