home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / spezial / 19 / pal / vgacol2.inc < prev   
Encoding:
Text File  |  1990-08-01  |  10.5 KB  |  327 lines
  1. (* ------------------------------------------------------ *)
  2. (*                       VGACOL2.INC                      *)
  3. (*     Include-Datei zu PALEDDI2.PAS für VGA-Karten       *)
  4. (*             Turbo Pascal Version ab 5.0                *)
  5. (*           (c) 1990 Gerald Arend & TOOLBOX              *)
  6. (* ------------------------------------------------------ *)
  7.  
  8. TYPE
  9.   RGBRec = RECORD
  10.              RedVal, GreenVal, BlueVal: BYTE;
  11.            END;
  12.  
  13. CONST                                 { Die Standardfarben }
  14.   VGAFarben: ARRAY[0..MaxColors] OF RGBRec =
  15.              ((RedVal: $00; GreenVal: $00; BlueVal: $00),
  16.               (RedVal: $00; GreenVal: $00; BlueVal: $3F),
  17.               (RedVal: $09; GreenVal: $3F; BlueVal: $09),
  18.               (RedVal: $00; GreenVal: $3F; BlueVal: $3F),
  19.               (RedVal: $3F; GreenVal: $05; BlueVal: $05),
  20.               (RedVal: $2C; GreenVal: $00; BlueVal: $3F),
  21.               (RedVal: $1C; GreenVal: $12; BlueVal: $00),
  22.               (RedVal: $31; GreenVal: $31; BlueVal: $31),
  23.               (RedVal: $0D; GreenVal: $0D; BlueVal: $0D),
  24.               (RedVal: $00; GreenVal: $00; BlueVal: $1C),
  25.               (RedVal: $00; GreenVal: $1C; BlueVal: $00),
  26.               (RedVal: $00; GreenVal: $1C; BlueVal: $1C),
  27.               (RedVal: $1C; GreenVal: $00; BlueVal: $00),
  28.               (RedVal: $1C; GreenVal: $00; BlueVal: $1C),
  29.               (RedVal: $3F; GreenVal: $3F; BlueVal: $09),
  30.               (RedVal: $3F; GreenVal: $3F; BlueVal: $3F));
  31.  
  32. VAR
  33.   FarbWert: LONGINT;  { Nummer der Farbe von 1 bis 262.144 }
  34.   SchriftY: ARRAY[1..3] OF INTEGER;
  35.   Step: BYTE;
  36.   StepX, StepY, WertX, WertY: INTEGER;
  37.   Ende: BOOLEAN;
  38.   THoehe, TBreite: WORD;
  39.  
  40. PROCEDURE DrawBars;         { Farbbalken und Info erzeugen }
  41. VAR
  42.   n: BYTE;
  43.   s: STRING[6];
  44. BEGIN
  45.   SetFillStyle(SolidFill, MaxColors);
  46.   Bar(0, 0, GetMaxX, 2*TextHeight('X')-1);
  47.   SetTextStyle(DefaultFont, HorizDir, 1);
  48.   SetTextJustify(CenterText, TopText);
  49.   SetColor(0);
  50.   OutTextXY(GetMaxX DIV 2, 2, 'toolbox Pal-Eddi  '+
  51.     'VGA-Modus 640 x 480, 16 Farben aus einer '+
  52.     'Palette von 262.144');
  53.   SetTextJustify(LeftText, BottomText);
  54.   SetColor(MaxColors);
  55.   SetWriteMode(XORPut);
  56.   TBreite:=TextWidth('X');
  57.   THoehe:=TextHeight('X');
  58.   SchriftY[1]:=GetMaxY div 2+7*THoehe;
  59.   SchriftY[2]:=GetMaxY div 2+10*THoehe;
  60.   SchriftY[3]:=GetMaxY div 2+13*THoehe;
  61.   OutTextXY(0, SchriftY[1]-3*THoehe, 'Nr.');
  62.   OutTextXY(0, SchriftY[1], 'Rot');
  63.   OutTextXY(0, SchriftY[2], 'Grün');
  64.   OutTextXY(0, SchriftY[3], 'Blau');
  65.   OutTextXY(0, GetMaxY-6*THoehe,
  66.             '<r> <g> <b>    Farbwert erhöhen');
  67.   OutTextXY(0, GetMaxY-4*THoehe,
  68.             '<R> <G> <B>    Farbwert erniedrigen');
  69.   OutTextXY(0, GetMaxY-2*THoehe,
  70.             '<F>            Fließenden Übergang errechnen'+
  71.             ' (Abschluß mit <ENTER>)');
  72.   OutTextXY(GetMaxX DIV 2, GetMaxY-6*THoehe,
  73.             '<C>  Color-Cycling-Demo');
  74.   OutTextXY(GetMaxX DIV 2, GetMaxY-4*THoehe,
  75.             '<S>  Turbo-Pascal-Prozedur erzeugen');
  76.   Str((LONGINT(VGAFarben[0].RedVal)*4096+
  77.       VGAFarben[0].GreenVal * 64 +
  78.       VGAFarben[0].BlueVal):6, s);
  79.   WertX:=15*TBreite;
  80.   WertY:=GetMaxY-10*THoehe;
  81.   OutTextXY(0, WertY, 'Farbwert: ');
  82.   OutTextXY(WertX, WertY, s);
  83.   Step:=1;
  84.   StepX:=GetMaxX DIV 2+13*TBreite;
  85.   StepY:=WertY;
  86.   OutTextXY(GetMaxX DIV 2, StepY,
  87.             'Schrittweite:      <+> / <->');
  88.   ShowValue(StepX, StepY, Step, 3);
  89.   FOR n:=0 TO MaxColors DO
  90.   BEGIN
  91.     SetColor(MaxColors);
  92.     Str(n:2, s);
  93.     OutTextXY(Succ(n)*GetMaxX DIV (MaxColors+2),
  94.               SchriftY[1]-3*THoehe, ' #'+s);
  95.     Str(VGAFarben[n].RedVal:4, s);
  96.     OutTextXY(Succ(n)*GetMaxX DIV (MaxColors+2),
  97.               SchriftY[1], s);
  98.     Str(VGAFarben[n].GreenVal:4, s);
  99.     OutTextXY(Succ(n)*GetMaxX DIV (MaxColors+2),
  100.               SchriftY[2], s);
  101.     Str(VGAFarben[n].BlueVal:4, s);
  102.     OutTextXY(Succ(n)*GetMaxX DIV (MaxColors+2),
  103.               SchriftY[3], s);
  104.     SetColor(n);
  105.     SetFillStyle(SolidFill, n);
  106.     Bar(Succ(n)*GetMaxX DIV (MaxColors+2), 2*THoehe,
  107.         (n+2)*GetMaxX DIV (MaxColors+2), GetMaxY div 2);
  108.   END;
  109. END;
  110.  
  111. PROCEDURE InitPalette;                    { Palette setzen }
  112. VAR
  113.   n: BYTE;
  114. BEGIN
  115.   FOR n:=0 TO MaxColors DO
  116.   BEGIN
  117.                      { Erst den Farbwert in der Palette
  118.                        gleich der Palettennummer setzen... }
  119.     SetPalette(n, n);
  120.      { ... und dann erst die RGB-Palettenwerte eintragen ! }
  121.     WITH VGAFarben[n] DO
  122.       SetRGBPalette(n, RedVal, GreenVal, BlueVal);
  123.   END;
  124. END;
  125.  
  126. PROCEDURE Palette2Disk; { Palette als Prozedur abspeichern }
  127. VAR
  128.   n: BYTE;
  129.   Datei: TEXT;
  130. CONST
  131.   DateiName: STRING[12] = 'PALETTE.ASC';
  132. BEGIN
  133. {$I-}
  134.   Assign(Datei, DateiName);
  135.   Rewrite(Datei);
  136. {$I+}
  137.   IF IOResult<>0 THEN
  138.   BEGIN
  139.     Write(^G);
  140.     Exit;
  141.   END;
  142.   Writeln(Datei, 'PROCEDURE PaletteSetzen;');
  143.   Writeln(Datei, 'VAR');
  144.   Writeln(Datei, '  n: BYTE;');
  145.   Writeln(Datei, 'TYPE');
  146.   Writeln(Datei, '  RGBRec = RECORD');
  147.   Writeln(Datei, '    RedVal, GreenVal, BlueVal: BYTE;');
  148.   Writeln(Datei, '  END;');
  149.   Writeln(Datei, 'CONST');
  150.   Writeln(Datei, '  VGAFarben: ARRAY[0..MaxColors] OF RGBRec =');
  151.   Write(Datei, '             ((');
  152.   FOR n:=0 TO MaxColors DO
  153.   BEGIN
  154.     IF n>0 THEN
  155.       Write(Datei, '              (');
  156.     WITH VGAFarben[n] DO
  157.       Write(Datei, 'RedVal: ', RedVal:2, '; GreenVal: ', GreenVal:2,
  158.             '; BlueVal: ', BlueVal:2);
  159.     IF n=MaxColors THEN
  160.       Writeln(Datei, '));')
  161.     ELSE
  162.       Writeln(Datei, '),');
  163.   END;
  164.   Writeln(Datei, 'BEGIN');
  165.   Writeln(Datei, '  FOR n:=0 TO MaxColors DO');
  166.   Writeln(Datei, '  BEGIN');
  167.   Writeln(Datei, '    SetPalette(n, n);');
  168.   Writeln(Datei, '    WITH VGAFarben[n] DO');
  169.   Writeln(Datei, '      SetRGBPalette(n, RedVal, GreenVal, BlueVal);');
  170.   Writeln(Datei, '  END;');
  171.   Writeln(Datei, 'END;');
  172.   Writeln(Datei);
  173.   Close(Datei);
  174. END;
  175.  
  176. PROCEDURE ChangeColors;      { Farben interaktiv verändern }
  177. VAR
  178.   x: INTEGER;
  179.   n: BYTE;
  180.   ch: CHAR;
  181.  
  182.   PROCEDURE MakeGradient;        { Fließende Farbübergänge }
  183.   VAR
  184.     i, n2: BYTE;
  185.     ch2: CHAR;
  186.     x2: INTEGER;
  187.     RDiff, GDiff, BDiff: Real;
  188.   BEGIN
  189.     n2:=n;
  190.     Add(n2, 0, MaxColors, 1, TRUE);
  191.     DrawFrame(n2, SchriftY[3]+10);
  192.     REPEAT
  193.       ch2:=ReadKey;
  194.       CASE ch2 OF
  195.         #0:  BEGIN
  196.                DrawFrame(n2, SchriftY[3]+10);
  197.                ch2:=ReadKey;
  198.                REPEAT
  199.                  CASE ch2 OF
  200.                    #75: Add(n2, 0, MaxColors, -1, TRUE);
  201.                    #77: Add(n2, 0, MaxColors, 1, TRUE);
  202.                  END;
  203.                UNTIL n2<>n;
  204.                DrawFrame(n2, SchriftY[3]+10);
  205.              END;
  206.         #27: BEGIN                               { Abbruch }
  207.                DrawFrame(n2, SchriftY[3]+10);
  208.                Exit;
  209.              END;
  210.       END;
  211.     UNTIL ch2=#13;
  212.     IF n2<n THEN
  213.     BEGIN
  214.       i:=n2;
  215.       n2:=n;
  216.       n:=i;
  217.     END;
  218.     RDiff:=(VGAFarben[n].RedVal-VGAFarben[n2].RedVal)/
  219.            (n2-n);
  220.     GDiff:=(VGAFarben[n].GreenVal-VGAFarben[n2].GreenVal)/
  221.            (n2-n);
  222.     BDiff:=(VGAFarben[n].BlueVal-VGAFarben[n2].BlueVal)/
  223.            (n2-n);
  224.     FOR i:=n+1 TO n2-1 DO
  225.       WITH VGAFarben[i] DO
  226.       BEGIN
  227.         x2:=Succ(i)*GetMaxX DIV (MaxColors+2)+TBreite;
  228.         RedVal:=VGAFarben[n].RedVal-Round((i-n)*RDiff);
  229.         GreenVal:=VGAFarben[n].GreenVal-Round((i-n)*GDiff);
  230.         BlueVal:=VGAFarben[n].BlueVal-Round((i-n)*BDiff);
  231.         ShowValue(x2, SchriftY[1],
  232.                   VGAFarben[i].RedVal, 3);
  233.         ShowValue(x2, SchriftY[2],
  234.                   VGAFarben[i].GreenVal, 3);
  235.         ShowValue(x2, SchriftY[3],
  236.                   VGAFarben[i].BlueVal, 3);
  237.         SetRGBPalette(i, RedVal, GreenVal, BlueVal);
  238.       END;
  239.     DrawFrame(n2, SchriftY[3]+10);
  240.   END;
  241.  
  242. BEGIN
  243.   n:=0;
  244.   Ende:=FALSE;
  245.   SetColor(MaxColors);
  246.   DrawFrame(n, SchriftY[3]+10);
  247.   REPEAT
  248.     x:=Succ(n)*GetMaxX DIV (MaxColors+2)+TBreite;
  249.     ch:=ReadKey;
  250.     CASE ch OF
  251.       #0:  BEGIN
  252.              DrawFrame(n, SchriftY[3]+10);
  253.              ch:=ReadKey;
  254.              CASE ch OF
  255.                #75: Add(n, 0, MaxColors, -1, TRUE);   { <- }
  256.                #77: Add(n, 0, MaxColors, 1, TRUE);    { -> }
  257.              END;
  258.              DrawFrame(n, SchriftY[3]+10);
  259.            END;
  260.       'r': BEGIN
  261.                                       { Farbwert verändern }
  262.              Add(VGAFarben[n].RedVal, 0, 63, Step, TRUE);
  263.                                      { Neuen Wert anzeigen }
  264.              ShowValue(x, SchriftY[1],
  265.                        VGAFarben[n].RedVal, 3);
  266.            END;
  267.       'g': BEGIN
  268.              Add(VGAFarben[n].GreenVal, 0, 63, Step, TRUE);
  269.              ShowValue(x, SchriftY[2],
  270.                        VGAFarben[n].GreenVal, 3);
  271.            END;
  272.       'b': BEGIN
  273.              Add(VGAFarben[n].BlueVal, 0, 63, Step, TRUE);
  274.              ShowValue(x, SchriftY[3],
  275.                        VGAFarben[n].BlueVal, 3);
  276.            END;
  277.       'R': BEGIN
  278.              Add(VGAFarben[n].RedVal, 0, 63, -Step, TRUE);
  279.              ShowValue(x, SchriftY[1],
  280.                        VGAFarben[n].RedVal, 3);
  281.            END;
  282.       'G': BEGIN
  283.              Add(VGAFarben[n].GreenVal, 0, 63, -Step, TRUE);
  284.              ShowValue(x, SchriftY[2],
  285.                        VGAFarben[n].GreenVal, 3);
  286.            END;
  287.       'B': BEGIN
  288.              Add(VGAFarben[n].BlueVal, 0, 63, -Step, TRUE);
  289.              ShowValue(x, SchriftY[3],
  290.                        VGAFarben[n].BlueVal, 3);
  291.            END;
  292.       'f',
  293.       'F': MakeGradient;
  294.       's',
  295.       'S': Palette2Disk;
  296.       '+': BEGIN                    { Schrittweite erhöhen }
  297.              Add(Step, 1, 8, 1, TRUE);
  298.              ShowValue(StepX, StepY, Step, 3);
  299.            END;
  300.       '-': BEGIN                 { Schrittweite vermindern }
  301.              Add(Step, 1, 8, -1, TRUE);
  302.              ShowValue(StepX, StepY, Step, 3);
  303.            END;
  304.       'c',
  305.       'C': BEGIN
  306.              CycleDemo;
  307.              Exit;
  308.            END;
  309.       #27: BEGIN
  310.              Ende:=TRUE;
  311.              Exit;
  312.            END;
  313.     END;
  314.      { Farbwert aus den einzelnen RGB-Werten zusammenbauen }
  315.     FarbWert:=
  316.       LONGINT(VGAFarben[n].RedVal)*4096+
  317.       VGAFarben[n].GreenVal*64 +
  318.       VGAFarben[n].BlueVal;
  319.     ShowValue(WertX, WertY, FarbWert, 6);  { Wert anzeigen }
  320.     WITH VGAFarben[n] DO         { Palettenwert neu setzen }
  321.       SetRGBPalette(n, RedVal, GreenVal, BlueVal);
  322.   UNTIL FALSE;
  323. END;
  324. (* ------------------------------------------------------ *)
  325. (*                 Ende von VGACOL2.INC                   *)
  326.  
  327.