home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / mesa5.zip / mesa5src.zip / MesaDLL / os2mesa.cpp < prev    next >
Text File  |  2002-12-29  |  60KB  |  1,868 lines
  1. /* os2mesa.c,v 0.1 27/02/2000 EK */
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include "WarpGL.h"
  5. #include "GL/os2mesa.h"
  6. #include "os2mesadef.h"
  7. #include "colors.h"
  8. #include "context.h"
  9. #include "colormac.h"
  10. #include "extensions.h"
  11. #include "matrix.h"
  12. #include "texformat.h"
  13. #include "texstore.h"
  14. #include "array_cache/acache.h"
  15. #include "swrast_setup/swrast_setup.h"
  16. #include "swrast/s_alphabuf.h"
  17. #include "tnl/tnl.h"
  18. #include "tnl/t_context.h"
  19. #include "tnl/t_pipeline.h"
  20.  
  21.  
  22.    #include "glutint.h"
  23.    /* ???? */
  24. #include "swrast/swrast.h"
  25.  
  26. /* external functions */
  27. BOOL DiveFlush(PWMC pwc);
  28. int DivePMInit(WMesaContext c);
  29.  
  30. void
  31. _swrast_CopyPixels( GLcontext *ctx,
  32.                    GLint srcx, GLint srcy, GLsizei width, GLsizei height,
  33.                    GLint destx, GLint desty,
  34.                    GLenum type );
  35.  
  36. /**********************/
  37. /* internal functions */
  38. /**********************/
  39. static void OS2mesa_update_state( GLcontext* ctx, GLuint new_state  );
  40. BOOL wmFlush(PWMC pwc);
  41. void wmSetPixel(PWMC pwc, int iScanLine, int iPixel, BYTE r, BYTE g, BYTE b);
  42. void wmSetPixel_db1(PWMC pwc, int iScanLine, int iPixel, BYTE r, BYTE g, BYTE b);
  43. void wmSetPixel_db2(PWMC pwc, int iScanLine, int iPixel, BYTE r, BYTE g, BYTE b);
  44. void wmSetPixel_db3(PWMC pwc, int iScanLine, int iPixel, BYTE r, BYTE g, BYTE b);
  45. void wmSetPixel_db4(PWMC pwc, int iScanLine, int iPixel, BYTE r, BYTE g, BYTE b);
  46. void wmSetPixel_sb(PWMC pwc, int iScanLine, int iPixel, BYTE r, BYTE g, BYTE b);
  47. int wmGetPixel(PWMC pwc, int x, int y);
  48.  
  49. void wmCreateDIBSection(
  50.                         HDC  hDC,
  51.                         PWMC pwc,   // handle of device context
  52.                         CONST BITMAPINFO2 *pbmi// address of structure containing bitmap size, format, and color data
  53.                        );
  54.                         //, UINT iUsage) // color data type indicator: RGB values or palette indices
  55.  
  56. BYTE DITHER_RGB_2_8BIT( int r, int g, int b, int x, int y);
  57.  
  58. /*******************/
  59. /* macros          */
  60. /*******************/
  61. #define LONGFromRGB(R,G,B) (LONG)(((LONG)R<<16)+((LONG)G<<8)+(LONG)B)
  62. /* Windos use inverse order for Red and Blue */
  63. #define GetRValue(rgb)     ((BYTE)((rgb)>>16))
  64. #define GetGValue(rgb)     ((BYTE)((rgb)>> 8))
  65. #define GetBValue(rgb)     ((BYTE)(rgb))
  66. #define MAKEWORD(a, b)       ((short int)(((BYTE)(a)) | (((short int)((BYTE)(b))) << 8)))
  67. /*
  68. * Useful macros:
  69. Modified from file osmesa.c
  70. */
  71.  
  72. //#define PIXELADDR(X,Y)  ((GLubyte *)Current->pbPixels + (Current->height-Y-1)* Current->ScanWidth + (X)*nBypp)
  73. #define PIXELADDR(X,Y)  ((GLubyte *)Current->pbPixels + (Y)* Current->ScanWidth + (X)*nBypp)
  74. #define PIXELADDR1( X, Y )  \
  75. ((GLubyte *)wmesa->pbPixels + (Y) * wmesa->ScanWidth + (X))
  76. //((GLubyte *)wmesa->pbPixels + (wmesa->height-Y-1) * wmesa->ScanWidth + (X))
  77. #define PIXELADDR2( X, Y )  \
  78. ((GLubyte *)wmesa->pbPixels + (Y) * wmesa->ScanWidth + (X)*2)
  79. //((GLubyte *)wmesa->pbPixels + (wmesa->height - Y - 1) * wmesa->ScanWidth + (X)*2)
  80. #define PIXELADDR4( X, Y )  \
  81. ((GLubyte *)wmesa->pbPixels + (Y) * wmesa->ScanWidth + (X)*4)
  82. //((GLubyte *)wmesa->pbPixels + (wmesa->height-Y-1) * wmesa->ScanWidth + (X)*4)
  83.  
  84.  
  85. #define PIXELADDR_1( X, Y )  \
  86. ((GLubyte *)pwc->pbPixels + (Y) * pwc->ScanWidth + (X))
  87. #define PIXELADDR_2( X, Y )  \
  88. ((GLubyte *)pwc->pbPixels + (Y) * pwc->ScanWidth + (X)*2)
  89. #define PIXELADDR_3( X, Y )  \
  90. ((GLubyte *)pwc->pbPixels + (Y) * pwc->ScanWidth + (X)*3)
  91. #define PIXELADDR_4( X, Y )  \
  92. ((GLubyte *)pwc->pbPixels + (Y) * pwc->ScanWidth + (X)*4)
  93.  
  94.  
  95. /*
  96.  * Values for the format parameter of OSMesaCreateContext()
  97.  */
  98. #define OSMESA_COLOR_INDEX GL_COLOR_INDEX
  99. #define OSMESA_RGBA        GL_RGBA
  100. #define OSMESA_BGRA        0x1
  101. #define OSMESA_ARGB        0x2
  102. #define OSMESA_RGB         GL_RGB
  103. #define OSMESA_BGR         0x4
  104. #define OSMESA_RGB_565     0x5
  105.  
  106.  
  107. /*******************/
  108. /* local constants */
  109. /*******************/
  110.  
  111. /* static */
  112. PWMC Current = NULL;
  113. GLenum stereoCompile = GL_FALSE ;
  114. GLenum stereoShowing  = GL_FALSE ;
  115. GLenum stereoBuffer = GL_FALSE;
  116.  
  117. GLint stereo_flag = 0 ;
  118.  
  119. static void wmSetPixelFormat( PWMC wc, HDC hDC)
  120. {
  121.     if(wc->rgb_flag)
  122.     {  long Alarray[4];
  123.        long lFormats[24];/* Formats supported by the device    */
  124.        int Nformats;
  125. /*
  126.   { int i;
  127.     long cAlarray[104];
  128.     FILE *fp;
  129.  
  130.     i = 64;
  131.     DevQueryCaps(hDC,CAPS_FAMILY,i, cAlarray);
  132.     fp=fopen("test.txt","w");
  133.     for(i=0;i<64;i++)
  134.       fprintf(fp,"%2i, %x\n",i,cAlarray[i]);
  135.     fclose(fp);
  136.   }
  137. */
  138.  
  139.         DevQueryCaps(hDC,CAPS_BITMAP_FORMATS,1, Alarray);
  140.          Nformats = (int)Alarray[0];
  141.        if(Nformats > 12) Nformats=12;
  142.  
  143.  /* Get screen supportable formats */
  144.  GpiQueryDeviceBitmapFormats(wc->hps, Nformats*2, lFormats);
  145. // pbmInfo.cPlanes = (USHORT) lFormats[0] ;
  146. // pbmInfo.cBitCount = (USHORT) lFormats[1];
  147.  
  148.          DevQueryCaps(hDC,CAPS_COLOR_BITCOUNT,1, Alarray);
  149.         wc->nColorBits = (int) Alarray[0];
  150.       printf("CAPS_COLOR_BITCOUNT=%i ",wc->nColorBits);
  151.  
  152.       if(wc->nColorBits == 24 && wc->useDive && (wc->DiveCaps.ulDepth == 32)) /* Matrox driver */
  153.                    wc->nColorBits = 32;
  154.       else
  155.       {   if(wc->nColorBits == 8 /* && wc->useDive */ )
  156.           {   wc->nColorBits = 24;
  157.              // wc->useDive = 0;
  158.           } else if(wc->nColorBits < 24){
  159.                 wc->nColorBits = 24;
  160.           } else if(wc->nColorBits == 32){
  161. /* éÑΘ∞, ß»Ñµ¿Σ¿τÑ߬á∩ ñ½∩ PM'á ?*/
  162. //             wc->nColorBits = 24;
  163.                 wc->nColorBits = 32;
  164.           }
  165.       }
  166.  
  167. //             else if(wc->nColorBits == 16 && wc->useDive)
  168. //          {   wc->nColorBits = 24;
  169. //          }
  170.     } else
  171.         wc->nColorBits = 8;
  172.  
  173.     printf("wc->nColorBits=%i\n",wc->nColorBits);
  174.  
  175.     switch(wc->nColorBits){
  176.     case 8:
  177.         if(wc->dither_flag != GL_TRUE)
  178.             wc->pixelformat = PF_INDEX8;
  179.         else
  180.             wc->pixelformat = PF_DITHER8;
  181.         break;
  182.     case 16:
  183.         wc->pixelformat = PF_5R6G5B;
  184.         break;
  185.     case 24:
  186.         wc->pixelformat = PF_8R8G8B;
  187.         break;
  188.     case 32:
  189.         wc->pixelformat = PF_8A8B8G8R;//PF_8R8G8B;
  190.         break;
  191.     default:
  192.         wc->pixelformat = PF_BADFORMAT;
  193.     }
  194. }
  195.  
  196. //
  197. // This function creates the DIB section that is used for combined
  198. // GL and GDI calls
  199. //
  200. BOOL  wmCreateBackingStore(PWMC pwc, long lxSize, long lySize)
  201. {
  202.     HDC hdc = pwc->hDC;
  203.  
  204.     BITMAPINFO2   *pbmi_mem = &(pwc->memb.bmi_mem);
  205.     BITMAPINFOHEADER2 *pbmi = &(pwc->bmi);
  206.  
  207.  
  208.     pbmi->cbFix = sizeof(BITMAPINFOHEADER2);
  209.     pbmi->cx = lxSize;
  210.     pbmi->cy = lySize;
  211.     pbmi->cPlanes = 1;
  212.     if(pwc->rgb_flag)
  213.     {  LONG *pVC_Caps;
  214.        pVC_Caps = GetVideoConfig(pwc->hDC);
  215.        pbmi->cBitCount = pVC_Caps[CAPS_COLOR_BITCOUNT];
  216. printf("1 pbmi->cBitCount=%i\n",pbmi->cBitCount);
  217.        if(pbmi->cBitCount == 24  && pwc->useDive && (pwc->DiveCaps.ulDepth == 32))   /* Matrox driver */
  218.            pbmi->cBitCount = 32;
  219.        else
  220.        {
  221.            if(pbmi->cBitCount == 8)
  222.            {  if(pwc->useDive&0x0f)
  223.                     pwc->useDive |= 0x200; /* use dithering for DIVE */
  224.               pbmi->cBitCount = 24;
  225.            }  else {
  226.                if(pbmi->cBitCount == 16 && (pwc->useDive&0x0f) )
  227.                                                    pwc->useDive |= 0x100;
  228. //tmpDEBUG      pbmi->cBitCount = 24;
  229.                if(pbmi->cBitCount < 32)
  230.                        pbmi->cBitCount = 24;
  231.            }
  232.        }
  233.     }
  234.       else
  235.         pbmi->cBitCount = 8;
  236.  
  237.     printf("pbmi->cBitCount=%i, useDive=%x\n",pbmi->cBitCount,pwc->useDive);
  238.  
  239.     pbmi->ulCompression = BCA_UNCOMP;
  240.     pbmi->cbImage = 0;
  241.     pbmi->cxResolution = 0;
  242.     pbmi->cyResolution = 0;
  243.     pbmi->cclrUsed = 0;
  244.     pbmi->cclrImportant = 0;
  245.       pbmi->usUnits = BRU_METRIC;
  246.       pbmi->usReserved = 0;
  247.       pbmi->usRecording = BRA_BOTTOMUP;
  248.       pbmi->usRendering = BRH_NOTHALFTONED;
  249.  
  250.       pbmi->cSize1 = 0;
  251.       pbmi->cSize2 = 0;
  252.       pbmi->ulColorEncoding = BCE_RGB;
  253.       pbmi->ulIdentifier = 1;
  254.  
  255. //    iUsage = (pbmi->cBitCount <= 8) ? DIB_PAL_COLORS : DIB_RGB_COLORS;
  256.  
  257.     pwc->nColorBits = pbmi->cBitCount;
  258.     pwc->ScanWidth = pwc->pitch = (int)lxSize;
  259.     memcpy((void *)pbmi_mem, (void *)pbmi, sizeof(BITMAPINFOHEADER2));
  260. //    pbmi_mem->argbColor[0] = 0;
  261.  
  262.     wmCreateDIBSection(hdc, pwc, pbmi_mem);
  263.  
  264. //    if ((iUsage == DIB_PAL_COLORS) && !(pwc->hGLPalette)) {
  265. //        wmCreatePalette( pwc );
  266. //        wmSetDibColors( pwc );
  267. //    }
  268.     wmSetPixelFormat(pwc, pwc->hDC);
  269.  
  270.     return(TRUE);
  271. }
  272.  
  273. //
  274. // Free up the dib section that was created
  275. //
  276. BOOL wmDeleteBackingStore(PWMC pwc)
  277. {
  278.   if(pwc->memb.pBmpBuffer)
  279.   {   free(pwc->memb.pBmpBuffer);
  280.       pwc->memb.pBmpBuffer = NULL;
  281.   }
  282.   pwc->pbPixels = NULL;
  283.   if(pwc->hbm) GpiDeleteBitmap(pwc->hbm);
  284.   pwc->hbm = 0;
  285.  
  286.   //free( pbmi);
  287.  
  288.   GpiDestroyPS(pwc->memb.hpsMem);       /* destroys presentation space */
  289.   DevCloseDC(pwc->memb.hdcMem);         /* closes device context       */
  290.   return TRUE;
  291. }
  292.  
  293.  
  294.  
  295. /***********************************************/
  296. /* Return characteristics of the output buffer. */
  297. /***********************************************/
  298. static void get_buffer_size( GLframebuffer *buffer, GLuint *width, GLuint *height )
  299. {
  300.    int New_Size;
  301.    RECTL CR;
  302.    GET_CURRENT_CONTEXT(ctx);
  303.    WinQueryWindowRect(Current->Window,&CR);
  304.  
  305.  
  306.    *width = (GLuint) (CR.xRight - CR.xLeft);
  307.    *height = (GLuint) (CR.yTop - CR.yBottom);
  308.  
  309.    New_Size=((*width)!=Current->width) || ((*height)!=Current->height);
  310.  
  311.    if (New_Size){
  312.       Current->width=*width;
  313.       Current->height=*height;
  314.       Current->ScanWidth=Current->width;
  315.       if ((Current->ScanWidth%sizeof(long))!=0)
  316.          Current->ScanWidth+=(sizeof(long)-(Current->ScanWidth%sizeof(long)));
  317.  
  318.       if (Current->db_flag){
  319.          if (Current->rgb_flag==GL_TRUE && Current->dither_flag!=GL_TRUE){
  320.             wmDeleteBackingStore(Current);
  321.             wmCreateBackingStore(Current, Current->width, Current->height);
  322.          }
  323.       }
  324.  
  325.       //  Resize OsmesaBuffer if in Parallel mode
  326.    }
  327. }
  328.  
  329. //
  330. // We cache all gl draw routines until a flush is made
  331. //
  332. static void flush(GLcontext* ctx)
  333. {
  334.         if((Current->rgb_flag /*&& !(Current->dib.fFlushed)*/&&!(Current->db_flag))
  335.             ||(!Current->rgb_flag))
  336.         {
  337.             wmFlush(Current);
  338.         }
  339. }
  340.  
  341. /*
  342.  * Set the color index used to clear the color buffer.
  343.  */
  344. static void clear_index(GLcontext* ctx, GLuint index)
  345. {
  346.         Current->clearpixel = index;
  347. }
  348.  
  349. /*
  350.  * Set the color used to clear the color buffer.
  351.  */
  352. static void clear_color( GLcontext* ctx, const GLfloat color[4] )
  353. {
  354.   GLubyte col[4];
  355.   CLAMPED_FLOAT_TO_UBYTE(col[0], color[0]);
  356.   CLAMPED_FLOAT_TO_UBYTE(col[1], color[1]);
  357.   CLAMPED_FLOAT_TO_UBYTE(col[2], color[2]);
  358.   Current->clearpixel = LONGFromRGB(col[0], col[1], col[2]);
  359. }
  360.  
  361.  
  362. /*
  363.  * Clear the specified region of the color buffer using the clear color
  364.  * or index as specified by one of the two functions above.
  365.  *
  366.  * This procedure clears either the front and/or the back COLOR buffers.
  367.  * Only the "left" buffer is cleared since we are not stereo.
  368.  * Clearing of the other non-color buffers is left to the swrast.
  369.  * We also only clear the color buffers if the color masks are all 1's.
  370.  * Otherwise, we let swrast do it.
  371.  */
  372.  
  373. static void clear(GLcontext* ctx, GLbitfield mask,
  374.                   GLboolean all, GLint x, GLint y, GLint width, GLint height)
  375. {  RECTL rect;
  376.    if (all)
  377.    {  x=y=0;
  378.       width=Current->width;
  379.       height=Current->height;
  380.    }
  381.   /* clear alpha */
  382.   if ((mask & (DD_FRONT_LEFT_BIT | DD_BACK_RIGHT_BIT)) &&
  383.       ctx->DrawBuffer->UseSoftwareAlphaBuffers &&
  384.       ctx->Color.ColorMask[ACOMP]) {
  385.       _mesa_clear_alpha_buffers( ctx );
  386.   }
  387.    if(Current->db_flag==GL_TRUE)
  388.    {
  389.     int         dwColor;
  390.     short int   wColor;
  391.     BYTE        bColor;
  392.     int         *lpdw = (int *)Current->pbPixels;
  393.     short int   *lpw = (short int *)Current->pbPixels;
  394.     PBYTE       lpb = Current->pbPixels;
  395.     int     lines;
  396.  
  397.  
  398.         if(Current->db_flag==GL_TRUE){
  399.             UINT    nBypp = Current->nColorBits / 8;
  400.             int     i = 0;
  401.             int     iSize = 0;
  402.  
  403.             if(nBypp ==1 ){
  404.                 /* Need rectification */
  405.                 iSize = Current->width/4;
  406.                 bColor  = (BYTE) BGR8(GetRValue(Current->clearpixel),
  407.                     GetGValue(Current->clearpixel),
  408.                     GetBValue(Current->clearpixel));
  409.                 wColor  = MAKEWORD(bColor,bColor);
  410.                 dwColor = (int) MAKELONG(wColor, wColor);
  411.             }
  412.             if(nBypp == 2){
  413.                  int r,g,b;
  414.                  r = GetRValue(Current->clearpixel);
  415.                  g = GetGValue(Current->clearpixel);
  416.                  b = GetBValue(Current->clearpixel);
  417.                 iSize = Current->width / 2;
  418.                 wColor = BGR16(GetRValue(Current->clearpixel),
  419.                     GetGValue(Current->clearpixel),
  420.                     GetBValue(Current->clearpixel));
  421.                 dwColor = (int)MAKELONG(wColor, wColor);
  422.             }
  423.             else if(nBypp == 4){
  424.                 iSize = Current->width;
  425.                 dwColor = (int)BGR32(GetRValue(Current->clearpixel),
  426.                     GetGValue(Current->clearpixel),
  427.                     GetBValue(Current->clearpixel));
  428.             }
  429.  
  430.             while(i < iSize){
  431.                 *lpdw = dwColor;
  432.                 lpdw++;
  433.                 i++;
  434.             }
  435.  
  436.             //
  437.             // This is the 24bit case
  438.             //
  439.             if (nBypp == 3) {
  440.                 iSize = Current->width *3/4;
  441.                 dwColor = (int)BGR24(GetRValue(Current->clearpixel),
  442.                     GetGValue(Current->clearpixel),
  443.                     GetBValue(Current->clearpixel));
  444.                 while(i < iSize){
  445.                     *lpdw = dwColor;
  446.                     lpb += nBypp;
  447.                     lpdw = (int *)lpb;
  448.                     i++;
  449.                 }
  450.             }
  451.  
  452.             i = 0;
  453.             if (stereo_flag)
  454.                lines = height /2;
  455.             else
  456.                lines = height;
  457.             do {
  458.                 memcpy(lpb, Current->pbPixels, iSize*4);
  459.                 lpb += Current->ScanWidth;
  460.                 i++;
  461.             }
  462.             while (i<lines-1);
  463.         }
  464.         mask &= ~DD_FRONT_LEFT_BIT;
  465.    } else { // For single buffer
  466.       rect.xLeft = x;
  467.       rect.xRight = x + width;
  468.       rect.yBottom = y;
  469.       rect.yTop = y + height;
  470.       WinFillRect(Current->hps, &rect, Current->clearpixel);
  471.       mask &= ~DD_FRONT_LEFT_BIT;
  472.    }
  473.  
  474.   /* Call swrast if there is anything left to clear (like DEPTH) */
  475.   if (mask)
  476.       _swrast_Clear( ctx, mask, all, x, y, width, height );
  477.  
  478. }
  479.  
  480. static void enable( GLcontext* ctx, GLenum pname, GLboolean enable )
  481. {
  482.   if (!Current)
  483.     return;
  484.  
  485.   if (pname == GL_DITHER) {
  486.     if(enable == GL_FALSE){
  487.       Current->dither_flag = GL_FALSE;
  488.       if(Current->nColorBits == 8)
  489.        Current->pixelformat = PF_INDEX8;
  490.     }
  491.     else{
  492.       if (Current->rgb_flag && Current->nColorBits == 8){
  493.           Current->pixelformat = PF_DITHER8;
  494.           Current->dither_flag = GL_TRUE;
  495.       }
  496.       else
  497.           Current->dither_flag = GL_FALSE;
  498.     }
  499.   }
  500. }
  501.  
  502. static void set_buffer(GLcontext *ctx, GLframebuffer *colorBuffer,
  503.                        GLuint bufferBit )
  504. {
  505.   /* XXX todo - examine bufferBit and set read/write pointers */
  506.   return;
  507. }
  508.  
  509.  
  510. /* Set the current color index. */
  511. static void set_index(GLcontext* ctx, GLuint index)
  512. {
  513.         Current->pixel=index;
  514. }
  515.  
  516.  
  517. /* Set the current RGBA color. */
  518. static void set_color( GLcontext* ctx, GLubyte r, GLubyte g, GLubyte b, GLubyte a )
  519. {
  520.         Current->pixel = LONGFromRGB( r, g, b );
  521. }
  522.  
  523.  
  524. /* Set the index mode bitplane mask. */
  525. static GLboolean index_mask(GLcontext* ctx, GLuint mask)
  526. {
  527.     /* can't implement */
  528.     return GL_FALSE;
  529. }
  530.  
  531.  
  532. /* Set the RGBA drawing mask. */
  533. static GLboolean color_mask( GLcontext* ctx,
  534.                             GLboolean rmask, GLboolean gmask,
  535.                             GLboolean bmask, GLboolean amask)
  536. {
  537.     /* can't implement */
  538.     return GL_FALSE;
  539. }
  540.  
  541.  
  542. /*
  543. * Set the pixel logic operation.  Return GL_TRUE if the device driver
  544. * can perform the operation, otherwise return GL_FALSE.  If GL_FALSE
  545. * is returned, the logic op will be done in software by Mesa.
  546. */
  547. GLboolean logicop( GLcontext* ctx, GLenum op )
  548. {
  549.     /* can't implement */
  550.     return GL_FALSE;
  551. }
  552.  
  553. /**********************************************************************/
  554. /*****                 Span-based pixel drawing                   *****/
  555. /**********************************************************************/
  556.  
  557. /* Write a horizontal span of 32-bit color-index pixels with a boolean mask. */
  558. static void write_ci32_span( const GLcontext* ctx,
  559.                              GLuint n, GLint x, GLint y,
  560.                              const GLuint index[],
  561.                              const GLubyte mask[] )
  562. {
  563.     GLuint i;
  564.     PBYTE Mem=Current->ScreenMem +  y*Current->ScanWidth + x;
  565.     assert(Current->rgb_flag==GL_FALSE);
  566.     for (i=0; i<n; i++)
  567.         if (mask[i])
  568.             Mem[i]=index[i];
  569. }
  570.  
  571.  
  572. /* Write a horizontal span of 8-bit color-index pixels with a boolean mask. */
  573. static void write_ci8_span( const GLcontext* ctx,
  574.                             GLuint n, GLint x, GLint y,
  575.                             const GLubyte index[],
  576.                             const GLubyte mask[] )
  577. {
  578.     GLuint i;
  579.     PBYTE Mem=Current->ScreenMem + y *Current->ScanWidth+x;
  580.     assert(Current->rgb_flag==GL_FALSE);
  581.     for (i=0; i<n; i++)
  582.         if (mask[i])
  583.             Mem[i]=index[i];
  584. }
  585.  
  586.  
  587.  
  588. /*
  589. * Write a horizontal span of pixels with a boolean mask.  The current
  590. * color index is used for all pixels.
  591. */
  592. static void write_mono_ci_span(const GLcontext* ctx,
  593.                                GLuint n,GLint x,GLint y,
  594.                                GLuint colorIndex, const GLubyte mask[])
  595. {
  596.    GLuint i;
  597.    BYTE *Mem=Current->ScreenMem + y * Current->ScanWidth+x;
  598.    assert(Current->rgb_flag==GL_FALSE);
  599.    for (i=0; i<n; i++)
  600.       if (mask[i])
  601.          Mem[i]= (BYTE) colorIndex;
  602. }
  603.  
  604. /* Write a horizontal span of RGBA color pixels with a boolean mask. */
  605. static void write_rgba_span( const GLcontext* ctx, GLuint n, GLint x, GLint y,
  606.                              const GLubyte rgba[][4], const GLubyte mask[] )
  607. {
  608.   PWMC    pwc = Current;
  609.    GLuint i;
  610. //  if (pwc->rgb_flag==GL_TRUE)
  611.     {
  612.         PBYTE  lpb = pwc->pbPixels;
  613.         UINT  *lpdw;
  614.         unsigned short int *lpw;
  615.       if(Current->db_flag)
  616.       {
  617.         UINT    nBypp = pwc->nColorBits / 8;
  618.         lpb += pwc->ScanWidth * y;
  619.         // Now move to the desired pixel
  620.         lpb += x * nBypp;
  621. // lpb = (PBYTE)PIXELADDR(x, iScanLine);
  622. //#define PIXELADDR(X,Y)  ((GLubyte *)Current->pbPixels + (Y+1)* Current->ScanWidth + (X)*nBypp)
  623. //                                                          ???
  624.  
  625.         if (mask) {
  626.             for (i=0; i<n; i++)
  627.                 if (mask[i])
  628.                     wmSetPixel(pwc, y, x + i, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
  629.         } else {
  630. // pá߬pδóáѼ óßÑ ó맮óδ
  631. //            for (i=0; i<n; i++)
  632. //                wmSetPixel(pwc, y, x + i, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
  633.            if(nBypp == 1)
  634.            {
  635.               if(pwc->dither_flag)
  636.                  for (i=0; i<n; i++,lpb++)
  637.                               *lpb = DITHER_RGB_2_8BIT(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP],y,x);
  638.               else
  639.                  for (i=0; i<n; i++,lpb++)
  640.                               *lpb = (BYTE) BGR8(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
  641.            } else if(nBypp == 2) {
  642.               lpw = (unsigned short int *)lpb;
  643.                  for (i=0; i<n; i++,lpw++)
  644.                                *lpw = BGR16(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
  645.            } else if (nBypp == 3) {
  646.  
  647.                  for (i=0; i<n; i++)
  648.                  {  *lpb++ = rgba[i][BCOMP]; // in memory: b-g-r bytes
  649.                     *lpb++ = rgba[i][GCOMP];
  650.                     *lpb++ = rgba[i][RCOMP];
  651.                  }
  652.            } else if (nBypp == 4) {
  653.               lpdw = (UINT  *)lpb;
  654. //???                 memcpy(lpb,rgba,n*4);
  655.                  for (i=0; i<n; i++,lpdw++)
  656.                     *lpdw = ((UINT)rgba[i][BCOMP]) | (((UINT)rgba[i][GCOMP])<<8 )|  (((UINT)rgba[i][RCOMP])<<16);
  657. //                     *lpdw = BGR32(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
  658. //#define BGR32(r,g,b) (unsigned long)((DWORD)(((BYTE)(b)|((WORD)((BYTE)(g))<<8))|(((DWORD)(BYTE)(r))<<16)))
  659.  
  660.            }
  661.  
  662.         }
  663.  
  664.       } else {  // (!Current->db_flag)
  665.           POINTL ptl;
  666.           int col=-1, colold=-1,iold=0;
  667.           ptl.y = y;
  668.           ptl.x = x;
  669.  
  670.           if (mask)
  671.           {
  672.             for (i=0; i<n; i++,ptl.x++)
  673.                 if (mask[i])
  674.                 {   GpiSetColor(pwc->hps,LONGFromRGB(rgba[i][RCOMP],rgba[i][GCOMP], rgba[i][BCOMP]));
  675.                     GpiSetPel(pwc->hps, &ptl);
  676.                 }
  677.           } else {
  678.             GpiMove(pwc->hps,&ptl);
  679.             for (i=0; i<n; i++,ptl.x++)
  680.                 {   col = (int) LONGFromRGB(rgba[i][RCOMP],rgba[i][GCOMP], rgba[i][BCOMP]);
  681.                     if(col != colold)
  682.                     {  GpiSetColor(pwc->hps,col);
  683.                        GpiLine(pwc->hps,&ptl);
  684.                        colold = col;
  685.                        iold = i;
  686.                     }
  687.                 }
  688.                 if(iold != n-1)
  689.                     {  ptl.x--;
  690.                       // GpiSetColor(pwc->hps,col);
  691.                        GpiLine(pwc->hps,&ptl);
  692.                     }
  693.          } //endif(mask)
  694.       } //endif(Current->db_flag)
  695.  
  696.     }
  697. //  endofif (pwc->rgb_flag==GL_TRUE)
  698. }
  699.  
  700. /* Write a horizontal span of RGB color pixels with a boolean mask. */
  701. static void write_rgb_span( const GLcontext* ctx,
  702.                             GLuint n, GLint x, GLint y,
  703.                             const GLubyte rgb[][3], const GLubyte mask[] )
  704. {
  705.     PWMC    pwc = Current;
  706.     GLuint i;
  707.     if(pwc->db_flag)
  708.     {
  709.         if (mask) {
  710.             for (i=0; i<n; i++)
  711.                 if (mask[i])
  712.                     wmSetPixel(pwc, y, x + i, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
  713.         }
  714.         else {
  715.             for (i=0; i<n; i++)
  716.                 wmSetPixel(pwc, y, x + i, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
  717.         }
  718.     } else {  // (!pwc->db_flag)
  719.           POINTL ptl;
  720.           int col=-1, colold=-1,iold=0;
  721.           ptl.y = y;
  722.           ptl.x = x;
  723.  
  724.           if (mask)
  725.           {
  726.             for (i=0; i<n; i++,ptl.x++)
  727.                 if (mask[i])
  728.                 {   GpiSetColor(pwc->hps,LONGFromRGB(rgb[i][RCOMP],rgb[i][GCOMP], rgb[i][BCOMP]));
  729.                     GpiSetPel(pwc->hps, &ptl);
  730.                 }
  731.           } else {
  732.             GpiMove(pwc->hps,&ptl);
  733.             for (i=0; i<n; i++,ptl.x++)
  734.                 {   col = (int) LONGFromRGB(rgb[i][RCOMP],rgb[i][GCOMP], rgb[i][BCOMP]);
  735.                     if(col != colold)
  736.                     {  GpiSetColor(pwc->hps,col);
  737.                        GpiLine(pwc->hps,&ptl);
  738.                        colold = col;
  739.                        iold = i;
  740.                     }
  741.                 }
  742.                 if(iold != n-1)
  743.                     {  ptl.x--;
  744.                       // GpiSetColor(pwc->hps,col);
  745.                        GpiLine(pwc->hps,&ptl);
  746.                     }
  747.          } //endif(mask)
  748.       } //endif(pwc->db_flag)
  749. }
  750.  
  751. /*
  752. * Write a horizontal span of pixels with a boolean mask all with the same color
  753. */
  754. static void write_mono_rgba_span( const GLcontext* ctx,
  755.                                   GLuint n, GLint x, GLint y,
  756.                                   const GLchan color[4], const GLubyte mask[])
  757. {
  758.     GLuint i;
  759.     PWMC pwc = Current;
  760.     assert(Current->rgb_flag==GL_TRUE);
  761.     if(pwc->db_flag)
  762.     { if(mask)
  763.       { for (i=0; i<n; i++)
  764.             if (mask[i])
  765.                  wmSetPixel(pwc,y,x+i,color[RCOMP], color[GCOMP], color[BCOMP]);
  766.       } else {
  767.         for (i=0; i<n; i++)
  768.                  wmSetPixel(pwc,y,x+i,color[RCOMP], color[GCOMP], color[BCOMP]);
  769.       }
  770.     } else {
  771.      POINTL   Point;  /*  Position in world coordinates. */
  772.      LONG l_Color = LONGFromRGB(color[RCOMP], color[GCOMP], color[BCOMP]);
  773.  
  774.         Point.y = y;
  775.         GpiSetColor(pwc->hps,l_Color);
  776.         if(mask)
  777.         { for (i=0; i<n; i++)
  778.             if (mask[i])
  779.             {  Point.x = x+i;
  780.                GpiSetPel(pwc->hps, &Point);
  781.             }
  782.         } else {
  783.             Point.x = x;
  784.             if(n <= 1)   GpiSetPel(pwc->hps, &Point);
  785.             else
  786.             {  GpiMove(pwc->hps,&Point);
  787.                Point.x += n-1;
  788.                GpiLine(pwc->hps,&Point);
  789.             }
  790.         }
  791.     }
  792. }
  793. /*************************************************/
  794. /*** optimized N-bytes per pixel functions    ****/
  795. /*************************************************/
  796. //static void write_clear_rgba_span_4rgb_db( const GLcontext* ctx, GLuint n, GLint x, GLint y,
  797. //                             const GLubyte rgba[4])
  798.  
  799. static void write_mono_rgba_span_4rgb_db( const GLcontext* ctx,
  800.                                   GLuint n, GLint x, GLint y,
  801.                                   const GLchan color[4], const GLubyte mask[])
  802. {
  803.     PWMC    pwc = Current;
  804.     GLuint i;
  805.     PBYTE  lpb = pwc->pbPixels;
  806.     UINT  *lpdw, col;
  807.         // Now move to the desired pixel
  808.     lpdw = (UINT  *)(lpb + pwc->ScanWidth * y);
  809.     lpdw += x;
  810.     col = ((UINT)color[BCOMP]) | (((UINT)color[GCOMP])<<8 ) |
  811.           (((UINT)color[RCOMP])<<16)| (((UINT)color[ACOMP])<<24);
  812.  
  813.      if (mask)
  814.      {  for (i=0; i<n; i++)
  815.               if (mask[i])
  816.               {  lpdw[i] = col;
  817.               }
  818.      } else {
  819.          for (i=0; i<n; i++,lpdw++)  *lpdw = col;
  820.      }
  821. }
  822.  
  823. //static void write_clear_rgba_span_3rgb_db( const GLcontext* ctx, GLuint n, GLint x, GLint y,
  824. //                             const GLubyte rgba[4])
  825. static void write_mono_rgba_span_3rgb_db( const GLcontext* ctx,
  826.                                   GLuint n, GLint x, GLint y,
  827.                                   const GLchan color[4], const GLubyte mask[])
  828. {
  829.  
  830.     PWMC    pwc = Current;
  831.     GLuint i;
  832.     PBYTE  lpb = pwc->pbPixels, pixel;
  833.     UINT  *lpdw, col;
  834.         // Now move to the desired pixel
  835.     lpb += pwc->ScanWidth * y +x*3;
  836.     if (mask)
  837.     {  for (i=0; i<n; i++)
  838.          if (mask[i])
  839.           { pixel = lpb+i*3;
  840.             pixel[0] = color[2];
  841.             pixel[1] = color[1];
  842.             pixel[2] = color[0];
  843.           }
  844.  
  845.     } else {
  846.       col = ((UINT)color[BCOMP]) | (((UINT)color[GCOMP])<<8 ) |  (((UINT)color[RCOMP])<<16);
  847.        for (i=0; i<n-1; i++,lpb+=3)
  848.        { lpdw = (UINT  *)lpb;
  849.          *lpdw = col;
  850.        }
  851.        lpdw = (UINT  *)lpb;
  852.        *lpdw = col | ((*lpdw)&0xff0000);
  853.     }
  854.  
  855. }
  856.  
  857. /* Write a horizontal span of RGBA color pixels with a boolean mask. */
  858. static void write_rgba_span_4rgb_db( const GLcontext* ctx, GLuint n, GLint x, GLint y,
  859.                              const GLubyte rgba[][4], const GLubyte mask[] )
  860. {
  861.     PWMC    pwc = Current;
  862.     GLuint i;
  863.     PBYTE  lpb = pwc->pbPixels;
  864.     UINT  *lpdw;
  865.     lpb += pwc->ScanWidth * y;
  866.         // Now move to the desired pixel
  867.     lpb += x * 4;
  868.  
  869.      if (mask)
  870.      {
  871.             for (i=0; i<n; i++)
  872.                 if (mask[i])
  873.                     wmSetPixel_db4(pwc, y, x + i, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
  874.      } else {
  875.         lpdw = (UINT  *)lpb;
  876. //???                 memcpy(lpb,rgba,n*4);
  877.                  for (i=0; i<n; i++,lpdw++)
  878.                     *lpdw = ((UINT)rgba[i][BCOMP]) | (((UINT)rgba[i][GCOMP])<<8 )|  (((UINT)rgba[i][RCOMP])<<16);
  879. //                     *lpdw = BGR32(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
  880. //#define BGR32(r,g,b) (unsigned long)((DWORD)(((BYTE)(b)|((WORD)((BYTE)(g))<<8))|(((DWORD)(BYTE)(r))<<16)))
  881.      }
  882.  
  883. }
  884.  
  885. /* Write a horizontal span of RGBA color pixels with a boolean mask. */
  886. static void write_rgba_span_3rgb_db( const GLcontext* ctx, GLuint n, GLint x, GLint y,
  887.                              const GLubyte rgba[][4], const GLubyte mask[] )
  888. {
  889.     PWMC    pwc = Current;
  890.     GLuint i;
  891.     PBYTE  lpb = pwc->pbPixels;
  892.     UINT  *lpdw;
  893.     lpb += pwc->ScanWidth * y;
  894.         // Now move to the desired pixel
  895.     lpb += x * 3;
  896.  
  897.      if (mask)
  898.      {
  899.             for (i=0; i<n; i++)
  900.                 if (mask[i])
  901.                     wmSetPixel_db3(pwc, y, x + i, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
  902.      } else {
  903.            for (i=0; i<n; i++)
  904.             {
  905. ///                *lpdw = ((UINT)rgba[i][BCOMP]) | (((UINT)rgba[i][GCOMP])<<8 )|  (((UINT)rgba[i][RCOMP])<<16);
  906.                    *lpb++ = rgba[i][BCOMP]; // in memory: b-g-r bytes
  907.                    *lpb++ = rgba[i][GCOMP];
  908.                    *lpb++ = rgba[i][RCOMP];
  909.             }
  910. //                     *lpdw = BGR32(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
  911. //#define BGR32(r,g,b) (unsigned long)((DWORD)(((BYTE)(b)|((WORD)((BYTE)(g))<<8))|(((DWORD)(BYTE)(r))<<16)))
  912.      }
  913.  
  914. }
  915. /* Write a horizontal span of RGBA color pixels with a boolean mask. */
  916. static void write_rgba_span_2rgb_db( const GLcontext* ctx, GLuint n, GLint x, GLint y,
  917.                              const GLubyte rgba[][4], const GLubyte mask[] )
  918. {
  919.     PWMC    pwc = Current;
  920.     GLuint i;
  921.     PBYTE  lpb = pwc->pbPixels;
  922.     UINT  *lpdw;
  923.     unsigned short int *lpw;
  924.  
  925.     lpb += pwc->ScanWidth * y;
  926.         // Now move to the desired pixel
  927.     lpb += x * 2;
  928.  
  929.      if (mask)
  930.      {
  931.             for (i=0; i<n; i++)
  932.                 if (mask[i])
  933.                     wmSetPixel_db2(pwc, y, x + i, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
  934.      } else {
  935.                lpw = (unsigned short int  *)lpb;
  936.                  for (i=0; i<n; i++,lpw++)
  937.                       *lpw = BGR16(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
  938.      }
  939.  
  940. }
  941.  
  942.  
  943. /**********************************************************************/
  944. /*****                   Array-based pixel drawing                *****/
  945. /**********************************************************************/
  946.  
  947. /* Write an array of 32-bit index pixels with a boolean mask. */
  948. static void write_ci32_pixels( const GLcontext* ctx,
  949.                                GLuint n, const GLint x[], const GLint y[],
  950.                                const GLuint index[], const GLubyte mask[] )
  951. {
  952.    GLuint i;
  953.    assert(Current->rgb_flag==GL_FALSE);
  954.    for (i=0; i<n; i++) {
  955.       if (mask[i]) {
  956.          BYTE *Mem=Current->ScreenMem + y[i] * Current->ScanWidth + x[i];
  957.          *Mem = index[i];
  958.       }
  959.    }
  960. }
  961.  
  962.  
  963. /*
  964. * Write an array of pixels with a boolean mask.  The current color
  965. * index is used for all pixels.
  966. */
  967. static void write_mono_ci_pixels( const GLcontext* ctx,
  968.                                   GLuint n,
  969.                                   const GLint x[], const GLint y[],
  970.                                   GLuint colorIndex, const GLubyte mask[] )
  971. {
  972.    GLuint i;
  973.    assert(Current->rgb_flag==GL_FALSE);
  974.    for (i=0; i<n; i++) {
  975.       if (mask[i]) {
  976.          BYTE *Mem=Current->ScreenMem + y[i] * Current->ScanWidth + x[i];
  977.          *Mem = (BYTE)  colorIndex;
  978.       }
  979.    }
  980. }
  981.  
  982.  
  983.  
  984. /* Write an array of RGBA pixels with a boolean mask. */
  985. static void write_rgba_pixels( const GLcontext* ctx,
  986.                                GLuint n, const GLint x[], const GLint y[],
  987.                                const GLubyte rgba[][4], const GLubyte mask[] )
  988. {
  989.         GLuint i;
  990.     PWMC    pwc = Current;
  991. //  HDC DC=DD_GETDC;
  992.     assert(Current->rgb_flag==GL_TRUE);
  993.     for (i=0; i<n; i++)
  994.        if (mask[i])
  995.           wmSetPixel(pwc, y[i],x[i],rgba[i][RCOMP],rgba[i][GCOMP],rgba[i][BCOMP]);
  996. //  DD_RELEASEDC;
  997. }
  998.  
  999.  
  1000.  
  1001. /*
  1002. * Write an array of pixels with a boolean mask.  The current color
  1003. * is used for all pixels.
  1004. */
  1005. static void write_mono_rgba_pixels( const GLcontext* ctx,
  1006.                                     GLuint n,
  1007.                                     const GLint x[], const GLint y[],
  1008.                                     const GLchan color[4],
  1009.                                     const GLubyte mask[] )
  1010. {
  1011.     GLuint i;
  1012.     PWMC    pwc = Current;
  1013. //  HDC DC=DD_GETDC;
  1014.     assert(Current->rgb_flag==GL_TRUE);
  1015.     for (i=0; i<n; i++)
  1016.         if (mask[i])
  1017.              wmSetPixel(pwc, y[i],x[i],color[RCOMP],
  1018.                     color[GCOMP], color[BCOMP]);
  1019. //  DD_RELEASEDC;
  1020. }
  1021.  
  1022. /**********************************************************************/
  1023. /*****            Read spans/arrays of pixels                     *****/
  1024. /**********************************************************************/
  1025.  
  1026. /* Read a horizontal span of color-index pixels. */
  1027. static void read_ci32_span( const GLcontext* ctx, GLuint n, GLint x, GLint y,
  1028.                             GLuint index[])
  1029. {
  1030.    GLuint i;
  1031.    BYTE *Mem=Current->ScreenMem + y *Current->ScanWidth+x;
  1032.    assert(Current->rgb_flag==GL_FALSE);
  1033.    for (i=0; i<n; i++)
  1034.       index[i]=Mem[i];
  1035. }
  1036.  
  1037.  
  1038.  
  1039.  
  1040. /* Read an array of color index pixels. */
  1041. static void read_ci32_pixels( const GLcontext* ctx,
  1042.                               GLuint n, const GLint x[], const GLint y[],
  1043.                               GLuint indx[], const GLubyte mask[] )
  1044. {
  1045.    GLuint i;
  1046.    assert(Current->rgb_flag==GL_FALSE);
  1047.    for (i=0; i<n; i++) {
  1048.       if (mask[i]) {
  1049.          indx[i]=*(Current->ScreenMem + y[i] * Current->ScanWidth+x[i]);
  1050.       }
  1051.    }
  1052. }
  1053.  
  1054.  
  1055.  
  1056. /* Read a horizontal span of color pixels. */
  1057. static void read_rgba_span( const GLcontext* ctx,
  1058.                             GLuint n, GLint x, GLint y,
  1059.                             GLubyte rgba[][4] )
  1060. {
  1061.    UINT i;
  1062.    LONG Color;
  1063.    PWMC pwc = Current;
  1064.  
  1065.    if(Current->db_flag)
  1066.    {    UINT    nBypp = pwc->nColorBits / 8;
  1067.         PBYTE  lpb = pwc->pbPixels;
  1068.         UINT  *lpdw;
  1069.         unsigned short int *lpw;
  1070.         lpb += pwc->ScanWidth * y;
  1071.         lpb += x * nBypp;
  1072. /*********************/
  1073.            if(nBypp == 1)
  1074.            {
  1075.                  for (i=0; i<n; i++,lpb++)
  1076.                  {     Color = (int)   *lpb;
  1077.                        rgba[i][RCOMP] = GetRValue(Color);
  1078.                        rgba[i][GCOMP] = GetGValue(Color);
  1079.                        rgba[i][BCOMP] = GetBValue(Color);
  1080.                        rgba[i][ACOMP] = 255;
  1081.                  }
  1082.            } else if(nBypp == 2) {
  1083.               lpw = (unsigned short int *)lpb;
  1084.                  for (i=0; i<n; i++,lpw++)
  1085.                  {     Color = (int) (*lpw);
  1086.                        rgba[i][RCOMP] = GetRValue(Color);
  1087.                        rgba[i][GCOMP] = GetGValue(Color);
  1088.                        rgba[i][BCOMP] = GetBValue(Color);
  1089.                        rgba[i][ACOMP] = 255;
  1090.                  }
  1091.            } else if (nBypp == 3) {
  1092.  
  1093.                  for (i=0; i<n; i++,lpb+=3)
  1094.                  {  // GLubyte rtst[4];
  1095.                      lpdw = (UINT  *)lpb;
  1096. //                        Color = (int) (*lpdw);
  1097. //                      *((int *)&rtst) = Color;
  1098. //                      rtst[RCOMP] = GetRValue(Color);
  1099. //                      rtst[GCOMP] = GetGValue(Color);
  1100. //                      rtst[BCOMP] = GetBValue(Color);
  1101. //                      rtst[ACOMP] = 255;
  1102.                       *((int *)&rgba[i]) = (int) (*lpdw);
  1103. //                       rgba[i][RCOMP] = GetRValue(Color);
  1104. //                       rgba[i][GCOMP] = GetGValue(Color);
  1105. //                       rgba[i][BCOMP] = GetBValue(Color);
  1106.                        rgba[i][ACOMP] = 255;
  1107.                  }
  1108.  
  1109.   //                  *lpdw = BGR24(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
  1110.            } else if (nBypp == 4) {
  1111.                 lpdw = (UINT  *)lpb;
  1112.                  for (i=0; i<n; i++,lpdw++)
  1113.                  {     Color = (int) (*lpdw);
  1114.                        rgba[i][RCOMP] = GetRValue(Color);
  1115.                        rgba[i][GCOMP] = GetGValue(Color);
  1116.                        rgba[i][BCOMP] = GetBValue(Color);
  1117.                        rgba[i][ACOMP] = 255;
  1118.                  }
  1119.  
  1120. //                    *lpdw = ((UINT)rgba[i][BCOMP]) | (((UINT)rgba[i][GCOMP])<<8 )|  (((UINT)rgba[i][RCOMP])<<16);
  1121. //                     *lpdw = BGR32(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
  1122. //#define BGR32(r,g,b) (unsigned long)((DWORD)(((BYTE)(b)|((WORD)((BYTE)(g))<<8))|(((DWORD)(BYTE)(r))<<16)))
  1123.  
  1124.            }
  1125.  
  1126. /*********************/
  1127.    } else {
  1128.      for (i=0; i<n; i++,x++)
  1129.      {
  1130.        Color = wmGetPixel(pwc,x, y); // GpiQueryPel(Current->hps, &Point);
  1131.        rgba[i][RCOMP] = GetRValue(Color);
  1132.        rgba[i][GCOMP] = GetGValue(Color);
  1133.        rgba[i][BCOMP] = GetBValue(Color);
  1134.        rgba[i][ACOMP] = 255;
  1135.      }
  1136.    }
  1137. }
  1138.  
  1139.  
  1140. /* Read an array of color pixels. */
  1141. static void read_rgba_pixels( const GLcontext* ctx,
  1142.                               GLuint n, const GLint x[], const GLint y[],
  1143.                               GLubyte rgba[][4], const GLubyte mask[] )
  1144. {
  1145.    GLuint i;
  1146.    LONG Color;
  1147.    PWMC pwc = Current;
  1148.  
  1149.    assert(Current->rgb_flag==GL_TRUE);
  1150.  
  1151.    for (i=0; i<n; i++) {
  1152.       if (mask[i]) {
  1153. //        Color = GpiQueryPel(Current->hps, &Point);
  1154.         Color = wmGetPixel(pwc,x[i], y[i]); // GpiQueryPel(Current->hps, &Point);
  1155.         rgba[i][RCOMP] = GetRValue(Color);
  1156.          rgba[i][GCOMP] = GetGValue(Color);
  1157.          rgba[i][BCOMP] = GetBValue(Color);
  1158.          rgba[i][ACOMP] = 255;
  1159. //??         rgba[i][ACOMP] = 0;
  1160.       }
  1161.    }
  1162. }
  1163.  
  1164.  
  1165.  
  1166. static const GLubyte *OS2get_string( GLcontext *ctx, GLenum name )
  1167. {
  1168.    switch (name)
  1169.    {  case GL_RENDERER:
  1170.          return (const GLubyte *) "WarpMesaGL OS/2 PM GPI";
  1171.       case GL_VENDOR:
  1172.          return (const GLubyte *) "Evgeny Kotsuba";
  1173.       default:
  1174.          return NULL;
  1175.    }
  1176. }
  1177.  
  1178. static void SetFunctionPointers(GLcontext *ctx)
  1179. {
  1180.   struct swrast_device_driver *swdd = _swrast_GetDeviceDriverReference( ctx );
  1181.   ctx->Driver.GetString = OS2get_string;
  1182. // ctx->Driver.UpdateState = wmesa_update_state;
  1183.    ctx->Driver.UpdateState = OS2mesa_update_state;
  1184.   ctx->Driver.ResizeBuffers = _swrast_alloc_buffers;
  1185.   ctx->Driver.GetBufferSize = get_buffer_size;
  1186.  
  1187.   ctx->Driver.Accum = _swrast_Accum;
  1188.   ctx->Driver.Bitmap = _swrast_Bitmap;
  1189.   ctx->Driver.Clear = clear;
  1190.  
  1191. // warning EDC0068: Operation between types
  1192. // "void(* _Optlink)(struct __GLcontextRec*,unsigned int,unsigned char,int,int,int,int)" and
  1193. // "unsigned int(* _Optlink)(struct __GLcontextRec*,unsigned int,unsigned char,int,int,int,int)" is not allowed.
  1194.  
  1195.   ctx->Driver.Flush = flush;
  1196.   ctx->Driver.ClearIndex = clear_index;
  1197.   ctx->Driver.ClearColor = clear_color;
  1198.  
  1199. // warning EDC0068: Operation between types
  1200. //"void(* _Optlink)(struct __GLcontextRec*,const float*)" and
  1201. //"void(* _Optlink)(struct __GLcontextRec*,unsigned char,unsigned char,unsigned char,unsigned char)" is not allowed.
  1202.   ctx->Driver.Enable = enable;
  1203.  
  1204.   ctx->Driver.CopyPixels = _swrast_CopyPixels;
  1205.   ctx->Driver.DrawPixels = _swrast_DrawPixels;
  1206.   ctx->Driver.ReadPixels = _swrast_ReadPixels;
  1207.   ctx->Driver.DrawBuffer = _swrast_DrawBuffer;
  1208.  
  1209.   ctx->Driver.ChooseTextureFormat = _mesa_choose_tex_format;
  1210.   ctx->Driver.TexImage1D = _mesa_store_teximage1d;
  1211.   ctx->Driver.TexImage2D = _mesa_store_teximage2d;
  1212.   ctx->Driver.TexImage3D = _mesa_store_teximage3d;
  1213.   ctx->Driver.TexSubImage1D = _mesa_store_texsubimage1d;
  1214.   ctx->Driver.TexSubImage2D = _mesa_store_texsubimage2d;
  1215.   ctx->Driver.TexSubImage3D = _mesa_store_texsubimage3d;
  1216.   ctx->Driver.TestProxyTexImage = _mesa_test_proxy_teximage;
  1217.  
  1218.   ctx->Driver.CompressedTexImage1D = _mesa_store_compressed_teximage1d;
  1219.   ctx->Driver.CompressedTexImage2D = _mesa_store_compressed_teximage2d;
  1220.   ctx->Driver.CompressedTexImage3D = _mesa_store_compressed_teximage3d;
  1221.   ctx->Driver.CompressedTexSubImage1D = _mesa_store_compressed_texsubimage1d;
  1222.   ctx->Driver.CompressedTexSubImage2D = _mesa_store_compressed_texsubimage2d;
  1223.   ctx->Driver.CompressedTexSubImage3D = _mesa_store_compressed_texsubimage3d;
  1224.  
  1225.   ctx->Driver.CopyTexImage1D = _swrast_copy_teximage1d;
  1226.   ctx->Driver.CopyTexImage2D = _swrast_copy_teximage2d;
  1227.   ctx->Driver.CopyTexSubImage1D = _swrast_copy_texsubimage1d;
  1228.   ctx->Driver.CopyTexSubImage2D = _swrast_copy_texsubimage2d;
  1229.   ctx->Driver.CopyTexSubImage3D = _swrast_copy_texsubimage3d;
  1230.   ctx->Driver.CopyColorTable = _swrast_CopyColorTable;
  1231.   ctx->Driver.CopyColorSubTable = _swrast_CopyColorSubTable;
  1232.   ctx->Driver.CopyConvolutionFilter1D = _swrast_CopyConvolutionFilter1D;
  1233.   ctx->Driver.CopyConvolutionFilter2D = _swrast_CopyConvolutionFilter2D;
  1234.  
  1235.   swdd->SetBuffer = set_buffer;
  1236.  
  1237.   /* Pixel/span writing functions: */
  1238.   swdd->WriteRGBASpan        = write_rgba_span;
  1239.   swdd->WriteRGBSpan         = write_rgb_span;
  1240.   swdd->WriteMonoRGBASpan    = write_mono_rgba_span;
  1241.   swdd->WriteRGBAPixels      = write_rgba_pixels;
  1242.   swdd->WriteMonoRGBAPixels  = write_mono_rgba_pixels;
  1243.   swdd->WriteCI32Span        = write_ci32_span;
  1244.   swdd->WriteCI8Span         = write_ci8_span;
  1245.   swdd->WriteMonoCISpan      = write_mono_ci_span;
  1246.   swdd->WriteCI32Pixels      = write_ci32_pixels;
  1247.   swdd->WriteMonoCIPixels    = write_mono_ci_pixels;
  1248.  
  1249.   swdd->ReadCI32Span        = read_ci32_span;
  1250.   swdd->ReadRGBASpan        = read_rgba_span;
  1251.   swdd->ReadCI32Pixels      = read_ci32_pixels;
  1252.   swdd->ReadRGBAPixels      = read_rgba_pixels;
  1253.  
  1254. //  switch(ctx->DriverCtx.format)
  1255. //  {  case OSMESA_RGB:
  1256. //       break;
  1257. //  }
  1258.  
  1259.  
  1260. }
  1261. static void OS2mesa_update_state4( GLcontext* ctx, GLuint new_state   )
  1262. {
  1263.    struct swrast_device_driver *swdd = _swrast_GetDeviceDriverReference( ctx );
  1264.    OS2mesa_update_state( ctx,new_state );
  1265.    ctx->Driver.UpdateState = OS2mesa_update_state4;
  1266.    swdd->WriteRGBASpan        = write_rgba_span_4rgb_db;
  1267.    swdd->WriteMonoRGBASpan    = write_mono_rgba_span_4rgb_db;
  1268. //   swdd->WriteClearRGBASpan   = write_clear_rgba_span_4rgb_db;
  1269. }
  1270.  
  1271. static void OS2mesa_update_state3( GLcontext* ctx, GLuint new_state   )
  1272. {
  1273.    struct swrast_device_driver *swdd = _swrast_GetDeviceDriverReference( ctx );
  1274.    OS2mesa_update_state( ctx,new_state );
  1275.    ctx->Driver.UpdateState = OS2mesa_update_state3;
  1276.    swdd->WriteRGBASpan        = write_rgba_span_3rgb_db;
  1277.    swdd->WriteMonoRGBASpan    = write_mono_rgba_span_3rgb_db;
  1278. //   swdd->WriteClearRGBASpan   = write_clear_rgba_span_3rgb_db;
  1279. }
  1280.  
  1281. static void OS2mesa_update_state2( GLcontext* ctx, GLuint new_state   )
  1282. {
  1283.    struct swrast_device_driver *swdd = _swrast_GetDeviceDriverReference( ctx );
  1284.    OS2mesa_update_state( ctx,new_state );
  1285.    ctx->Driver.UpdateState = OS2mesa_update_state2;
  1286.    swdd->WriteRGBASpan        = write_rgba_span_2rgb_db;
  1287. //   swdd->WriteClearRGBASpan   = write_clear_rgba_span_2rgb_db;
  1288. }
  1289.  
  1290. static void OS2mesa_update_state1( GLcontext* ctx, GLuint new_state   )
  1291. {
  1292. //   struct swrast_device_driver *swdd = _swrast_GetDeviceDriverReference( ctx );
  1293.    OS2mesa_update_state( ctx,new_state );
  1294.    ctx->Driver.UpdateState = OS2mesa_update_state1;
  1295. //   ctx->Driver.WriteRGBASpan        = write_rgba_span_3rgb_db;
  1296. //   ctx->Driver.WriteClearRGBASpan   = write_clear_rgba_span_3rgb_db;
  1297. }
  1298.  
  1299. static void OS2mesa_update_state( GLcontext* ctx, GLuint new_state  )
  1300. {
  1301.   struct swrast_device_driver *swdd = _swrast_GetDeviceDriverReference( ctx );
  1302.   TNLcontext *tnl = TNL_CONTEXT(ctx);
  1303.  
  1304.   /*
  1305.    * XXX these function pointers could be initialized just once during
  1306.    * context creation since they don't depend on any state changes.
  1307.    * kws - This is true - this function gets called a lot and it
  1308.    * would be good to minimize setting all this when not needed.
  1309.    */
  1310. #ifndef SET_FPOINTERS_ONCE
  1311.   SetFunctionPointers(ctx);
  1312. #endif //  !SET_FPOINTERS_ONCE
  1313.   tnl->Driver.RunPipeline = _tnl_run_pipeline;
  1314.  
  1315.   _swrast_InvalidateState( ctx, new_state );
  1316.   _swsetup_InvalidateState( ctx, new_state );
  1317.   _ac_InvalidateState( ctx, new_state );
  1318.   _tnl_InvalidateState( ctx, new_state );
  1319.  
  1320. }
  1321. /***********************************************/
  1322.  
  1323. WMesaContext WMesaCreateContext
  1324.         ( HWND hWnd, HPAL* Pal, HPS   hpsCurrent, HAB hab,
  1325.           GLboolean rgb_flag, GLboolean db_flag, int useDive )
  1326. //todo ??                               GLboolean alpha_flag )
  1327. {
  1328.     RECTL CR;
  1329.     WMesaContext c;
  1330.     GLboolean true_color_flag;
  1331.     UINT  nBypp;
  1332.     int rc;
  1333.  
  1334.     c = (struct wmesa_context * ) calloc(1,sizeof(struct wmesa_context));
  1335.     if (!c)
  1336.         return NULL;
  1337.  
  1338.     c->Window=hWnd;
  1339.     c->hDC = WinQueryWindowDC(hWnd);
  1340.     c->hps = hpsCurrent;
  1341.     c->hab = hab;
  1342.     if(!db_flag)
  1343.         useDive = 0; /* DIVE can be used only with db */
  1344.  
  1345.     c->hDive = NULLHANDLE;
  1346. //printf("2 useDive=%i\n",useDive);
  1347.     if(useDive)
  1348.     {       rc = DivePMInit(c);
  1349.             if(rc)
  1350.             { useDive = 0;
  1351.             }
  1352.     }
  1353.     c->useDive = useDive;
  1354. //??    true_color_flag = GetDeviceCaps(c->hDC, BITSPIXEL) > 8;
  1355.     true_color_flag = 1;
  1356.     c->dither_flag = GL_FALSE;
  1357. #ifdef DITHER
  1358.     if ((true_color_flag==GL_FALSE) && (rgb_flag == GL_TRUE)){
  1359.         c->dither_flag = GL_TRUE;
  1360.         c->hPalHalfTone = WinGCreateHalftonePalette();
  1361.     }
  1362.     else
  1363.         c->dither_flag = GL_FALSE;
  1364. #else
  1365.     c->dither_flag = GL_FALSE;
  1366. #endif
  1367.  
  1368.  
  1369.     if (rgb_flag==GL_FALSE)
  1370.     {
  1371.         c->rgb_flag = GL_FALSE;
  1372.         //    c->pixel = 1;
  1373.         c->db_flag = db_flag =GL_TRUE; // WinG requires double buffering
  1374.         printf("Single buffer is not supported in color index mode, setting to double buffer.\n");
  1375.     }
  1376.     else
  1377.     {
  1378.         c->rgb_flag = GL_TRUE;
  1379.         //    c->pixel = 0;
  1380.     }
  1381.     WinQueryWindowRect(c->Window,&CR);
  1382.     c->width=CR.xRight - CR.xLeft;
  1383.     c->height=CR.yTop - CR.yBottom;
  1384.     if (db_flag)
  1385.     {
  1386.         c->db_flag = 1;
  1387.         /* Double buffered */
  1388. #ifndef DDRAW
  1389.         //  if (c->rgb_flag==GL_TRUE && c->dither_flag != GL_TRUE )
  1390.         {
  1391.             wmCreateBackingStore(c, c->width, c->height);
  1392.  
  1393.         }
  1394. #endif
  1395.     }
  1396.     else
  1397.     {
  1398.         /* Single Buffered */
  1399.         if (c->rgb_flag)
  1400.             c->db_flag = 0;
  1401.     }
  1402.  
  1403. #ifdef DDRAW
  1404.     if (DDInit(c,hWnd) == GL_FALSE) {
  1405.         free( (void *) c );
  1406.         exit(1);
  1407.     }
  1408. #endif
  1409.  
  1410.  
  1411.     c->gl_visual = _mesa_create_visual(rgb_flag,
  1412.                                     db_flag,    /* db_flag */
  1413.                                     GL_FALSE,   /* stereo */
  1414.                                     8,8,8,8,    /* r, g, b, a bits , todo: alpha_flag ? 8 : 0,  alpha bits */
  1415.                                     0,          /* index bits */
  1416.                                     16,         /* depth_bits */
  1417.                                     8,          /* stencil_bits */
  1418.                                     16,16,16,/* accum_bits */
  1419.                                     16,      /* todo:  alpha_flag ? 16 : 0,  alpha accum */
  1420.                                     1);
  1421.  
  1422.     if (!c->gl_visual) {
  1423.         return NULL;
  1424.     }
  1425.     /* allocate a new Mesa context */
  1426.     c->gl_ctx = _mesa_create_context( c->gl_visual, NULL, (void *) c, GL_FALSE );
  1427.  
  1428.  
  1429.     if (!c->gl_ctx) {
  1430.        _mesa_destroy_visual( c->gl_visual );
  1431.         free(c);
  1432.         return NULL;
  1433.     }
  1434.  
  1435.   _mesa_enable_sw_extensions(c->gl_ctx);
  1436.   _mesa_enable_1_3_extensions(c->gl_ctx);
  1437.   _mesa_enable_1_4_extensions(c->gl_ctx);
  1438.  
  1439.   c->gl_buffer = _mesa_create_framebuffer( c->gl_visual,
  1440.                           c->gl_visual->depthBits > 0,
  1441.                           c->gl_visual->stencilBits > 0,
  1442.                           c->gl_visual->accumRedBits > 0,
  1443.                           1  /* alpha_flag  s/w alpha */ );
  1444.   if (!c->gl_buffer) {
  1445.     _mesa_destroy_visual( c->gl_visual );
  1446.     _mesa_free_context_data( c->gl_ctx );
  1447.     free(c);
  1448.     return NULL;
  1449.   }
  1450.  
  1451.  
  1452.     nBypp = c->nColorBits / 8;
  1453.     if(useDive)
  1454.     {
  1455.     printf("\aTodo Dive\n");
  1456.     exit(1);
  1457. //        if(nBypp == 4)
  1458. //          c->gl_ctx->Driver.UpdateState = OS2Dive_mesa_update_state4;
  1459. //        else
  1460. //            if(nBypp == 3)
  1461. //          c->gl_ctx->Driver.UpdateState = OS2Dive_mesa_update_state3;
  1462. //        else
  1463. //            if(nBypp == 2)
  1464. //          c->gl_ctx->Driver.UpdateState = OS2Dive_mesa_update_state2;
  1465. //        else
  1466. //          c->gl_ctx->Driver.UpdateState = OS2Dive_mesa_update_state1;
  1467.     } else {
  1468.        if(db_flag && rgb_flag)
  1469.        {
  1470.           if(nBypp == 4)
  1471.              c->gl_ctx->Driver.UpdateState = OS2mesa_update_state4;
  1472.           else
  1473.             if(nBypp == 3)
  1474.                  c->gl_ctx->Driver.UpdateState = OS2mesa_update_state3;
  1475.           else
  1476.             if(nBypp == 2)
  1477.                  c->gl_ctx->Driver.UpdateState = OS2mesa_update_state2;
  1478.           else
  1479.                  c->gl_ctx->Driver.UpdateState = OS2mesa_update_state1;
  1480.        }
  1481.          else
  1482.              c->gl_ctx->Driver.UpdateState = OS2mesa_update_state;
  1483.     }
  1484.  
  1485.   /* Initialize the software rasterizer and helper modules.
  1486.    */
  1487.   {
  1488.     GLcontext *ctx = c->gl_ctx;
  1489.     _swrast_CreateContext( ctx );
  1490.     _ac_CreateContext( ctx );
  1491.     _tnl_CreateContext( ctx );
  1492.     _swsetup_CreateContext( ctx );
  1493.  
  1494. #ifdef SET_FPOINTERS_ONCE
  1495.     SetFunctionPointers(ctx);
  1496. #endif // SET_FPOINTERS_ONCE
  1497.     _swsetup_Wakeup( ctx );
  1498.   }
  1499. #ifdef COMPILE_SETPIXEL
  1500.   ChooseSetPixel(c);
  1501. #endif
  1502.  
  1503.  
  1504.   return c;
  1505. }
  1506.  
  1507.  
  1508. void WMesaDestroyContext( void )
  1509. {
  1510. }
  1511.  
  1512.  
  1513.  
  1514. void WMesaMakeCurrent( WMesaContext c )
  1515. {
  1516.   if(!c){
  1517.     Current = c;
  1518.     return;
  1519.   }
  1520.  
  1521.   if(Current == c)
  1522.     return;
  1523.  
  1524.   Current = c;
  1525.   c->gl_ctx->Driver.UpdateState(c->gl_ctx,0);
  1526.   _mesa_make_current(c->gl_ctx, c->gl_buffer);
  1527.  
  1528.  
  1529.   if (Current->gl_ctx->Viewport.Width==0) {
  1530.     /* initialize viewport to window size */
  1531.     _mesa_Viewport( 0, 0, Current->width, Current->height );
  1532.     Current->gl_ctx->Scissor.Width = Current->width;
  1533.     Current->gl_ctx->Scissor.Height = Current->height;
  1534.   }
  1535.   if ((c->nColorBits <= 8 ) && (c->rgb_flag == GL_TRUE)){
  1536.     WMesaPaletteChange(c->hPalHalfTone);
  1537.   }
  1538.  
  1539. }
  1540.  
  1541. void WMesaSwapBuffers( void )
  1542. {
  1543. //    HDC DC = Current->hDC;
  1544.     if (Current->db_flag)
  1545.     { if( Current->useDive)
  1546.                DiveFlush(Current);
  1547.       else
  1548.                wmFlush(Current);
  1549.     }
  1550.  
  1551. }
  1552.  
  1553. void  WMesaPaletteChange(HPAL Pal)
  1554. {
  1555.     int vRet;
  1556. #if POKA
  1557.     LPPALETTEENTRY pPal;
  1558.     if (Current && (Current->rgb_flag==GL_FALSE || Current->dither_flag == GL_TRUE))
  1559.     {
  1560.         pPal = (PALETTEENTRY *)malloc( 256 * sizeof(PALETTEENTRY));
  1561.         Current->hPal=Pal;
  1562.         //  GetPaletteEntries( Pal, 0, 256, pPal );
  1563.         GetPalette( Pal, pPal );
  1564.         vRet = SetDIBColorTable(Current->dib.hDC,0,256,pPal);
  1565.         free( pPal );
  1566.     }
  1567. #endif /* POKA */
  1568. }
  1569.  
  1570. void  wmSetPixel(PWMC pwc, int iScanLine, int iPixel, BYTE r, BYTE g, BYTE b)
  1571. {
  1572.  POINTL ptl;
  1573.  
  1574.    if(Current->db_flag)
  1575.    {
  1576.         PBYTE  lpb; /* = pwc->pbPixels; */
  1577.         UINT  *lpdw;
  1578.         unsigned short int *lpw;
  1579.         UINT    nBypp = pwc->nColorBits >>3; /* /8 */
  1580. //        UINT    nOffset = iPixel % nBypp;
  1581.  
  1582.         // Move the pixel buffer pointer to the scanline that we
  1583.         // want to access
  1584.  
  1585.         //      pwc->dib.fFlushed = FALSE;
  1586.  
  1587. //        lpb += pwc->ScanWidth * iScanLine;
  1588.         // Now move to the desired pixel
  1589. //        lpb += iPixel * nBypp;
  1590.         lpb = (PBYTE)PIXELADDR(iPixel, iScanLine);
  1591.  
  1592.         if(nBypp == 1)
  1593.         {
  1594.             if(pwc->dither_flag)
  1595.                 *lpb = DITHER_RGB_2_8BIT(r,g,b,iScanLine,iPixel);
  1596.             else
  1597.                 *lpb = BGR8(r,g,b);
  1598.         } else if(nBypp == 2) {
  1599.             lpw = (unsigned short int *)lpb;
  1600.             *lpw = BGR16(r,g,b);
  1601.         } else if (nBypp == 3) {
  1602.            *lpb++ = b;
  1603.            *lpb++ = g;
  1604.            *lpb   = r;
  1605. //            lpdw = (UINT  *)lpb;
  1606. //            *lpdw = BGR24(r,g,b);
  1607.         } else if (nBypp == 4) {
  1608.             lpdw = (UINT  *)lpb;
  1609.             *lpdw = BGR32(r,g,b);
  1610.         }
  1611.     } else {
  1612.        ptl.y = iScanLine;
  1613.        ptl.x = iPixel;
  1614.        GpiSetColor(pwc->hps,LONGFromRGB(r,g,b));
  1615.        GpiSetPel(pwc->hps, &ptl);
  1616.     }
  1617. }
  1618.  
  1619. void  wmSetPixel_db1(PWMC pwc, int iScanLine, int iPixel, BYTE r, BYTE g, BYTE b)
  1620. {
  1621.    PBYTE  lpb;
  1622. // UINT    nBypp = 1
  1623.         // Move the pixel buffer pointer to the scanline that we
  1624.         // want to access
  1625.  
  1626.    lpb = (PBYTE)PIXELADDR_1(iPixel, iScanLine);
  1627.  
  1628.     if(pwc->dither_flag)
  1629.                 *lpb = DITHER_RGB_2_8BIT(r,g,b,iScanLine,iPixel);
  1630.     else
  1631.                 *lpb = BGR8(r,g,b);
  1632. }
  1633.  
  1634. void wmSetPixel_db2(PWMC pwc, int iScanLine, int iPixel, BYTE r, BYTE g, BYTE b)
  1635. {
  1636.     unsigned short int *lpw;
  1637. //  UINT    nBypp = 2
  1638.         // Move the pixel buffer pointer to the scanline that we
  1639.         // want to access
  1640.  
  1641.      lpw = (unsigned short int *)PIXELADDR_2(iPixel, iScanLine);
  1642.      *lpw = BGR16(r,g,b);
  1643. }
  1644.  
  1645. void wmSetPixel_db3(PWMC pwc, int iScanLine, int iPixel, BYTE r, BYTE g, BYTE b)
  1646. {
  1647. //    UINT  *lpdw;
  1648. //   UINT  lpdw;
  1649.     PBYTE  lpb;
  1650. //  UINT    nBypp = 3
  1651.     lpb = ( PBYTE)PIXELADDR_3(iPixel, iScanLine);
  1652. //    lpdw = (UINT  *)PIXELADDR_3(iPixel, iScanLine);
  1653.  
  1654. //    lpdw = BGR24(r,g,b);
  1655.  
  1656.     *lpb++ = b;
  1657.     *lpb++ = g;
  1658.     *lpb   = r;
  1659.  
  1660. }
  1661.  
  1662. void wmSetPixel_db4(PWMC pwc, int iScanLine, int iPixel, BYTE r, BYTE g, BYTE b)
  1663. {
  1664.     UINT  *lpdw;
  1665. //  UINT    nBypp = 4
  1666.     lpdw = (UINT  *)PIXELADDR_4(iPixel, iScanLine);
  1667.     *lpdw = BGR32(r,g,b);
  1668. }
  1669.  
  1670. int wmGetPixel(PWMC pwc, int x, int y)
  1671. {
  1672.    int val;
  1673.    if(Current->db_flag)
  1674.    {
  1675.         PBYTE  lpb = pwc->pbPixels;
  1676.         UINT  *lpdw;
  1677.         unsigned short int *lpw;
  1678.         UINT    nBypp = pwc->nColorBits / 8;
  1679. //      UINT    nOffset = x % nBypp;
  1680.  
  1681.         // Move the pixel buffer pointer to the scanline that we
  1682.         // want to access
  1683.  
  1684.         //      pwc->dib.fFlushed = FALSE;
  1685.  
  1686. //        lpb += pwc->ScanWidth * y;
  1687.         // Now move to the desired pixel
  1688. //        lpb += x * nBypp;
  1689.       lpb = (PBYTE)PIXELADDR(x, y);
  1690.  
  1691.  
  1692.         if(nBypp == 1)
  1693.         {
  1694.            //?? if(pwc->dither_flag)
  1695.            //??      *lpb = DITHER_RGB_2_8BIT(r,g,b,iScanLine,iPixel);
  1696.            //?? else
  1697.             val = (int) (*lpb);
  1698.         } else if(nBypp == 2) {
  1699.             lpw = (unsigned short int *)lpb;
  1700.             val = (int) (*lpw);
  1701.         } else if (nBypp == 3) {
  1702.             lpdw = (UINT  *)lpb;
  1703.             val  = ((int)(*lpdw)) & 0xffffff;
  1704.         } else if (nBypp == 4) {
  1705.             lpdw = (UINT  *)lpb;
  1706.             val  =  (int) (*lpdw);
  1707.         }
  1708.     } else {
  1709.        POINTL ptl;
  1710.        ptl.y = y;
  1711.        ptl.x = x;
  1712.        val = GpiQueryPel(pwc->hps, &ptl);
  1713.     }
  1714.     return val;
  1715. }
  1716.  
  1717. void wmCreateDIBSection( HDC   hDC,
  1718.                          PWMC pwc,    // handle of device context
  1719.                          CONST BITMAPINFO2 *pbmi  // address of structure containing bitmap size, format, and color data
  1720.                        )
  1721.                         // ,UINT iUsage)  // color data type indicator: RGB values or palette indices
  1722. {
  1723.     int   dwSize = 0,LbmpBuff;
  1724.     int   dwScanWidth;
  1725.     UINT    nBypp = pwc->nColorBits / 8;
  1726.     HDC     hic;
  1727.    PSZ pszData[4] = { "Display", NULL, NULL, NULL };
  1728.    SIZEL sizlPage = {0, 0};
  1729.    LONG alData[2];
  1730.  
  1731.     dwScanWidth = (((pwc->ScanWidth * nBypp)+ 3) & ~3);
  1732.  
  1733.     pwc->ScanWidth =pwc->pitch = dwScanWidth;
  1734.  
  1735. //    if (stereo_flag)
  1736. //        pwc->ScanWidth = 2* pwc->pitch;
  1737.  
  1738.     dwSize = sizeof(BITMAPINFO) + (dwScanWidth * pwc->height);
  1739.  
  1740.     pwc->memb.bNx = (pwc->width/32+1)*32;
  1741.     pwc->memb.bNy = (pwc->height/32+1)*32;
  1742.  
  1743.     pwc->memb.BytesPerBmpPixel = nBypp;
  1744.     LbmpBuff = pwc->memb.BytesPerBmpPixel * pwc->memb.bNx * pwc->memb.bNy+4;
  1745.  
  1746.     if(pwc->memb.pBmpBuffer)
  1747.     {  if(pwc->memb.LbmpBuff != LbmpBuff)
  1748.         {   pwc->memb.pBmpBuffer = (BYTE *) realloc(pwc->memb.pBmpBuffer,LbmpBuff);
  1749.         }
  1750.     } else {
  1751.        pwc->memb.pBmpBuffer = (BYTE *)malloc(LbmpBuff);
  1752.     }
  1753.     pwc->pbPixels = pwc->memb.pBmpBuffer;
  1754.     pwc->memb.LbmpBuff = LbmpBuff;
  1755.  
  1756.     pwc->memb.hdcMem = DevOpenDC(pwc->hab, OD_MEMORY, "*", 4, (PDEVOPENDATA) pszData, NULLHANDLE);
  1757.     pwc->memb.hpsMem = GpiCreatePS(pwc->hab, pwc->memb.hdcMem, &sizlPage,
  1758.           PU_PELS | GPIA_ASSOC | GPIT_MICRO);
  1759.  
  1760.  
  1761. }
  1762.  
  1763.  
  1764. BYTE DITHER_RGB_2_8BIT( int red, int green, int blue, int pixel, int scanline)
  1765. {
  1766.     char unsigned redtemp, greentemp, bluetemp, paletteindex;
  1767.  
  1768.     //*** now, look up each value in the halftone matrix
  1769.     //*** using an 8x8 ordered dither.
  1770.     redtemp = aDividedBy51[red]
  1771.         + (aModulo51[red] > aHalftone8x8[(pixel%8)*8
  1772.         + scanline%8]);
  1773.     greentemp = aDividedBy51[(char unsigned)green]
  1774.         + (aModulo51[green] > aHalftone8x8[
  1775.         (pixel%8)*8 + scanline%8]);
  1776.     bluetemp = aDividedBy51[(char unsigned)blue]
  1777.         + (aModulo51[blue] > aHalftone8x8[
  1778.         (pixel%8)*8 +scanline%8]);
  1779.  
  1780.     //*** recombine the halftoned rgb values into a palette index
  1781.     paletteindex =
  1782.         redtemp + aTimes6[greentemp] + aTimes36[bluetemp];
  1783.  
  1784.     //*** and translate through the wing halftone palette
  1785.     //*** translation vector to give the correct value.
  1786.     return aWinGHalftoneTranslation[paletteindex];
  1787. }
  1788.  
  1789. //
  1790. // Blit memory DC to screen DC
  1791. //
  1792. BOOL wmFlush(PWMC pwc)
  1793. {
  1794.     BOOL  bRet = 0;
  1795.     int   dwErr = 0;
  1796.     POINTL aptl[4];
  1797. extern GLUTwindow * __glutCurrentWindow;
  1798.     HBITMAP hbmpold;
  1799.     LONG rc;
  1800.     // Now search through the torus frames and mark used colors
  1801.     if(pwc->db_flag)
  1802.     {
  1803. //      if(isChange)
  1804.       {  if(pwc->hbm)
  1805.                 GpiDeleteBitmap(pwc->hbm);
  1806.          pwc->hbm = GpiCreateBitmap(pwc->memb.hpsMem, &pwc->bmi, CBM_INIT,
  1807.                                        (PBYTE)pwc->memb.pBmpBuffer, &(pwc->memb.bmi_mem));
  1808.          if(pwc->hbm == 0)
  1809.          {  printf("Error creating Bitmap\n");
  1810.          }
  1811.  
  1812.          hbmpold = GpiSetBitmap(pwc->memb.hpsMem,pwc->hbm);
  1813.       }
  1814. //      else
  1815. //      {    GpiSetBitmap(hpsMem,hbm);
  1816. //           GpiSetBitmapBits(hpsMem, 0,bmp.cy,(PBYTE) pBmpBuffer, pbmi);
  1817. //      }
  1818.  
  1819.       aptl[0].x = 0;       /* Lower-left corner of destination rectangle  */
  1820.       aptl[0].y = 0;       /* Lower-left corner of destination rectangle  */
  1821.       aptl[1].x = pwc->bmi.cx;  /* Upper-right corner of destination rectangle */
  1822.       aptl[1].y = pwc->bmi.cy; /* Upper-right corner of destination rectangle */
  1823.      /* Source-rectangle dimensions (in device coordinates)              */
  1824.       aptl[2].x = 0;      /* Lower-left corner of source rectangle       */
  1825.       aptl[2].y = 0;      /* Lower-left corner of source rectangle       */
  1826.       aptl[3].x = pwc->bmi.cx;
  1827.       aptl[3].y = pwc->bmi.cy;
  1828.  
  1829.      rc = GpiBitBlt(pwc->hps, pwc->memb.hpsMem,   3,   /* 4 Number of points in aptl */
  1830.          aptl, ROP_SRCCOPY,  BBO_IGNORE/* | BBO_PAL_COLORS*/ );
  1831.      if(rc = GPI_ERROR)
  1832.          {  printf("Error GpiBitBlt\n");
  1833.          }
  1834.  
  1835. //??            bRet = BitBlt(pwc->hDC, 0, 0, pwc->width, pwc->height,
  1836. //??                pwc->dib.hDC, 0, 0, SRCCOPY);
  1837.       GpiSetBitmap(pwc->memb.hpsMem,hbmpold);
  1838.     }
  1839.  
  1840.  
  1841.  
  1842.     return(TRUE);
  1843. }
  1844.  
  1845.  
  1846. static struct VideoDevConfigCaps VideoDevConfig = { 0 };
  1847.  
  1848. /* Å«½πτ¿Γ∞ ó¿ñÑ«¬«¡Σ¿úπpáµ¿ε »« »«½¡«⌐ »p«úpἼѠ*/
  1849. LONG *GetVideoConfig(HDC hdc)
  1850. {
  1851.    LONG lCount = CAPS_PHYS_COLORS;
  1852.    LONG lStart = CAPS_FAMILY; /* 0 */
  1853.    BOOL rc;
  1854.  
  1855.    if( hdc  || !VideoDevConfig.sts)
  1856.    {  rc = DevQueryCaps( hdc, lStart, lCount, VideoDevConfig.Caps );
  1857.       if(rc)
  1858.       {   VideoDevConfig.sts = 1;
  1859.           return VideoDevConfig.Caps;
  1860.       }
  1861.    } else {
  1862.             return VideoDevConfig.Caps;
  1863.    }
  1864.    return NULL;
  1865. }
  1866.  
  1867.  
  1868.