============================================================================ = = = A M O K = = = A M I G A M O D U L A K L U B Stuttgart ============================================================================ Dokumentation zu GraphicSupport V1.0 Autor: Frank Staudte, 7000 Stuttgart 1 Für alle, die Textcraft haben: Es existiert KEIN Textcraft-File, weil Commodore mich nicht in den Genuß dieses Programmes kommen läßt, und mir Textcraft schenkt! (Das macht nichts, da sich der "Guru" während der letzten Wochen oft genug "gemeldet" hat.) Einleitung ---------- GraphicSupport soll Ihnen die Arbeit mit den Graphic-Primitves etwas er- leichtern. Ihnen stehen eine Menge Prozeduren zur Verfügung, die Sie nicht nur für die Programmierung der Graphic-Primitives, sondern auch z.B. für Super-BitMap-Windows ect. benötigen. WICHTIG: ******** GraphicSupport ist nicht nur als Hilfe für die Graphic-Primitives gedacht, sondern besitzt auch Routinen, die die Arbeit mit Intuition vereinfachen!! Diese sind: - CreateBitMap(): Für SuperBitMapWindows, Double-Buffering & DualPlayField in Screens. - Swap(): Für Double-Buffering in Screens oder Windows. - MakeVPDualPF(): Für DualPlayField. Ich habe es noch nicht getestet, kann es mir aber gut vorstellen!! ALSO: Bitte weiter lesen, auch wenn Sie weiter bei Intuition bleiben wollen, aber Double-Buffering oder DualPlayfield programmieren möchten. Ich habe GraphicSupport mit Bene's MemSystem V1.0 (Amok#5) geschrieben, da oft Speicher allociiert werden muß. Bitte lesen Sie unter >MemSystem< nach, wie Sie am besten mit MemSystem und GPSupport arbeiten! Grundbegriffe / Grundlagen -------------------------- Das nun Folgende soll und kann kein Kurs für die Graphicprogrammierung des Amigas sein. Es soll lediglich einige der wichtigsten Begriffe erläutern! Als Literatur zu diesem Thema kann ich Ihnen folgende Bücher empfelen: - Data Becker: Supergrafik ISB N 3-89011-254-4 - Addison Wesley: ARK: Libraries & Devices 11078 - Sybex: Amiga Programmer's Handbook Volume 1 367-8 »»»»» Bitplane, Bitmap, RastPort, ViewPort, View, RasInfo. ««««« Viele dieser Begriffe ist Ihnen von Intuition her sicher bekannt! Grundsätzlich gilt: !!! Was unter Intuition gleich heißt, wie unter den Graphic-Primitives, ist IMMER das selbe !!! Die BitMap: ----------- Eine BitMap besteht aus einer bis mehreren Bitplanes. Eine BitPlane ist ein Stück Speicher - er muß sich unbedingt im CHIP-Mem befinden - "auf" den ge- zeichnet werden kann. Je mehr Bitplanes eine BitMap hat, desto mehr Farben lassen sich auf ihr darstellen, desto mehr Speicher benötigt sie aber auch. Die Farbzahl berechnet sich aus > zwei hoch Anzahl der Bitplanes < (Jeder, der schon einmal mit DPaint II gearbeitet hat, kennt die Gadgets am Anfang, mit dessen Hilfe man die Farbzahl einstellen kann. Hier wird also "nur" festgelegt, wieviele BitPlanes ihre BitMap (Das Papier) haben soll!) Nun ist die maximale Tiefe einer BitMap zur Zeit (1988 auf Amiga 500/1000/2000 auf 6 festgelegt. Ich hoffe sehr, daß sich dies bald ändern wird) Also: 2 hoch 6 ist 64. D.h es sind maximal 64 Farben gleichzeitig darstellbar. Das ist FALSCH. (Schade!) Im Normalfall stellt ihr Amiga (sofern genug Speicher für die BitMap vorhanden ist) max. 32 Farben gleichzeitig dar. Durch setzen von verschiedenen Flags kann diese Zahl verändert werden!!! Der ExtraHalfBrite-Mode: Hier wird die maximale Farbzahl verdoppelt! Das bedeutet, wenn Sie 4 Farben haben (Tiefe 2), so erhalten Sie durch ExtraHB 8 Farben. (8 -> 16, 16 -> 32, 32 -> 64!) Der HAM-Mode: Hier können Sie durch aufwendige Programmierung alle 4096 Farben darstellen. Ich möchte an dieser Stelle nicht weiter auf den HAM-Mode eingehen, da er überall sehr gut erklärt wird. (Z.B. auf AMOK#1 HAM.MOD) Doch nun zurück auf unsere BitMap: Eine BitMap darf heute (1988) 1024 Pixel (Punkte) breit und 1024 Pixel hoch sein. Es können jedoch nicht alle gleichzeitig dargestellt weden. Man kann dann nur auf ihr scrollen (siehe GraphicSupport.ScrollVPort()!). WICHTIG: Eine BitMap legt nicht die Farben selber fest, sondern nur die Zahl der MAXIMAL VERWENDBAREN FARBEN! Diese BitMap (das Papier) wandert nun in den RastPort: Der RastPort ------------ Der RastPort ist sicher ein "Alter Freund" von ihenen. Nahezu alle Graphic läuft über ihn. (Gels, Linien, Kreise, Text, Zeichensätze) Um einen RastPort zu definieren benötigen Sie nur eine BitMap, auf die er Zeichnen soll. (Siehe CreateRastPort()) Ein selbst erstellter RastPort wird gleich angesprochen wie unter Intuition. Der View -------- Obwohl er View heißt, ist er meistens unsichtbar! Wollen Sie ihn sichtbar machen? Schließen Sie alle Screens, außer dem Workbench-Screen. Ziehen Sie nun den Workbench-Screen nach unten. Was sie über ihm sehen, ist der View! Nicht gerade Überragend !?! Hier ist ein Black-Box-Denken nötig: Er muß vorhanden sein, er wird mittels CreateView() definiert, und man benötigt einen Zeiger auf ihn. Das sollte genügen. Der ViewPort ------------ Der ViewPort ist nun schon um einiges interessanter. Auf dem View befinden sich nämlich einer oder mehrere ViewPorts. (Deshalb kann man den View kaum sehen!!) Ein ViewPort definiert nun eine ganze Menge: - Die Grafikart: HAM, ExtraHB, oder Standard - Die Auflösung: Hires (640) oder LowRes/Standard(320 Pixel Breite) Interlace(auf Pal-Amigas 512. Auf NTSC 400 Pixel Hoch) oder Non-Interlace(PAL 256, NTSC 200) - Die BitMap[s], die gerade sichtbar ist [sind]. - Die Farben. Ein Intuition-Screen ist (fast) nichts weiter als ein ViewPort mit Titelleiste!! WICHTIG: Sie können beliebig viele ViewPorts pro View öffnen. Aber: - Es muß mindestens EINE Reihe Pixel Abstand zwischen zwei ViewPorts liegen, und - Es dürfen keine 2 ViewPorts NEBENEINANDER liegen. Jeder ViewPort kann andere Farben, eine andere Auflösung oder Grafikarten gegenüber einem anderen ViewPort haben. Ist jedoch einer der ViewPorts auf Interlace gesetzt, so ist das Flimmern (zumindest auf bei Monitoren mit 50 Herz,wie in Europa) auf allen anderen ViewPorts bemerkbar! Wollen Sie mehrere ViewPorts, gleichzeitig darstellen, so müßen diese mittels MyViewPort^.next verkettet sein. Der Letze sollte dort NIL stehen haben. Der erste ist der Prozedur CreateView() zu übergeben. RasInfo: -------- Jeder ViewPort zeigt auf mindestens ein RasInfo. Ich sage mindestens, da er im Normalfall auf nur einen zeigt. Sie benötigen den zweiten nur, wenn Sie "DualPlayfield" wollen. Dann müßen beide durch MyViewPort^.rasInfo^.next verkettet sein. (Dies geschiet automatisch durch MakeVPDualPF()). Mehr über DualPF unter DualPlayField! RasInfo trägt wie der Name schon sagt, Informtionen über ein Raster (Bild) mit sich. So z.B. die BitMap. In ViewPort^.RasInfo^.bitMap steht immer die BitMap, welche gerade sichtbar ist! Normalerweise sind MyRastPort^.bitMap und MyViewPort^.rasInfo^.bitMap immer die selben. Das bedeutet, daß alles, was gezeichnet wird, auch sofort dargestellt wird. Sind die BitMaps im RastPort und im RasInfo unterschiedlich, so spricht man von "Buffering". Mehr dazu unter Double-Buffering. Weitere Werte für RasInfo sind rx/ryOffset. Diese Werte werden vor allem für das Scrolling benötigt. Normalerweise sind beide Werte null. Das bedeutet, daß bei einer übergroßen BitMap immer die linke, obere Ecke zu sehen ist. Ansonsten gilt für RasInfo das selbe Black-Box-Denken wie für den View. ============================================================================= Handhabung von GraphicSupport ----------------------------- Modula-2 bietet gegenüber C oder Assembler die Möglichkeit einer TermProcedure. Dies ist eine Prozedur, die immer am Ende oder bei einem frühzeitigen Ausstieg aus dem Programm aufgerufen wird. Sie bietet sich also geradezu an, um zum "Aufräumen" benutzt zu werden. Tragen Sie also bitte alle Free-Prozeduren dort ein, um dem System nach Be- endigung des Programmes oder nach einem frühzeitigen Ausstieg den belegten Speicher zurückzugeben, und den Urzustand (WorkBench) wieder herzustellen. Wenn Sie sich die Prozedur FreeView einmal genauer anschauen, merken Sie, daß dort 3 ViewPointer benötigt werden. NewView, ActiveView und OldView. Nun, NewView ist ein VAR-Parameter, den Sie zurückbekommen. Dies ist normalerweise der selbe wie OldView. OldView ist ein Zeiger auf den View, der die WorkBench darstellt. Sie erhalten ihn durch Intuition.ViewAddress! Schalten Sie also immer nach Beendigung ihres Programmes auf die WorkBench zurück! NewView benötigen Sie nur wenn Sie innerhalb eines Programmes zwei Views erstellen wollen. Bitte lesen Sie unter >MemSystem< nach, wie Sie optimal mit MemSystem arbeiten können! Als Erleichterung dazu dient auch das File >Standard.MOD< =========================================================================== DoubleBuffering --------------- Im Normalfall zeigen RastPort^.bitMap und ViewPort^.rasInfo^.bitMap immer auf die selbe BitMap. Das heißt, wenn man etwas durch z.B. Graphics.Draw zeichnet, so erscheint es sofort auf dem Monitor. Das hat oft den Nachteil, daß ein Flimmern entsteht. (Am meisten bei Bobs!). Dann empfielt sich eine Technik, die man Double-Buffering nennt. Das bedeutet, daß man 2 BitMaps erstellt, die eine dem RastPort zuordnet (MyRPort^.bitMap:=BitMap1) und die andere dem ViewPort bzw. seinem RasInfo, (MyViewPort^.rasInfo^.bitMap:=BitMap2) während nun auf der BitMap im RastPort gezeichnet wird (versteckt), wird die zweite BitMap im ViewPort dargestellt. Ist man fertig mit zeichnen, werden die BitMaps mittels >Swap< ausgetauscht. Nun ist die bemalte BitMap sichtbar und die andere - vorher dargestellte - liegt im RastPort und kann nun versteckt bemalt werden. Das Double-Buffering wird in der Demo DBuffDemo.MOD gezeigt. DualPlayfield ------------- DualPlayFiel bedeutet, daß man 2 unabhängige Bitmaps gleichzeitig übereinander darstellt. Als Beispiel: Ein Hubschrauber fliegt über eine Landschaft, die unter ihm wegscrollt. Dabei befindet sich die Landschaft auf der einen BitMap, die mittels Scroll bewegt wird, und der Hubschrauber ist über allem auf einer starren BitMap. Um nun einen ViewPort mit dieser Fähigkeit auszustatten, erstellen Sie wie immer einen ViewPort. Beachten Sie, daß dieser NICHT über das ViewModeFlag >dualpf< verfügen muß. Es wird später automatisch gesetzt! Die Bitmap, die Sie dieser CreateViewPort() übergeben, ist die "untere". D.H. Sie ist nur dort sichtbar, wo die "obere" Bitmap die Farbe 0 gesetzt hat. (Dort ist sie also durchsichtig!) Rufen Sie nun noch MakeVPDualPF() auf. Dabei wird automatisch das Flag MyViewPort^.modes "dualpf" und "pfba" gesetzt. Als BitMap übergeben Sie hier einen Zeiger auf die "obere" Bitmap. Der RasInfoPtr zeigt Ihnen nun den Weg zu ihrer zweiten BitMap. Diesen benötigen Sie vor allem beim Scrolling oder Double-Buffering. DualPlayField wird in der Demo "DualPFDemo" erklärt! ============================================================================ Prozeduren & Erklärung ---------------------- Funktion : RasSize(width, height: CARDINAL): CARDINAL Übergabe : width und height: die Breite und Höhe einer BitMap Rückgabe : Ausmaße der BitMap.Dieser Wert wird z.B. für Graphics.BltClear benötigt wird. Erklärung: RasSize ist schon im M2Amiga implementiert (GelMacros.RasSize), funktioniert aber laut Meier-Vogt nicht richtig. Ich hoffe das dieses vollkommen richtig arbeitet. Die Aufgabe von RasSize ist es, das Format einer BitMap (Breite * Höhe) so zu berechnen, daß beide Werte immer durch 8 teilbar sind. Dies ist nötig, um eine Bitmap im Speicher des Amigas unterzubringen. RasSize habe ich aus Bene's IntuiStruct herausgekoppelt, es ist also nicht mein Werk! ------------------------------------------------------------------------------ Funktion : CreateBitMap(width,height,depth: INTEGER): BitMapPtr Übergabe : width, height und depth geben die Ausmaße ihrer BitMap an. Rückgabe : Zeiger auf eine BitMap, die erstellt wurde. Erklärung: CreateBitMap erstellt eine BitMap, reserviert Speicher im Chip-Mem (da Sie dort liegen muß!!), und gibt einen Pointer auf eine BitMap zurück. Bei dieser Prozedur ist es sehr wichtig, daß sie eine Abfrage machen, ob der Speicher auch reserviert werden konnte, oder ob der Systemspeicher zu knapp war, da hier bis zu 100 KB benötigt werden können! Ich möchte noch anmerken, daß ich den Speicher nicht durch Graphics.AllocRaster reserviere, sondern durch MemSystem.AllocMem oder Heap.AllocMem, da mein Compiler bei Graphics.AllocRaster immer abgestürzt ist. ------------------------------------------------------------------------------ Funktion : CreateRastPort(BitMap: BitMapPtr): RastPortPtr Übergabe : Zeiger auf eine BitMap, auf die gezeichnet werden soll. Rückgabe : Zeiger auf einen RastPort. Erklärung: >BitMap< darf den auf die selbe BitMap wie ViewPort^.RasInfo zeigen. Das würde bedeuten, daß alles, was gezeichnet wird, auch sofort sichbar wird. Andernfalls spricht man von Buffering. Mehr dazu unter Buffering. ------------------------------------------------------------------------------ Funktion : CreateViewPort(VAR rInfo: RasInfoPtr; nextViewPort: ViewPortPtr; leftEdge,topEdge: INTEGER; width,height: INTEGER; BitMap: BitMapPtr; Modes: ViewModeSet; NumberOFColors: INTEGER): ViewPortPtr; Übergabe : - in "nextViewPort" sollten Sie einen Pointer auf einen weiteren ViewPort eintragen, sich gleichzeitig auf ihrem View befinden soll. Soll ihr ViewPort der einzige sein, übergeben Sie nur NIL. Sie können soviele ViewPorts erstellen, wie Speicher vor- handen ist, es muß sich jedoch mindestens EIN PIXEL in der y-Richtung FREI BLEIBEN! Es ist auch nicht möglich, 2 ViewPorts NEBENEINANDER zu gestalten! - leftEdge und topEdge geben den Abstand zur linken oberen Ecke des View's an. (Wie bei Intuition.Screen.topEdge/leftEdge!) - width und height geben auch wieder parallel zu Intuition die Breite und Höhe ihres ViewPorts an. Achten Sie darauf, daß Sie nur "sinnvolle" Werte übergeben. Andernfalls sehen Sie ihren Computer beim Meditieren! - bitMap ist parallel zu CreateRastPort() ein Zeiger auf eine Bitmap. Sie sollte im Normalfall die selbe wie beim RastPort sein. Andernfalls spricht man wieder vom "Buffern". - Modes ist ein ViewModeSet, unt bestimmt folglich die Auflösung ihres ViewPortes. (HAM, Hires, Lace,..) Wenn Sie eine oder mehere der Konstanten aus GraphicSupport benützen, sparen Sie sich ein zusätzliches Importieren! Das Flag "ViewModeSet.Sprites" ist immer gesetzt. Es schaltet die Sprite-DMA ein. Für ein DualPlayField setzen Sie nur die Flags, die die Auflößung bestimmen (Hires, Lace, HAM,..), nicht aber dualpf! Dies wird bei der Prozedur NakeVPDualPF() gemacht!! - NumberOFColors gibt die genaue Zahl der ColorMap an. Es sollte im Normalfall 2^ViewPort^.rasInfo^.bitMap^.depth sein. Ist die Tiefe ihrer Bitmap z.B. 3, so können Sie 2^3 also 8 Farben benützen. Sie sparen jedoch Speicherplatz, wenn Sie nur "6" übergeben, und somit auch nur 6 Farben zur Verfügung haben. Rückgabe : Als VAR-Paramete erhalten Sie einen Zeiger auf ihr rasInfo. Diesen benötigen Sie aber nur, wenn Sie entweder DualPlayfield programmieren wollen, oder später die "sichtbare" BitMap tauschen wollen. (Siehe Buffering) Als Funktionsrückgabe erhalten Sie einen Zeiger auf ihren ViewPort. Erklärung: Der ViewPort ist Ihnen sicher schon von Intuition her bekannt. Sie erhalten ihn dort bekanntlich durch MyViewPort:=ADR(MyScreen^.viewPort); Sie können nun allen Prozeduren, die einen ViewPort verlangen, genau gleich benützen, indem Sie den mit CreateViewPort() er- stellten Zeiger übergeben. ------------------------------------------------------------------------------ Funktion : CreateView(FirstView: ViewPortPtr): ViewPtr Übergabe : Zeiger auf den ViewPort, der am Anfang einer Kette von ViewPorts steht. Haben Sie nur einen ViewPort auf ihrem View, so übergeben Sie den Pointer auf ihn. Rückgabe : Zeiger auf ihren eigenen View. Erklärung: Der View hält ihr gesammtes Display zusammem. Der Pointer wird hauptsächlich für die Prozedur Reamke() benötigt! Ohne eine View läuft allerdings nichts! ------------------------------------------------------------------------------ Prozedur: FreeBitmap(BitMap: BitMapPtr) Übergabe : Zeiger auf eine zu Löschende BitMap Erklärung: Gibt den benötigten Speicher wieder ans System zurück. Bitte auf jeden Fall in der TermProzedur eintragen!!! Achtung: BitMaps, die mit ReadILBMBitMap erstellt wurden, arbeiten (momentan) nicht mit MemSystem. Das hat zur Folge, daß MemSystem eine Fehlermeldung zeigt. Solche BitMaps bitte mit FreeILBMBitMap löschen! ------------------------------------------------------------------------------ Prozedur: FreeRastPort(rastPort: RastPortPtr) Übergabe : Zeiger auf einen zu löschenden RastPort Erklärung: Gibt den benötigten Speicher wieder ans System zurück. Bitte auf jeden Fall in der TermProzedur eintragen!!! ------------------------------------------------------------------------------ Prozedur: FreeViewPort(viewPort: ViewPortPtr; rInfo: RasInfoPtr) Übergabe : Zeiger auf einen zu löschenden ViewPort und dessen RasInfo Erklärung: Gibt den benötigten Speicher wieder ans System zurück. Bitte auf jeden Fall in der TermProzedur eintragen!!! Aufruf: FreeViewPort(MyViewPort,MyViewPort^.rasInfo); ------------------------------------------------------------------------------ Prozedur: FreeView(VAR NewView: ViewPtr; ActiveView,OldView: ViewPtr) Übergabe : Zeiger auf einen zu löschenden View. Rückgabe : Als VAR-Parameter ein Zeiger auf den Workbench-View Erklärung: Gibt den benötigten Speicher wieder ans System zurück. Bitte auf jeden Fall in der TermProzedur eintragen!!! Stellt den alten Display-Zustand ein. Aufruf: BEGIN OldView:=Intuition.ViewAddress(); . ActiveView:=CreateView() . FreeView(NewView,ActiveView,OldView) <------ END ------------------------------------------------------------------------------ Funktion : MakeVPDualPF(VAR viewPort: ViewPortPtr; bitMap: BitMapPtr): RasInfoPtr Übergabe : - viewPort: Zeiger auf einen mit CreateViewPort() erstellten viewPort oder "ADR(MyScreen.viewPort)" - bitMap: Zeiger auf eine mit CreateBitMap() erstellte BitMap. Rückgabe : Als VAR-Parameter eine leicht veränderte ViewPort-Structur. Als Funktionsrückgabe einen Zeiger auf ein zweites RasInfo. Erklärung: Die BitMap, die Sie bei CreateViewPort() übergeben haben, ist die "untere" der zwei BitMaps. D.H. sie ist nur dort sichtbar, wo die bei MakeVPDualPF() übergebene BitMap "durchlässig" ist. Mehr zu Dual-Playfield unter DualPlayField. ------------------------------------------------------------------------------ Prozedur: Remake(View: ViewPtr; ViewPort: ViewPortPtr) Übergabe : Zeiger auf einen zu >Refreshenden< ViewPort und einen Zeiger auf den dazugehörigen View. Erklärung: Remake stellt Ihr neu erzeugtes Display her. Benutzen Sie auch Remake nach jeder Veränderung Ihres Display. Z.B. wenn Sie nachträglich ihren ViewPort von Lace auf Non-Lace stellen wollen, oder nach einem Scrolling das neue Display darzustellen. Gehen Sie also nicht zu zimperlich mit diesem Befehl um! ------------------------------------------------------------------------------ Funktion : ScrollVPort(viewPort: ViewPortPtr; rInfo: RasInfoPtr; pixX, pixY: INTEGER): BOOLEAN Übergabe : - Zeiger auf einen zu Scrollenden ViewPort - Zeiger auf eine der RasInfos eines ViewPorts. - PixX und PixY: Anzahl der Pixel, die gescrollt werden sollen Rückgabe : TRUE, wenn das Scrollen erfolgreich war, FALSE, wenn man versucht, zu weit zu Scrollen. Erklärung: ScrollVPort funktioniert genau so, wie in ScrollScreen auf Amok#6, nur das nun kein Screen mehr gebraucht wird. Allerdings kann es zu Störungen kommen, da nicht mit dem VBeam-Strahl synchronisiert wird. ------------------------------------------------------------------------------ Prozedur: Swap(VAR rastPort: RastPortPtr; VAR rInfo: RasInfoPtr) Übergabe : Zeiger auf den RastPort, in dem sich beim Buffering (siehe dort) die unsichtbare BitMap befindet, und einen Zeiger auf das RasInfo eines ViewPortes, dessen sichtbare BitMap getauscht werden soll. Rückgabe : Zeiger auf die leicht veränderte RastPort und RasInfo Struktur. Erklärung: Swap wird nur beim Double Buffering benützt. Es wird auch dort erklärt. Swap kann auch für normale Intuition-Screens benutzt werden. ------------------------------------------------------------------------------ Funktion : ReadILBMBitMap(name: ARRAY OF CHAR; VAR Width, Height, Depth: INTEGER; VAR Colors: ILBMColors; VAR err: BOOLEAN): BitMapPtr; Übergabe : name: Pfadname zum Bild Rückgabe : Als VAR-Parameter: Width, Height, Depth: Die Ausmaße der BitMap. Colors: Die Farben. Diese Variable später an SetILBMColors() übergeben. err: TRUE, wenn ein Fehler aufgetreten ist. Als Funktions-Rückgabe: Zeiger auf die geladene BitMap, auf der sich Ihr Bild befindet. Erklärung: Es handelt sich hierbei nicht um einen eigenen ILBM-Lader, sondern um Fridtjof's ReadILBM() auf Amok#3. Ich habe nur eine kleine "Operation" an der Schnittstelle gemacht, da sie für meine Zwecke nicht gut geeignet war. ------------------------------------------------------------------------------ Prozedur: SetILBMColors(viewPort: ViewPortPtr; Colors: ILBMColors); Übergabe : Der ViewPort, der die BitMap darstellt. Die Farben, die dargestellt werden sollen. Rückgabe : Keine Erklärung: Es ist wichtig, die Farben erst NACH CreateViewPort() aufzu- rufen, da CreateViewPort eine eigene Color-Tabelle festlegt! Wollen Sie die Farben beliebig ändern, so können Sie dies mit Graphics.SetRGB4() tun. ------------------------------------------------------------------------------ Prozedur: FreeILBMBitMap(bitMap: BitMapPtr); Übergabe : BitMap, deren Speicher dem System zurückgegeben werden soll. Rückgabe : Keine Erklärung: Siehe FreeBitMap. Mit dieser Prozedur sollten Sie nur Speicher zurückgeben, der durch ReadILBMBitMap allociiert wurde. ============================================================================ Demos: ------ Die Demos sind absichtlich etwas klein gehalten, damit Sie leichter zu Verstehen sind, und nicht irgendwelcher "SchnickSchnack" stört. Jede Demo zeigt den grundsätzlichen Umgang mit GraphicSupport. SimpleDemo: Diese Demo zeigt nur die Verwendung von GraphicSupport. Sie simuliert einen Intuition-Screen. Beendigung durch drücken der Maus. Scroll: Diese Demo zeigt die Verwendung von ScrollVPort(), von ReadILBMBitMap(), SetILBMColors() und FreeILBMBitMap(). Sie ist fast identisch mit meiner ScrollDemo auf Amok#6, jedoch diesmal für die Graphic-Primitives, und nicht für Intuition. Um diese Demo zu starten, benötigen Sie ein Bild, welches als Argument doppel-geklickt wird. Beendigung durch drücken der Maus. DualPF: Diese Demo zeigt sehr simpel die Verwendung von MakeVPDualPF(). Es werden zwei BitMaps übereinander gelegt, wobei die eine waagerechte, die andere vertikale Linien zeigt. Beendigung durch drücken der Maus. DBuffDemo: Diese Demo zeigt die Technik des "Double-Bufferns". Es werden abwechslungsweise zwei BitMaps gezeigt. Während eines "richtigen" bufferns wird nun auf der nicht sichtbaren BitMap (sie befindet sich im RastPort!!!) gezeichnet. Ist der Zeichenvorgang beendet, und es soll umgeschaltet werden ( Swap() ), so sollten Sie zuvor mit Graphics.WaitBOVP() warten, um ein Flackern zu vermeiden. Beendigung durch drücken der Maus. (Lange gedrückt halten!!!) ============================================================================ MemSystem: ---------- MemSystem hat den Vorteil, daß z.B. bei Speichermangel ein Requester gezeigt wird, des einen von Ihnen wählbaren Text zeigt. Am Anfang des Standard.Files befindet sich unter anderem eine Konstante, in der Sie ihren Programmnamen eintragen sollen. Dieser erscheint als Titel für ihren Requester, wenn Speichermangel vorliegen sollte. Eine Zweite Konstante gibt den Text an, der als eigentliche Meldung erscheinen soll. (z.B. Wenig Speicher). Kann nun z.B. CreateBitMap() nicht allen Speicher zu Verfügung bekommen, den es benötigt, so erscheint ihr oben erklärter Requester. Nun soll der Anwender versuchen, Speicher dem System zurückzugeben (Schließen von Fenstern), und dann den Requester mit >Retry< beantworten. Ist dann genügend Speicher vor- handen, so arbeiten MemSystem und Graphic-Support wie gewohnt weiter. Sollte zwar Speicher gewonnen worden sein, dieser reicht aber nicht aus, so wird obiges wiederholt. Beantwortet der User den von MemSystem erstellten Requester mit >Cancel<, so bricht soll das Programm abbrechen. Dies geschieht z.B. durch MemSystem.DeadEndAlert(). Die Termprocedure wird aber in jedem Fall ausgeführt. Deshalb ist es wichtig, daß Sie allen Speicher, den Sie belegen, auch in der Termprocedure wieder zurückgeben!!! Zusätzlich besitzt GraphicSupport noch einige Konstanten, die etwas über die Modi des ViewPorts Auskunft geben (HAM, extraHB, Lace, Hires,..). Sie entsprechen Graphics.ViewModes, ersparn Ihnen also das Importieren. Wollen Sie nun einen ViewPort in Hires, Lace und HAM haben, importieren Sie nur die 3 entsprechenden Constanten, und "addieren" sie. MyViewModes:=Hires+Lace+HAM Die Sprite-DMA wird immer eingeschaltet, da Sie oft vergessen wird. Wer Sie nicht benötigt und glaubt, daß sie stört, kann sie mit GfxMacros.OffSprite wieder ausschalten. ============================================================================ Das wärs auch schon. Viel Spaß ! Euer Frank Staudte (Tippfehler und Schreibfehler sind wie immer un- beabsichtigt und von Ihnen zu entschuldigen!) --- cut --- cut --- cut --- cut --- cut --- cut --- cut --- cut --- cut ---