home *** CD-ROM | disk | FTP | other *** search
/ PC Interdit / pc-interdit.iso / graph / scal_tst.pas < prev    next >
Pascal/Delphi Source File  |  1994-10-17  |  6KB  |  138 lines
  1. Uses Crt,Sprites,ModeXLib,Gif,Tools;
  2.  
  3. Procedure PutScalSprt(pg_ofs,x,y,scale_y:Integer;sSprite:spritetyp);
  4. var planecount,          {nombre de plans déjà copiés }
  5.     masqueplan:Byte;     {masque le plan Write dans le registre 2 du TS }
  6.     Skip,                {nombre d'octets à sauter }
  7.     ofs,                 {offset courant dans la mémoire d'écran }
  8.     plane,               {numéro du plan courant }
  9.     Largeur,             {largeur en nombre d'octets à copier dans une ligne }
  10.     dty:Word;            {hauteur }
  11.     source:Pointer;      {pointe sur les données graphiques quand ds varie}
  12.  
  13.     ppp:Array[0..3] of Byte;    {nombre de pixels par plan }
  14.     rel_y,                      {partie décimale de l'ordonnée relative }
  15.     add_y:Word;                 {partie décimale à additionner }
  16.     direction:Integer;          {direction de déplacement (+/- 80)}
  17.     i:Word;                     {compteur d'itérations local }
  18. Begin
  19.   if (x + sSprite.dtx > 319)    {Clipping ? on arrête }
  20.   or (x < 0)
  21.   or (y + sSprite.dty*scale_y div 100 > 199) or (y < 0) then exit;
  22.   add_y:=100-abs(scale_y);           {calcule le nombre à additionner }
  23.   if scale_y < 0 then direction:=-80 else direction:=80;
  24.                                      {fixe la direction }
  25.   Source:=sSprite.adr;               {pointe sur les données graphiques }
  26.   dty:=sSprite.dty;                  {charge la hauteur en local }
  27.    plane:=x mod 4;                   {plan et }
  28.   ofs:=pg_ofs+80*y+(x div 4);        {offset de début }
  29.   Largeur:=0;                        {initialise la largeur et le saut }
  30.   Skip:=0;
  31.  
  32.   i:=sSprite.dtx shr 2;              {nombre de groupes de 4 octets complets}
  33.   ppp[0]:=i;ppp[1]:=i;               {nombre minimum d'octets à copier }
  34.   ppp[2]:=i;ppp[3]:=i;
  35.   For i:=1 to sSprite.dtx and 3 do{mémorise en ppp les pixels restants }
  36.     Inc(ppp[(plane+i - 1) and 3]);{ajoute les pixels en commençant par le plan de début }
  37. asm
  38.   push ds                       {sauve ds}
  39.   mov ax,0a000h                 {charge le segment de destination (VGA)}
  40.   mov es,ax
  41.  
  42.   lds si,source         {ds:di va pointer sur la source (données graphiques) }
  43.   mov cx,plane          {crée le masque de plan de début }
  44.   mov ax,1              {décale le bit 0 vers la gauche }
  45.   shl ax,cl
  46.   mov masqueplan,al     {sauve le masque }
  47.   shl al,4              {le recopie dans le quartet supérieur }
  48.   or masqueplan,al
  49.   mov planecount,4          {4 plans à copier }
  50. @lplane:                    {boucle des plans }
  51.   mov cl,byte ptr plane     {charge le plan courant }
  52.   mov di,cx                 {en di}
  53.   mov cl,byte ptr ppp[di]   {charge le nombre ppp correspondant en cx }
  54.   mov byte ptr Largeur,cl   {recalcule skip }
  55.   mov ax,direction          {forme la différence direction-largeur }
  56.   sub ax,cx
  57.   mov skip,ax               {et écrit le résultat dans skip }
  58.  
  59.   mov rel_y,0               {on recommence en y=0}
  60.  
  61.   mov cx,Largeur            {charge la largeur en cx }
  62.   or cl,cl                  {largeur 0, plan terminé }
  63.   je @planfini
  64.  
  65.   mov di,ofs   {charge en di l'offset de destination dans la mémoire d'écran }
  66.   mov ah,masqueplan      {réduit le masque de plan aux bits [0..3] }
  67.   and ah,0fh
  68.   mov al,02h             {active le registre 2 du TS (Write Plane Mask)}
  69.   mov dx,3c4h
  70.   out dx,ax
  71.   mov bx,dty             {initialise le compteur de lignes y }
  72. @lcopy_y:                {boucle des lignes }
  73. @lcopy_x:                {boucle des pixels }
  74.   lodsb                  {lit un octet }
  75.   or al,al               {si 0, passe}
  76.   je @Valeur0
  77.   stosb                  {sinon copie }
  78. @entry:
  79.   loop @lcopy_x          {suite de la boucle }
  80.  
  81.   mov ax,rel_y      {ajoute la partie décimale de la constante additionnelle }
  82.   add ax,add_y
  83.   cmp ax,100                    {partie entière à augmenter ?}
  84.   jb @noaddovfl                 {non, on continue }
  85.   sub ax,100                    {sinon met à jour la partie décimale }
  86.   sub di,direction              {ligne suivante/précédente }
  87. @noaddovfl:
  88.   mov rel_y,ax                  {réécrit la partie décimale }
  89.  
  90.   dec bx                        {suite du décomptage de lignes }
  91.   je @planfini                  {compteur = 0, alors plan suivant }
  92.   add di,skip                   {sinon saute au début de ligne suivant }
  93.   mov cx,Largeur                {réinitialise le compteur de colonnes }
  94.   jmp @lcopy_y                  {retourne dans la boucle des lignes }
  95. @valeur0:                       {couleur du sprite 0 }
  96.   inc di                        {saute l'octet de destination }
  97.   jmp @entry                    {retourne dans la boucle }
  98. @planfini:                      {fin de la boucle des lignes }
  99.  
  100.   rol masqueplan,1              {masque le plan suivant }
  101.   mov cl,masqueplan             {plan 0 sélectionné ?}
  102.   and cx,1                      {(bit 1 à 1), alors}
  103.   add ofs,cx              {incrémente de 1 l'offset de destination (bit 1 !)}
  104.   inc plane               {incrémente le numéro de plan (indice dans ppp) }
  105.   and plane,3             {réduit de 0 à 3 }
  106.   dec planecount          {déjà 4 plans copiés, on arrête }
  107.   jne @lplane
  108.   pop ds                  {restaure ds, ciao }
  109. End;                      {asm}
  110. End;
  111.  
  112. Var Logo:SpriteTyp;
  113.     Sinus:Array[0..99] of Word;
  114.     Hauteur:Integer;
  115.     i:Word;
  116.  
  117.  
  118. Begin
  119.   Init_ModeX;                        {active le mode X }
  120.   LoadGif('sprites');                {charge une image avec un logo }
  121.   GetSprite(88+ 6*320,150,82,Logo);  {initialise le logo }
  122.   LoadGif('phint');                  {charge l'image d'arrière-plan }
  123.   p13_2_ModeX(48000,16000);          {et la copie dans la page de fond }
  124.   Sin_Gen(Sinus,100,100,0);          {calcule une table de sinus }
  125.   I:=0;                              {indice à 0 dans la table des sinus}
  126.   repeat
  127.     Inc(i);                             {incrémente l'index }
  128.     Hauteur:=Integer(Sinus[i mod 100]); {fixe la hauteur à partir du sinus }
  129.     CopyScreen(vpage,48000);            {efface le fond }
  130.     PutScalSprt(vpage,85,100-Hauteur *84 div 200,Hauteur,Logo);
  131.     {copie dans la page courante le sprite en réduction }
  132.     Switch;                         {active la page }
  133.     WaitRetrace;                    {attend le retour de balayage vertical }
  134.   Until KeyPressed;
  135.   ReadLn;
  136.   TextMode(3);                      {revient au mode texte normal }
  137. End.
  138.