Discussion :

[fabrice001]

Bonjour j'ai une question d'ordre général sur directX et les images 8 bits (je précise je débute).

J 'ai une appliquation graphique qui est en mode 16 bits pour l'affichage (hardware dépendant - faut pas chercher à comprendre).

Lorsque je déclare une surface tampon (pas le backbuffer) direct X dans laquelle je load une série d'image bmp 8 bits (sans loader la palette), si je copie une partie de cette surface dans mon backbuffer puis ma surface primaire directX qui contient des images 16 bits que se passe-t-il au niveau des couleurs?
J'ai essayer sans faire de loadpalette et je ne vois rien d'anormal (coup de bol?) ... ça me parrait pas trop catholique...

Plus généralement si les couleurs contenues dans l'image 8 bits sont déjà comprise dans l'image 16 bits est ce que je peux incruster une image 8 bits dans une 16 bits sans me soucier des palettes? (mon idée est demander au graphiste de mettre au moins quelques éléménts dans mes images 16 bits avec le même code couleur que celles dans l'image 8 bits).

Si c'est pas possible, quel précautions je doit prendre lorsque je fais un blfast d'une surface X (contenant des images 8 bits) vers une surface 16 bits

Salutations

[fabrice001]

help svp

question plus simple lorsqu'on est en mode 16 bits et qu'on load une image 8 bits sans loader la palette pour cette image, est-ce normal que cette image s'affiche correctement, ma question peut parraître bête pour certain (je débute) mais j'ai peur de faire une connerie, à moins que l'on doit se tracasser des palettes uniquement lorsqu'on est en full 8 bits pour tout?

[Sivrît]

Il me semble qu'un fichier bmp contient (ou du moins peut contenir) une palette donc si les couleurs tombent bien il est probable que la palette ait été chargée de façon transparente par directX.

En 16bits il n'y a pas de palette. Les couleurs sont prédéfinies, on peut même dire codées, comme en 24bpp, il y en a juste un peu moins (http://en.wikipedia.org/wiki/Color_depth). Par contre le 8bits est un mode palettisé. Une image 8bits c'est deux dimensions, une série de valeurs d'un octet et une palette. Sans palette pas de notion de couleurs (à moins de faire des niveaux de gris auquel cas on a quand même une palette implicite).

Donc pour afficher une image 8 bits :
- Si on travaille tout en 8bits il faudra que les palettes des images à afficher et la palette de la surface de destination (l'écran) correspondent sinon cetaines images auront leurs couleurs dénaturée.
- En 16bits ou plus les images seront plaquées dans la surface de destination en utilisant leurs palettes (chacune peut avoir la sienne) qui font la correspondance entre les valeurs 8bits et un sous-ensembles des couleurs sur 16/24bits. Si la palette donne des couleurs 24bits et que l'on est en 16, c'est la couleur la plus proche du mode 16bits qui sera prise.

J'espère que ça pourra t'aider.

[Mat.M]

Lorsque je déclare une surface tampon (pas le backbuffer) direct X dans laquelle je load une série d'image bmp 8 bits (sans loader la palette), si je copie une partie de cette surface dans mon backbuffer puis ma surface primaire directX qui contient des images 16 bits que se passe-t-il au niveau des couleurs?
J'ai essayer sans faire de loadpalette et je ne vois rien d'anormal (coup de bol?) ... ça me parrait pas trop catholique...

charger une 256 couleurs vers =>16 bits aucun problème l'OS s'arrange , je pense, pour convertir l'image.
Dans le cas inverse , Windows effectue un "dithering" ou tramage

dans laquelle je load une série d'image bmp 8 bits

Avec quelles API ? LoadBitmap ?
L'OS doit s'arranger pour convertir la bitmap et chaque pixel de l'image selon la palette
Dans une bmp 256 couleurs tu as un header de 128 octets , l'image brute et 256 teintes parmi les 3 composantes=768 octets de palette

En 16bits il n'y a pas de palette. Les couleurs sont prédéfinies, on peut même dire codées, comme en 24bpp,

16 bits soit 2 octets =>65536 couleurs
24 bits soit 3 octets=>16M de couleurs codées en RGB

[Mat.M]

à moins que l'on doit se tracasser des palettes uniquement lorsqu'on est en full 8 bits pour tout?

Si tu crées une image avec la palette de couleurs standard non.
Dès que tu changes la palette de couleurs oui .
Il faut appeler les API pour les palettes CreatePalette et LoadPalette.
Avec le SDK de Direct X il y a si tu le trouves encore DDutil.cpp qui permet de charger des palettes d'images 8 bits.
Mais le plus simple c'est de passer en mode 16bits, le 8bits je ne sais pas s'il sera de moins en moins supporté par les cartes et deviendra obsolète...

[Mat.M]

Fabrice1 voilà peut-être un élément de réponse tiré du MSDN octobre 2001 sur IDirectDraw7 :: SetDisplayMode

DirectX SDK
Off-Screen Surface Formats
The following table shows the pixel formats for off-screen plain surfaces supported by the DirectX hardware emulation layer (HEL). The Masks column contains the red, green, blue, and alpha masks for each set of pixel format flags and bit depths.

DDPF_RGB |
DDPF_PALETTEINDEXED1 1 R: 0x00000000
G: 0x00000000
B: 0x00000000
A: 0x00000000


DDPF_RGB |
DDPF_PALETTEINDEXED2 2 R: 0x00000000
G: 0x00000000
B: 0x00000000
A: 0x00000000

DDPF_RGB |
DDPF_PALETTEINDEXED4 4 R: 0x00000000
G: 0x00000000
B: 0x00000000
A: 0x00000000

DDPF_RGB |
DDPF_PALETTEINDEXED8 8 R: 0x00000000
G: 0x00000000
B: 0x00000000
A: 0x00000000

DDPF_RGB 16 R: 0x0000F800
G: 0x000007E0
B: 0x0000001F
A: 0x00000000

DDPF_RGB 16 R: 0x00007C00
G: 0x000003E0
B: 0x0000001F
A: 0x00000000

DDPF_RGB 24 R: 0x00FF0000
G: 0x0000FF00
B: 0x000000FF
A: 0x00000000

DDPF_RGB 24 R: 0x000000FF
G: 0x0000FF00
B: 0x00FF0000
A: 0x00000000

DDPF_RGB 32 R: 0x00FF0000
G: 0x0000FF00
B: 0x000000FF
A: 0x00000000

DDPF_RGB 32 R: 0x000000FF
G: 0x0000FF00
B: 0x00FF0000
A: 0x00000000

DDPF_RGB |
DDPF_ZPIXELS 32 R: 0x0000F800
G: 0x000007E0
B: 0x0000001F
Z: 0xFFFF0000

Donc en 16bits c'est ce qu'il me semblait il y a un masquage qui est effectué

DDPF_RGB |
DDPF_ZPIXELS 32 R: 0x00007C00
G: 0x000003E0
B: 0x0000001F
Z: 0xFFFF0000