@DATABASE "Screens" @AUTHOR "Paul Manias" @NODE "Main" "Documentation sur les Ecrans" @{b}@{u}MODULE DOCUMENTATION@{uu}@{ub} Nom : @{"SCREENS" LINK "Functions"} Version: 0.8 Beta. Date: Septembre 1997 Auteur: Paul Manias Traducteur: Julien Boibessot Copyright: DreamWorld Productions, 1996-1997. Tous droits réservés. Notes: Ce document est perpétuellement en cours d'écriture et contiendra sûrement bon nombre d'erreurs. Les informations données ne seront officielles que lorsque cette autodoc atteindra la version 1.0. @EndNode --------------------------------------------------------------------------- @NODE "Functions" "Module: Screens" @{b}OBJETS@{ub} @{"Screen" LINK "GMSDev:AutoDocs/Objects/Screenfr.guide/Description"} @{"Sprite" LINK "GMSDev:AutoDocs/Objects/Spritefr.guide/Description"} @{b}FONCTIONS@{ub} @{"AllocVideoMem()" LINK "AllocVideoMem()"} @{"BlankOn() " LINK "BlankOn()"} @{"BlankOff() " LINK "BlankOff()"} @{"FreeVideoMem() " LINK "FreeVideoMem()"} @{"GetScrType() " LINK "GetScrType()"} @{"HideDisplay() " LINK "HideDisplay()"} @{"MovePicture() " LINK "MovePicture()"} @{"ReturnDisplay()" LINK "ReturnDisplay()"} @{"SwapBuffers() " LINK "SwapBuffers()"} @{"TakeDisplay() " LINK "TakeDisplay()"} @{"WaitVBL() " LINK "WaitVBL()"} @{"WaitRastLine() " LINK "WaitRastLine()"} @{b}Fonctions liées aux couleurs@{ub} @{"BlankColours() " LINK "BlankColours()"} @{"ChangeColours() " LINK "ChangeColours()"} @{"ColourMorph() " LINK "ColourMorph()"} @{"ColourToPalette()" LINK "ColourToPalette()"} @{"PaletteToColour()" LINK "PaletteToColour()"} @{"PaletteMorph() " LINK "PaletteMorph()"} @{"UpdatePalette() " LINK "UpdatePalette()"} @{"UpdateColour() " LINK "UpdateColour()"} @{b}Fonctions liées aux RasterList@{ub} @{"HideRasterlist() " LINK "HideRasterlist()"} @{"InitRasterlist() " LINK "InitRasterlist()"} @{"RemoveRasterlist() " LINK "RemoveRasterlist()"} @{"ShowRasterlist() " LINK "ShowRasterlist()"} @{"UpdateRasterlist() " LINK "UpdateRasterlist()"} @{"UpdateRasterLines() " LINK "UpdateRasterLines()"} @{"UpdateRasterCommand() " LINK "UpdateRasterCommand()"} @{"UpdateRasterCommands()" LINK "UpdateRasterCommands()"} @EndNode --------------------------------------------------------------------------- @NODE "AllocVideoMem()" "Screens: AllocVideoMem()" @{b}@{u}FONCTION@{uu}@{ub} Nom: AllocVideoMem() Résumé: Alloue de la mémoire pour le Blitter. Assembleur: Memory = AllocVideoMem(Size [d0], Flags [d1]) C/C++: APTR AllocVideoMem(LONG Size) @{b}@{u}DESCRIPTION@{uu}@{ub} Alloue un bloc mémoire servant à l'affichage vidéo. Ce type de mémoire est compatible avec le module blitter, et doit aussi l'être avec toutes les configurations matérielles. La mémoire sera recherchée de la même manière que celle précisée dans AllocMemBlock() si la recherche de ressources est activée. @{b}@{u}ENTREES@{uu}@{ub} Size - La taille de la mémoire à allouer. @{b}@{u}RESULTAT@{uu}@{ub} Memory - Pointeur vers la mémoire allouée. Toute mémoire vidéo est remplie de zéros lorsqu'on l'alloue. Retourne NULL si il y a une erreur. @{b}@{u}VOIR AUSSI@{uu}@{ub} Kernel: @{"FreeMemBlock()" LINK "GMSDev:AutoDocs/Kernelfr.guide/FreeMemBlock()"} Screens: @{"FreeVideoMem()" LINK "FreeVideoMem()"} @EndNode --------------------------------------------------------------------------- @NODE "BlankColours()" "Screens: BlankColours()" @{b}@{u}FONCTION@{uu}@{ub} Nom: BlankColours() Résumé: Met toutes les couleurs de l'écran à zéro (noir). Assembleur: BlankColours(Screen [a0]) C/C++: void BlankColours(struct Screen *) @{b}@{u}DESCRIPTION@{uu}@{ub} Met toutes les couleurs à zéro, ce qui devrait donner un écran noir. (seulement si le ScrType utilise le registre de palette).Vous serez incapable de voir une image après avoir appelé cette routine avec succès. @{b}@{u}ENTREES@{uu}@{ub} Screen - Pointeur vers une structure Screen initialisée. @{b}@{u}VOIR AUSSI@{uu}@{ub} Screens: @{"BlankOn()" LINK "BlankOn()"} @EndNode --------------------------------------------------------------------------- @NODE "BlankOn()" "Screens: BlankOn()" @{b}@{u}FONCTION@{uu}@{ub} Nom: BlankOn() Résumé: Rend invisible l'affichage jusqu'à ce que BlankOff() soit appelée. Assembleur: BlankOn() C/C++: void BlankOn(void) @{b}@{u}DESCRIPTION@{uu}@{ub} Après avoir appelé cette fonction l'affichage sera complètement invisible jusqu'à ce BlankOff() soit appelée. Durant cette période aucun effet à l'écran ne sera visible. Notez que ShowScreen() est incapable de terminer une "screen blanking period", mais une fois que l'affichage est à nouveau rétabli toutes les altérations de l'écran seront visibles. Cette fonction a pour but de faire une transition propre entre deux écrans, ie fermer un écran puis en ouvrir un autre. @{b}@{u}VOIR AUSSI@{uu}@{ub} Screens: @{"BlankOff()" LINK "BlankOff()"} @EndNode --------------------------------------------------------------------------- @NODE "BlankOff()" "Screens: BlankOff()" @{b}@{u}FONCTION@{uu}@{ub} Nom: BlankOff() Résumé: Réactive l'affichage après un appel à BlankOn(). Assembleur: BlankOff() C/C++: void BlankOff(void) @{b}@{u}DESCRIPTION@{uu}@{ub} Cette fonction réactive l'affichage après un appel à BlankOn(). Tous les effets qui étaient invisibles après un appel à BlankOn() deviennent immédiatement visibles après l'appel à cette fonction. @{b}@{u}VOIR AUSSI@{uu}@{ub} Screens: @{"BlankOn()" LINK "BlankOn()"} @EndNode ----------------------------------------- ---------------------------------- @NODE "ColourMorph()" "Screens: ColourMorph()" @{b}@{u}FONCTION@{uu}@{ub} Nom: ColourMorph() Résumé: Fait le fondu d'un set de couleurs vers une couleur définie. Assembleur: FadeState = ColourMorph(Screen [a0], FadeState [d0], Speed [d1], StartColour [d3], AmtColours [d4], SrcColour [d2], DestColour [d5]) C/C++: WORD ColourMorph(struct Screen *, WORD FadeState, WORD Speed, LONG StartColour, LONG AmtColours, LONG SrcColour, LONG DestColour) @{b}@{u}DESCRIPTION@{uu}@{ub} Fait un fondu à l'écran d'une couleur vers une autre. Une fois que vous avez appelé cette fonction, vous devez continuer à l'appeler jusqu'à ce qu'elle vous donne le résultat NULL. Cela vous permet de placer cette fonction dans une boucle et de faire toutes sortes de choses pendant que le fondu suit son cours. Cette fonction utilise le "proportional fading" (fondu proportionnel) pour créer cet effet. @{b}@{u}NOTE@{uu}@{ub} Toutes les fonctions de fondu ignore les valeurs des couleurs qui sont gardées en interne. Cela vous causera donc des problèmes si vous ne savez pas à quoi ressemble votre palette courante en utilisant ces fonctions. @{b}@{u}EXEMPLE@{uu}@{ub} FadeState = NULL; do { WaitVBL(); FadeState = ColourMorph(Screen,FadeState,1,0,32,0xFF00AA,0xA7BC30); } while (FadeState != NULL) @{b}@{u}ENTREES@{uu}@{ub} Screen - Pointeur vers une structure Screen initialisée. FadeState - Initialisez le à 0 et continuer à envoyer la valeur retournée jusqu'à ce que ce paramètre soit NULL. Speed - La vitesse requise pour le fondu. SrcColour - La couleur source du fondu, au format 0xRRGGBB. DestColour - La couleur de destination du fondu, au format 0xRRGGBB. StartColour - La couleur par laquelle on commence le fondu (0 .... AmtColours-1). AmtColours - La quantité de couleurs dans le fondu (1 ... Maximum de couleurs). Vous ne devez jamais utiliser une valeur nulle ici. @{b}@{u}RESULTAT@{uu}@{ub} FadeState - Retourne NULL lorsque le fondu est terminé. @{b}@{u}VOIR AUSSI@{uu}@{ub} Screens: @{"ColourToPalette()" LINK "ColourToPalette()"} @{"PaletteMorph() " LINK "PaletteMorph()"} @{"PaletteToColour()" LINK "PaletteToColour()"} @EndNode --------------------------------------------------------------------------- @NODE "ColourToPalette()" "Screens: ColourToPalette()" @{b}@{u}FONCTION@{uu}@{ub} Nom: ColourToPalette() Résumé: Fait un fondu d'un set de couleurs vers un certain nombre de valeurs. Assembleur: FadeState = ColourToPalette(Screen [a0], FadeState [d0], Speed [d1], StartColour [d3], AmtColours [d4], Palette [a1], Colour [d2]) C/C++: WORD ColourToPalette(struct Screen *, WORD FadeState, WORD Speed, WORD StartColour, WORD AmtColours, APTR Palette, LONG Colour) @{b}@{u}DESCRIPTION@{uu}@{ub} Fait un fondu entre un certain nombre de couleurs de la même valeur et des couleurs spécifiées de la Palette. Une fois que vous avez appelé cette fonction, vous devez continuer à l'appeler jusqu'à ce qu'elle vous donne le résultat NULL. Cela vous permet de placer cette fonction dans une boucle et de faire toutes sortes de choses pendant que le fondu suit son cours. Cette fonction utilise le "proportional fading" (fondu proportionnel) pour créer cet effet. @{b}@{u}NOTE@{uu}@{ub} Toutes les fonctions de fondu ignore les valeurs des couleurs qui sont gardées en interne. Cela vous causera donc des problèmes si vous ne savez pas à quoi ressemble votre palette courante en utilisant ces fonctions. Gardez une trace de votre palette courante peut être utile avec des fonctions comme PaletteMorph(). @{b}@{u}ENTREES@{uu}@{ub} Screen - Pointeur vers une structure Screen initialisée. FadeState - Initialisez le à zéro et continuer à envoyer la valeur retournée jusqu'à ce que ce paramètre soit NULL. Speed - La vitesse requise pour le fondu. SrcColour - La couleur source du fondu, au format 0xRRGGBB. DestColour - La couleur de destination du fondu, au format 0xRRGGBB. StartColour - La couleur par laquelle on commence le fondu (0 .... AmtColours-1). AmtColours - La quantité de couleurs dans le fondu (1 ... Maximum de couleurs). Vous ne devez jamais utiliser une valeur nulle ici. @{b}@{u}RESULTAT@{uu}@{ub} FadeState - Renvoie NULL si le fondu est terminé. @{b}@{u}VOIR AUSSI@{uu}@{ub} Screens: @{"ColourMorph() " LINK "ColourMorph()"} @{"ColourToPalette()" LINK "ColourToPalette()"} @{"PaletteMorph() " LINK "PaletteMorph()"} @EndNode --------------------------------------------------------------------------- @NODE "ChangeColours()" "Screens/ChangeColours" @{b}@{u}FONCTION@{uu}@{ub} Nom: ChangeColours() Résumé: Change un set de couleurs de la palette interne d'un Screen Assembleur: ChangeColours(Screen [a0], Colours [a1], StartColour [d0], AmtColours [d1]) C/C++: void ChangeColours(struct Screen *, APTR Colours, LONG StartColour, LONG AmtColours). @{b}@{u}DESCRIPTION@{uu}@{ub} Change toutes les couleurs comprises entre un certain rang. Les changements ne seront appliqués qu'à la palette interne de l'écran. @{b}@{u}ENTREES@{uu}@{ub} Screen - Pointeur vers une structure Screen initialisée. Colours - Pointeur vers une liste de couleurs 24 bit. StartColour - Première couleur devant être affectée par le changement. NB: La première couleur commence à 0. AmtColours - Nombre de couleurs devant être affectées par le changement, doit être au moins de 1. @EndNode --------------------------------------------------------------------------- @NODE "FreeVideoMem()" "Screens: FreeVideoMem()" @{b}@{u}FONCTION@{uu}@{ub} Nom: FreeVideoMem() Résumé: Libère un bloc mémoire alloué par AllocVideoMem(). Assembleur: FreeVideoMem(MemBlock) C/C++: void FreeVideoMem(APTR MemBlock); @{b}@{u}DESCRIPTION@{uu}@{ub} Libère un bloc mémoire alloué par AllocVideoMem(). @{b}@{u}ENTREE@{uu}@{ub} MemBlock - Le bloc mémoire à libérer. @{b}@{u}VOIR AUSSI@{uu}@{ub} Kernel: @{"AllocMemBlock()" LINK "GMSDev:AutoDocs/Kernelfr.guide/AllocMemBlock()"} Screens: @{"AllocVideoMem()" LINK "AllocVideoMem()"} @EndNode --------------------------------------------------------------------------- @NODE "GetScrType()" "Screens: GetScrType()" @{b}@{u}FONCTION@{uu}@{ub} Nom: GetScrType() Résumé: Obtient le type d'écran par défaut/de l'utilisateur. Assembleur: ScrType = GetScrType() C/C++: LONG GetScrType(void); @{b}@{u}DESCRIPTION@{uu}@{ub} Retourne le type d'écran qui est utilisé par défaut dans le module Screen. Cette FONCTION est souvent utilisée par d'autres modules, car ScrType est un paramètre commun à toutes les structures non initialisées par le module Screen. @{b}@{u}RESULTAT@{uu}@{ub} ScrType - Le type d'écran par défaut(eg PLANAR). @EndNode --------------------------------------------------------------------------- @NODE "HideDisplay()" "Screens: HideDisplay()" @{b}@{u}FONCTION@{uu}@{ub} Nom: HideDisplay() Résumé: Cache l'affichage de GMS. Assembleur: Screen = HideDisplay() C/C++: struct Screen * HideDisplay(void); @{b}@{u}DESCRIPTION@{uu}@{ub} Cette FONCTION est privée et à usage interne seulement. Cette FONCTION va cacher l'affichage de GMS. Cela aura pour conséquence de retourner le viewport de l'OS, mais GMS tournera toujours en tâche de fond. Si GMS ne tourne pas par dessus un autre OS alors l'écran GMS DeskTop sera affiché et la tâche appelante placée en tâche de fond. Si aucun écran GMS n'est affiché alors cette FONCTION ne fait rien, et renvoie la valeur NULL. @{b}@{u}RESULTAT@{uu}@{ub} Screen - Pointe vers la structure du Screen qui a été cachée par cette FONCTION. Est à NULL si aucun Screen était actif. @{b}@{u}VOIR AUSSI@{uu}@{ub} Kernel: @{"Display()" LINK "Display()"} @EndNode --------------------------------------------------------------------------- @NODE "HideRasterlist()" "Screens: HideRasterlist()" @{b}@{u}FONCTION@{uu}@{ub} Nom: HideRasterlist() Résumé: Enlève une rasterlist de l'affichage. Assembleur: HideRasterlist(Screen [a0]) C/C++: void HideRasterlist(struct Screen *) @{b}@{u}DESCRIPTION@{uu}@{ub} Enlève l'effet d'une rasterlist sur l'affichage. Cette FONCTION n'efface pas la rasterlist et ne change pas non plus la structure Screen. Vous pouvez redonner un effet à la liste simplement en appelant ShowRasterList(). @{b}@{u}NOTE@{uu}@{ub} Il y a un délai VBL dans cette FONCTION donc la rasterlist n'est pas retirée pendant que le spot vidéo est en pleine action. @{b}@{u}ENTREES@{uu}@{ub} Screen - Pointeur vers une structure Screen initialisée. @{b}@{u}VOIR AUSSI@{uu}@{ub} Screens: @{"RemoveRasterlist()" LINK "RemoveRasterlist()"} @{"ShowRasterlist() " LINK "ShowRasterlist()"} @EndNode --------------------------------------------------------------------------- @NODE "InitRasterlist()" "Screens: InitRasterlist()" @{b}@{u}FONCTION@{uu}@{ub} Nom: InitRasterlist() Résumé: Initialise une nouvelle rasterlist. Assembleur: ErrorCode = InitRasterlist(Screen [a0]) C/C++: WORD InitRasterlist(struct Screen *) @{b}@{u}DESCRIPTION@{uu}@{ub} Initialise une nouvelle "rasterlist" dans une structure Screen. Une "rasterlist" est un groupe de commandes éxécutées à une position spécifique de l'affichage. Sur les Amigas actuels, les "rasterlists" sont éxécutées par le Copper (par l'intermédiaire de la "copperlist") à une ligne bien définie de l'affichage. Quand vous appelez cette FONCTION une "copperlist" sera définie en tenant compte des commandes que vous avez données dans la structure de la "rasterlist".Dans le passé, créer des copperlists posait un probleme au niveau de la compatibilité car vous aviez besoin de passer directement par les adresses hardware du Copper. Heureusement ce n'est plus un problème. Il y a toujours le cas où les cartes graphiques n'ont pas de puces comme le copper. Heureusement la plupart de ces commandes peuvent, dans certains cas, être émulées donc tout n'est pas perdu de ce côté. Les commandes qui marchent actuellement sont: @{u}WAITLINE @{uu} Attend que le faisceau d'électron ait atteint une position spécifique de l'écran. Il est parfaitement autorisé d'entrer des nombres qui sont en dehors des limites verticales de votre écran (ie des nombres négatifs et des nombres plus grand que la hauteur de l'écran), mais pas plus que d'une valeur de 10. Notez que le but de cette commande est de spécifier la position de l'écran à laquelle la prochaine commande devra être éxécutée. Toutes les valeurs des lignes doivent être données en pixel lo-res, quelle que soit la résolution de votre écran. @{u}COLOUR ,@{uu} Change la valeur d'une couleur 24 bit en une autre. @{u}COLOURLIST ,,,@{uu} Vous permet de générer des lignes de couleurs classiques utilisées partout dans les jeux et les démos. Cette commande est surtout utile pour des effets de ciel/dégradé en arrière-plan, bien que vous puissiez les utiliser pour toutes sortes de choses. @{u}SPRITE @{uu} Ré-active une banque de sprites à une ligne spécifiée. Cette méthode est couramment appelée le "sprite-splitting" (découpage de sprites). Cette fonction est considérée comme "dangereuse" et peut n'avoir aucun effet sur certaines cartes graphiques (bien qu'une émulation soit certainement possible). @{u}REPOINT @{uu} Pointe vers une autre partie de la mémoire chip et affiche le bitmap correspondant, cela a pour conséquence de diviser l'écran à l'endroit où la commande est éxécutée. @{u}SCROLL @{uu} Modifie la position de scrolling d'un bitplan jusqu'à 16 pixels. Ce n'est réellement utile que pour les paysages en scrolling parallaxe. @{u}FSCROLL ,@{uu} Modifie la position de scrolling d'un bitplan jusqu'à 16+4 quarts de pixels. Ce n'est réellement utile que pour les paysages en scrolling parallaxe. @{u}FLOOD@{uu} Effet spécial qui "renverse" le modulo d'un bitplan, ce qui a pour effet que le bitplan se répète lui même. Cet effet est utilisé comme un nouveau moyen de faire faire "fondre" l'écran. @{u}MIRROR@{uu} Similaire à Flood, mais inverse complètement le modulo de sorte que le bitplane soit "renversé". Regardez AGAMirror.s pour voir comment ça marche. @{u}RASTEND@{uu} Vous devez terminer une rasterlist avec cette commande. [Si vous avez d'autres idées de commande, envoyez un mail à Paul] @{b}@{u}ENTREES@{uu}@{ub} Screen - Pointeur vers une structure Screen initialisée. Le pointeur GS_RasterList de cette structure doit contenir l'adresse d'une rasterlist standard. Regardez les exemples fournis dans cette distribution pour vous aider à créer vos propres rasterlists. @{b}@{u}RESULTAT@{uu}@{ub} ErrorCode - Est NULL si l'initialisation a réussi. Sinon vous aurez une des valeurs suivantes: ERR_NOMEM = Il n'y avait pas assez de mémoire disponible pour l'une des allocations. ERR_NOPTR = Vous n'avez pas mis de pointeur d'adresse dans GS_RasterList. ERR_INUSE = L'écran a déjà une rasterlist en cours d'utilisation (enlevez la). @{b}@{u}VOIR AUSSI@{uu}@{ub} Includes: @{"graphics/screens.i" LINK "INCLUDES:graphics/screens.i/Main"} Screens: @{"UpdateRasterlist()" LINK "UpdateRasterlist()"} @{"ShowRasterlist() " LINK "ShowRasterlist()"} @{"HideRasterlist() " LINK "HideRasterlist()"} @{"RemoveRasterlist()" LINK "RemoveRasterlist()"} @EndNode --------------------------------------------------------------------------- @NODE "MovePicture()" "Screens: MovePicture()" @{b}@{u}FONCTION@{uu}@{ub} Nom: MovePicture() Résumé: Déplace l'écran aux valeurs spécifiées par X/Y. Assembleur: MovePicture(Screen [a0]) C/C++: void MovePicture(struct Screen *) @{b}@{u}DESCRIPTION@{uu}@{ub} Cette routine a deux utilisations: le déplacement d'une image à n'importe quelle position de l'affichage et le Scrolling Hardware. Elle va prendre les valeurs de PicXOffset et PicYOffset de la structure Screen et les utiliser pour trouver la nouvelle position de l'image. Cette FONCTION s'éxécute à la même vitesse quelles que soient les valeurs des déplacements. Vous devez avoir mis le bit HSCROLL à un pour un scrolling horizontal et le bit VSCROLL à un pour un scrolling vertical si vous voulez utiliser cette FONCTION. Si vous mettez HBUFFER à un dans ScrAttrib alors vous pouvez utiliser cette fonction pour créer un scrolling hardware légal qui peut aller jusqu'à 50 écrans dans les deux directions suivant X. Ne dessinez aucun graphisme au-delà de ces limites ou bien votre programme peut se crasher. @{b}NOTES@{ub} Si le hardware ne supporte pas le scrolling hardware, cette routine blittera problablement l'image entière à la nouvelle position. C'est très lent mais c'est la seule option. Le temps d'éxécution de cette fonction en ECS/AGA est de 2/3 d'une rasterline sur un A1200+Fast. @{b}@{u}ENTREES@{uu}@{ub} Screen - Pointeur vers une structure Screen initialisée. Les valeurs PicXOffset et PicYOffset seront utilisées pour calculer la nouvelle position de l'image sur l'écran. @{b}@{u}VOIR AUSSI@{uu}@{ub} Screens: @{"ResetPicture()" LINK "ResetPicture()"} @EndNode --------------------------------------------------------------------------- @NODE "PaletteMorph()" "Screens: PaletteMorph()" @{b}@{u}FONCTION@{uu}@{ub} Nom: PaletteMorph() Résumé: Fait un fondu d'un set de certaines couleurs vers un autre set de couleurs. Assembleur: FadeState = PaletteMorph(Screen [a0], FadeState [d0], Speed [d1], StartColour [d3], AmtColours [d4], SrcPalette [a1], DestPalette [a2]) C/C++: WORD PaletteMorph(struct Screen *, WORD FadeState, WORD Speed, WORD StartColour, WORD AmtColours, APTR SrcPalette, APTR DestPalette) @{b}@{u}DESCRIPTION@{uu}@{ub} Cette FONCTION prend la palette désignée par SrcPalette, et l'utilise pour faire un fondu de certaines de ses couleurs vers celles de la palette désignée par DestPalette. Une fois que vous avez appelé cette FONCTION, vous devez continuer à l'appeler jusqu'à ce qu'elle vous donne le résultat NULL. Cela vous permet de placer cette fonction dans une boucle et de faire toutes sortes de choses pendant que le fondu suit son cours. Cette FONCTION utilise le "proportional fading" (fondu proportionnel) pour créer cet effet. @{b}@{u}NOTE@{uu}@{ub} Toutes les FONCTIONS de fondu ignore les valeurs des couleurs qui sont gardées en interne. Cela vous causera donc des problèmes si vous ne savez pas à quoi ressemble votre palette courante en utilisant ces FONCTIONS. Gardez une trace de votre palette courante peut être utile avec des fonctions comme PaletteMorph(). @{b}@{u}ENTREES@{uu}@{ub} Screen - Pointeur vers une structure Screen initialisée. FadeState - Initialisez le à zéro et continuer à envoyer la valeur retournée jusqu'à ce que ce paramètre soit NULL. Speed - La vitesse requise pour le fondu. SrcPalette - Pointeur vers la palette utilisée comme source. Destpalette - Pointeur vers la palette vers laquelle vous voulez fondre. StartColour - La couleur par laquelle on commence le fondu (0 .... AmtColours-1). AmtColours - La quantité de couleurs dans le fondu (1 ... Maximum de couleurs). Vous ne devez jamais utiliser une valeur nulle ici. @{b}@{u}RESULTAT@{uu}@{ub} FadeState - Renvoie NULL si le fondu est terminé. @{b}@{u}VOIR AUSSI@{uu}@{ub} Screens: @{"ColourMorph() " LINK "ColourMorph()"} @{"ColourToPalette()" LINK "ColourToPalette()"} @{"PaletteToColour()" LINK "PaletteToColour()"} @EndNode --------------------------------------------------------------------------- @NODE "PaletteToColour()" "Screens: PaletteToColour()" @{b}@{u}FONCTION@{uu}@{ub} Nom: PaletteToColour() Résumé: Fait un fondu entre certaines couleurs et une couleur spécifiée. Assembleur: FadeState = PaletteToColour(Screen [a0], FadeState [d0], Speed [d1], StartColour [d3], AmtColours [d4], Palette [a1], Colour [d2]) C/C++: WORD PaletteToColour(struct Screen *, WORD FadeState, WORD Speed, LONG StartColour, LONG AmtColours, APTR Palette, LONG Colour) @{b}@{u}DESCRIPTION@{uu}@{ub} Cette FONCTION va faire un fondu entre un certain nombre de couleurs et une couleur donnée. C'est très pratique pour faire un fondu noir de l'écran par exemple. Une fois que vous avez appelé cette FONCTION, vous devez continuer à l'appeler jusqu'à ce qu'elle vous donne le résultat NULL. Cela vous permet de placer cette FONCTION dans une boucle et de faire toutes sortes de choses pendant que le fondu suit son cours. Cette FONCTION utilise le "proportional fading" (fondu proportionnel) pour créer cet effet. @{b}@{u}NOTE@{uu}@{ub} Toutes les FONCTIONS de fondu ignore les valeurs des couleurs qui sont gardées en interne. Cela vous causera donc des problèmes si vous ne savez pas à quoi ressemble votre palette courante en utilisant ces FONCTIONS. @{b}@{u}ENTREES@{uu}@{ub} Screen - Pointeur vers une structure Screen initialisée. FadeState - Initialisez le à zéro et continuer à envoyer la valeur retournée jusqu'à ce que ce paramètre soit NULL. Speed - La vitesse requise pour le fondu. Palette - Pointeur vers la palette utilisée comme source. Colour - La couleur vers laquelle vous voulez fondre, dans le format 0xRRGGBB. StartColour - La couleur par laquelle on commence le fondu (0 .... AmtColours-1). AmtColours - La quantité de couleurs dans le fondu (1 ... Maximum de couleurs). Vous ne devez jamais utiliser une valeur nulle ici. @{b}@{u}RESULTAT@{uu}@{ub} FadeState - Renvoie NULL si le fondu est terminé. @{b}@{u}VOIR AUSSI@{uu}@{ub} Screens: @{"ColourMorph() " LINK "ColourMorph()"} @{"PaletteMorph() " LINK "PaletteMorph()"} @{"PaletteToColour()" LINK "PaletteToColour()"} @EndNode --------------------------------------------------------------------------- @NODE "RefreshScreen()" "Screens: RefreshScreen()" @{b}@{u}FONCTION@{uu}@{ub} Nom: RefreshScreen() Résumé: Met à jour l'affichage de l'écran. Assembleur: RefreshScreen(Screen [a0]) C/C++: void RefreshScreen(struct Screen *); @{b}@{u}DESCRIPTION@{uu}@{ub} @{b}@{u}ENTREE@{uu}@{ub} Screen - Pointeur vers une structure Screen initialisée. @{b}@{u}VOIR AUSSI@{uu}@{ub} Screens: @{"WaitVBL()" LINK "WaitVBL()"} @EndNode --------------------------------------------------------------------------- @NODE "RemakeScreen()" "Screens: RemakeScreen()" @{b}@{u}FONCTION@{uu}@{ub} Nom: RemakeScreen() Résumé: Réorganise l'affichage de l'écran en tenant compte de sa taille, sa largeur, et sa position sur le moniteur. Assembleur: RemakeScreen(Screen [a0]) C/C++: void RemakeScreen(struct Screen *) @{b}@{u}DESCRIPTION@{uu}@{ub} Recalcul le viewport du Screen aussi vite que possible. Si le Screen est caché, alors les changements ne se verront que la prochaine fois où vous appellerez la fonction Display(Screen). Vous ne pouvez pas changer le mode d'affichage, le type de l'écran ou le nombre de couleurs avec cette FONCTION. @{b}@{u}ENTREES@{uu}@{ub} Screen - Pointeur vers une structure Screen initialisée. @EndNode --------------------------------------------------------------------------- @NODE "ResetPicture()" "Screens: ResetPicture()" @{b}@{u}FONCTION@{uu}@{ub} Nom: ResetPicture() Résumé: Remet la position de l'image à X=0,Y=0. Assembleur: ResetPicture(Screen [a0]) C/C++: void ResetPicture(struct Screen *) @{b}@{u}DESCRIPTION@{uu}@{ub} Remet la position de l'image à 0,0. Cette méthode est plus rapide que de mettre à zéro les paramètres PicXOffset et PicYOffset et ensuite appeler MovePicture(). @{b}@{u}ENTREES@{uu}@{ub} Screen - Pointeur vers une structure Screen initialisée. @{b}@{u}RESULTAT@{uu}@{ub} PicXOffset et PicYOffset du Gamescreen seront mis à zéro. @{b}@{u}VOIR AUSSI@{uu}@{ub} Screens: @{"MovePicture" LINK "MovePicture()"} @EndNode --------------------------------------------------------------------------- @NODE "ReturnDisplay()" "Screens: ReturnDisplay()" @{b}@{u}FONCTION@{uu}@{ub} Nom: ReturnDisplay() Résumé: FONTION privée. Assembleur: Screen = ReturnDisplay(); C/C++: struct Screen * ReturnDisplay(); @{b}@{u}DESCRIPTION@{uu}@{ub} Redonne le contrôle de l'affichage à l'OS depuis lequel GMS a été lancé C'est une FONCTION spéciale située dans les drivers de moniteurs, et elle est réservée à une utilisation par le module Screen. @{b}@{u}RESULTAT@{uu}@{ub} Screen - Pointeur vers le Screen qui a été supprimé. @{b}@{u}VOIR AUSSI@{uu}@{ub} Screens: @{"TakeDisplay()" LINK "TakeDisplay()"} @EndNode --------------------------------------------------------------------------- @NODE "RemoveRasterlist()" "Screens: RemoveRasterlist()" @{b}@{u}FONCTION@{uu}@{ub} Nom: RemoveRasterlist() Résumé: Cache une RasterList et l'efface de la mémoire. Assembleur: RemoveRasterlist(Screen [a0]) C/C++: void RemoveRasterlist(struct Screen *) @{b}@{u}DESCRIPTION@{uu}@{ub} Libère la mémoire utilisée par la définition interne d'une rasterlist. Si la rasterlist est active à ce moment alors elle sera cachée avant d'être effacée. Une fois cette FONCTION appelée la rasterlist disparait - si vous voulez la réafficher vous devez la réinitialiser en appelant InitRasterList(). @{b}@{u}ENTREES@{uu}@{ub} Screen - Pointeur vers une structure Screen initialisée. @{b}@{u}VOIR AUSSI@{uu}@{ub} Screens: @{"ShowRasterlist()" LINK "ShowRasterlist()"} @{"HideRasterlist()" LINK "HideRasterlist()"} @EndNode --------------------------------------------------------------------------- @NODE "ShowRasterlist()" "Screens: ShowRasterlist()" @{b}@{u}FONCTION@{uu}@{ub} Nom: ShowRasterlist() Résumé: Affiche une rasterlist à l'écran. Assembleur: ShowRasterlist(Screen [a0]) C/C++: void ShowRasterlist(struct Screen *) @{b}@{u}DESCRIPTION@{uu}@{ub} Affiche une rasterlist à l'écran. Le pointeur vers la rasterlist doit se trouver dans GS_RasterList, et doit avoir été initialisé par un appel à InitRasterList(). @{b}@{u}ENTREES@{uu}@{ub} Screen - Pointeur vers une structure Screen initialisée. @{b}@{u}VOIR AUSSI@{uu}@{ub} Screens: @{"HideRasterlist()" LINK "HideRasterlist()"} @EndNode --------------------------------------------------------------------------- @NODE "SwapBuffers()" "Screens: SwapBuffers()" @{b}@{u}FONCTION@{uu}@{ub} Nom: SwapBuffers Résumé: Intervertit les buffers d'affichage de l'écran. Assembleur: SwapBuffers(Screen [a0]) C/C++: void SwapBuffers(struct Screen *) @{b}@{u}DESCRIPTION@{uu}@{ub} Si l'écran est en double buffer, cette FONCTION échange GS_MemPtr1 et GS_MemPtr2 et active le nouveau bitmap pour qu'il soit affiché. Si vous utilisez le triple buffering, alors les 3 MemPtr sont intervertis. Cela donne: @{b}AVANT APRES@{ub} MemPtr1 MemPtr2 MemPtr2 ----> MemPtr3 MemPtr3 MemPtr1 Vous pouvez récupérer les adresses contenues dans ces pointeurs, mais vous ne devez jamais les changer vous-même. @{b}@{u}ENTREES@{uu}@{ub} Screen - Pointeur vers une structure Screen initialisée. @EndNode --------------------------------------------------------------------------- @NODE "TakeDisplay()" "Screens: TakeDisplay()" @{b}@{u}FONCTION@{uu}@{ub} Nom: TakeDisplay() Résumé: FONCTION privée.. Assembleur: ErrorCode = TakeDisplay(Screen [a0]) C/C++: LONG TakeDisplay(struct Screen *); @{b}@{u}DESCRIPTION@{uu}@{ub} Prend le contrôle de l'affichage du système d'exploitation sur lequel GMS a été lancé. C'est une FONCTION spéciale située dans les drivers de moniteurs, et elle est réservée à une utilisation par le module Screen. @{b}@{u}ENTREES@{uu}@{ub} Screen - Pointeur vers une structure Screen initialisée. @{b}@{u}RESULTAT@{uu}@{ub} ErrorCode - Retourne ERR_OK si l'appel a réussi. @{b}@{u}VOIR AUSSI@{uu}@{ub} Screens: @{"ReturnDisplay()" LINK "ReturnDisplay()"} @EndNode --------------------------------------------------------------------------- @NODE "UpdateColour()" "Screens: UpdateColour()" @{b}@{u}FONCTION@{uu}@{ub} Nom: UpdateColour() Résumé: Met à jour la valeur d'une couleur 24 bit $RRGGBB dans la palette d'un écran. Assembleur: UpdateColour(Screen [a0], Colour [d0], RRGGBB [d1]) C/C++: void UpdateRGB(struct Screen *, LONG Colour, LONG RRGGBB) @{b}@{u}DESCRIPTION@{uu}@{ub} Met à jour la valeur d'une couleur de la palette de l'écran. Le changement est immédiatement visible lors de la prochaine "Vertical BLank". @{b}@{u}ENTREES@{uu}@{ub} Screen - Pointeur vers une structure Screen initialisée. Colour - Le numéro de la couleur à mettre à jour, compris entre 0 et Screen->AmtColours. RRGGBB - Valeur de la couleur au format standard RRGGBB. @{b}@{u}VOIR AUSSI@{uu}@{ub} Screens: @{"UpdatePalette()" LINK "UpdatePalette()"} @EndNode --------------------------------------------------------------------------- @NODE "UpdatePalette()" "Screens: UpdatePalette()" @{b}@{u}FONCTION@{uu}@{ub} Nom: UpdatePalette() Résumé: Met à jour la palette entière d'un Screen avec les valeurs données. Assembleur: UpdatePalette(Screen [a0]) C/C++: void UpdatePalette(struct Screen *) @{b}@{u}DESCRIPTION@{uu}@{ub} Met à jour la palette entière d'un GameScreen avec les nouvelles valeurs definies dans GS_Palette. Si GS_Palette est NULL alors toutes les couleurs de l'écran deviendront noires. Cette FONCTION n'aucun effet sur les écrans en true colour. @{b}@{u}NOTE@{uu}@{ub} Les changements dans la palette ne seront effectifs que lors de la prochaine "Vertical BLank". @{b}@{u}ENTREES@{uu}@{ub} Screen - Pointeur vers une structure Screen initialisée. @{b}@{u}VOIR AUSSI@{uu}@{ub} Screens: @{"UpdateColour()" LINK "UpdateColour()"} @EndNode --------------------------------------------------------------------------- @NODE "UpdateRasterlist()" "Screens: UpdateRasterlist()" @{b}@{u}FONCTION@{uu}@{ub} Nom: UpdateRasterlist() Résumé: Met à jour une rasterlist déjà existante. Assembleur: UpdateRasterlist(Screen [a0]) C/C++: void UpdateRasterlist(struct Screen *) @{b}@{u}DESCRIPTION@{uu}@{ub} Met à jour les commandes et les attentes de ligne d'une rasterlist avec les valeurs que peut contenir à ce moment GS_RasterList. Le temps nécessaire pour cette opération dépend de la taille de votre rasterlist (en général, la mise à jour sera suffisamment rapide). Assurez vous que vos changements sont dans les limites des valeurs originales par exemple vous ne pouvez pas changer le nombre de couleurs utilisées dans une commande NEWPALETTE. Si vous voulez seulement modifier les attentes de lignes ou bien seulement les commandes, alors vous pouvez appeler UpdateRastLines() ou UpdateRastCommands(), qui peuvent être plus rapides dans certaines situations. @{b}@{u}ENTREES@{uu}@{ub} Screen - Pointeur vers une structure Screen initialisée. @{b}@{u}VOIR AUSSI@{uu}@{ub} Screens: @{"UpdateRastCommands()" LINK "UpdateRastCommands()"} @{"UpdateRastLines() " LINK "UpdateRastLines()"} @EndNode --------------------------------------------------------------------------- @NODE "UpdateRasterLines()" "Screens: UpdateRasterLines()" @{b}@{u}FONCTION@{uu}@{ub} Nom: UpdateRasterLines() Résumé: Met à jour les WaitLines (lignes d'attente) d'une rasterlist active. Assembleur: void UpdateRasterLines(Screen [a0]) C/C++: void UpdateRasterLines(struct Screen *) @{b}@{u}DESCRIPTION@{uu}@{ub} Met à jour chaque occurance d'une commande WAITLINE dans une rasterlist active. Cela comprend la mise à jour de commandes telles que COLOURLIST. Toutes les autre commandes sont ignorées par cette FONCTION. Cette FONCTION a été créée car les autres FONCTIONS sont moins sûr pour mettre à jour seulement les commandes WAITLINE. Que vous vouliez mettre à jour une ou plusieurs raster line nous insistons pour que vous utilisiez UpdateRasterList(). @{b}@{u}ENTREES@{uu}@{ub} Screen - Pointeur vers une structure Screen initialisée. @{b}@{u}VOIR AUSSI@{uu}@{ub} Screens: @{"UpdateRasterCommand()" LINK "UpdateRasterCommand()"} @{"UpdateRasterlist() " LINK "UpdateRasterlist()"} @EndNode --------------------------------------------------------------------------- @NODE "UpdateRasterCommand()" "Screens: UpdateRasterCommand()" @{b}@{u}FONCTION@{uu}@{ub} Nom: UpdateRasterCommand() Résumé: Met à jour une commande d'une rasterlist. Assembleur: UpdateRasterCommand(Screen [a0], Command [a2]) C/C++: void UpdateRasterCommand(struct Screen *, APTR Command) @{b}@{u}DESCRIPTION@{uu}@{ub} Met à jour une commande d'une rasterlist. C'est le moyen le plus rapide de mettre à jour une commande quelconque d'une rasterlist. Pour la mise à jour de plusieurs commandes utilisez UpdateRasterList() ou UpdateRasterCommands(). Vous ne devez en aucun cas utiliser cette fonction pour mettre à jour un WAITLINE. Le faire peut avoir des résultats imprévisible sur les commandes à d'autres lignes de l'écran. @{b}@{u}ENTREES@{uu}@{ub} Screen - Pointeur vers une structure Screen initialisée. Command - Pointe vers la commande de la rasterlist à mettre jour. @{b}@{u}VOIR AUSSI@{uu}@{ub} Screens: @{"UpdateRasterCommands()" LINK "UpdateRasterCommands()"} @EndNode --------------------------------------------------------------------------- @NODE "UpdateRasterCommands()" "Screens: UpdateRasterCommands()" @{b}@{u}FONCTION@{uu}@{ub} Nom: UpdateRasterCommands() Résumé: Met à jour un groupe de commandes d'une rasterlist. Assembleur: UpdateRasterCommands(Screen [a0], Command [a2], Amount [d0]) @{b}@{u}DESCRIPTION@{uu}@{ub} Met à jour un groupe de commandes d'une rasterlist active d'un écran. C'est le moyen le plus rapide de mettre à jour un groupe de commandes sans avoir à mettre à jour complètement une rasterlist. Si vous voulez mettre à jour juste une commande, utlisez UpdateRasterCommand(). Pour toutes les commandes utilisez UpdateRasterList(). Vous ne devez en aucun cas utiliser cette fonction pour mettre à jour un WAITLINE. Le faire peut avoir des résultats imprévisible sur les commandes à d'autres lignes de l'écran. @{b}@{u}ENTREES@{uu}@{ub} Screen - Pointeur vers une structure Screen initialisée. Command - Pointe vers la première commande de la rasterlist à mettre à jour. Amount - Nombre de commandes à mettre à jour. @{b}@{u}VOIR AUSSI@{uu}@{ub} Screens: @{"UpdateRasterCommand()" LINK "UpdateRasterCommand()"} @EndNode --------------------------------------------------------------------------- @NODE "WaitRastLine()" "Screens: WaitRastLine()" @{b}@{u}FONCTION@{uu}@{ub} Nom: WaitRastLine() Résumé: Attend que le spot atteigne une ligne spécifique. Assembleur: WaitRastLine(LineNumber [d0]) C/C++: void WaitRastLine(WORD LineNumber) @{b}@{u}DESCRIPTION@{uu}@{ub} Attend que le faisceau d'électrons atteigne une ligne de l'écran spécifiée par LineNumber. Les valeurs possibles pour ce paramètre dépendent de la résolution en hauteur de votre écran, ex 0-255 pour un écran standard de 320x256. Il est possible d'entrer des valeurs négatives ou des valeurs qui dépassent le nombre de lignes de l'écran, mais faites le seulement si vous le jugez nécessaire. Cette FONCTION a été spécialement écrite pour éviter les pertes du spot engendrées par des interruptions inopportunes. @{b}@{u}ENTREES@{uu}@{ub} LineNumber - Position verticale du spot à attendre. @{b}@{u}BUGS@{uu}@{ub} Si vous entrez une grande valeur comme #350 par exemple, alors le spot n'atteindra jamais cette ligne car elle n'existe pas. Cela aura pour conséquence de bloquer votre programme. Veuillez donc SVP prendre des valeurs inférieures ou égales à la hauteur de votre écran. @{b}@{u}VOIR AUSSI@{uu}@{ub} Screens: @{"WaitVBL()" LINK "WaitVBL()"} @EndNode --------------------------------------------------------------------------- @NODE "WaitVBL()" "Screens: WaitVBL()" @{b}@{u}FONCTION@{uu}@{ub} Nom: WaitVBL() Résumé: Attend un "Vertical BLank". Assembleur: WaitVBL() C/C++: void WaitVBL(void); @{b}@{u}DESCRIPTION@{uu}@{ub} Attend le moment où le spot vidéo atteint le début du VBL (juste après que toutes les données soient affichées à l'écran). Cette routine essaiera de vous donner le plus d'espace VBL possible en attendant par exemple le point exact où l'affichage se termine. Si ce n'est pas possible, alors elle attendra que le spot atteigne le haut du moniteur. Cette FONCTION contient un appel à AutoSwitch() ce qui permet de mettre en oeuvre des permutations d'écrans assez simplement. @{b}@{u}VOIR AUSSI@{uu}@{ub} Screens: @{"WaitRastLine()" LINK "WaitRastLine()"} @EndNode --------------------------------------------------------------------------- @NODE "()" "Screens:" @{b}@{u}FONCTION@{uu}@{ub} @{b}@{u}DESCRIPTION@{uu}@{ub} @{b}@{u}ENTREES@{uu}@{ub} @{b}@{u}RESULTAT@{uu}@{ub} @{b}@{u}VOIR AUSSI@{uu}@{ub} @EndNode