unit pilotGen;
{$N+}
{pilote graphique g‚n‚ral}
interface
uses global;

type tChoixUser=record DriverChoisi:1..nbDriver;
                       PaletteChoisie:1..nbPalette;
                       DitherChoisi:1..nbDither;
                       ImageChoisie:1..nbImage;
               end;

var taillePixelX,taillePixelY:float; {peut etre utile au programme principal}
    ChoixUser:tChoixUser;

procedure finGraphique;
{retour au mode Texte et efface les variables dynamiques}
procedure initGraphique(minX,minY,maxX,maxY:float);
{passe en mode graphique tout en d‚finissant les coordonn‚es utilisateur}
procedure FixeLimite(minX,minY,maxX,maxY:float);
{fixe les limites de l'image en coordonn‚es utilisateur apres initgraphique
 obligatoire meme en mode plein ‚cran}
function encoreXY(var x,y:float):boolean;
{retourne FALSE si plus de point … calculer,
 sinon r‚ajuste X et Y pour le calcul suivant}
procedure couleurXY(coul:couleur);
{fixe la couleur du point X,Y courant}


{-----------------------------IMPLEMENTATION--------------------------------}
implementation
uses crt,driverG,palette,dither,optimise;

var usedPixelX,usedPixelY:word; {pixels utilis‚s dans fenetre}
    XCoord,YCoord:integer;      {coordonn‚e courante en entier}
    decalX,decalY:integer;      {decalage en X et Y du premier point}
    Xfloat,Yfloat:float;        {coordonn‚e courante en reel}
    EcranMinX,EcranMaxX,EcranMinY,EcranMaxY:float; {coord ecran}
    FenMinX,FenMaxX,FenMinY,FenMaxY:float;  {coord fenetre}
    firstPassOptim:boolean;     {premiŠre passe palette optimis‚e}

    {les diff‚rents objets utilis‚s}
    usedDriver:pDriver;
    usedPalette:pPalette;
    usedDither:pDither;

{-------------------------------COULEUR XY----------------------------------}
function choisisPalette(coul:couleur):byte;
var color:byte;
begin
  if avecDithering then modifieCouleur(coul,errSuivante);
  color:=usedPalette^.choixPalette(coul);
  if avecDithering then begin
    usedPalette^.ecart(coul,color,errCoul);
    usedDither^.corrige(Xcoord-decalX+2);
      {Xcoord-decalX+2 pointe sur suivant}
  end;
  choisisPalette:=color;
end;

procedure couleurXY(coul:couleur);
begin
  with UsedDriver^ do
    if trueColor then truePixel(Xcoord,Ycoord,coul)
    else if firstPassOptim then
       with coul do inc(hist[r shr 3]^[v shr 3,b shr 3])
       {cr‚e histogramme}
    else pixel(Xcoord,Ycoord,choisisPalette(coul));
end;

{------------------------INIT GRAPHIQUE-------------------------------------}
procedure initData;
begin
  UsedPixelX:=round(UsedDriver^.nbPixelX*(FenMaxX-fenMinX)/(EcranMaxX-EcranMinX));
  UsedPixelY:=round(UsedDriver^.nbPixelY*(FenMaxY-fenMinY)/(EcranMaxY-EcranMinY));
  decalX:=round((UsedDriver^.nbPixelX-1)*(FenMinX-EcranMinX)/(EcranMaxX-EcranMinX));
  decalY:=round((UsedDriver^.nbPixelY-1)*(FenMinY-EcranMinY)/(EcranMaxY-EcranMinY));
  XCoord:=decalX-1; YCoord:=decalY;
  taillePixelX:=(EcranMaxX-EcranMinX)/(UsedDriver^.nbPixelX-1);
  taillePixelY:=(EcranMaxY-EcranMinY)/(UsedDriver^.nbPixelY-1);
  Xfloat:=fenMinX-taillePixelX;  Yfloat:=fenMaxY;
end;

procedure InitGraphique(minX,minY,maxX,maxY:float);
begin
  with ChoixUser do begin
    {s‚lectionne et cr‚e l'objet driver}
    selectDriver(usedDriver,driverChoisi);
    {s‚lectionne et cr‚e l'objet palette}
    with usedDriver^ do begin
      if (paletteChoisie<>palOptim) or (trueColor) or (driverChoisi=modeEGA)
      then begin
          firstPassOptim:=false;
          selectPaletteMode(usedPalette,paletteChoisie,nbCouleurs,maxValeurPalette);
        {en mode trueColor ou EGA, l'optimisation de palette n'a pas de sens !}
      end else begin
        firstPassOptim:=true;
        InitOptim(nbCouleurs,maxValeurPalette);
        {initialise optimisation}
      end;
    end;
  end;
  EcranMinx:=MinX; EcranMaxX:=maxX; EcranMinY:=minY; EcranMaxY:=maxY;
  FenMinx:=MinX; FenMaxX:=maxX; FenMinY:=minY; FenMaxY:=maxY;
  initdata;
  if not(firstPassOptim) then begin
    usedDriver^.modeGraphique;
    usedDriver^.validePalette(paletteDeBase);
  end;
end;

{------------------------FIXE LIMITE----------------------------------------}
procedure FixeLimite(minX,minY,maxX,maxY:float);
begin
  if minX>EcranMinX then FenMinX:=minX else FenMinX:=EcranMinX;
  if maxX<EcranMaxX then FenMaxX:=maxX else FenMaxX:=EcranMaxX;
  if minY>EcranMinY then FenMinY:=minY else FenMinY:=EcranMinY;
  if maxY<EcranMaxY then FenMaxY:=maxY else FenMaxY:=EcranMaxY;
  initData;
  with ChoixUser do begin
    if usedDriver^.trueColor then DitherChoisi:=ditAucun;
      {idiot en mode trueColor et stockage par octet}
    selectDither(usedDither,ditherChoisi,usedPixelX);
    if ditherChoisi=ditAucun then avecDithering:=false
                             else avecDithering:=true;
  end;
end;

{----------------------------ENCORE XY--------------------------------------}
function encoreXY(var X,Y:float):boolean;
var fini:boolean;
begin
  fini:=false;
  inc(Xcoord);
  if (Xcoord>=decalX+usedPixelX) then begin
    Xcoord:=decalX; Xfloat:=FenMinX; usedDither^.changeLigne;
    inc(Ycoord);
    if Ycoord>=decalY+usedPixelY then fini:=true
      else YFloat:=YFloat-TaillePixelY;
    if firstPassOptim then begin
      gotoxy(1,2); writeln(Ycoord-decalY:3,' lignes');
    end;
  end else XFloat:=XFloat+taillePixelX;
  if fini and firstPassOptim then with choixUser do begin
    chercheCouleurs(paletteDeBase);
    with usedDriver^ do
      selectPaletteMode(usedPalette,palOptim,nbCouleurs,maxValeurPalette);
    InitData; Xcoord:=decalX; Xfloat:=FenMinX;
    with usedDriver^ do begin
      modeGraphique;
      validePalette(paletteDeBase);
    end;
    fini:=false; firstPassOptim:=false;
  end;
  X:=Xfloat;
  Y:=Yfloat;
  encoreXY:=not(fini);
end;

{----------------------------FIN GRAPHIQUE----------------------------------}
procedure finGraphique;
begin
  usedDriver^.modeTexte;
  dispose(usedDither,finDither);
  if choixUser.paletteChoisie=palOptim then dispose(maTable);
  dispose(usedPalette,finPalette);
  dispose(usedDriver,finDriver);
end;

begin end.