Fonction permettant d'afficher directement à l'écran une image RGB
ou une partie d'image de taille indifférente. Cette fonction permet
de réduire les couleurs et d'afficher du mode RVB 32bits au mode
palette 8bits avec tramage.
vdihandle: numéro de la station virtuelle VDI de votre application
display : strcture préalablement remplie décrivant ce que l'on veut
faire.
--------------------------
long __CDECL virtual_display(long vdihandle, videoinf *display, char *type_memoire, sortievideo
*more_infos)
Permet de travailler en mémoire et permet par exemple de faire du
tramage rapide. Le type de format d'image à gérer en mémoire
doit être décrit par *display et *type_mémoire que vous aurez
rempli préallablement.
paramêtres
virtual_display() retourne 0 si l'écran n'est pas supporté 1 si il l'est
et que le mode est rapide, 2 si il est supporté mais que le mode est
lent et -1 si le type d'écran proposé est stupide.
vdihandle: numéro de la station virtuelle VDI de votre application
display: pointeur sur une structure "videoinf" il faut remplir
les champs largeur_ECRAN, hauteur_ECRAN, octets, add_ECRAN, contrairement à la
fonction screen_init(). add_ECRAN doit correspondre à l'adresse
mémoire où vous voulez faire la copie.
type_memoire: description du format de sorti désiré comme pour
screen_init()
more_infos: structure remplie par la fonction vous permettant de
connaitre les palettes nécessaires.
Remarque: Il est interdit d'utiliser screen_init() si vous décidez
d'utiliser l'affichage virtuel
--------------------------
void __CDECL fix_palette(sortievideo *more_infos, long mode, long vdihandle)
Pour fixer la palette (valable jusqu'à 256 couleurs) à utiliser
après screen_init()
more_infos: déja passé à screen_init()
mode: 1L pour le moment
vdihandle: numéro vdi de la virtual worstation.
--------------------------
long __CDECL screen_detect(long vdihandle, char *answer)
Permet de détecter le format hard de la mémoire vidéo
Supporte normalement toutes les machines GEM même les
émulateurs.
paramêtres
screen_detect() retourne un long <0L si il y a erreur
vdihandle: handle VDI de votre application
*answer: pointeur sur une chaine de caractère (mini 50), dans cette
chaine sera retourné le format en ASCII de la vidéo, désignée comme
suit:
_En premier un chiffre précédé éventuellement par -, ce chiffre
représente le nombre de plans de la vidéo, le - indique qu'il s'agit
d'un codage au format Little Endiant (format Intel) au lieu d'un
Big Endiant (format Motorola).
_Ensuite vient le format par lui même, deux cas distincts, les formats
à palette (jusqu'à 8 plans) et les formats RVB au delà.
Dans le premier cas le chiffre est suivi éventuellement de E si
l'écran est au format entrelacé puis de C puis éventuellement de
SP qui signifie que la palette n'est pas hard mais de type soft (si
vous changez la définition d'une couleur, les pixels déja dessinés à
l'écran ne seront pas modifiés, seuls les pixels dessinés après
auront la couleur voulue) ex: 8C, 8EC, 8CSP ...
Dans le second cas sont exprimés le codage RVB, dans l'ordre de codage
du poids fort vers le poids faible chaque couleur désignée par la
lettre R(rouge), V(vert), B(bleu) ou encore X(bit non utilisé) suivi
du nombre de bits utilisés. ex: 32X8R8V8B8
_Ce codage peut être suivi de la mention "VDI", qui signifie que
l'écran n'est pas accessible directement (Physbase, Logbase ne
fonctionne pas), c'est possible avec certains émulateurs. Il faut donc
adresser l'écran avec le VDI pas le choix. ex: 8CSPVDI
screen_display() ne sait pas directement réaliser cette opération, il
est nécessaire d'allouer un bloc mémoire suffisament grand puis par
virtual_display() de demander le dessin dans ce bloc. Il ne vous reste
plus qu'à faire une copie avec vro_cpyfm(). Le format bien sur doit
correspondre au format d'écran si vous copiez avec le paramêtre
fd_stand = 0 des structures MFDB passées. Si fd_stand = 1 alors il
faut prendre le format VDI standard correspondant au nombre de plans
de votre écran (note pour le moment il n'existe pas ce mode en 8
plans, cette fonctionalité est à l'étude)
_Le codage est ensuite suivi de la lettre ':' puis du nombre
supplémentaire d'octets en fin de ligne (la plupart du temps 0 mais
ce genre de carte existe sur Mac)
Actuellement le systême supporte les mémoires video suivantes:
32 plans:
32X8R8V8B8
32R8V8B8X8
32B8V8R8X8
32X8B8V8R8 (rem: TGA32)
24 plans:
24R8V8B8 (format de base des fonctions)
24B8V8R8 (rem: TGA24)
16(15) plans:
-16R5V6B5
-16X1R5V5B5
16R5V6B5
16X1R5V5B5
16R5V5X1B5 (TC color Falcon)
8 plans avec palette:
8C
8G
8EC
8EG
4 plans: (pour le moment la couleur n'est pas gérée -> tramage
en noir et blan a terme j'espere fournir un tramage couleur pour 4EC
et 4C)
4C (existe sur vieux Mac???)
4EC (format ST basse)
4G
4EG (format ST basse)
4P (existe sur vieux mac, ET4000: mode plan par plan comme
VDI pas sur que cela marche!)
2 plans: (pour le moment la couleur n'est pas gérée -> tramage
en noir et blan a terme j'espere fournir un tramage couleur pour 2EC
et 2C)
2C (existe sur vieux Mac???)
2EC (format ST moyenne)
2G
2EG (format ST moyenne)
1 plan:
1C ou 1G (ST haute)
WARNING: Utilisation: L'écran doit être retenu avant l'appel à
screen_detect() sous peine de mauvaise détection, une fois la
détection l'écran doit être libéré.
exemple:
while(!wind_update(BEG_UPDATE));
flag=screen_detect((long)vdihandle,retourneecc);
wind_update(END_UPDATE);
--------------------------
long __CDECL trnfm_to_R8V8B8(unsigned char *src, long destR8V8B8, unsigned char *palette,long width, long height,long nb_plans,long mode)
transforme une image entière à différents formats vers mode TC 24R8V8B8 (le mode normalisé pour screen)
*src: pointeur sur l'image à transformer
destR8V8B8: pointeur sur le buffer destination ou numéro GEMDOS donné par Fopen()
*palette: palette RGB de l'image source 8bits par couleur fondamentale, donc 3octets par couleur
les valeurs sont à la suites les unes des autres couleurs de 0 à 255 dans l'ordre RVB
Si -1L pour 1 plan et 4plans palette par défaut, ne pas utiliser pour les autres plans
width: largeur de l'image en pixels
height: hauteur de l'image en pixels
nb_plans: nombres de plans dans l'image source (1, 2, 3,4,5,6,7,8, 16, 32 pas de 24 bien sur!!!)
mode: 0L : Source type VDI (description plan par plan)
1L : Source entrelacée (typiquement video entrelacée ST et Falcon jusqu'à 8 plans (256 couleurs))
ce mode n'est supporté que pour 2, 4 et 8
plans ou standard VDI 16, 24 et 32 plans (RVB
la largeur source peut etre quelconque mais
pour compatibilité VDI la largeur réelle de
la source est le multiple de 16 supérieur si
largeur%16!=0) Ne pas appeler cette fonction
en 24plans si largeur%16==0 c'est alors le
format natif de screen_display()
2L : Source mode non entrelacée pixel par pixel (format le + simple!)
ce mode n'est supporté que pour 4, 8, 16 et 32
plans
au dela de 8 plans "mode" n'est plus pris en compte le format est du type RVB
ainsi que pour le mode 1 plan
Si bit 8 de mode = 1 (256) alors la destination n'est plus un pointeur mémoire
mais le numéro GEMDOS d'un fichier ouvert en écriture de la fonction cliente
où la transformation sera écrite.
Si bit 9 de mode = 1 alors sauvegarde du fichier texture.24b dans le répertoire
courant.
retourne 1L si ok,
0L si non supporté,
<0L si erreur
-1 largeur image non supportée ex en mono multiple de 8, mode 1 doit être multiple de 16
-2 palette manquante (nécessaire même pour le mode noir et blanc car on peut substituer au noir et au blanc 2 couleurs au choix)
-3 mode non supporté
-4 erreur source
-5 erreur destination
-6 conversion impossible (en mode 1 uniquement nb plans demandés incohérent)
-7 la conversion demandée pour le moment ne supporte pas l'écriture sur disque
-8 Erreur handle GEMDOS!
-9 Conversion stupide! vous êtes déja en 24bits comme il faut
Attention l'image doit être complète en largeur on ne peut donc pas s'en servir pour faire
de l'affichage directe ca doit se passer en mémoire, le client est supposer savoir calculer
la taille du buffer destination (3*width*height) et le réserver avant appel. L'image source
n'est pas modifiée. Source et destination ne peuvent pas être confondues!!!
--------------------------
long __CDECL trnfm_plane_to_VDI(unsigned char *src, unsigned char *dest, long nb_plans,char *srcdef, long width, long height, long options)
/*Transformations à nombre de plans constants sans modification des couleurs juste une
réorganisation de l'image sans changement de repère vers le format VDI pour le nombre
de plans donnés CAD:
Nb de plans Format initial Format VDI nom srcdef autorisé
1 1 plan aucune transformation!
2 Entrelacé 2 plans séparés EC
4 Entrelacé/non entrelacé 4 plans séparés EC et C
8 Entrelacé/non entrelacé 8 plans séparés EC et C
16 Formats RVB divers R5V6B5 ex B5V6B5 ...
24 Formats RVB divers R8V8B8 ex B8V8R8 ...
32 Formats RVB divers X8R8V8B8 ex X8B8V8R8 ...
Ces formats peuvent ensuites être utilisés avec vr_trnfm() pour le mettre au format de la carte
soit pour mettre en forme vers trnfm_to_R8V8B8() principalements pour les plans >8 car cette
fonction sait directement déja transformer directement vers 24 plans les nombres de plans inférieurs.
*src : source
*dest : destination WARNING le buffer destination doit assumer avoir la bonne taille
si options==0 ou 1 CAD ((width+15)&(0xFFFFFFFFL-15L))*height*nb_plans sinon width*height*nb_plans
nb_plans : nombre de plans
*srcdef : format du source
width : largeur image
height : hauteur image
option : 0 transformation vers VDI, 2 transformation vers mode simple
retourne 1 si Ok sinon:
0 non supporté
-1 largeur image non supportée
la destination doit être réservée par le client à la taille du source
ATTENTION: cette procédure est actuellement très incomplète elle supporte les transformations suivantes:
8C ainsi que toutes les transformations 24 et 32 plans
--------------------------
void __CDECL trnfm_ind_pal( unsigned char *palette, long nbplans)
converti une palette GEMDOS vers une palette standard VDI
(positionnement des couleurs)
fonctionne pour 4 et 8 plans.
unsigned char *palette : palette de départ et de retour
long nbplans : nombre de plans
*/
--------------------------
void __CDECL restore_palette(long vdihandle)
restore la palette quand il n'y a plus de client intéressé
--------------------------
void __CDECL screen_display_texture(long vdihandle, videoinf *display, long startx, long starty)
affiche une texture
startx, starty, x,y ou commence la référence à l'écran de la
texture
--------------------------
short __CDECL screen_display_from_disk(long vdihandle, videoinf *display,long gemdos_handle)
fait l'affichage à partir d'un bloc RVB sur disque retourne 0 si ok
vdihandle : station VDI ouverte
display :strcture préalablement remplie décrivant ce que l'on veut faire.
gemdos_handle : numéro de fichier Gemdos ouvert par le client sur
le buffer RVB enregistré.
--------------------------
void __CDECL Save_TGA(char *file, void *buffer, long WIDTH, long HEIGHT, long mode)
--------------------------
void __CDECL direct_display(long vdihandle,videoinf *display,long nbplans,long mode) /* affiche une image au format déja de l'écran vers l'écran par VDI */
/* si mode == 1 alors à partir du disque add_RGB devient le numéro GEMDOS de fichier
Ce mode n'est pour le moment pas supporté mettre 0
sinon add_RGB == adresse en mémoire de l'image Bitmap (sans octets supplémentaires!)
et au format déja transformé écran
add_ECRAN n'est pas pris en compte affichage uniquement sur écran par VDI */
Attention: screen_detect() doit être obligatoirement appelée pour
utiliser cette fonction
--------------------------
void __CDECL direct_display_texture(long vdihandle, videoinf *display, long startx, long starty)
/* affiche l'image en considerant que c'est une texture CAD répête l'image pour remplir
la destination idem screen_display_texture() Cette procédure utilise
le VDI */
Attention: screen_detect() doit être obligatoirement appelée pour
