Nox-Rhea

Outils pour utilisateurs

Outils du site

Piste:
back2root:archives:denthor:part-06

Différences

Ci-dessous, les différences entre deux révisions de la page.

Lien vers cette vue comparative

Les deux révisions précédentes Révision précédente
back2root:archives:denthor:part-06 [2021/09/02 10:28]
frater 		back2root:archives:denthor:part-06 [2021/09/05 13:55] (Version actuelle)
frater [In closing]
Ligne 125: Ligne 125:
  
 Denthor Denthor
 +
 +==== Code Source ====
 +
 +=== PASCAL ===
 +
 +<code pascal>
 +(*****************************************************************************)
 +(*                                                                           *)
 +(* TUT6.PAS - VGA Trainer Program 6 (in Pascal)                              *)
 +(*                                                                           *)
 +(* "The VGA Trainer Program" is written by Denthor of Asphyxia.  However it  *)
 +(* was limited to Pascal only in its first run.  All I have done is taken    *)
 +(* his original release, translated it to C++, and touched up a few things.  *)
 +(* I take absolutely no credit for the concepts presented in this code, and  *)
 +(* am NOT the person to ask for help if you are having trouble.              *)
 +(*                                                                           *)
 +(* Program Notes : This program presents pregenerated arrays.                *)
 +(*                                                                           *)
 +(* Author        : Grant Smith (Denthor)  - denthor@beastie.cs.und.ac.za     *)
 +(*                                                                           *)
 +(*****************************************************************************)
 +
 +{$X+}
 +USES crt;
 +
 +CONST VGA = $a000;
 +
 +TYPE tbl = Array [1..8000] of real;
 +             { This will be the shape of the 'table' where we look up
 +               values, which is faster then calculating them }
 +
 +VAR loop1:integer;
 +    Pall : Array [1..20,1..3] of byte;
 +      { This is our temporary pallette. We ony use colors 1 to 20, so we
 +        only have variables for those ones. }
 +
 +{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
 +Procedure SetMCGA;  { This procedure gets you into 320x200x256 mode. }
 +BEGIN
 +  asm
 +     mov        ax,0013h
 +     int        10h
 +  end;
 +END;
 +
 +
 +{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
 +Procedure SetText;  { This procedure returns you to text mode.  }
 +BEGIN
 +  asm
 +     mov        ax,0003h
 +     int        10h
 +  end;
 +END;
 +
 +{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
 +Procedure Cls (Col : Byte);
 +   { This clears the screen to the specified color }
 +BEGIN
 +  Fillchar (Mem [VGA:0],64000,col);
 +END;
 +
 +
 +{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
 +Procedure Putpixel (X,Y : Integer; Col : Byte);
 +  { This puts a pixel on the screen by writing directly to memory. }
 +BEGIN
 +  Mem [VGA:X+(Y*320)]:=Col;
 +END;
 +
 +
 +{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
 +procedure WaitRetrace; assembler;
 +  {  This waits for a vertical retrace to reduce snow on the screen }
 +label
 +  l1, l2;
 +asm
 +    mov dx,3DAh
 +l1:
 +    in al,dx
 +    and al,08h
 +    jnz l1
 +l2:
 +    in al,dx
 +    and al,08h
 +    jz  l2
 +end;
 +
 +
 +{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
 +Procedure Pal(ColorNo : Byte; R,G,B : Byte);
 +  { This sets the Red, Green and Blue values of a certain color }
 +Begin
 +   Port[$3c8] := ColorNo;
 +   Port[$3c9] := R;
 +   Port[$3c9] := G;
 +   Port[$3c9] := B;
 +End;
 +
 +
 +{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
 +Function rad (theta : real) : real;
 +  {  This calculates the degrees of an angle }
 +BEGIN
 +  rad := theta * pi / 180
 +END;
 +
 +
 +
 +{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
 +Procedure NormCirc;
 +  { This generates a spireal without using a lookup table }
 +VAR deg,radius:real;
 +    x,y:integer;
 +
 +BEGIN
 +  gotoxy (1,1);
 +  Writeln ('Without pregenerated arrays.');
 +  for loop1:=60 downto 43 do BEGIN
 +    deg:=0;
 +    radius:=loop1;
 +    repeat
 +      X:=round(radius*COS (rad (deg)));
 +      Y:=round(radius*sin (rad (deg)));
 +      putpixel (x+160,y+100,61-loop1);
 +      deg:=deg+0.4;           { Increase the degree so the circle is round }
 +      radius:=radius-0.02;    { Decrease the radius for a spiral effect }
 +    until radius<0; {  Continue till at the centre (the radius is zero) }
 +  END;
 +END;
 +
 +
 +{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
 +Procedure LookupCirc;
 +  {  This draws a spiral using a lookup table }
 +VAR radius:real;
 +    x,y,pos:integer;
 +    costbl : ^tbl;
 +    sintbl : ^tbl;
 +
 +    Procedure Setupvars;
 +      {  This is a nested procedure (a procedure in a procedure), and may
 +         therefore only be used from within the main part of this procedure.
 +         This section gets the memory for the table, then generates the
 +         table. }
 +    VAR deg:real;
 +    BEGIN
 +      getmem (costbl,sizeof(costbl^));
 +      getmem (sintbl,sizeof(sintbl^));
 +      deg:=0;
 +      for loop1:=1 to 8000 do BEGIN         { There are 360 degrees in a    }
 +        deg:=deg+0.4;                       { circle. If you increase the   }
 +        costbl^[loop1]:=cos (rad(deg));     { degrees by 0.4, the number of }
 +        sintbl^[loop1]:=sin (rad(deg));     { needed parts of the table is  }
 +      END;                                  { 360/0.4=8000                  }
 +    END;
 +    { NB : For greater accuracy I increase the degrees by 0.4, because if I
 +           increase them by one, holes are left in the final product as a
 +           result of the rounding error margin. This means the pregen array
 +           is bigger, takes up more memory and is slower to calculate, but
 +           the finished product looks better.}
 +
 +BEGIN
 +  cls (0);
 +  gotoxy (1,1);
 +  Writeln ('Generating variables....');
 +  setupvars;
 +  gotoxy (1,1);
 +  Writeln ('With pregenerated arrays.');
 +  for loop1:=60 downto 43 do BEGIN
 +    pos:=1;
 +    radius:=loop1;
 +    repeat
 +      X:=round (radius*costbl^[pos]);   { Note how I am not recalculating sin}
 +      Y:=round (radius*sintbl^[pos]);   { and cos for each point.            }
 +      putpixel (x+160,y+100,61-loop1);
 +      radius:=radius-0.02;
 +      inc (pos);
 +      if pos>8000 then pos:=1;    { I only made a table from 1 to 8000, so it}
 +                                  { must never exceed that, or the program   }
 +                                  { will probably crash.                     }
 +    until radius<0;
 +  END;
 +  freemem (costbl,sizeof(costbl^));   { Freeing the memory taken up by the   }
 +  freemem (sintbl,sizeof(sintbl^));   { tables. This is very important.      }
 +END;
 +
 +
 +{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
 +Procedure PalPlay;
 +  { This procedure mucks about with our "virtual pallette", then shoves it
 +    to screen. }
 +Var Tmp : Array[1..3] of Byte;
 +  { This is used as a "temporary color" in our pallette }
 +    loop1 : Integer;
 +BEGIN
 +   Move(Pall[1],Tmp,3);
 +     { This copies color 1 from our virtual pallette to the Tmp variable }
 +   Move(Pall[2],Pall[1],18*3);
 +     { This moves the entire virtual pallette down one color }
 +   Move(Tmp,Pall[18],3);
 +     { This copies the Tmp variable to no. 18 of the virtual pallette }
 +   WaitRetrace;
 +   For loop1:=1 to 18 do
 +     pal (loop1,pall[loop1,1],pall[loop1,2],pall[loop1,3]);
 +END;
 +
 +
 +BEGIN
 +  ClrScr;
 +  writeln ('Hi there! This program will demonstrate the usefullness of ');
 +  writeln ('pregenerated arrays, also known as lookup tables. The program');
 +  writeln ('will first draw a spiral without using a lookup table, rotate');
 +  writeln ('the pallette until a key is pressed, the calculate the lookup');
 +  writeln ('table, then draw the same spiral using the lookup table.');
 +  writeln;
 +  writeln ('This is merely one example for the wide range of uses of a ');
 +  writeln ('lookup table.');
 +  writeln;
 +  writeln;
 +  Write ('  Hit any key to contine ...');
 +  Readkey;
 +  setmcga;
 +  directvideo:=FALSE;  { This handy trick allows you to use GOTOXY and }
 +                       { Writeln in GFX mode. Hit CTRL-F1 on it for more }
 +                       { info/help }
 +  For Loop1 := 1 to 18 do BEGIN
 +    Pall[Loop1,1] := (Loop1*3)+9;
 +    Pall[Loop1,2] := 0;
 +    Pall[Loop1,3] := 0;
 +  END;
 +       { This sets colors 1 to 18 to values between 12 to 63. }
 +
 +   WaitRetrace;
 +   For loop1:=1 to 18 do
 +     pal (loop1,pall[loop1,1],pall[loop1,2],pall[loop1,3]);
 +        { This sets the true pallette to variable Pall }
 +
 +  normcirc;         { This draws a spiral without lookups }
 +  Repeat
 +    PalPlay;
 +  Until keypressed;
 +  readkey;
 +  lookupcirc;       { This draws a spiral with lookups }
 +  Repeat
 +    PalPlay;
 +  Until keypressed;
 +  Readkey;
 +
 +  SetText;
 +  Writeln ('All done. This concludes the sixth sample program in the ASPHYXIA');
 +  Writeln ('Training series. You may reach DENTHOR under the name of GRANT');
 +  Writeln ('SMITH on the MailBox BBS, or leave a message to ASPHYXIA on the');
 +  Writeln ('ASPHYXIA BBS. I am also an avid Connectix BBS user.');
 +  Writeln ('Get the numbers from Roblist, or write to :');
 +  Writeln ('             Grant Smith');
 +  Writeln ('             P.O. Box 270');
 +  Writeln ('             Kloof');
 +  Writeln ('             3640');
 +  Writeln ('I hope to hear from you soon!');
 +  Writeln; Writeln;
 +  Write   ('Hit any key to exit ...');
 +  Readkey;
 +END.
 +</code>
 +
 +=== C ===
 +
 +<code c>
 +/////////////////////////////////////////////////////////////////////////////
 +//                                                                         //
 +// TUTPROG6.CPP - VGA Trainer Program 6 (in Turbo C++ 3.0)                 //
 +//                                                                         //
 +// "The VGA Trainer Program" is written by Denthor of Asphyxia. However it //
 +// was limited to Pascal only in its first run.  All I have done is taken  //
 +// his original release, translated it to C++ and touched up a few things. //
 +// I take absolutely no credit for the concepts presented in this code and //
 +// am NOT the person to ask for help if you are having trouble.            //
 +//                                                                         //
 +// Program Notes : This program demonstrates the advantages of             //
 +//                 pregenerated arrays.                                    //
 +//                                                                         //
 +//                 The Compact memory model (-mc) seems to provide the     //
 +//                 best results for this tutorial.  Remember, use this     //
 +//                 memory model when you have little code and lots of      //
 +//                 data.                                                   //
 +//                                                                         //
 +// Author        : Grant Smith (Denthor) - denthor@beastie.cs.und.ac.za    //
 +// Translator    : Christopher G. Mann   - r3cgm@dax.cc.uakron.edu         //
 +//                                                                         //
 +// Last Modified : January 4, 1995                                         //
 +//                                                                         //
 +/////////////////////////////////////////////////////////////////////////////
 +
 +//               //
 +// INCLUDE FILES //
 +//               //
 +
 +  #include <conio.h>
 +    // clrscr(), getch(), kbhit(), gotoxy(),
 +    // directvideo
 +  #include <dos.h>
 +    // MK_FP, geninterrupt()
 +  #include <iostream.h>
 +    // cout, memset(), memmove()
 +  #include <math.h>
 +    // sin(), cos()
 +  #include <stdlib.h>
 +    // calloc(), free(), exit()
 +
 +//           //
 +// CONSTANTS //
 +//           //
 +
 +  const PI = 3.1415927;
 +  const TABLESIZE = 900;
 +
 +//                     //
 +// FUNCTION PROTOTYPES //
 +//                     //
 +
 +  // UTILITY FUNCTIONS
 +  void  SetMCGA();
 +  void  SetText();
 +  void  Cls(unsigned char Col);
 +  void  Pal(unsigned char ColorNo, unsigned char R,
 +     unsigned char G,       unsigned char B);
 +  void  Putpixel(int x, int y, unsigned char Col);
 +  void  WaitRetrace();
 +  float rad(float theta);
 +
 +  // MID-LEVEL FUNCTIONS
 +  void  NormCirc();
 +  void  LookupCirc();
 +  void  PalPlay();
 +
 +//                              //
 +// GLOBAL VARIABLE DECLARATIONS //
 +//                              //
 +
 +  // pointer to the offset of the VGA memory
 +  unsigned char *vga = (unsigned char *) MK_FP(0xA000, 0);
 +
 +  // This is our temporary pallette.  We only use colors 1 to 20, so we
 +  // only have variables for those ones.
 +  unsigned char Pall[18][3];
 +
 +
 +///////////////////////////////////////////////////////////////////////////////
 +//                                                                           //
 +//                                MAIN FUNCTION                              //
 +//                                                                           //
 +///////////////////////////////////////////////////////////////////////////////
 +
 +void main() {
 +
 +  int loop1;
 +
 +  clrscr();
 +  cout
 +    << "Hi there! This program will demonstrate the usefullness of\n"
 +    << "pregenerated arrays, also known as lookup tables. The program\n"
 +    << "will first draw a spiral without using a lookup table, rotate\n"
 +    << "the pallette until a key is pressed, the calculate the lookup\n"
 +    << "table, then draw the same spiral using the lookup table.\n\n";
 +  cout
 +    << "This is merely one example for the wide range of uses of a\n"
 +    << "lookup table.\n\n";
 +  cout
 +    << "Hit any key to contine ...";
 +  getch();
 +  SetMCGA();
 +
 +  // This handy trick allows you to use gotoxy() and cout in graphics mode.
 +  directvideo = 0;
 +
 +  // This sets our pallette colors 0 to 17 with red values between 12 to 63.
 +  for (loop1=0;loop1<18;loop1++) {
 +    Pall[loop1][0] = ((loop1+1)*3)+9;
 +    Pall[loop1][1] = 0;
 +    Pall[loop1][2] = 0;
 +  }
 +
 +  WaitRetrace();
 +
 +  // This sets the true pallette to variable Pall
 +  for (loop1=0;loop1<18;loop1++)
 +    // loop+1 (make sure to leave color 0 for black)
 +    Pal(loop1+1,Pall[loop1][0],Pall[loop1][1],Pall[loop1][2]);
 +
 +  // This draws a spiral without lookups
 +  NormCirc();
 +  while (!kbhit()) PalPlay();
 +  getch(); // clear the keyboard buffer after kbhit()
 +
 +  // This draws a spiral with lookups
 +  LookupCirc();
 +  while (!kbhit()) PalPlay();
 +  getch();
 +
 +  getch();
 +  SetText();
 +  cout
 +    << "All done. This concludes the sixth sample program in the ASPHYXIA\n"
 +    << "Training series. You may reach DENTHOR under the name of GRANT\n"
 +    << "SMITH on the MailBox BBS, or leave a message to ASPHYXIA on the\n"
 +    << "ASPHYXIA BBS. I am also an avid Connectix BBS user.\n"
 +    << "Get the numbers from Roblist, or write to :\n"
 +    << "             Grant Smith\n"
 +    << "             P.O. Box 270\n"
 +    << "             Kloof\n"
 +    << "             3640\n"
 +    << "I hope to hear from you soon!\n\n";
 +  cout
 +    << "Hit any key to exit ...";
 +  getch();
 +
 +}
 +
 +
 +/////////////////////////////////////////////////////////////////////////////
 +//                                                                         //
 +// SetMCGA() - This function gets you into 320x200x256 mode.               //
 +//                                                                         //
 +/////////////////////////////////////////////////////////////////////////////
 +
 +void SetMCGA() {
 +  _AX = 0x0013;
 +  geninterrupt (0x10);
 +}
 +
 +
 +/////////////////////////////////////////////////////////////////////////////
 +//                                                                         //
 +// SetText() - This function gets you into text mode.                      //
 +//                                                                         //
 +/////////////////////////////////////////////////////////////////////////////
 +
 +void SetText() {
 +  _AX = 0x0003;
 +  geninterrupt (0x10);
 +}
 +
 +/////////////////////////////////////////////////////////////////////////////
 +//                                                                         //
 +// Cls() - This clears the screen to the specified color.                  //
 +//                                                                         //
 +/////////////////////////////////////////////////////////////////////////////
 +
 +void Cls(unsigned char Col) {
 +  memset(vga, Col, 0xffff);
 +}
 +
 +
 +/////////////////////////////////////////////////////////////////////////////
 +//                                                                         //
 +// Pal() - This sets the Red, Green, and Blue values of a certain color.   //
 +//                                                                         //
 +/////////////////////////////////////////////////////////////////////////////
 +
 +void Pal(unsigned char ColorNo, unsigned char R,
 + unsigned char G,       unsigned char B) {
 +
 +  outp (0x03C8,ColorNo); // here is the pallette color I want to set
 +  outp (0x03C9,R);
 +  outp (0x03C9,G);
 +  outp (0x03C9,B);
 +
 +}
 +
 +
 +/////////////////////////////////////////////////////////////////////////////
 +//                                                                         //
 +// Putpixel() - This puts a pixel at X,Y using color Col, on VGA or the    //
 +//              Virtual Screen;                                            //
 +//                                                                         //
 +/////////////////////////////////////////////////////////////////////////////
 +
 +void Putpixel (int x, int y, unsigned char Col) {
 +  memset(vga+x+(y*320),Col,1);
 +}
 +
 +
 +/////////////////////////////////////////////////////////////////////////////
 +//                                                                         //
 +// WaitRetrace() - This waits until you are in a Verticle Retrace.         //
 +//                                                                         //
 +/////////////////////////////////////////////////////////////////////////////
 +
 +void WaitRetrace() {
 +
 +  _DX = 0x03DA;
 +
 +  l1: asm {
 + in  al,dx;
 + and al,0x08;
 + jnz l1;
 +      }
 +
 +  l2: asm {
 + in  al,dx;
 + and al,0x08;
 + jz  l2;
 +      }
 +}
 +
 +
 +/////////////////////////////////////////////////////////////////////////////
 +//                                                                         //
 +// rad() - This calculates the degrees of an angle.                        //
 +//                                                                         //
 +/////////////////////////////////////////////////////////////////////////////
 +
 +float rad(float theta) {
 +  return ((theta * PI)/180);
 +}
 +
 +
 +/////////////////////////////////////////////////////////////////////////////
 +//                                                                         //
 +// NormCirc() - This generates a spiral without using a lookup table.      //
 +//                                                                         //
 +/////////////////////////////////////////////////////////////////////////////
 +
 +void NormCirc() {
 +
 +  int loop1,x,y;
 +  float deg,radius;
 +
 +  gotoxy(1,1);
 +  cout << "Without pregenerated arrays.";
 +
 +  for (loop1=60;loop1>42;loop1--) {
 +    deg = 0.0;
 +    radius = (float) loop1;
 +
 +    do {
 +      x = radius*cos(rad(deg));
 +      y = radius*sin(rad(deg));
 +      Putpixel(x+160,y+100,61-loop1);
 +      deg += 0.4;          // Increase the degree so the circle is round
 +      radius -= 0.019;     // Decrease the radius for a spiral effect
 +
 +      // NOTE: If you change this last statement to "radius -= 0.02;" like
 +      // the Pascal code has it, you will get holes in the spiral.  You
 +      // get bonus credit if you can tell me why this is.
 +
 +    }
 +    while (radius >= 0.0); // continue until the radius is zero (at center)
 +  }
 +}
 +
 +
 +/////////////////////////////////////////////////////////////////////////////
 +//                                                                         //
 +// LookupCirc() - This draws a spiral using a lookup table.                //
 +//                                                                         //
 +/////////////////////////////////////////////////////////////////////////////
 +
 +void LookupCirc() {
 +
 +  int x, y, pos, loop1;
 +  float radius, deg;
 +  float *costbl=NULL, *sintbl=NULL;
 +
 +  // allocate memory for the two tables
 +  costbl = (float *) calloc(TABLESIZE,sizeof(float));
 +  sintbl = (float *) calloc(TABLESIZE,sizeof(float));
 +
 +  // always check to see if enough memory was allocated
 +  if ((costbl == NULL) || (sintbl == NULL)) {
 +    SetText();
 +    cout << "Insufficient memory for lookup tables, exiting...";
 +    exit(1);
 +  }
 +
 +  Cls(0);
 +  gotoxy(1,1);
 +  cout << "Generating variables....";
 +
 +  // There are 360 degrees in a circle.  If you increase the degrees by 0.4,
 +  // the number of needed parts of the table is 360/0.4=900. (TABLESIZE)
 +  //
 +  // For greater accuracy I increase the degrees by 0.4, because if I
 +  // increase them by one, holes are left in the final product as a
 +  // result of the rounding error margin. This means the pregenerated array
 +  // is bigger, takes up more memory and is slower to calculate, but
 +  // the finished product looks better.
 +
 +  deg = 0.0;
 +  for (loop1=0;loop1<TABLESIZE;loop1++) {
 +    costbl[loop1] = cos(rad(deg));
 +    sintbl[loop1] = sin(rad(deg));
 +    deg += 0.4;
 +  }
 +
 +  gotoxy(1,1);
 +  cout << "With pregenerated arrays.";
 +
 +  // NOTE: The spiral drawn with this function leaves a small piece missing
 +  // on the right side.  It looks like a pie with a piece cut out.  You get
 +  // extra credit if you can tell me why this is.
 +
 +  for (loop1=60;loop1>42;loop1--) {
 +    pos = 0;
 +    radius = loop1;
 +    do {
 +      // Note how I am not recalculating sin and cos for each point.
 +      x = radius*costbl[pos];
 +      y = radius*sintbl[pos];
 +      Putpixel(x+160,y+100,61-loop1);
 +      // Decrease the radius for a spiral effect
 +      radius -= 0.020;
 +      // I only made a table from 1 to 900, so it must never exceed that,
 +      // or the program will probably crash.  Go ahead and increment
 +      // pos while you are at it (more compact but less readable). :)
 +      if (++pos > TABLESIZE-1) pos = 0;
 +    }
 +    while (radius >= 0.0);
 +  }
 +
 +  // Freeing the memory taken up by the tables. This is very important.
 +  free(costbl);
 +  free(sintbl);
 +
 +}
 +
 +
 +/////////////////////////////////////////////////////////////////////////////
 +//                                                                         //
 +// PalPlay() - This function mucks about with our "virtual pallette", then //
 +//             shoves it to the screen.                                    //
 +//                                                                         //
 +/////////////////////////////////////////////////////////////////////////////
 +
 +void PalPlay() {
 +
 +  // This is used as a "temporary color" in our pallette
 +  unsigned char Tmp[3];
 +  int loop1;
 +
 +  // This copies color 0 from our virtual pallette to the Tmp variable.
 +  memmove(Tmp,Pall[0],3);
 +
 +  // This moves the entire virtual pallette down one color.
 +  memmove(Pall[0],Pall[1],17*3);
 +
 +  // This copies the Tmp variable to the bottom of the virtual pallette.
 +  // Don't change 0: leave this always black to not change overscan color.
 +  memmove(Pall[17],Tmp,3);
 +
 +  WaitRetrace();
 +  for (loop1=0;loop1<18;loop1++)
 +   Pal(loop1+1,Pall[loop1][0], Pall[loop1][1], Pall[loop1][2]);
 +
 +}
 +</code>
  
 <nspages back2root/archives/denthor -simpleList -title -h1 -exclude:start -textPages="Denthor VGA Trainer"> <nspages back2root/archives/denthor -simpleList -title -h1 -exclude:start -textPages="Denthor VGA Trainer">
back2root/archives/denthor/part-06.txt · Dernière modification: 2021/09/05 13:55 de frater

Outils de la page

Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki