Obligement - L'Amiga au maximum

Vendredi 21 juillet 2017 - 04:46  

Translate

En De Nl Nl
Es Pt It Nl


Rubriques

 · Accueil
 · A Propos
 · Articles
 · Galeries
 · Glossaire
 · Hit Parade
 · Liens
 · Liste jeux Amiga
 · Quizz
 · Téléchargements
 · Trucs et astuces


Articles

 · Actualité (récente)
 · Actualité (archive)
 · Comparatifs
 · Dossiers
 · Entrevues
 · Matériel (tests)
 · Matériel (bidouilles)
 · Points de vue
 · En pratique
 · Programmation
 · Reportages
 · Tests de jeux
 · Tests de logiciels
 · Tests de compilations
 · Articles divers

 · Articles in english
 · Articles in other languages


Twitter

Suivez-nous sur Twitter




Liens

 · Sites de téléchargements
 · Associations
 · Pages Personnelles
 · Moteurs de recherche
 · Pages de liens
 · Constructeurs matériels
 · Matériel
 · Autres sites de matériel
 · Réparateurs
 · Revendeurs
 · Presse et médias
 · Programmation
 · Développeurs logiciels
 · Logiciels
 · Développeurs de jeux
 · Jeux
 · Autres sites de jeux
 · Scène démo
 · Divers
 · Informatique générale


Jeux Amiga

0, A, B, C, D, E, F,
G, H, I, J, K, L, M,
N, O, P, Q, R, S, T,
U, V, W, X, Y, Z


Trucs et astuces

0, A, B, C, D, E, F,
G, H, I, J, K, L, M,
N, O, P, Q, R, S, T,
U, V, W, X, Y, Z


Glossaire

0, A, B, C, D, E, F,
G, H, I, J, K, L, M,
N, O, P, Q, R, S, T,
U, V, W, X, Y, Z


Partenaires

Annuaire Amiga

Amedia Computer

Relec

Hit Parade


Contact

David Brunet

Courriel

 


Programmation : AMOS - gestion des couleurs
(Article écrit par Jean Monos et extrait de off-soft.com - juillet 2017)


Les goûts et les couleurs avec AMOS !

Bonjour, voici un petit article sur la gestion des couleurs avec le langage de programmation Amiga AMOS.

OSC, ECS et AGA

AMOS est compatible avec plusieurs types d'Amiga. Je peux sans trop me tromper dire que deux modèles étaient ou sont encore populaires chez les utilisateurs : les A500 (avec ses variantes) et les A1200. Il existe bien sûr d'autres modèles d'Amiga et ceux-ci disposent de plusieurs types de puces graphiques : OCS (A1000, A2000, A500), ECS (A600, A500+, A3000) et AGA (A1200, A4000).

L'OCS et l'ECS permettent d'afficher, dans les conditions normales, 32 couleurs et il est même possible de passer à 64 couleurs en mode Half-Brite. Dans ce mode, on prend les 32 couleurs choisies par l'utilisateur et on applique une division par deux du code couleur pour en créer 32 autres. La palette de couleurs des modes OCS et ECS est de 4096 couleurs.

L'AGA, lui, joue dans une autre arène. Il permet d'afficher 256 couleurs à l'écran en condition normale et permet de choisir une couleur parmi une palette de 16 777 216. Malheureusement, AMOS ne gère pas nativement l'AGA. Mais des extensions permettent quand même d'afficher des images en 256 couleurs.

Caractéristiques d'AMOS au niveau couleurs

Quand vous allez dans l'éditeur de sprites (BOB) ou d'icônes, vous avez accès aux caractéristiques graphiques d'AMOS dans le petit bouton "RES".

AMOS

Vous avez le choix entre 2, 4, 8, 16, 32 et 64 couleurs. Il faut savoir que plus vous attribuez de couleurs à un objet graphique, plus il est gourmand en mémoire et en poids. Nous ne sommes pas sur un PC doté de 4 Go de mémoire et d'un espace disque de plusieurs téraoctets : quand on commence à développer de gros jeux en AMOS, ce sont des informations à prendre en compte.

Jusqu'à 32 couleurs comprises, vous avez la mainmise sur toute la palette. Vous pouvez les choisir comme bon vous semble (dans la limite des 4096 couleurs imposée par AMOS). Pour 64 couleurs, c'est le mode Half-Brite, vous configurez 32 couleurs et les 32 autres sont créées automatiquement en fonction des premières.

Paramétrer une palette

Si vous cliquez sur la palette de peinture avec le pinceau, vous avez accès à une fenêtre pour définir la couleur. Cliquez sur une couleur à gauche, bougez ensuite les trois curseurs et vous pouvez créer une teinte.

AMOS

Une teinte en AMOS est définie par composante : Rouge, Vert, Bleu (en anglais : Red, Green, Blue). Soit en acronyme : RVB/RGB, un terme que l'on rencontre souvent.

La teinte finale est donc un dosage entre du rouge, du vert et du bleu. Et souvent, elle est représentée par une valeur hexadécimale, utile pour réaliser des sites Web par exemple. Quand vous choisissez des couleurs, vous avez une valeur du style $FAG292, la couleur étant représentée par six chiffres/lettres. En mode 24/32 bits, donc sur les ordinateurs actuels, chaque teinte est représentée par deux valeurs. Les deux premiers à gauche sont le rouge, les deux du milieu sont le vert, et les deux de droite sont le bleu. Cela va, pour chaque teinte, de 0 à FF (soit de 0 à 255, soit 256 possibilités par teinte) et donc 256*256*256=16 777 216 possibilités de teintes. Le mode AGA des A1200/A4000 utilise le même système pour représenter les teintes.

En AMOS, chaque teinte permet d'avoir une valeur comprise entre 0 et F (0 et 15, soit 16 possibilités), ce qui permet d'avoir 16*16*16=4096 possibilités.
  • $000 est le code couleur qui représente la teinte noire.
  • $FFF est le blanc.
  • $F00 est le rouge pur.
  • $0F0 est le vert pur.
  • $00F est le bleu pur.
  • $777 et $888 sont des exemples de gris.
En mode 64 couleurs, les teintes de la ligne droite de la palette représentent tout simplement la moitié du code couleur des teintes gauches. Par exemple, si je définis une couleur dans la partie gauche en blanc pur $FFF, sa couleur opposée sera $777 (16/2 = 8 et comme on débute à 0, on applique un -1 et cela fait 7). Dans le calcul, nous ne pouvons pas dépasser F ni descendre en dessous de 0.

On ne mélange pas les torchons et les serviettes

L'affichage des couleurs est défini par le paramétrage de la fenêtre dans AMOS. Dans votre programmation, il faut définir les propriétés de la fenêtre : définition de la fenêtre et le nombre de couleurs qu'elle peut afficher.

Screen Open Numéros_de_l'écran,Largeur_Ecran,Hauteur_Ecran_Nombre_de_couleur,Mode

Exemple :

Screen Open 0,320,256,16,Lowres

C'est la valeur inscrite dans nombre de couleurs qui compte. Vous ne pouvez pas afficher plus de couleurs par rapport à la configuration de l'écran.

Création d'une palette de couleurs en programmation

Voici une première fonction qui permet d'assigner une couleur à un numéro :

Colour nombre,$RGB

Le nombre est une valeur comprise entre 0 et 31, ce qui représente le numéro du stylo pour faire simple.

Exemple : "Colour 1,$FFF" permet de mémoriser la couleur blanche dans le stylo numéro 1 (on appelle ça aussi un index ou id). Si vous faite après ça "pen 1", le texte avec print "bla bla" se fera en blanc.

La deuxième méthode est l'utilisation de la fonction "Palette liste_de_couleur". Exemple :

Palette $FFF,$000,,$777

Dans cet exemple, la couleur 0 (l'id débute toujours par 0) prend la valeur $FFF (blanc). L'id 1 prend la valeur $000 (noir), l'id 2 ne change pas car il n'y a rien entre les virgules, et l'id 3 prend la valeur $777 (gris). Cette fonction permet donc d'avoir des arguments vides avec virgules et rien marqué entre (attention à ne pas inscrire 0).

Palette ou Colour ?

Utilisez la fonction "Palette" quand il faut redéfinir complètement ou une bonne partie de la palette à la main. La fonction "Colour" est utile quand il faut retoucher peu de couleurs ou pour définir une palette de couleurs via par exemple "Data".

Data

"Data", dans le langage BASIC, est un outil puissant. Il permet d'inscrire facilement des données. Voici une petite routine qui pourrait vous plaire :

Restore E_PALETTE

For C =0 to 7

       Read ID_COULEUR
       Colour C,ID_COULEUR
NEXT

End

E_PALETTE :
Data $FFF,$000,$777,$245
Data $0F1,$BBB,$693,$123

Ceci est un exemple pour assigner 8 couleurs en mémoire avec les Datas. On se branche sur l'étiquette E_PALETTE (attention, entre l'étiquette et la première ligne, il ne doit pas y avoir de ligne vide sinon ça bogue !). Une boucle For/Next va fonctionner huit fois dans cet exemple et mémoriser le nombre de "tours" dans C.

On va lire une valeur Data et on mémorise cela dans la variable "ID_COULEUR". On l'injecte dans le stylo dont l'id est pointé par la valeur qui est mémorisée dans C (donc l'id du stylo = C) et l'encre utilisée est la valeur qui se trouve dans "ID_COULEUR".

Ensuite, on crée les lignes Data. Attention, quand on fait plusieurs lignes Data, on ne place pas de virgule à la fin sinon, après la virgule, c'est considéré comme 0.

Récupérer automatiquement une palette de couleurs, transformer les couleurs 24/32 bits (en AGA, alias le TrueColor) en couleurs ECS

Voici une astuce, une méthode, du moins ma méthode. C'est super subjectif mais nous allons utiliser cette méthode pour mettre en place des palettes. A l'heure actuelle, votre code couleurs RGB est composé d'une valeur entre 0 et 255 (1 octet). Le blanc, c'est $FF,FF,FF (j'ai placé une virgule pour séparer les composantes pour la lisibilité). En AMOS, c'est une valeur entre 0 et 15 $F,F,F.

Quand je veux m'approcher d'une couleur comme celle-ci en AMOS, je garde la partie gauche d'une composante et je supprime la partie droite. Par exemple pour le blanc, c'est facile car $FF,FF,FF donne $FFF. Un autre exemple : $F1,5G,33 donne $F53.

Méthode inverse, pour passer de la palette AMOS à une palette TrueColor, je double simplement la composante. Exemple : $F53 donne $FF5533. Ensuite, à vous de régler plus finement s'il le faut.

La mémoire dans la peau !

Nous ne sommes pas sur une machine avec 4 ou 8 Go de mémoire. L'Amiga nous limite beaucoup (512 ko de mémoire pour un Amiga 500 nu et 2 Mo pour un A1200). Le choix du nombre de couleurs à l'écran est un facteur sur la place que va prendre la "mémoire vidéo". Elle se calcule facilement : pour un écran ouvert, vous ouvrez avec la commande "Screen open". La formule est simple : (hauteur x largeur x plans)/8.

Les plans sont un coefficient en fonction du nombre de couleurs que peut afficher l'écran :
  • Coefficient 1 pour 2 couleurs.
  • Coefficient 2 pour 4 couleurs.
  • Coefficient 3 pour 8 couleurs.
  • Coefficient 4 pour 16 couleurs.
  • Coefficient 5 pour 32 couleurs.
  • Coefficient 6 pour 64 et 4096 couleurs.
Un écran plus ou moins standard en 320x256 pixels en 16 couleurs consomme : (320*256*4)/8 = 40 960 ko de mémoire. A cela s'ajoute chaque BOB et sprites affichés à l'écran.

La formule pour les BOB/sprites en mode Blitter est : (hauteur x largeur x plans)*3/8.
La formule pour les sprites est : longueur totale x 96.

Personnellement, j'utilise beaucoup les BOB/icônes en taille de 16 pixels. Ce qui fait (16*16*4)*3/8 = 384 octets le morceau affiché à l'écran.

A cela s'ajoute bien sûr la place des variables, du programme en lui-même, des musiques et autres joyeusetés. Donc, il y a des chances que suivant ce que vous réalisez, il y ait des compromis à faire en fonction du type de projet.

Récupérer automatiquement la palette d'une image et d'un BOB

Les fonctions "Get Icon Palette", "Get Sprite Palette" et "Get Bob Palette" permettent directement de récupérer le jeu de palette des sprites, BOB ou icônes voulus. Pratique, non ?

Compilation croisée avec Photoshop

Le logiciel graphique Photoshop a un atout, il permet d'exporter et de charger des images au format Amiga IFF, ce qui permet de travailler avec lors de compilations croisées. Il y a deux ou trois paramétrages à prendre en compte.

Ce qui est bien, c'est que l'image IFF sauvegardée avec AMOS possède la palette de couleurs de l'écran. La fonction pour sauvegarder l'écran dans AMOS est simple :

Save iff "Nom de votre fichier.iff"

(n'oubliez pas l'extension)

Sortez l'image IFF de votre Amiga pour l'intégrer dans votre PC ou votre Mac. Ouvrez l'image avec Photoshop. Vous avez une image, ou l'écran avec la couleur de fond si vous n'avez rien fait, mais la palette est là. L'image est indexée. Dans le menu "Image/Mode/Table des couleurs", vous avez une fenêtre avec les couleurs indexées de l'image. Toujours dans cette fenêtre, vous pouvez enregistrer la palette utilisée au format ACT ou PAL. Activez le nuancier si cela n'est pas fait (dans fenêtre et nuancier) et chargez le nuancier de l'image. Dans la fenêtre du nuancier, remplacez le nuancier et aller cherchez le nuancier que vous avez sauvegardé dans la table des couleurs.

AMOS

Maintenant, il faut réaliser une autre manipulation. Car là, si avec le "crayon" vous posez un pixel, il se peut que vous affichiez un double pixel en largeur. Pour corriger cela, choisissez "carré" dans le menu "Affichage/Format de Pixels".

Voilà, vous pouvez utiliser Photoshop pour réaliser vos graphismes avec AMOS. Quand vous sauvegardez, choisissez IFF et Amiga. Attention, si vous avez désindexé l'image, pensez à la réindexer avec la bonne palette.

Quelle est l'utilité de passer par Photoshop ? L'éditeur de sprites/icônes d'AMOS était très bien pour l'époque mais Photoshop propose d'autres types d'outils. Vous pouvez aussi créer vos décors et sprites/BOB dans Photoshop en respectant les grilles de 16 pixels (ou autres). Sauvegardez ainsi votre image et vous pourrez recréer, avec AMOS, les banques d'images appropriées. Pour cela, faites-le en programmation et non directement en chargeant l'image dans l'éditeur d'objet.

Voici l'exemple de routine pour mémoriser des icônes qui sont souvent utilisées pour des "tiles". La fonction "Get Icon" permet de mémoriser un morceau de graphisme de l'écran, dans la banque des icônes.

Get Icon numéros_de_l'icône, X1,Y1 to X2,Y2

Imaginons que vous avez réalisé sur votre image 10 tiles de 16 pixels placées l'une à la suite des autres horizontalement. La routine sera :

Load Iff "Nom de votre image qui contient les tiles.iff"

For X =0 to 9
Get Icon X+1,X*16,0 to X*16+16,16
Next

Pourquoi X+1 ? Car les numéros icône et de BOB débutent par 1 et non 0 dans l'éditeur d'icônes.

Et Gimp ?

Photoshop est un logiciel payant mais il existe une bonne alternative. C'est un logiciel libre qui se nomme Gimp, il est disponible sur Linux, Windows et Mac OS X. Cependant, il ne permet pas, par défaut, d'exporter et de charger une image IFF. Pour cela, il faut un greffon nommé Gimp IFF. Téléchargez ce greffon et installez-le dans le dossier Gimp\Gimp\2\lib\gimp\2.0\Plug-ins. C'est un fichier "exe". Vous pouvez charger l'image IFF avec un glisser-déposer. Pour sauvegarder votre image, ne faites pas "enregistrer" ou "enregistrer sous" mais "exporter sous". Et n'oubliez pas de placer un ".iff" derrière le nom du fichier.

De plus, gardez l'alpha treshold à 0,50, cochez "compress" et décochez le reste. Un load iff "Nom de l'image.iff" fonctionne bien à condition de bien configurer la fenêtre d'affichage en AMOS.

Des palettes

Voici des palettes nostalgiques !

L'Apple II

$000
$735
$548
$d4F
$165
$999
$3AF
$CCF

$550
$D71
$999
$EBC
$3C1
$CD9
$ADC
$FFF
AMOS

Le C64

$000
$FFF
$944
$7CC
$95A
$6A5
$549
$CD8

$963
$650
$377
$666
$888
$AE9
$87C
$AAA
AMOS

Le ZX Spectrum

$000
$00C
$C00
$C0C
$0C0
$0CC
$CC0
$CCC

$000
$00F
$F00
$F0F
$0FO
$0FF
$FFO
$FFF
AMOS

L'Amstrad CPC

$0
$7
$F
$700
$707
$70F
$F00
$F07
$F0F

$70
$77
$7F
$770
$777
$77F
$F70
$F77
$F7F

$F0
$F7
$FF
$7F0
$7F7
$7FF
$FF0
$FF7
$FFF
AMOS

ARNE 16

$0
$999
$FFF
$B23
$E68
$432
$A62
$E83

$FE6
$244
$481
$AC2
$123
$58
$3AF
$BDE
AMOS

Quelques explications sur androidarts.com/palette/16pal.htm.

Le MSX

La première couleur sur MSX est une "couleur transparente", c'est pour cela qu'il y a deux couleurs noires.

$0
$0
$2B5
$6C8
$55D
$87E
$B55
$5DE

$E65
$F87
$CC6
$DC8
$2A4
$B6B
$CCC
$FFF
AMOS

YouTube

Vous pouvez retrouver d'autres exemples de palettes sur cette vidéo complémentaire : www.youtube.com/watch?v=57fVyQB8tNk.


[Retour en haut] / [Retour aux articles]