(*---------------------------------------------------------------------------
    :Program.    IFFtoCode.mod / IFFtoSprIm
    :Author.     Pit Burkhardt
    :Address.    Stettinerstraße 25, D-7030 Böblingen
    :Phone.      ----
    :Shortcut.   [pit]
    :Version.    0.1
    :Date.       19.05.88
    :Copyright.  PD
    :Language.   Modula-II
    :Translator. M2Amiga
    :Imports.    LoadIFF.mod [fbs] of Amok#1, UpDate on Amok#2.
    :UpDate.     none.
    :Contents.   Umwandlung von IFF-Bildern in M2-Source-Code für ImageData.
    :Remark.     Thanks to Fridjoff for his IFF-loading-module
---------------------------------------------------------------------------*)

- DOKUMENTATION: IFFtoCode, IFFtoSprIm

Es ist jetzt nicht mehr nötig auf Millimeterpapier gezeichnete Images in 
Hex-Zahlen umzurechnen! Gut, was?!
Denn IFFtoCode/IFFtoSprIm generiert Modula-2-Source-Code aus IFF-Dateien 
beliebiger Breite, Höhe und Tiefe. 


* Der Unterschied zwischen beiden Tools:


IFFtoCode generiert M2Source für Images (Intuition) und Bobs (Graphics)

IFFtoSprIm generiert M2Source für Hardware-Sprites und VSprites. Deren 
Image-Daten sind anders organisiert, außerdem sind Sprites generell 
16 Pixel breit und 2 Planes tief. Das Programm berücksichtigt diese 
Einschränkungen. 

(im folgenden wird überwiegend von IFFtoCode die Rede sein, analoges gilt 
dann auch für IFFtoSprIm)


* Wie geht das? 


Ganz einfach: Die Images werden in D-Paint gezeichnet und als 
Brush abgespeichert. IFFtoXXX verwendet den Namen des Brushes als 
Feldname und schreibt die Deklaration der Feldelemente. 

das Programm IFFtoCode bearbeitet natürlich auch ganze IFF-Bilder es ist 
aber kaum sinnvoll ganze IFF-Bilder als Code zu installieren weil dies zum 
einen eine Riesenmenge an SourceCode bedeutet, zum zweiten bei Bildern mit 
mehr als 32k vom M2Compiler nicht mehr in einem Modul verarbeitet wird und 
drittens hat Fridtjof [fbs] ja einen IFF-Lader geschrieben!                  


* Ausführung der Tools 


Die Programme werden folgendermaßen gestartet.

Von der Workbench: IFF-Datei-Icon(s) <SHIFT>-klicken dann IFFtoCode-Icon 
		   <SHIFT>-doppelklicken.	

CLI-Aufruf:	   IFFtoCode Brushname1 Brushname2 ... BrushnameN
                        
Das Programm erwartet dann die Eingabe eines Dateinamens für die Ausgabe-
Datei, in die der Source-Code geschrieben werden soll. (Die Ausgabe-Datei 
wird nicht mit einem Icon versehen!) Wird nur <RETURN> eingegeben, dann wird 
der Source-Code ins Ausgebefenster geschrieben.

Mit <CTRL>-C oder durch Anklicken des Closing-Gadgets kann das Programm 
jederzeit abgebrochen werden.   		


* Verwendung mehrerer Images in einem Modul


Die Pointer auf die einzelnen Image-Daten werden als ARRAY definiert, wenn 
mehr als ein Brush auf einmal durch IFFtoCode bearbeitet wird und dadurch 
mehrere Images in einem Modul abgelegt werden.

Die Eingabe mehrerer Brushes ist aber nur dann sinnvoll, wenn alle Brushes 
die gleiche Größe und Tiefe haben. Breite und Höhe werden für alle Brushes 
am ersten eingelesenen Brush orientiert. Das untenstehende Beispiel zeigt, 
wie der generierte Code aussieht.


* Was ist am erzeugten Code noch zu tun?


Sie wollen Daten für VSprites mit Hilfe von IFFtoSprIm erzeugen? OK, aber 
VSprite-Image-Daten sind etwas anders aufgebeut als Image-Daten von 
Hardware-Sprites. Letztere benötigen in ihren Image-Daten noch Felder für 
spezielle Zwecke, ihre ImageDaten sind wie folgt aufgebaut: 

TYPE    Img=RECORD
          Pos:ARRAY [0..1] OF WORD;
          Dat:ARRAY [0..n] OF WORD; --> Hier liegen die eigentlichen Daten
          Add:ARRAY [0..1] OF WORD;
        END;

IFFtoSprIm erzeugt die obige Struktur im DEFINITION-Teil. Da sie von 
VSprites nicht verstanden wird, sollte sie für diese wie folgt abgeändert 
werden:

TYPE    Img=RECORD
          Dat:ARRAY [0..49] OF WORD;
        END;

Ja, ganz recht, das ist alles (es müssen lediglich zwei Zeilen gelöscht 
werden), jedenfalls fast, denn jetzt müssen natürlich noch die 
entsprechenden Initialisierungen im IMPLEMENTATION MODULE gelöscht werden
(Img.Pos und Img.Add existieren ja nicht mehr, dürfen also auch nicht mehr 
initialisiert werden).

ACHTUNG: Habe einen Fehler entdeckt: Manchmal stimmt die für Img.Dat 
deklarierte Feldgröße nicht mit der tatsächlichen Anzahl an Feldelementen 
überein. Vorsichtshalber im IMPLEMENTATION-Teil nachschauen, welche Nummer 
das letzte Feldelement besitzt und die Deklaration entsprechend abändern.
  
Der erzeugte Code muß vor dem Compilieren noch zweigeteilt werden:
Der DEFINITION-Teil muß als getrennte Datei abgespeichert und zuerst 
compiliert werden (.def). Jetzt kann der IMPLEMENTATION-Teil compiliert 
werden (.mod). 


* Importieren der Image-Daten


Die IM IMPLEMENTATION-MODULE vereinbarten Variablen ...

        Imgwidth   :INTEGER;
        Imgheight  :INTEGER;
        Imgdepth   :INTEGER;
        
        ImgPtr     :POINTER TO Img;
        bzw.
        ImgPtr     :ARRAY [0..  n] OF POINTER TO Img;

können im RECORD Image (Intuition) direkt an die Variablen ... 
	
        width 
	height 
	depth  
	ImageData
                           
übergeben werden. Ist ImgPtr als "ARRAY [0..  n] OF POINTER TO Img" 
vereinbart, so sollten auch die Konstanten "Brushname1 Brushname2 ... 
...BrushnameN" importiert werden und an ImageData sollte ImgPtr[Brushname] 
übergeben werden.

Für IFFtoSprIm fallen die Variablen Imgwidth und Imgplanes weg. alles 
andere analog.         

Das untenstehende Beispiel zeigt die Variablenübergabe  


* BeispielCode


Der folgende Code wurde aus 2 IFF-Brushes mit den Namen "Brush1" und 
"Pinsel" vom Programm IFFtoCode erzeugt:

========================================================================

          (* -------> DEFINITION MODULE <-------- *)

DEFINITION MODULE Img;

FROM SYSTEM IMPORT      WORD;

FROM Heap IMPORT        AllocMem;

TYPE    Img=RECORD
          Dat:ARRAY [0..17] OF WORD;
        END;


CONST   Brush1=  0;
        Pinsel=  1;
        

VAR     Imgwidth   :INTEGER;
        Imgheight  :INTEGER;
        Imgdepth   :INTEGER;
        ImgPtr     :ARRAY [0..  1] OF POINTER TO Img;


END Img.

          (* -------> IMPLEMENTATION MODULE <-------- *)

IMPLEMENTATION MODULE Img;

FROM SYSTEM IMPORT      WORD;

FROM Heap IMPORT        AllocMem;

VAR     i   :INTEGER;



BEGIN   (* MAIN *)

FOR i:=0 TO   1  DO
  AllocMem(ImgPtr[i],SIZE(ImgPtr[i]^),TRUE);
END;

Imgwidth := 16;
Imgheight:=  9;
Imgdepth :=  2;



WITH ImgPtr[Brush1]^ DO         (* Brush1 *)

  (* Plane 1 *)
 Dat[ 0]:=0FFFFH;(* 1*)
 Dat[ 1]:=0C0FFH;(* 2*)
 Dat[ 2]:=0CCFFH;(* 3*)
 Dat[ 3]:=0C003H;(* 4*)
 Dat[ 4]:=0FCF3H;(* 5*)
 Dat[ 5]:=0FCF3H;(* 6*)
 Dat[ 6]:=0FCF3H;(* 7*)
 Dat[ 7]:=0FC03H;(* 8*)
 Dat[ 8]:=0FFFFH;(* 9*)

  (* Plane 2 *)
 Dat[ 9]:=00000H;(* 1*)
 Dat[10]:=00000H;(* 2*)
 Dat[11]:=00000H;(* 3*)
 Dat[12]:=00000H;(* 4*)
 Dat[13]:=00000H;(* 5*)
 Dat[14]:=00000H;(* 6*)
 Dat[15]:=00000H;(* 7*)
 Dat[16]:=00000H;(* 8*)
 Dat[17]:=00000H;(* 9*)

END; 


WITH ImgPtr[Pinsel]^ DO         (* Pinsel *)

  (* Plane 1 *)
 Dat[ 0]:=0FFFFH;(* 1*)
 Dat[ 1]:=0C0FFH;(* 2*)
 Dat[ 2]:=0CCFFH;(* 3*)
 Dat[ 3]:=0C003H;(* 4*)
 Dat[ 4]:=0FCF3H;(* 5*)
 Dat[ 5]:=0FCF3H;(* 6*)
 Dat[ 6]:=0FCF3H;(* 7*)
 Dat[ 7]:=0FC03H;(* 8*)
 Dat[ 8]:=0FFFFH;(* 9*)

  (* Plane 2 *)
 Dat[ 9]:=00000H;(* 1*)
 Dat[10]:=00000H;(* 2*)
 Dat[11]:=00000H;(* 3*)
 Dat[12]:=00000H;(* 4*)
 Dat[13]:=00000H;(* 5*)
 Dat[14]:=00000H;(* 6*)
 Dat[15]:=00000H;(* 7*)
 Dat[16]:=00000H;(* 8*)
 Dat[17]:=00000H;(* 9*)

END; 
END Img.

==========================================================================


* Beispiel Importliste

Die Importliste für das obige MODULE sollte wie folgt aussehen:

FROM Img IMPORT	Brush1,Pinsel,Imgwidth,Imgheight,Imgdepth,ImgPtr;	


Die Übergabe an den RECORD vom TYPE Image sieht für das Image mit dem 
Namen Brush1 so aus:

WITH ImageType DO
  leftEdge	:=
  topEdge	:=
  width		:=Imgwidth;
  height	:=Imgheight;
  depth		:=ImgDepth;
  imageData	:=ImgPtr[Brush1]
  planePick	:=
  planeOnOff	:=
  nextImage	:=
END;




Für Anfragen stehe ich gerne zur Verfügung.

Ich wünsche viel Spaß mit IFFtoCode ...

				
                                ... Pit Burkhardt