7.11 Rasterfunktionen

void v_get_pixel (int16_t handle, int16_t x, int16_t y,
                  int16_t *pel, int16_t *index)
{
   ptsin[0]  = x;
   ptsin[1]  = y;
   contrl[0] = 105;
   contrl[1] = 1;
   contrl[3] = 0;
   contrl[6] = handle;

   vdi ();

   *pel   = intout[0];
   *index = intout[1];
}

int32_t vq_hilite_color( int16_t handle,
                         COLOR_ENTRY *hilite_color )
{
   contrl[0] = 209;
   contrl[1] = 0;
   contrl[3] = 0;
   contrl[5] = 0;
   contrl[6] = handle;

   vdi ();

   hilite_color = intout[2..5];

   return ( intout[0..1] );
}

int32_t vq_max_color( int16_t handle, COLOR_ENTRY *max_color )
{
   contrl[0] = 209;
   contrl[1] = 0;
   contrl[3] = 0;
   contrl[5] = 2;
   contrl[6] = handle;

   vdi ();

   max_color = intout[2..5];
   return ( intout[0..1] );
}

int32_t vq_min_color( int16_t handle, COLOR_ENTRY *min_color )
{
   contrl[0] = 209;
   contrl[1] = 0;
   contrl[3] = 0;
   contrl[5] = 1;
   contrl[6] = handle;

   vdi ();

   min_color = intout[2..5];
   return ( intout[0..1] );
}

int32_t vq_weight_color( int16_t handle,
                         COLOR_ENTRY *weight_color )
{
   contrl[0] = 209;
   contrl[1] = 0;
   contrl[3] = 0;
   contrl[5] = 3;
   contrl[6] = handle;

   vdi ();

   weight_color = intout[2..5];
   return ( intout[0..1] );
}

int16_t vr_clip_rects32_by_dst ( int16_t handle,
                                 RECT32 *dst_clip_rect,
                                 RECT32 *src_rect,
                                 RECT16 *dst_rect,
                                 RECT32 *clipped_src_rect,
                                 RECT32 *clipped_dst_rect )
{
   ptsin[0..7] = dst_clip_rect;
   ptsin[8..15] = src_rect;
   ptsin[16..23] = dst_rect;

   contrl[0] = 171;
   contrl[1] = 12;
   contrl[3] = 0;
   contrl[5] = 2;
   contrl[6] = handle;

   vdi ();

   clipped_src_rect = ptsout[0..7];
   clipped_dst_rect = ptsout[8..15];

   return ( intout[0] );
}

int16_t vr_clip_rects32_by_src ( int16_t handle,
                                 RECT32 *src_clip_rect,
                                 RECT32 *src_rect,
                                 RECT16 *dst_rect,
                                 RECT32 *clipped_src_rect,
                                 RECT32 *clipped_dst_rect )
{
   ptsin[0..7] = src_clip_rect;
   ptsin[8..15] = src_rect;
   ptsin[16..23] = dst_rect;

   contrl[0] = 171;
   contrl[1] = 12;
   contrl[3] = 0;
   contrl[5] = 3;
   contrl[6] = handle;

   vdi ();

   clipped_src_rect = ptsout[0..7];
   clipped_dst_rect = ptsout[8..15];

   return ( intout[0] );
}

int16_t vr_clip_rects_by_dst ( int16_t handle,
                               RECT16 *dst_clip_rect,
                               RECT16 *src_rect,
                               RECT16 *dst_rect,
                               RECT16 *clipped_src_rect,
                               RECT16 *clipped_dst_rect )
{
   ptsin[0..3] = dst_clip_rect;
   ptsin[4..7] = src_rect;
   ptsin[8..11] = dst_rect;

   contrl[0] = 171;
   contrl[1] = 6;
   contrl[3] = 0;
   contrl[5] = 0;
   contrl[6] = handle;

   vdi ();

   clipped_src_rect = ptsout[0..3];
   clipped_dst_rect = ptsout[4..7];

   return ( intout[0] );
}

int16_t vr_clip_rects_by_src ( int16_t handle,
                               RECT16 *src_clip_rect,
                               RECT16 *src_rect,
                               RECT16 *dst_rect,
                               RECT16 *clipped_src_rect,
                               RECT16 *clipped_dst_rect )
{
   ptsin[0..3] = src_clip_rect;
   ptsin[4..7] = src_rect;
   ptsin[8..11] = dst_rect;

   contrl[0] = 171;
   contrl[1] = 6;
   contrl[3] = 0;
   contrl[5] = 1;
   contrl[6] = handle;

   vdi ();

   clipped_src_rect = ptsout[0..3];
   clipped_dst_rect = ptsout[4..7];

   return ( intout[0] );
}

/* logische Transfermodi */
/* dst = src; */
#define T_LOGIC_COPY         0

/* dst = src OR dst; */
#define T_LOGIC_OR           1

/* dst = src XOR dst; */
#define T_LOGIC_XOR          2

/* dst = src AND dst; */
#define T_LOGIC_AND          3

/* dst = ( NOT src ); */
#define T_LOGIC_NOT_COPY     4

/* dst = ( NOT src ) OR dst; */
#define T_LOGIC_NOT_OR       5

/* dst = ( NOT src ) XOR dst; */
#define T_LOGIC_NOT_XOR      6

/* dst = ( NOT src ) AND dst; */
#define T_LOGIC_NOT_AND      7


/* Zeichenmodi */
/* dst = src; */
#define T_REPLACE            32

/* if ( src != bg_col ) dst = src; */
#define T_TRANSPARENT        33

/* if ( src != bg_col )            */
/* {                               */
/*    if ( dst == bg_col )         */
/*       dst = hilite_col;         */
/*    else if ( dst == hilite_col )*/
/*       dst = bg_col;             */
/* }                               */
#define T_HILITE             34

/* if ( src == bg_col ) dst = src; */
#define T_REVERS_TRANSPARENT 35

/* arithmetische Transfermodi */
/* Quell- und Zielfarbe mischen     */
/* rgb = RGB( src ) * Gewichtung ); */
/* rgb += RGB( dst ) * (1-Gewichtung));*/
/* dst = PIXELWERT( rgb );          */
#define T_BLEND     64

/* Quell- und Zielfarbe addieren    */
/* rgb = RGB( src ) + RGB( dst )    */
/* if ( rgb > max_rgb )             */
/*    rgb = max_rgb;                */
/* dst = PIXELWERT( rgb );          */
#define T_ADD       65

/* Quell- und Zielfarbe addieren,   */
/* überlauf nicht abfangen          */
/* rgb = RGB( src ) + RGB( dst )    */
/* dst = PIXELWERT( rgb );          */
#define T_ADD_OVER  66

/* Quell- von Zielfarbe subtrahieren   */
/* rgb = RGB( dst ) - RGB( src )    */
/* if ( rgb < min_rgb )             */
/*    rgb = min_rgb;                */
/* dst = PIXELWERT( rgb );          */
#define T_SUB       67

/* maximale RGB-Komponenten         */
/* rgb = MAX(RGB( dst ), RGB( src ))*/
/* dst = PIXELWERT( rgb );          */
#define T_MAX       69

/* Quell- von Zielfarbe subtrahieren,  */
/* überlauf nicht abfangen          */
/* rgb = RGB( dst ) - RGB( src )    */
/* dst = PIXELWERT( rgb );          */
#define T_SUB_OVER  70

/* minimale RGB-Komponenten         */
/* rgb = MIN(RGB( dst ), RGB( src ))*/
/* dst = PIXELWERT( rgb );          */
#define T_MIN       71

#define T_COLORIZE     16    /* Quelle einfärben */
#define T_DITHER_MODE  128   /* Quelldaten dithern */

• Wenn ein logischer Modus mit <T_COLORIZE> aufgerufen wird, erfolgt die Art der Einfärbung abhängig vom Modus:
   

  T_LOGIC_COPY
  
  Blende bei allen gesetzen Bits im Farbwert die
  Hintergrundfarbe ein und bei allen gelöschten Bits
  die Vordergrundfarbe:
  rgb = (( NOT RGB( src )) & RGB( fg_col )) OR
        ( RGB( src ) AND RGB( bg_col ));
  dst = PIXELWERT( rgb );
  
  T_LOGIC_NOT_COPY
  
  Blende bei allen gesetzen Bits im Farbwert die
  Vordergrundfarbe ein und bei allen gelöschten Bits die
  Hintergrundfarbe:
  rgb = ( RGB( src ) & RGB( fg_col )) OR
        ((( NOT RGB( src )) AND RGB( bg_col ));
  dst = PIXELWERT( rgb );
  
  T_LOGIC_OR
  
  überall dort, wo Quellbits gesetzt sind, wird beim Ziel
  ( src AND fg_col) eingeblendet:
  dst = ( src AND fg_col ) OR (( NOT src ) AND dst );
  
  T_LOGIC_NOT_OR
  
  überall dort, wo Quellbits gelöscht sind, wird beim Ziel
  ((NOT src ) AND fg_col) eingeblendet:
  dst = (( NOT src ) AND fg_col ) OR ( src AND dst );
  
  T_LOGIC_XOR
  T_LOGIC_NOT_XOR
  
  Die XOR-Verknüpfung ignoriert die Einfärbung.
  
  T_LOGIC_AND
  
  überall dort, wo Quellbits gelöscht sind, wird beim Ziel
  ((NOT src ) AND bg_col) eingeblendet:
  dst = ((NOT src ) AND bg_col ) OR ( src AND dst );
  
  T_LOGIC_NOT_AND
  
  überall dort, wo Quellbits gesetzt sind, wird beim Ziel
  ( src AND bg_col) eingeblendet:
  dst = ( src AND bg_col ) OR ((NOT src ) AND dst );
  

• Bei den Modi T_REPLACE, T_TRANSPARENT, T_HILITE und T_REVERS_TRANSPARENT wirkt die Einfärbung nicht binär auf die Farb- oder Pixelwerte, sondern die Farbwerte werden skaliert. Das folgende Beispiel zeigt, wie ein Farbwert eingefärbt wird; <bg_col>, <fg_col>, <src> und <dst> sind RGB-Farbwerte (zwischen 0 und 65535):
   

  red_range = bg_col.red - fg_col.red;
  green_range = bg_col.green - fg_col.green;
  blue_range = bg_col.blue - fg_col.blue;
  
  dst.red = fg_col.red + ( src_color.red * red_range / 65535 );
  dst.green = fg_col.green + ( src_color.green * green_range / 65535 );
  dst.blue = fg_col.blue + ( src_color.blue * blue_range / 65535 );
  

  
  Hinweis: Momentan wird die Einfärbung in den Modi T_REPLACE, T_TRANSPARENT, T_HILITE und T_REVERS_TRANSPARENT nur für Quellbitmaps mit bis zu 256 Farben unterstützt. Für Quellbitmaps mit 16 oder 32 Bit wird in diesen Modi zur Zeit keine Einfärbung unterstützt.
   

• Die arithmetischen Transfermodi unterstützen keine Einfärbung.
   

• Wenn die Quelle keine Farbtabelle hat (0L), wird die Farbtabelle des Geräts genommen, wenn dieses die gleiche Bittiefe hat. Ist das nicht der Fall, wird die Systemfarbtabelle für die Bittiefe der Quelle benutzt.
   

• Wenn das Ziel keine (inverse) Farbtabelle hat (0L), wird die (inverse) Farbtabelle des Geräts genommen, wenn dieses die gleiche Bittiefe hat. Ist das nicht der Fall, wird die Systemfarbtabelle für die Bittiefe des Ziels benutzt und für den Aufruf wird extra intern eine inverse Farbtabelle aufgebaut. D.h. Zielbitmaps sollten, wenn sie keine inverse Farbtabelle haben, unbedingt die gleiche Bittiefe wie das zum VDI-Handle gehörende Gerät haben.
   

/* Konstanten für Pixelformate */
/* Pixel besteht aus einer benutzten Komponente:
   Farbindex */
#define  PX_1COMP    0x01000000L
/* Pixel besteht aus drei benutzten Komponenten,
   z.B. RGB */
#define  PX_3COMP    0x03000000L
/* Pixel besteht aus vier benutzten Komponenten,
   z.B. CMYK */
#define  PX_4COMP    0x04000000L
/* Pixel wird in umgekehrter Bytereihenfolge ausgegeben */
#define  PX_REVERSED 0x00800000L
/* unbenutzte Bits liegen vor den benutzen
   (im Motorola-Format betrachtet) */
#define  PX_xFIRST   0x00400000L
/* K liegt vor CMY (im Motorola-Format betrachtet) */
#define  PX_kFIRST   0x00200000L
/* Alphakanal liegen vor den Farbbits
   (im Motorola-Format betrachtet) */
#define  PX_aFIRST   0x00100000L
/* Bits sind aufeinanderfolgend abgelegt */
#define  PX_PACKED   0x00020000L
/* Bits sind auf mehrere Ebenen verteilt
   (Reihenfolge: 0, 1, ..., n) */
#define  PX_PLANES   0x00010000L
/* Bits sind auf mehrere Worte verteilt
   (Reihenfolge: 0, 1, ..., n) */
#define  PX_IPLANES  0x00000000L
/* 1 Bit des Pixels wird benutzt */
#define  PX_USES1    0x00000100L
/* 2 Bit des Pixels werden benutzt */
#define  PX_USES2    0x00000200L
/* 3 Bit des Pixels werden benutzt */
#define  PX_USES3    0x00000300L
/* 4 Bit des Pixels werden benutzt */
#define  PX_USES4    0x00000400L
/* 8 Bit des Pixels werden benutzt */
#define  PX_USES8    0x00000800L
/* 15 Bit des Pixels werden benutzt */
#define  PX_USES15   0x00000f00L
/* 16 Bit des Pixels werden benutzt */
#define  PX_USES16   0x00001000L
/* 24 Bit des Pixels werden benutzt */
#define  PX_USES24   0x00001800L
/* 32 Bit des Pixels werden benutzt */
#define  PX_USES32   0x00002000L
/* 48 Bit des Pixels werden benutzt */
#define  PX_USES48   0x00003000L
/* Pixel besteht aus 1 Bit */
#define  PX_1BIT     0x00000001L
/* Pixel besteht aus 2 Bit */
#define  PX_2BIT     0x00000002L
/* Pixel besteht aus 3 Bit */
#define  PX_3BIT     0x00000003L
/* Pixel besteht aus 4 Bit */
#define  PX_4BIT     0x00000004L
/* Pixel besteht aus 8 Bit */
#define  PX_8BIT     0x00000008L
/* Pixel besteht aus 16 Bit */
#define  PX_16BIT    0x00000010L
/* Pixel besteht aus 24 Bit */
#define  PX_24BIT    0x00000018L
/* Pixel besteht aus 32 Bit */
#define  PX_32BIT    0x00000020L
/* Pixel besteht aus 48 Bit */
#define  PX_48BIT    0x00000030L
/* Maske für Anzahl der Pixelkomponenten */
#define  PX_CMPNTS   0x0f000000L
/* Maske für diverse Flags */
#define  PX_FLAGS    0x00f00000L
/* Maske für Pixelformat */
#define  PX_PACKING  0x00030000L
/* Maske für Anzahl der benutzten Bits */
#define  PX_USED     0x00003f00L
/* Maske für Anzahl der Bits pro Pixel */
#define  PX_BITS     0x0000003fL

/* Pixelformate für ATARI-Grafik */
#define  PX_ATARI1   ( PX_PACKED + PX_1COMP + PX_USES1 + PX_1BIT )
#define  PX_ATARI2   ( PX_IPLANES + PX_1COMP + PX_USES2 + PX_2BIT )
#define  PX_ATARI4   ( PX_IPLANES + PX_1COMP + PX_USES4 + PX_4BIT )
#define  PX_ATARI8   ( PX_IPLANES + PX_1COMP + PX_USES8 + PX_8BIT )
#define  PX_FALCON15 ( PX_PACKED + PX_3COMP + PX_USES16 + PX_16BIT )

/* Pixelformate für Mac */
#define  PX_MAC1     ( PX_PACKED + PX_1COMP + PX_USES1 + PX_1BIT )
#define  PX_MAC4     ( PX_PACKED + PX_1COMP + PX_USES4 + PX_4BIT )
#define  PX_MAC8     ( PX_PACKED + PX_1COMP + PX_USES8 + PX_8BIT )
#define  PX_MAC15    ( PX_xFIRST + PX_PACKED + PX_3COMP + PX_USES15 + PX_16BIT )
#define  PX_MAC32    ( PX_xFIRST + PX_PACKED + PX_3COMP + PX_USES24 + PX_32BIT )

/* Pixelformate für Grafikkarten */
#define  PX_VGA1     ( PX_PACKED + PX_1COMP + PX_USES1 + PX_1BIT )
#define  PX_VGA4     ( PX_PLANES + PX_1COMP + PX_USES4 + PX_4BIT )
#define  PX_VGA8     ( PX_PACKED + PX_1COMP + PX_USES8 + PX_8BIT )
#define  PX_VGA15    ( PX_REVERSED + PX_xFIRST + PX_PACKED + PX_3COMP + PX_USES15 + PX_16BIT )
#define  PX_VGA16    ( PX_REVERSED + PX_PACKED + PX_3COMP + PX_USES16 + PX_16BIT )
#define  PX_VGA24    ( PX_REVERSED + PX_PACKED + PX_3COMP + PX_USES24 + PX_24BIT )
#define  PX_VGA32    ( PX_REVERSED + PX_xFIRST + PX_PACKED + PX_3COMP + PX_USES24 + PX_32BIT )
#define  PX_MATRIX16 ( PX_PACKED + PX_3COMP + PX_USES16 + PX_16BIT )
#define  PX_NOVA32   ( PX_PACKED + PX_3COMP + PX_USES24 + PX_32BIT )

/* Pixelformate für Drucker */
#define  PX_PRN1     ( PX_PACKED + PX_1COMP + PX_USES1 + PX_1BIT )
#define  PX_PRN8     ( PX_PACKED + PX_1COMP + PX_USES8 + PX_8BIT )
#define  PX_PRN32    ( PX_xFIRST + PX_PACKED + PX_3COMP + PX_USES24 + PX_32BIT )

/* bevorzugte (schnelle) Pixelformate für Bitmaps */
#define  PX_PREF1    ( PX_PACKED + PX_1COMP + PX_USES1 + PX_1BIT )
#define  PX_PREF2    ( PX_PACKED + PX_1COMP + PX_USES2 + PX_2BIT )
#define  PX_PREF4    ( PX_PACKED + PX_1COMP + PX_USES4 + PX_4BIT )
#define  PX_PREF8    ( PX_PACKED + PX_1COMP + PX_USES8 + PX_8BIT )
#define  PX_PREF15   ( PX_xFIRST + PX_PACKED + PX_3COMP + PX_USES15 + PX_16BIT )
#define  PX_PREF32   ( PX_xFIRST + PX_PACKED + PX_3COMP + PX_USES24 + PX_32BIT )

void vr_transfer_bits( int16_t handle, GCBITMAP *src_bm,
                       GCBITMAP *dst_bm, RECT16 *src_rect,
                       RECT16 *dst_rect, int16_t mode )
{
   intin[o] = mode;
   intin[1] = 0;
   intin[2] = 0;
   intin[3] = 0;

   ptsin[0..3] = src_rect;
   ptsin[4..7] = dst_rect;

   contrl[0] = 170;
   contrl[1] = 4;
   contrl[3] = 4;
   contrl[5] = 0;
   contrl[6] = handle;
   contrl[7..8] = src_bm;
   contrl[9..10] = dst_bm;
   contrl[11..12] = 0;

   vdi ();
}

void vr_trnfm (int16_t handle, MFDB *psrcMFDB, MFDB *pdesMFDB)
{
   iptr (psrcMFDB);
   iptr_2 (pdesMFDB);

   contrl[0] = 110;
   contrl[1] = 0;
   contrl[3] = 0;
   contrl[6] = handle;

   vdi ();
}

void vro_cpyfm (int16_t handle, int16_t vr_mode,
                int16_t *pxyarray, MFDB *psrcMFDB,
                MFDB *pdesMFDB)
{
   intin[0]    = vr_mode;
   ptsin[0..7] = pxyarray[0..7];
   iptr (psrcMFDB);
   iptr2 (pdesMFDB);

   contrl[0] = 109;
   contrl[1] = 4;
   contrl[3] = 1;
   contrl[6] = handle;

   vdi ();
}

void vrt_cpyfm (int16_t handle, int16_t vr_mode,
                int16_t *pxyarray,MFDB *psrcMFDB,
                MFDB *pdesMFDB, int16_t *color_index)
{
   intin[0]    = vr_mode;
   intin[1]    = *color_index++;
   intin[2]    = *color_index;
   ptsin[0..7] = pxyarray[0..7];

   iptr (psrcMFDB);
   iptr_2 (pdesMFDB);

   contrl[0] = 121;
   contrl[1] = 4;
   contrl[3] = 3;
   contrl[6] = handle;

   vdi ();
}

int16_t vs_hilite_color( int16_t handle, int32_t color_space,
                         COLOR_ENTRY *hilite_color )
{
   intin[0..1]    = color_space;
   intin[2..5]    = hilite_color;

   contrl[0] = 207;
   contrl[1] = 0;
   contrl[3] = 6;
   contrl[5] = 0;
   contrl[6] = handle;

   vdi ();

   return ( intout[0] );
}

int16_t vs_max_color( int16_t handle, int32_t color_space,
                      COLOR_ENTRY *max_color )
{
   intin[0..1]    = color_space;
   intin[2..5]    = max_color;

   contrl[0] = 207;
   contrl[1] = 0;
   contrl[3] = 6;
   contrl[5] = 2;
   contrl[6] = handle;

   vdi ();

   return ( intout[0] );
}

int16_t vs_min_color( int16_t handle, int32_t color_space,
                      COLOR_ENTRY *min_color )
{
   intin[0..1]    = color_space;
   intin[2..5]    = min_color;

   contrl[0] = 207;
   contrl[1] = 0;
   contrl[3] = 6;
   contrl[5] = 1;
   contrl[6] = handle;

   vdi ();

   return ( intout[0] );
}

int16_t vs_weight_color( int16_t handle, int32_t color_space,
                         COLOR_ENTRY *weight_color )
{
   intin[0..1]    = color_space;
   intin[2..5]    = weight_color;

   contrl[0] = 207;
   contrl[1] = 0;
   contrl[3] = 6;
   contrl[5] = 3;
   contrl[6] = handle;

   vdi ();

   return ( intout[0] );
}