amiga-news ENGLISH VERSION
.
Links| Forum| Kommentare| News melden
.
Chat| Umfragen| Newsticker| Archiv
.

amiga-news.de Forum > Programmierung > Kreis Zeichnen ohne graphics.library [ - Suche - Neue Beiträge - Registrieren - Login - ]

1 2 -3- 4 5 [ - Beitrag schreiben - ]

01.04.2008, 19:00 Uhr

Der_Wanderer
Posts: 1229
Nutzer
BMF_SPECIALFMT = 0x80

Probiers mal damit. Einfach weglassen geht nicht. Sonst wäre es ja nicht da!

--
Thilo Köhler, Author von:
HD-Rec, Sweeper, Samplemanager, ArTKanoid, Monkeyscript, Toadies, AsteroidsTR, TuiTED, PosTED, TKPlayer, AudioConverter, ScreenCam, PerlinFX, MapEdit, TK AB3 Includes und viele mehr...
Homepage: http://www.hd-rec.de


[ - Antworten - Zitieren - Direktlink - ]

01.04.2008, 19:12 Uhr

MaikG
Posts: 5172
Nutzer
>BMF_SPECIALFMT = 0x80

>Probiers mal damit. Einfach weglassen geht nicht. Sonst wäre es ja nicht da!


Und woher kommt diese Konstante?

Ja, OS4 kann so die Bitmap Allocieren. Aber die Zeichenfunktionen
(cgx) machen jetzt falsch Farben.


Unter OS3 geht AllocBitmap jetzt nicht mehr.

[ - Antworten - Zitieren - Direktlink - ]

01.04.2008, 20:52 Uhr

Blackbird
Posts: 634
Nutzer
Zitat:
Original von MaikG:
>BMF_SPECIALFMT = 0x80

>Probiers mal damit. Einfach weglassen geht nicht. Sonst wäre es ja nicht da!


Und woher kommt diese Konstante?



wie wäre es damit:

Auszug aus der cybergraphics.h
------------------------------

/* *
* graphics.library/AllocBitMap() extended flags *
* */

#ifndef BMB_SPECIALFMT
#define BMB_SPECIALFMT (7UL)
#define BMF_SPECIALFMT (1UL << BMB_SPECIALFMT)
#endif /* BMB_SPECIALFMT */


--
regards
Blackbird

Have a look at:
http://www.blackbird-net.de

Skins for PlayCD OS3.9
BlackShoot, Zombies Apocalypse, GalagaWars, VcdImager-Gui,PerfectPaint

[ - Antworten - Zitieren - Direktlink - ]

01.04.2008, 21:17 Uhr

MaikG
Posts: 5172
Nutzer
Hab schon bei per google gesehen das man da was Shiften muss.



bm& = AllocBitMap&(1600, 1200, 24, BMF_SPECIALFMT||(24<<PIXFMT_RGB24&), NULL&)


Das geht unter OS3.
Unter OS4 geht das anzeigen, wenn man das für jede Bitmap angibt.
Ja, aber sobald man denn druckt kommt nur müll raus. Obwohl
unter OS4 Turboprint zumindest mit dem Grafic Publisher läuft.

Also irgendwas OS4 fähig zu machen ist ja schlimmer als etwas
für OS1.3 :-(

[ - Antworten - Zitieren - Direktlink - ]

01.04.2008, 22:58 Uhr

Der_Wanderer
Posts: 1229
Nutzer
Also so wie ich dir geposted habe funktioniert es unter OS3 und OS4.

Drucken habe ich aber nicht probiert.
Dass man darauf mit OS Funktionen nicht zeichnen kann, haben wir hier ja lang und breit erörtert. Da wird vermutlich nur in schwarz drauf gezeichnet. Unter OS4/MOS/AROS würde es aber gehen, wenn man den Penless Mode benutzt.

--
Thilo Köhler, Author von:
HD-Rec, Sweeper, Samplemanager, ArTKanoid, Monkeyscript, Toadies, AsteroidsTR, TuiTED, PosTED, TKPlayer, AudioConverter, ScreenCam, PerlinFX, MapEdit, TK AB3 Includes und viele mehr...
Homepage: http://www.hd-rec.de


[ - Antworten - Zitieren - Direktlink - ]

02.04.2008, 00:10 Uhr

MaikG
Posts: 5172
Nutzer
>Dass man darauf mit OS Funktionen nicht zeichnen kann,
>haben wir hier ja lang und breit erörtert.

Ja, ist auch nicht das Problem, da ich die CGX Funktionen benutze.




>Da wird vermutlich nur in schwarz drauf gezeichnet.
>Unter OS4/MOS/AROS würde es aber gehen, wenn man den Penless Mode
>benutzt.


Nicht direkt, du hast Farben die du nutzen kannst. Leider
unterscheiden die sich bei CGX/P96.

Schwarz ist aber immer 1 und weiss 2.

Man könnte jetzt aber mit Pen 1-255 einen Punkt malen,
per cgx auslesen und wüsste so welche farben auf diesem Screen
zur verfügung stehen.

[ - Antworten - Zitieren - Direktlink - ]

02.04.2008, 00:57 Uhr

Der_Wanderer
Posts: 1229
Nutzer
> Ja, ist auch nicht das Problem, da ich die CGX Funktionen benutze.
> ..., du hast Farben die du nutzen kannst. Leider
> unterscheiden die sich bei CGX/P96.
> Schwarz ist aber immer 1 und weiss 2.
Mensch MaikG, du bist echt ein harter Fall...
Bitte lese den Thread nochmal genau durch, und mache dir klar was Colormap vs. Hi/True Color bedeutet, also ein Pen vs. RGB Farben sind.

--
Thilo Köhler, Author von:
HD-Rec, Sweeper, Samplemanager, ArTKanoid, Monkeyscript, Toadies, AsteroidsTR, TuiTED, PosTED, TKPlayer, AudioConverter, ScreenCam, PerlinFX, MapEdit, TK AB3 Includes und viele mehr...
Homepage: http://www.hd-rec.de


[ - Antworten - Zitieren - Direktlink - ]

02.04.2008, 01:48 Uhr

Mad_Dog
Posts: 1944
Nutzer
Zitat:
Original von Der_Wanderer:
Mensch MaikG, du bist echt ein harter Fall...
Bitte lese den Thread nochmal genau durch, und mache dir klar was Colormap vs. Hi/True Color bedeutet, also ein Pen vs. RGB Farben sind.


Und ich dachte, ich hätte das Pen-Sharing Konzept Einsteigerfreundlich erklärt: http://w3.norman-interactive.com/C-Kurs_8_5.html. :shock2:
Falls in meinem C-Kurs was nicht klar sein sollte, bin ich jederzeit für konstruktive Kritik offen.

Nochmal kurz das "Pen-Konzept für Dummies":

Ein Pen kann man sich vorstellen wie einen Buntstift. Alle Stifte sind nummeriert. Mit ObtainBestPen() kann man die Nummer des Stiftes ermitteln, die am besten zur gewünschten Farbe passt. Allerdings haben die AmigaOS-Pens im Gegensatz zu Buntstiften keine feste Farbe, sondern die Farbe eines Stiftes kann sich ändern. Wenn man also z.B. schreibt SetAPen(rp, 2L) und dies beim ersten Programmlauf schwarz sein sollte, kann man sich nicht sicher sein, daß dies beim nächsten Programmlauf ebenfalls wieder so sein wird. Pen Nr. 2 ist zwar einer der Pens, die von der Workbench gesetzt werden, aber es kann ja durchaus sein, daß der User eine andere Farbeinstellung wählt. Dann kann Pen Nr. 2 z.B. auch lila-blass-blau oder sonst was sein.

Was anderes ist es, wenn man Grafik-Funktionen verwendet, die einen RGB-Wert als Eingabeparameter erwarten, wie z.B. die CybergraphX-Funktion WriteRGBPixel():

Zitat:
CyberGFX/WriteRGBPixel
NAME

WriteRGBPixel -- Writes a pixel to a specified location
SYNOPSIS

error = WriteRGBPixel(RastPort,x ,y ,color)
D0 A1 D0 D1 D2
ULONG WriteRGBPixel(struct RastPort *,UWORD,UWORD,ULONG);

FUNCTION

Write the alpha,red,green and blue 8-bit color component of the given color to a specified x,y location within a certain RastPort
INPUTS

rp - pointer to a RastPort structure
x,y - the coordinates of the pixel
color - the desired color in AARRGGBB format. Every component
allocates 8 bits of the returned longword. The coding is as
follows:
AA - 8-bit alpha channel component
(set it to 00 if you dont want to use it!)
RR - 8-bit red component of the pixel
GG - 8-bit green component
BB - 8-bit blue component

RESULT

error = 0 if pixel succesfully changed
= -1 if (x,y) is outside the rastport

NOTES

This function should only be used on screens depths > 8 bits. Use WritePixel() on 8 bit screens!
SEE ALSO

ReadRGBPixel(), graphics.library/WritePixel()


--
http://www.norman-interactive.com

[ Dieser Beitrag wurde von Mad_Dog am 02.04.2008 um 01:49 Uhr geändert. ]

[ - Antworten - Zitieren - Direktlink - ]

02.04.2008, 10:32 Uhr

MaikG
Posts: 5172
Nutzer
>Mensch MaikG, du bist echt ein harter Fall...
>Bitte lese den Thread nochmal genau durch, und mache dir klar was
>Colormap vs. Hi/True Color bedeutet, also ein Pen vs. RGB Farben
>sind.

Ich hab das doch verstanden!

Trotzdem kann ich auf einer nicht angezeigten 24 Bit BitMap Text
schreiben und auch SetAPen verwenden. Das geht unter OS3-CGX, OS4
und UAE-P96.

Das OptainBestBen und konsorten nicht gehen ist klar.

[ - Antworten - Zitieren - Direktlink - ]

03.04.2008, 18:51 Uhr

Holger
Posts: 8116
Nutzer
Zitat:
Original von Mad_Dog:
Mit Hilfe der CybergraphiX Funktion WritePixelArray() (Nicht zu verwechseln mit der OS 3.1-Funktion WritePixelArray8()) Kann man das sehr wohl in einen RastPort einbringen und anschließend Systemkonform damit umgehen.

Wenn Du jetzt gesagt hättest, dass es CGX-Funktionen gibt, die einen Puffer statt einer BitMap akzeptieren, hätte man das vielleicht so stehen lassen können (Abgesehen von der Sinnlosigkeit Deines Statements, weil es ja gerade darum ging, dass man unter AmigaOS3.x ohne cybergraphics oder picasso96 keine 24 Bit-BitMaps anlegen kann).
Da Du allerdings jetzt mit einem RastPort kommst, der definitiv einen Pointer auf eine BitMap benötigt und keinesfalls Deinen von Hand erzeugten Custom-Buffer akzeptiert, muss man Dich doch für den Unsinn abwatschen.
Bleiben wir also dabei:
  • Du kannst unter AOS3.x ohne P96 oder CGX keine 24Bit-BitMap anlegen
  • Du kannst keine 24Bit-BitMap von Hand (statt über AllocBitMap o.ä. OS-Funktion anlegen)
    Zitat:
    Mit AGA sehe ich irgendwie keinen Sinn in der Sache, das führt an der eigentlichen Fragestellung vorbei. Mike will ja eine 24 Bit Grafik auch in 24 Bit und nicht in einer runtergerechneten 8 Bit Version drucken.
    Was hat der AGA-Chipsatz mit dem Druckertreiber zu tun?
    Zitat:
    Ohne CybergraphX oder ein vergleichbares Grafiksystem sehe ich im Moment nicht, wie man das sonst systemkonform lösen könnte.
    Tataaaa!
    Sind wir am Ende doch einer Meinung...
    Bleibt nur noch die Frage, was Deine Behauptung, man könne eine TrueColor-BitMap von Hand anlegen, uns hier für einen Nutzen gebracht hat bzw. gebracht hätte, wenn sie richtig gewesen wäre.

    mfg

    --
    Good coders do not comment. What was hard to write should be hard to read too.

    [ - Antworten - Zitieren - Direktlink - ]

  • 03.04.2008, 18:59 Uhr

    Holger
    Posts: 8116
    Nutzer
    Zitat:
    Original von MaikG:
    Trotzdem kann ich auf einer nicht angezeigten 24 Bit BitMap Text
    schreiben und auch SetAPen verwenden. Das geht unter OS3-CGX, OS4
    und UAE-P96.

    Du weißt aber nicht, wo die Farben herkommen, und solange Du diesbezüglich keine Spezifikation hast, kannst Du Dich nicht darauf verlassen. Auch das Ausprobieren ist nicht akzeptabel, da Du ja nicht weißt, ob sich diese Farben nicht zwischendurch ändern. Vielleicht sind es ja bei fehlender ColorMap zufällig die des zuletzt benutzten Screens und ändern sich, je nachdem, welcher Screen gerade vorne ist oder welche Anwendung den letzten Zeichenbefehl ausgeführt hat. Würde Dir das gefallen?

    mfg

    --
    Good coders do not comment. What was hard to write should be hard to read too.

    [ - Antworten - Zitieren - Direktlink - ]

    03.04.2008, 19:08 Uhr

    kev
    Posts: 56
    Nutzer
    Wird bei p96 eine BitMap *ohne* Friend alloziert, so erhält die neue BitMap eine ColorMap bei der alle Farben 0 sind. Ausnahme ist die Hintergrundfarbe, die wird von der Workbench übernommen.
    Bei Verwendung eines "Friends" wird die Farbtabelle des Friends, resp. des Screens, übernommen. Daher Änderungen an der Bildschirmpalette führen auch zu Änderungen an der ColorMap der BitMap(s).
    Soweit ich weiß, gibt es nur unter p96/OS4 die Möglichkeit eine eigene ColorMap für die BitMap anzulegen.

    [ - Antworten - Zitieren - Direktlink - ]

    03.04.2008, 19:29 Uhr

    Der_Wanderer
    Posts: 1229
    Nutzer
    Da haben wir schon die erste Inkonsistenz. Auch der Pen 0 malt auf meinem System mit der Farbe schwarz, so wie alle Pens, wenn eine 24bit Bitmap keine Colormap hat.

    Wie man eine Colormap anlegt bzw. an eine Bitmap anhägnt weiss ich nicht.

    Als alternative gibt es aber in OS4, MOS, AROS den sog. "penless" Modus, bei dem man per SetRastPortAttrs() eine RGB Farbe definiert, die anschliessende von den Zeichenfunktion genutzt werden. Das wäre eigentlich die Lösung für MaikG. Allerdings geht das nicht unter OS3, es sei den AfAOS ist installiert. Aber selbst dann geht es nicht, weil es in Afa OS nur ein Hack ist und ohne Screen wird trotzdem schwarz gezeichnet.
    Dazu müsste man den Picasso Treiber ändern. Vielleicht wird das ja aber bald gemacht ;-)


    --
    Thilo Köhler, Author von:
    HD-Rec, Sweeper, Samplemanager, ArTKanoid, Monkeyscript, Toadies, AsteroidsTR, TuiTED, PosTED, TKPlayer, AudioConverter, ScreenCam, PerlinFX, MapEdit, TK AB3 Includes und viele mehr...
    Homepage: http://www.hd-rec.de


    [ - Antworten - Zitieren - Direktlink - ]

    03.04.2008, 21:35 Uhr

    MaikG
    Posts: 5172
    Nutzer
    >Du weißt aber nicht, wo die Farben herkommen,
    >und solange Du diesbezüglich keine Spezifikation hast,
    >kannst Du Dich nicht darauf verlassen.

    Schon, da es aber eine Colormap/Penzuordnung bei CGX Screens
    gibt welche immer gleich ist, es sei denn man spezifiziert
    SA_FullPalette&,TRUE& gehe davon aus das die Farben immer
    gleich sind. Also in der FastMem bitmap. P96 macht da wieder
    die ausnahme weil es nicht wirklich cgx kompatibel ist.


    >Wird bei p96 eine BitMap *ohne* Friend alloziert, so erhält die
    >neue BitMap eine ColorMap bei der alle Farben 0 sind.

    Ich habe friend nicht angegeben und trotzdem farben unter OS4 und
    UAE. Nur sind das nicht die selben wie bei CGX.

    [ - Antworten - Zitieren - Direktlink - ]

    04.04.2008, 10:09 Uhr

    Holger
    Posts: 8116
    Nutzer
    Zitat:
    Original von kev:
    Bei Verwendung eines "Friends" wird die Farbtabelle des Friends, resp. des Screens, übernommen. Daher Änderungen an der Bildschirmpalette führen auch zu Änderungen an der ColorMap der BitMap(s).

    Dann wird die ColorMap von beiden Screens genutzt? Was passiert, wenn der friend-Bildschirm geschlossen wird?

    Zitat:
    Original von Der_Wanderer:
    Wie man eine Colormap anlegt bzw. an eine Bitmap anhägnt weiss ich nicht.

    Na ja, das war ja auch das Fazit dieses Threads: ohne existierenden Screen geht's eben nicht. Bleibt also nur Screen öffnen, wie schon gesagt zur Not auch nicht-ziehbar hinter einen anderen geklebt, so dass man ihn definitiv niemals sehen kann, oder eine friend-BitMap anlegen, was auch einen existierenden Screen voraussetzt. Natürlich ist man im ersten Fall auf darstellbare BitMap-Formate beschränkt, bzw. hat im zweiten Fall gar keine Kontrolle über das Format...
    Zitat:
    Allerdings geht das nicht unter OS3, es sei den AfAOS ist installiert. Aber selbst dann geht es nicht, weil es in Afa OS nur ein Hack ist und ohne Screen wird trotzdem schwarz gezeichnet.
    Dazu müsste man den Picasso Treiber ändern. Vielleicht wird das ja aber bald gemacht ;-)

    Selbst wenn es ein AfA mit angepassten P96 oder was auch immer gibt, mit dem das geht, ist das nicht mehr AOS3.x. Da iirc Maiks Wunsch war, ein AOS3.x ohne Erweiterungen zu unterstützen, fällt das dann raus.

    Ansonsten würde ich, was das angeht, eher auf die Portierung der Portierung von Cairo nach Aros nach AOS3.x warten ;)

    mfg

    --
    Good coders do not comment. What was hard to write should be hard to read too.

    [ - Antworten - Zitieren - Direktlink - ]

    04.04.2008, 11:33 Uhr

    Der_Wanderer
    Posts: 1229
    Nutzer
    Auf einem nackten OS3.x geht es soweiso nicht mit OS Befehlen.

    Zusammenfasend würde ich MaikG folgendes empfehlen:

    Die "Bitmap" einfach als ARGB PixelArray (also simpler, formloser Speicherblock) mit AllocMem(höhe*breite*4byte,MEMF_ANY) allocieren und alles selbst hineinzeichnen.
    Erfordert zwar höheren Implementierungsaufwand, funktioniert
    dann aber garantiert überall, zumindest eben die Grafik zu erstellen.
    Wie man dann zum printer.device kommt, weiss ich nicht, aber
    wenn es Pixelarrays akzeptiert umso besser.
    Im schlimmsten Fall kann man mit WritePixelArray() das ganze in eine True Color Bitmap übertragen. Das malen im PixelArray hat den Vorteil, dass man das Pixelformat garantieren kann, was man bei einer Bitmap, die mit einem Screen verbunden ist, nicht machen kann. (nur mit einer Bitmap ohne Screen, aber auf die kann man ja nicht verlässlich mit OS Funktionen zeichnen).
    Erleichtert würde das ganze natürlich durch einen Port von Cairo oder zumindest mit ttengine.library für Text, da Text wohl am schwierigsten wäre, selbst zu implementieren.

    BTW; weis jemand den Status der Cairo Portierung? Würde mich auch brennend interessieren.

    --
    Thilo Köhler, Author von:
    HD-Rec, Sweeper, Samplemanager, ArTKanoid, Monkeyscript, Toadies, AsteroidsTR, TuiTED, PosTED, TKPlayer, AudioConverter, ScreenCam, PerlinFX, MapEdit, TK AB3 Includes und viele mehr...
    Homepage: http://www.hd-rec.de



    [ Dieser Beitrag wurde von Der_Wanderer am 04.04.2008 um 12:20 Uhr geändert. ]

    [ - Antworten - Zitieren - Direktlink - ]

    04.04.2008, 12:58 Uhr

    kev
    Posts: 56
    Nutzer
    @ Holger

    Die Farbtabelle wird zusammen mit der letzten BitMap, von der sie benutzt wird, gelöscht.

    [ - Antworten - Zitieren - Direktlink - ]

    04.04.2008, 16:23 Uhr

    Mad_Dog
    Posts: 1944
    Nutzer
    Ich habe den Bresenham mal entsprechend aufgebohrt.
    Aber irgendetwas ist noch faul, entweder in diesen Includes selbst oder in meinem Demoprogramm. Trotzdem hier mal mein Zwischenergebnis:
    c code:
    /*
     *  bresenham.h
     *
     *  Grafikfunktionen zum Zeichnen von Linien und Keisen mit Hilfe des
     *  Bresenham Algorithmus.
     *
     *  Autor: Norman Walter
     *  Datum: 30.3.2008
     *
     */
    
    #ifndef BRESENHAM_H
    #define BRESENHAM_H
    
    #include <exec/types.h>
    #include <cybergraphx/cybergraphics.h>
    
    #include <proto/exec.h>
    #include <clib/cybergraphics_protos.h>
    
    #define SGN(x) (x > 0) ? 1 : (x < 0) ? -1 : 0
    
    /*
     *  struct raster_bitmap
     *
     *  In dieser Struktur sind die Parameter für das Bitmap zusammengefasst.
     *  Nachdem mit Hilfe der Funktion AllocRasterBitmap eine Instanz dieser Struktur
     *  erzeugt wurde, zeigt der Zeiger *data auf den Speicherbereich, in dem das
     *  eigentliche Bitmap mit der Größe size Byte liegt.
     *
     *  Die Funktionen ClearRaster, setpixel, rasterLine und rasterCircle schreiben
     *  ihre Daten in diesen Speicherbereich. Der Zeiger *date kann anschließend
     *  mit Hilfe der Funktion WritePixelArray8 aus der graphics.library in einen
     *  RastPort geschrieben werden.
     *
     */
    struct raster_bitmap
    {
      unsigned int width;   // Breite des Bitmaps
      unsigned int height;  // Höhe des Bitmaps
      UBYTE Depth;		// Farbtiefe in Bit
      ULONG PixFmt;		// Das Pixelformat (RGB, ARGB...)
      UBYTE BytesPerPixel;  // Bytes pro Pixel
      ULONG BytesPerRow;	// Bytes pro Zeile des Bitmaps
      UBYTE color;          // Aktuelle Pen Nummer
      UBYTE Alpha;		// Alpha der Zeichenfarbe
      UBYTE Red;		// Rotanteil der Zeichenfarbe
      UBYTE Green;		// Grünanteil der Zeichenfarbe
      UBYTE Blue;		// Blauanteil der Zeichenfarbe
      ULONG size;           // Größe des bitmapy in Byte
      UBYTE *data;          // Bilddaten des Bitmaps
    };
    
    /*
     *  AllocRaster
     *
     *  Legt eine raster_bitmap-Struktur an und initialisiert diese
     *
     *  Eingabe:	 unsigned int width  - Breite des Bitmaps in Pixel
     *           	 unsigned int height - Höhe des Bitmaps in Pixel
     *
     *  Rückgabe:    ein Zeiger auf eine raster_bitmap Struktur
     *
     */
    struct raster_bitmap * AllocRasterBitmap(unsigned int width, unsigned int height, ULONG PixFmt);
    
    /*
     *  FreeRasterBitmap
     *
     *  Gibt den Speicher einer raster_bitmap Struktur wieder frei.
     *
     *  Einganbe:	struct raster_bitmap *bm - Zeiger auf raster_bitmap Struktur
     *
     */
    void FreeRasterBitmap(struct raster_bitmap *bm);
    
    /*
     *  rasterLine
     *
     *  Zeichnet eine Linie von xstart, ystart nach xend, yend in der angegebenen
     *  raster_bitmap Struktur bm.
     *
     *  Eingabe:	struct raster_bitmap *bm - Zeiger auf raster_bitmal Struktur
     *		int xstart,ystart - Koordinaten des Anfangspunkts der Linie
     *              int xend, yend - Koordinaten des Endpunkts der Linie
     *
     */
    void rasterLine(struct raster_bitmap *bm,int xstart,int ystart,int xend,int yend);
    
    /*
     *  ClearRaster
     *
     *  Löscht den Inhalt des raster_bitmap bm mit der aktuellen Farbe.
     *
     *  Eingabe:	struct raster_bitmap *bm - Zeiger auf raster_bitmal Struktur
     *
     */
    void ClearRaster(struct raster_bitmap *bm);
    
    /*
     *  SetColor
     *
     *  Stellt die Zeichenfarbe des raster_bitmap für Zeichenoperationen ein.
     *
     *  Eingabe:	struct raster_bitmap *bm - Zeiger auf raster_bitmal Struktur
     *		UBYTE col - Pen Nr.
     *
     */
    void SetColor(struct raster_bitmap *bm, UBYTE col);
    
    void SetColorRGBA(struct raster_bitmap *bm, UBYTE r, UBYTE g, UBYTE b, UBYTE a);
    
    /*
     *  setpixel
     *
     *  Setzt den Bildpunkt x,y in der Farbe des eingestellten Pens.
     *
     *  Eingabe:	struct raster_bitmap *bm - Zeiger auf raster_bitmal Struktur
     *		unsigned int x,y - Koordinaten des Bildpunkts
     *
     */
    void setpixel(struct raster_bitmap *bm, unsigned int  x, unsigned int y);
    
    /*
     *  rasterCircle
     *
     *  Zeichnet einen Kreis mit Radius radius um den Kreismittelpunkt x0,y0.
     *
     *  Eingabe:	struct raster_bitmap *bm - Zeiger auf raster_bitmal Struktur
     *		int y0,y0 - Koordinaten des Kreismittelpunks.
     *              int radius - Radius des Kreises
     *
     */
    void rasterCircle(struct raster_bitmap *bm, int x0, int y0, int radius);
    
    #endif

    c code:
    /*
     *  bresenham.c
     *
     *  Autor: Norman Walter
     *  Datum: 30.3.2008
     *
     */
    
    #ifndef BRESENHAM_H
    #include "bresenham.h"
    #endif
    
    struct raster_bitmap * AllocRasterBitmap(unsigned int width, unsigned int height, ULONG PixFmt)
    {
       struct raster_bitmap *bm;
    
       bm = (struct raster_bitmap *)AllocVec(sizeof(struct raster_bitmap),NULL);
    
       bm->width = width;
       bm->height = height;
       bm->PixFmt = PixFmt;
    
       switch (PixFmt)
       {
    	case PIXFMT_RGB24:
    	case PIXFMT_BGR24:
    		bm->Depth = 24;
    		bm->BytesPerPixel = 3;
    	break;
    
    	case PIXFMT_ARGB32:
    	case PIXFMT_BGRA32:
    	case PIXFMT_RGBA32:
    		bm->Depth = 32;
    		bm->BytesPerPixel = 4;
    	break;
    
    	default:
    		bm->Depth = 8;
    		bm->BytesPerPixel = 1;		
       }
    
       bm->BytesPerRow = bm->width * bm->BytesPerPixel;
       bm->size = bm->BytesPerRow * bm->height;
       bm->color = 1;
    
       // RGBA-Komponenten für die Zeichenfarbe setzen
       bm->Alpha = 0xFF;
       bm->Red = 0xFF;
       bm->Green = 0xFF;
       bm->Blue = 0xFF;
    
       bm->data = (UBYTE *)AllocVec(bm->size, MEMF_CLEAR);
    
       return bm;
    }
    
    void FreeRasterBitmap(struct raster_bitmap *bm)
    {
       FreeVec(bm->data);
       FreeVec(bm);
    }
    
    void ClearRaster(struct raster_bitmap *bm)
    {
       ULONG x,y;
       
       for (x=0; x < bm->width; x++)
       {
    	for (y=0; y < bm->height; y++)
    	{
    		setpixel(bm,x,y);
    	}
       }
    
    }
    
    void SetColor(struct raster_bitmap *bm, UBYTE col)
    {
        bm->color = col;
    }
    
    void SetColorRGBA(struct raster_bitmap *bm, UBYTE r, UBYTE g, UBYTE b, UBYTE a)
    {
        bm->Red = r;
        bm->Green = g;
        bm->Blue = b;
        bm->Alpha = a;
    }
    
    void setpixel(struct raster_bitmap *bm, unsigned int x, unsigned int y)
    {
        ULONG pos = bm->width * y + x;
    
        if (x >= 0 && x < bm->width && y >= 0 && y < bm->height)
        {
    	switch (bm->PixFmt)
    	{
    		case PIXFMT_RGB24:
    			bm->data[pos] = bm->Red;
    			bm->data[pos + 1] = bm->Green;
    			bm->data[pos + 2] = bm->Blue;
    		break;
    
    		case PIXFMT_BGR24:
    			bm->data[pos] = bm->Blue;
    			bm->data[pos + 1] = bm->Green;
    			bm->data[pos + 2] = bm->Red;
    		break;
    
    		case PIXFMT_RGBA32:
    			bm->data[pos] = bm->Red;
    			bm->data[pos + 1] = bm->Green;
    			bm->data[pos + 2] = bm->Blue;
    			bm->data[pos + 3] = bm->Alpha;
    		break;
    
    		case PIXFMT_ARGB32:
    			bm->data[pos] = bm->Alpha;
    			bm->data[pos + 1] = bm->Red;
    			bm->data[pos + 2] = bm->Green;
    			bm->data[pos + 3] = bm->Blue;
    		break;
    
    		case PIXFMT_BGRA32:
    			bm->data[pos] = bm->Blue;
    			bm->data[pos + 1] = bm->Green;
    			bm->data[pos + 2] = bm->Red;
    			bm->data[pos + 3] = bm->Alpha;
    		break;
    
    		default:
    			bm->data[pos] = bm->color;
    	}
    
        }
    }
    
    void rasterLine(struct raster_bitmap *bm,int xstart,int ystart,int xend,int yend)
    {
       int x, y, t, dx, dy, incx, incy, pdx, pdy, ddx, ddy, es, el, err;
     
    /* Entfernung in beiden Dimensionen berechnen */
       dx = xend - xstart;
       dy = yend - ystart;
     
    /* Vorzeichen des Inkrements bestimmen */
       incx = SGN(dx);
       incy = SGN(dy);
       if(dx<0) dx = -dx;
       if(dy<0) dy = -dy;
     
    /* feststellen, welche Entfernung größer ist */
       if (dx>dy)
       {
          /* x ist schnelle Richtung */
          pdx=incx; pdy=0;    /* pd. ist Parallelschritt */
          ddx=incx; ddy=incy; /* dd. ist Diagonalschritt */
          es =dy;   el =dx;   /* Fehlerschritte schnell, langsam */
       }
       else
       {
          /* y ist schnelle Richtung */
          pdx=0;    pdy=incy; /* pd. ist Parallelschritt */
          ddx=incx; ddy=incy; /* dd. ist Diagonalschritt */
          es =dx;   el =dy;   /* Fehlerschritte schnell, langsam */
       }
     
    /* Initialisierungen vor Schleifenbeginn */
       x = xstart;
       y = ystart;
       err = el/2;
       setpixel(bm,x,y);
     
    /* Pixel berechnen */
       for(t=0; t<el; ++t) /* t zaehlt die Pixel, el ist auch Anzahl */
       {
          /* Aktualisierung Fehlerterm */
          err -= es; 
          if(err<0)
          {
              /* Fehlerterm wieder positiv (>=0) machen */
              err += el;
              /* Schritt in langsame Richtung, Diagonalschritt */
              x += ddx;
              y += ddy;
          }
          else
          {
              /* Schritt in schnelle Richtung, Parallelschritt */
              x += pdx;
              y += pdy;
          }
    
          setpixel(bm,x,y);
       }
    } /* gbham() */
    
    void rasterCircle(struct raster_bitmap *bm, int x0, int y0, int radius)
    {
        int f = 1 - radius;
        int ddF_x = 0;
        int ddF_y = -2 * radius;
        int x = 0;
        int y = radius;
     
        setpixel(bm, x0, y0 + radius);
        setpixel(bm, x0, y0 - radius);
        setpixel(bm, x0 + radius, y0);
        setpixel(bm, x0 - radius, y0);
     
        while(x < y) 
        {
          if(f >= 0) 
          {
            y--;
            ddF_y += 2;
            f += ddF_y;
          }
          x++;
          ddF_x += 2;
          f += ddF_x + 1;
     
          setpixel(bm, x0 + x, y0 + y);
          setpixel(bm, x0 - x, y0 + y);
          setpixel(bm, x0 + x, y0 - y);
          setpixel(bm, x0 - x, y0 - y);
          setpixel(bm, x0 + y, y0 + x);
          setpixel(bm, x0 - y, y0 + x);
          setpixel(bm, x0 + y, y0 - x);
          setpixel(bm, x0 - y, y0 - x);
        }
    }

    --
    http://www.norman-interactive.com

    [ - Antworten - Zitieren - Direktlink - ]

    04.04.2008, 17:21 Uhr

    Der_Wanderer
    Posts: 1229
    Nutzer
    code:
    void setpixel(struct raster_bitmap *bm, unsigned int x, unsigned int y)
    {
        ULONG pos = bm->width * y + x;
    ...


    muss heissen:

    code:
    void setpixel(struct raster_bitmap *bm, unsigned int x, unsigned int y)
    {
        ULONG pos = (bm->width * y + x) * bm->Depth/8;
    ...

    --
    Thilo Köhler, Author von:
    HD-Rec, Sweeper, Samplemanager, ArTKanoid, Monkeyscript, Toadies, AsteroidsTR, TuiTED, PosTED, TKPlayer, AudioConverter, ScreenCam, PerlinFX, MapEdit, TK AB3 Includes und viele mehr...
    Homepage: http://www.hd-rec.de


    [ - Antworten - Zitieren - Direktlink - ]

    04.04.2008, 18:21 Uhr

    MaikG
    Posts: 5172
    Nutzer
    >Die "Bitmap" einfach als ARGB PixelArray (also simpler, formloser
    >Speicherblock) mit AllocMem(höhe*breite*4byte,MEMF_ANY) allocieren
    >und alles selbst hineinzeichnen.

    Grade bei P96 oder AGA wäre das wohl das beste.

    Ich müsste dann aber auch irgendwie die Bitmap flags eintragen,
    weil ich muss das ja Blitten(vorschau).

    Dann hab ich noch ein anderes Problem.
    Ich hab jetzt ein paar farbreduzierungen geschrieben, um auch
    eine vorschau auf AGA zu ermöglichen.
    Nun bekomme ich die Workbenchtiefe nicht raus. 1-8 Bit geht aber
    für alles darüber wird 8 Bit angegeben.
    So kann ich nicht unterscheiden wann welche Funktion verwendet
    werden muss.

    Datatypes sind auch so eine Sache, wenn man 8 Bit oder weniger
    hat muss die Palette ja dem Screen angepasst werden.
    Kein Screen -> keine Farbneuberechnung.

    Von Drucken noch gar nicht zu reden, sofern die Workbench
    in PAL ist (auch wenn cgx vorhanden) kommt aus dem Drucker
    ein schwarzes Bild. Da kann das printer.device scheinbar
    nichtmehr feststellen das es sich um 24 Bit Daten handelt.

    [ - Antworten - Zitieren - Direktlink - ]

    04.04.2008, 19:20 Uhr

    Der_Wanderer
    Posts: 1229
    Nutzer
    An alle Maiks, Reths, und Ralfs:
    (Entschuldingung, ich bin gerade etwas cholerisch drauf, aber manche stellen sich hier an, dass sogar einem Holger beinahe der Hut hochgeht)

    ==============================================================
    = Bitte die Threads auch genau lesen. Programmieren ist eine
    = Angelegenheit, bei der man alles sehr genau nehmen muss, und so
    = sollte man auch die Antworten lesen, die man hier bekommt.
    ==============================================================

    Zitat:
    Ich müsste dann aber auch irgendwie die Bitmap flags eintragen,
    weil ich muss das ja Blitten(vorschau).

    Vorschau machst du mit WritePixelArray, falls der User einen Hi/True Color Screen auf hat. Anderen falls musst du selbst re-mappen, dafür gibts keine OS Routine.
    Das ist aber auch nicht so furchtbar schwer. Da würde ich einfach die Colormap des Screens auslesen und locken, die Pen Nummern in ein 8-bit Array schreiben und anschliessend mit WriteChunkyPixels ausgeben.
    Nicht vergessen nach der anzeige die Pens wieder freizugeben.

    Zitat:
    Dann hab ich noch ein anderes Problem.
    Ich hab jetzt ein paar farbreduzierungen geschrieben, um auch
    eine vorschau auf AGA zu ermöglichen.
    Nun bekomme ich die Workbenchtiefe nicht raus. 1-8 Bit geht aber
    für alles darüber wird 8 Bit angegeben.
    So kann ich nicht unterscheiden wann welche Funktion verwendet
    werden muss.

    Wenn du jetzt erzählst, du malst Pen-basierend, dann macht die ganze Diskussion von wegen True/Hi Color hier gar keinen Sinn.
    Die Workbenchtiefe herausfinden solltest du GetBitMapAttr(*bitmap,#BMA_DEPTH) benutzen, wie so ziemlich bei allen Attributen, die du von einer Bitmap wissen willst.

    Zitat:
    Datatypes sind auch so eine Sache, wenn man 8 Bit oder weniger
    hat muss die Palette ja dem Screen angepasst werden.
    Kein Screen -> keine Farbneuberechnung.

    Kein Screen -> warum zum Teufel eine Farbneuberechnung machen?

    Ich dachte, du willst ein beleibiges Bild erstellen und drucken, unabhängig von der gerade verwendeten Farbtiefe der Workbench und den Fähigkeiten der Grafikkarte.

    Bitte definiere doch erstmal, was du überhaupt machen willst, mit welchen Einschränkungen du leben kannst und mit welchen nicht.

    --
    Thilo Köhler, Author von:
    HD-Rec, Sweeper, Samplemanager, ArTKanoid, Monkeyscript, Toadies, AsteroidsTR, TuiTED, PosTED, TKPlayer, AudioConverter, ScreenCam, PerlinFX, MapEdit, TK AB3 Includes und viele mehr...
    Homepage: http://www.hd-rec.de


    [ - Antworten - Zitieren - Direktlink - ]

    04.04.2008, 20:01 Uhr

    MaikG
    Posts: 5172
    Nutzer
    >Vorschau machst du mit WritePixelArray, falls der User einen Hi/True
    >Color Screen auf hat.

    Hab ich per Blitbitmap auf Hi/Truecolor, weil ich eh noch scalieren muss.


    >Anderen falls musst du selbst re-mappen, dafür gibts keine OS Routine.

    Ja, hab ich. Momentan mit WritePixel.


    >Wenn du jetzt erzählst, du malst Pen-basierend, dann macht die ganze
    >Diskussion von wegen True/Hi Color hier gar keinen Sinn.

    Pen Basierend male ich nur für die Preview auf der Workbench unter
    8 Bit.
    Den Text mache ich auf der nicht sichtbaren Bitmap mit Pens,
    da dort nicht tausende farben nötig sind.
    Alles andere mit writepixel. Datatypes per Blitbitmap, ausser
    für 8 Bit Bilder geht das nicht.


    >Die Workbenchtiefe herausfinden solltest du GetBitMapAttr(*bitmap,
    >BMA_DEPTH) benutzen, wie so ziemlich bei allen Attributen, die du
    >von einer Bitmap wissen willst.

    Danke.


    Zitat:
    Datatypes sind auch so eine Sache, wenn man 8 Bit oder weniger
    hat muss die Palette ja dem Screen angepasst werden.
    Kein Screen -> keine Farbneuberechnung.

    >Kein Screen -> warum zum Teufel eine Farbneuberechnung machen?

    Das bild im Speicher hat 24 Bit, die Workbench 8 Bit oder weniger.
    Um das Bild darzustellen muss es auf die Farben der 8 Bit Workbench
    umgerechnet werden.

    >Ich dachte, du willst ein beleibiges Bild erstellen und drucken,
    >unabhängig von der gerade verwendeten Farbtiefe der Workbench und
    >den Fähigkeiten der Grafikkarte.

    Ja, das wäre Optimal. Bissher scheint das 24 Bit drucken mit
    meinen derzeitigen kenntnissen unter AGA nicht möglich.

    [ - Antworten - Zitieren - Direktlink - ]

    04.04.2008, 23:14 Uhr

    NoImag
    Posts: 1050
    Nutzer
    Zitat:
    Original von MaikG:
    Bissher scheint das 24 Bit drucken mit
    meinen derzeitigen kenntnissen unter AGA nicht möglich.


    Aus dem NDK 3.5 (also ab printer.device V44):
    Zitat:
    Das Drucken von Graphik erlaubt nun die Angabe von RTG Bitmaps. Dabei werden
    alle RTG Systeme untertützt, die das CyberGFX API cybergraphics.library
    unerstützen. Wenn Die Applikation bislang die Druckausgabe nur mit einer
    planaren Bitmap der graphics.library aufgebaut hat oder eine Bitmap eines
    dieser RTG Systeme auf 12 oder 8 Bit Farbtiefe konvertiert hat, so kann sie
    jetzt direkt die RTG Bitmaps ausgeben. Eine Colormap muß für eine High- (16 bit)
    oder Truecolor (24 oder 32 Bit) Bitmap nicht angegeben werden.


    Dies gilt, wenn Du eine echte Bitmap drucken möchtest.

    Außerdem:
    Zitat:
    Der neue Befehl PRD_DUMPRPORTTAGS erweitert den alten Befehl PRD_DUMPRPORT
    um eine Tagliste. Derzeit sind 3 Tags definiert und implementiert:

    DRPA_SouceHook: Der Wert für dieses Tags muß ein Pointer auf eine struct Hook
    sein. Dieser Hook wird aufgerufen, um die Quelldaten zu lesen. Der Hook
    erhält als object NULL und als message einen Zeiger auf struct DRPSourceMsg.
    Diese Struktur enthält die Position und Größe des Arrays, das ausgelesen
    werden soll, sowie einen Zeiger auf ein Feld von ULONGs, in die die Daten
    geschrieben werden. Dieses Feld hat genau die Größe Breite*Höhe, wie sie
    in der message stehen. Jedes Pixel wird als ein ULONG mit der Form
    0x00RRGGBB eingetragen.

    Typischerweise ist die Höhe für normalen Druck und die Breite für Querdruck
    jeweils 1. Ein Programm kann für diesen Fall spezielle Optimierungen
    verwenden, aber muß den allgemeinen Fall auch unterstützen.

    Benutzt man das Tag DRPA_SourceHook so braucht weder ein RastPort noch eine
    Colormap angegeben werden.


    Dies kannst Du benutzen, wenn Du ein ARGB-Array drucken möchtest.

    Tschüß



    [ - Antworten - Zitieren - Direktlink - ]

    05.04.2008, 00:09 Uhr

    MaikG
    Posts: 5172
    Nutzer
    >Dies gilt, wenn Du eine echte Bitmap drucken möchtest.


    Hab ich zwar auch gelesen, nur finde ich keine Funktion der
    ich eine Bitmap übergeben könnte.



    > Benutzt man das Tag DRPA_SourceHook so braucht weder ein RastPort noch eine
    > Colormap angegeben werden.

    >Dies kannst Du benutzen, wenn Du ein ARGB-Array drucken möchtest.

    Ich weiss nicht was ein Hook ist *duck und wegrenn

    ARGB-Arrays bekomme ich nur Zeilenweise hin, mehr als eine
    Zeile endete immer in grafikmüll.

    [ - Antworten - Zitieren - Direktlink - ]

    05.04.2008, 00:32 Uhr

    Mad_Dog
    Posts: 1944
    Nutzer
    Zitat:
    Original von Der_Wanderer:
    muss heissen:

    code:
    void setpixel(struct raster_bitmap *bm, unsigned int x, unsigned int y)
    {
        ULONG pos = (bm->width * y + x) * bm->Depth/8;
    ...



    Danke!

    Die Division kann man sich aber sparen, da im raster_bitmap schon eine Komponente existiert, die die Bytes pro Pixel hält:
    c code:
    void setpixel(struct raster_bitmap *bm, unsigned int x, unsigned int y)
    {
        ULONG pos = (bm->width * y + x) * bm->BytesPerPixel;
    ...



    --
    http://www.norman-interactive.com

    [ Dieser Beitrag wurde von Mad_Dog am 05.04.2008 um 00:35 Uhr geändert. ]

    [ - Antworten - Zitieren - Direktlink - ]

    05.04.2008, 00:38 Uhr

    Mad_Dog
    Posts: 1944
    Nutzer
    Zitat:
    Original von MaikG:
    ARGB-Arrays bekomme ich nur Zeilenweise hin, mehr als eine
    Zeile endete immer in grafikmüll.


    Dann schau Dir den Code an, denn ich letztens gepostet habe. Der macht genau das, was Du haben willst.
    --
    http://www.norman-interactive.com

    [ - Antworten - Zitieren - Direktlink - ]

    05.04.2008, 06:39 Uhr

    Mad_Dog
    Posts: 1944
    Nutzer
    Ich hab jetzt mal den Bresenham in der 24 Bit Version samt Demoprogramm in ein Archiv gepackt: bresenham24.lha

    Hier mal der Ausschnitt aus dem Code, wo das Pixel-Array in den RastPort des Fensters mittels WritePixelArray() eingefügt wird.
    c code:
    ...
    
    struct raster_bitmap *bm24;
    
    ...
    
    bm24 = AllocRasterBitmap(BMWIDTH,BMHEIGHT,PIXFMT_RGB24);
    
    ... Zeichenoperationen hier einfügen
    
    WritePixelArray(bm24->data, 0, 0,
    		bm24->BytesPerRow,
    		win->RPort,
    		win->BorderLeft,
    		win->BorderTop,
    		BMWIDTH,BMHEIGHT,
    		RECTFMT_RGB);


    Hier ein Screenshot aus dem Demoprogramm:

    Bild: http://w3.norman-interactive.com/files/bresenham.png

    Wie man sieht, funktioniert das ganz gut.

    P.S.: Die Polygone, die auf dem Bild zu sehen sind, werden nicht mittels AmigaOS oder CybergraphX Funktionen gezeichnet, sondern mit Hilfe der Funktion rasterLine() aus meinem Include bresenham.c.

    --
    http://www.norman-interactive.com

    [ Dieser Beitrag wurde von Mad_Dog am 05.04.2008 um 12:03 Uhr geändert. ]

    [ - Antworten - Zitieren - Direktlink - ]

    05.04.2008, 11:38 Uhr

    MaikG
    Posts: 5172
    Nutzer
    >Hier mal der Ausschnitt aus de, Code, wo das Pixel-Array in den
    >RastPort des Fensters mittels WritePixelArray() eingefügt wird.


    Ah, danke. Jetzt weiss ich was falsch war, ich hab PixelsPerRow
    statt BytesPerRow angegeben.

    [ - Antworten - Zitieren - Direktlink - ]

    05.04.2008, 11:54 Uhr

    Mad_Dog
    Posts: 1944
    Nutzer
    Zitat:
    Original von MaikG:
    >Hier mal der Ausschnitt aus de, Code, wo das Pixel-Array in den
    >RastPort des Fensters mittels WritePixelArray() eingefügt wird.


    Ah, danke. Jetzt weiss ich was falsch war, ich hab PixelsPerRow
    statt BytesPerRow angegeben.


    Bedenke auch, dass solch ein Pixel-Array ja nach Farbtiefe unterschiedliche Bytes per Row hat:
    c code:
    switch (PixFmt)
       {
    	case PIXFMT_RGB24:
    	case PIXFMT_BGR24:
    		bm->Depth = 24;
    		bm->BytesPerPixel = 3;
    	break;
    
    	case PIXFMT_ARGB32:
    	case PIXFMT_BGRA32:
    	case PIXFMT_RGBA32:
    		bm->Depth = 32;
    		bm->BytesPerPixel = 4;
    	break;
    
    	default:
    		bm->Depth = 8;
    		bm->BytesPerPixel = 1;		
       }


    Also: Bei 24 Bit Farbtiefe 3 Bytes, bei 32 Bit 4 Bytes pro Pixel.
    Folglich ergibt sich Bytes per Row aus Bytes per Pixel * Breite des Bitmaps (für Holger: Die Breite, die das Bild hat, welches durch das Pixel Array dargestellt wird).
    c code:
    bm->BytesPerRow = bm->width * bm->BytesPerPixel;


    --
    http://www.norman-interactive.com

    [ Dieser Beitrag wurde von Mad_Dog am 05.04.2008 um 12:01 Uhr geändert. ]

    [ - Antworten - Zitieren - Direktlink - ]

    05.04.2008, 21:56 Uhr

    MaikG
    Posts: 5172
    Nutzer
    Also ich wollte das mit der neuen OS3.5 Funktionalität mal
    probieren. Passiert aber nichts, die Function wird nicht
    aufgerufen.

    code:
    '$INCLUDE dos.bh
    '$INCLUDE exec.bh
    '$INCLUDE graphics.bh
    '$INCLUDE intuition.bh
    '$INCLUDE Printer.bc
    '$INCLUDE utility.bh
    
    LIBRARY OPEN "dos.library",37
    LIBRARY OPEN "exec.library",37
    LIBRARY OPEN "graphics.library",39
    LIBRARY OPEN "intuition.library",37
    LIBRARY OPEN "utility.library"
    
    DEFINT a-z
    
    REM $VARCHECKS
    
    DIM SHARED temptag&(20)
    DIM SHARED h&(Hook_sizeof%2)
    
    DECLARE FUNCTION Readpixels&
    
    
    FUNCTION Readpixels&(DRPMsg2&)
    STATIC x&,y&, myWidht&, myHeight&, r&,buffer&
    STATIC DRPMsg&
     PRINT "reached"
     DRPMsg&=PEEKL(DRPMsg2&)
     x&=PEEKL(DRPMsg&+DRP_x%)
     y&=PEEKL(DRPMsg&+DRP_y%)
     myWidht&=PEEKL(DRPMsg&+DRP_width%)
     myHeight&=PEEKL(DRPMsg&+DRP_height%)
     buffer&=PEEKL(DRPMsg&+DRP_buf%)
     r&=y&<<16
      FOR x&=0 TO myWidht&-1
       POKEL buffer&, (r& OR x&) ^&h00ffffff
      NEXT x&
    Readpixels&=TRUE&
    END FUNCTION
    
    
    
    FUNCTION dumpRP%(BYVAL rp&, BYVAL cm&, BYVAL modeID&, x%,y%,x1%,y1%)
    	STATIC pmp&, pio&, sigfr&, r%
    
    	dumpRP% = -1
    
    	pmp& = CreateMsgPort&()
    		pio& = CreateIORequest&(pmp&, IODRPTagsReq_sizeof%)
    			r% = OpenDevice&(SADD("printer.device" + CHR$(0)), 0, pio&, 0)
    			IF r% = 0 THEN
    				POKEW pio& + IODRPReqio_Command%, PRD_DUMPRPORTTAGS&
    				POKEL pio& + io_RastPort%, NULL&
    				POKEL pio& + io_ColorMap%, NULL&
    				POKEL pio& + io_Modes%,    NULL&
    				POKEW pio& + io_SrcX%, 0
    				POKEW pio& + io_SrcY%, 0
    				POKEW pio& + io_SrcWidth%, 256
    				POKEW pio& + io_SrcHeight%, 256
    				POKEL pio& + io_DestCols%, 256
    				POKEL pio& + io_DestRows%, 256
    				POKEW pio& + io_Special%, SPECIAL_MILROWS& OR SPECIAL_MILCOLS&
    				POKEL pio& + io_Taglist%, VARPTR(temptag&(0))
    
    				SendIO pio&
    
    				sigfr& = xWait&((1& << PEEKB(pmp& + mp_SigBit)))
    
    				IF sigfr& AND (1& << PEEKB(pmp& + mp_SigBit%)) THEN
    					' printer is either ready or an error has occurred
    
    					WHILE GetMsg&(pmp&)
    					WEND
    				END IF
    
    				dumpRP% = PEEKB(pio& + IODRPReqio_Error%)
    
    				CloseDevice pio&
    			ELSE
    				dumpRP% = r%
    			END IF
    			DeleteIORequest& pio&
    			DeleteMsgPort pmp&
    END FUNCTION
    
    
    
    INITHOOK VARPTR(h&(0)), VARPTRS(Readpixels&)
    
    TAGLIST VARPTR(temptag&(0)), _
     DRPA_SourceHook&, VARPTR(h&(0)) ,_
     DRPA_AspectX&, 1, _
     DRPA_AspectY&, 1, _
    TAG_END&
    
    
    junk&=dumpRP%(rp&, cm&, modeID&, x%,y%,x1%,y1%)




    Vielleicht hab ich auch die Include ergänzungen falsch gemacht

    code:
    ' >=OS3.5 stuff
    CONST PRD_RESETPREFS& = &hD&
    CONST PRD_LOADPREFS&  = &hE&
    CONST PRD_USEPREFS& =   &hF&
    CONST PRD_SAVEPREFS&=&h10&
    CONST PRD_READPREFS&=&h11&
    CONST PRD_WRITEPREFS&=&h12&
    CONST PRD_EDITPREFS&=&h13&
    CONST PRD_SETERRHOOK&=&h14&
    CONST PRD_DUMPRPORTTAGS&=&h15&
    
    
    'IODRPTagsReq fields 
    CONST io_Taglist% =62
    CONST IODRPTagsReq_sizeof%=66
    
    
    'DRPSourceMsg fields 
    CONST DRP_x% = 0
    CONST DRP_y% = 4
    CONST DRP_width% = 8
    CONST DRP_height% = 16
    CONST DRP_buf% = 20
    CONST DRPSourceMsg_sizeof%=78 'fill this buffer with 0x00RRGGBB pixels
    
    CONST DRPA_Dummy&=&h80060000
    
    CONST DRPA_ICCProfile&=&h80060001&
    CONST DRPA_ICCName&=&h80060002&
    CONST DRPA_NoColCorrect&=&h80060003&
    CONST DRPA_SourceHook&=&h80060004& 
    CONST DRPA_AspectX&=&h80060005& 
    CONST DRPA_AspectY&=&h80060006&


    [ - Antworten - Zitieren - Direktlink - ]


    1 2 -3- 4 5 [ - Beitrag schreiben - ]


    amiga-news.de Forum > Programmierung > Kreis Zeichnen ohne graphics.library [ - Suche - Neue Beiträge - Registrieren - Login - ]


    .
    Impressum | Datenschutzerklärung | Netiquette | Werbung | Kontakt
    Copyright © 1998-2024 by amiga-news.de - alle Rechte vorbehalten.
    .