(* $M- *)

DEFINITION MODULE GfxDecs;


(*****************************************************************************)
(*                                                                           *)
(*  Definitionsmodul: GfxDecs              Version 1.0 vom 1. November 1990  *)
(*                                                                           *)
(*  Für M2Amiga Modula-2 von Olaf Pfeiffer & Paul Lukowicz / Copyright 1990  *)
(*                                                                           *)
(*---------------------------------------------------------------------------*)
(*                                                                           *)
(*  In diesem Modul sind die von den GraphicTreasures benötigten Typen und   *)
(*  Datenstrukturen deklariert.                                              *)
(*                                                                           *)
(*****************************************************************************)


FROM  Graphics      IMPORT  AreaInfo, TmpRas, RegionPtr, Rectangle,
                            ViewPortPtr, RastPortPtr;
FROM  Intuition     IMPORT  ScreenPtr, WindowPtr;
FROM  SYSTEM        IMPORT  ADDRESS;


TYPE GfxMode       = (Lo8,Hi8,Lo16,Hi16,Lo32,EHB,HAM);
(*
Die von den GraphicTreasures unterstützten Grafik-Modi:
Lo8  - Breite: 320 Pixel; Farben:    8
Hi8  - Breite: 640 Pixel; Farben:    8
Lo16 - Breite: 320 Pixel; Farben:   16
Hi16 - Breite: 640 Pixel; Farben:   16
Lo32 - Breite: 320 Pixel; Farben:   32
EHB  - Breite: 320 Pixel; Farben:   64 (Extra-Halfbrite-Modus)
HAM  - Breite: 320 Pixel; Farben: 4096 (Hold-And-Modify-Modus)
*)


TYPE GfxPtr        = POINTER TO GfxSpecial;
(*
Ein Adreßzeiger auf alle zu einem "Grafik-Screen" gehörende Daten.
*)


TYPE ColorEntry    = ARRAY [1..3] OF INTEGER;
(*
Ein Farbeintrag: die 3 Farbanteile (Rot,Grün,Blau) eines Farbregisters.
*)


TYPE ColorRegsPtr  = POINTER TO ARRAY [0..31] OF ColorEntry;
(*
Ein kompletter "Satz" Farbregister.
*)


TYPE Pixel         = RECORD
                       x,y: INTEGER;
                     END;
(*
Die Definition eines Bildschirmpunktes, bestehend aus einer x- und einer
y-Koordinate.
*)


TYPE Voxel         = ARRAY [1..3] OF INTEGER;
(*
Die Definition eines Punktes im Raum, also eines "Volume-Pixels".
*)


TYPE Direction     = ARRAY [1..3] OF INTEGER;
(*
Die Definition eines Drehwinkels um die drei Koordinatenachsen. Die drei Winkel
werden in zehntel Grad angegeben.
*)


TYPE RotMtx        = ARRAY [1..3],[1..3] OF INTEGER;
     RotMtxPtr     = POINTER TO RotMtx;
(*
Die Definition einer Rotationsmatrix. Diese wird benötigt um Punkte im Raum
drehen zu können.
*)


TYPE ScenePtr     = POINTER TO SceneType;  (* Adreßzeiger auf eine 3D-Szene. *)
     NameType     = ARRAY[1..16] OF CHAR;  (* Der Name eines Objektes in einer
                                              3D-Szene. *)


(*****************************************************************************)
(*  ------------------  Fehlermeldungen und Asserts  ----------------------  *)


CONST nomem =     "Speichermangel!";
      nochip =    "Nicht genug CHIP-Memory!";
      gfxnil =    "GfxPtr mit NIL übergeben!";
      scenenil =  "ScenePtr mit NIL übergeben!";
      objexists = "Objekt gibt es bereits!";
      colnil =    "ColorRegsPtr mit NIL übergeben!";
      notinit =   "Initxxx erwartet!";
      notend =    "Endxxx erwartet!";
      notopen =   "Openxxx erwartet!";
      notclose =  "Closexxx erwartet!";


(*****************************************************************************)
(*  ------------------------------  PRIVATE  ------------------------------  *)

TYPE
     AreaSpecial   = RECORD                  (* Wird für die Areaxxx- *)
                       AInfo  : AreaInfo;    (* Routinen benötigt. *)
                       TRas   : TmpRas;
                       Buff1  : ADDRESS;
                       Buff2  : ADDRESS;
                     END;

     ClipSpecial   = RECORD                  (* Wird zur Erstellung eines *)
                       NewReg : RegionPtr;   (* Clipping-Rechtecks benötigt. *)
                       OldReg : RegionPtr;
                       Rect   : Rectangle;
                     END;

     G3DSpecial    = RECORD
                       Dir    : Direction;   (* Für die 3D-Projektion *)
                       Rot    : RotMtx;      (* Für die 3D-Projektion *)
                       Eye    : INTEGER;     (* Entfernung Auge - Bildschirm *)
                       Zoom   : INTEGER;     (* Größenfaktor in Prozent *)
                       Sizer  : INTEGER;     (* interner Größenfaktor *)
                       CamNor : Voxel;       (* Vektor in Richtung Camera *)
                       Lite   : Voxel;       (* Vektor in Richtung Licht *)
                       LitNor : Voxel;       (* Vektor für gr. Lichtreflex. *)
                     END;

     GfxSpecial    = RECORD
                       GMode  : GfxMode;     (* Grafikmodus *)
                       GLace  : BOOLEAN;     (* Interlace aktiviert? *)
                       GHiRes : BOOLEAN;     (* HiRes-Modus aktiviert? *)
                       G3D    : G3DSpecial;
                       Colr   : [7..31];     (* Anzahl der Farbregister-1 *)
                       Urx,Ury: INTEGER;     (* Ursprung des Koord.systems *)

                       Scr    : ScreenPtr;   (* Der zugehörige Screen *)
                       Win    : WindowPtr;   (* Das zugehörige Window *)
                       RP     : RastPortPtr; (* Der zugehörige RastPort *)
                       VP     : ViewPortPtr; (* Der zugehörige ViewPort *)

                       WBScr  : BOOLEAN;     (* Ist Scr die Workbench ? *)
                       OwnGfx : BOOLEAN;     (* Gfx durch MakeGfx erzeugt ? *)

                       area   : BOOLEAN;     (* Areaxxx initialisiert? *)
                       clip   : BOOLEAN;     (* ClipRect initialisiert? *)
                       Area   : AreaSpecial;
                       Clip   : ClipSpecial;
                       T2D    : ADDRESS;
                       T3D    : ADDRESS
                     END;


(* ----------------------------- PRIVAT ------------------------------------ *)
(* PrivateScene, SceneLib, ShapeLib & ShowScene *)


TYPE PolyEntryPtr = POINTER TO PolyEntry;
     ObjEntryPtr  = POINTER TO ObjectEntry;

     PixVox       = RECORD
                      vox: Voxel;        (* Weltkoordinaten *)
                      x,y,z: INTEGER;    (* Bildschirmkoordinaten *)
                    END;
     PixVoxPtr    = POINTER TO PixVox;
     PiVoPtrList  = ARRAY[1..4] OF PixVoxPtr;  (* maximal 4 Zeiger *)
     PiVoList     = ARRAY[1..4] OF PixVox;     (* maximal 4 Punkte *)

     PolyEntry    = RECORD                     (* Single-Polygon der Szene *)
                      PLeft:   PolyEntryPtr;
                      PRight:  PolyEntryPtr;
                      PPVList: PiVoPtrList;
                      PzTan:   LONGINT;
                      PxTan:   LONGINT;
                      PNorm:   Voxel;
                      Edges:   [1..256];
                      PBal:    [-1..1];
                      PCol:    [0..63];
                      Depth:   INTEGER;
                    END;

     PiVoListPtr  = POINTER TO ARRAY[1..50000] OF PixVox;
     EdgeListPtr  = POINTER TO ARRAY[1..50000] OF PixVoxPtr;
     PolyListPtr  = POINTER TO ARRAY[1..50000] OF PolyEntry;

     ObjectEntry  = RECORD                   (* Zu jedem Objekt gehört: *)
                      VName:   NameType;     (* Name des Objektes *)
                      VNext:   ObjEntryPtr;  (* Zur Verknüpfung: vorwärts *)
                      VPrev:   ObjEntryPtr;  (* Zur Verknüpfung: rückwärts *)
                      VPVList: PiVoListPtr;  (* Alle Punkte des Objektes *)
                      VEdge:   EdgeListPtr;  (* Alle Kanten des Objektes *)
                      VPoly:   PolyListPtr;  (* Alle Polygone des Objektes *)
                      VPos:    Voxel;        (* Position des Objektes *)
                      VCol:    [0..63];      (* Grundfarbe des Objektes *)
                      Volume:  BOOLEAN;      (* Ein geschlossener Körper? *)
                      points:  INTEGER;      (* Anzahl der Punkte *)
                      edges:   INTEGER;      (* Anzahl der Kanten *)
                      polys:   INTEGER;      (* Anzahl der Polygone *)
                      proj:    BOOLEAN;      (* Punkte schon projeziert? *)
                    END;

     SceneType    = RECORD
                      Objs:     ObjEntryPtr;  (* alle Objekte *)
                      PoTree:   PolyEntryPtr; (* alle sichtbaren Polygone *)
                      ProDir:   Direction;    (* Die bei der Projektion *)
                      ProEye:   INTEGER;      (* zuletzt verwendeten *)
                      ProSizer: INTEGER;      (* Werte. *)
                      NewProj:  BOOLEAN;      (* neuer Gfx? *)
                    END;


(*  ------------------------------  PRIVATE  ------------------------------  *)
(*****************************************************************************)


END GfxDecs.