home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / mesa5.zip / mesa5src.zip / MesaDLL / drawpix.cpp < prev    next >
C/C++ Source or Header  |  2002-10-24  |  9KB  |  285 lines
  1. /* $Id: drawpix.c,v 1.63 2002/10/24 23:57:20 brianp Exp $ */
  2.  
  3. /*
  4.  * Mesa 3-D graphics library
  5.  * Version:  4.1
  6.  *
  7.  * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
  8.  *
  9.  * Permission is hereby granted, free of charge, to any person obtaining a
  10.  * copy of this software and associated documentation files (the "Software"),
  11.  * to deal in the Software without restriction, including without limitation
  12.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  13.  * and/or sell copies of the Software, and to permit persons to whom the
  14.  * Software is furnished to do so, subject to the following conditions:
  15.  *
  16.  * The above copyright notice and this permission notice shall be included
  17.  * in all copies or substantial portions of the Software.
  18.  *
  19.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20.  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  22.  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  23.  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  24.  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25.  */
  26.  
  27. #include "glheader.h"
  28. #include "imports.h"
  29. #include "colormac.h"
  30. #include "context.h"
  31. #include "drawpix.h"
  32. #include "feedback.h"
  33. #include "macros.h"
  34. #include "mmath.h"
  35. #include "state.h"
  36. #include "mtypes.h"
  37.  
  38.  
  39. /*
  40.  * Execute glDrawPixels
  41.  */
  42. void
  43. _mesa_DrawPixels( GLsizei width, GLsizei height,
  44.                   GLenum format, GLenum type, const GLvoid *pixels )
  45. {
  46.    GET_CURRENT_CONTEXT(ctx);
  47.    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
  48.  
  49.    if (width < 0 || height < 0) {
  50.       _mesa_error( ctx, GL_INVALID_VALUE, "glDrawPixels(width or height < 0" );
  51.       return;
  52.    }
  53.  
  54.    if (ctx->RenderMode==GL_RENDER) {
  55.       GLint x, y;
  56.       if (!pixels || !ctx->Current.RasterPosValid) {
  57.      return;
  58.       }
  59.  
  60.       if (ctx->NewState) {
  61.          _mesa_update_state(ctx);
  62.       }
  63.  
  64.       /* Round, to satisfy conformance tests (matches SGI's OpenGL) */
  65.       x = IROUND(ctx->Current.RasterPos[0]);
  66.       y = IROUND(ctx->Current.RasterPos[1]);
  67.  
  68.       ctx->OcclusionResult = GL_TRUE;
  69.       ctx->Driver.DrawPixels(ctx, x, y, width, height, format, type,
  70.                  &ctx->Unpack, pixels);
  71.    }
  72.    else if (ctx->RenderMode==GL_FEEDBACK) {
  73.       /* Feedback the current raster pos info */
  74.       if (ctx->Current.RasterPosValid) {
  75.      FLUSH_CURRENT( ctx, 0 );
  76.          FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_DRAW_PIXEL_TOKEN );
  77.          _mesa_feedback_vertex( ctx,
  78.                 ctx->Current.RasterPos,
  79.                 ctx->Current.RasterColor,
  80.                 ctx->Current.RasterIndex,
  81.                 ctx->Current.RasterTexCoords[0] );
  82.       }
  83.    }
  84.    else if (ctx->RenderMode==GL_SELECT) {
  85.       if (ctx->Current.RasterPosValid) {
  86.          _mesa_update_hitflag( ctx, ctx->Current.RasterPos[2] );
  87.       }
  88.    }
  89. }
  90.  
  91.  
  92.  
  93. void
  94. _mesa_ReadPixels( GLint x, GLint y, GLsizei width, GLsizei height,
  95.           GLenum format, GLenum type, GLvoid *pixels )
  96. {
  97.    GET_CURRENT_CONTEXT(ctx);
  98.    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
  99.  
  100.    if (width < 0 || height < 0) {
  101.       _mesa_error( ctx, GL_INVALID_VALUE,
  102.                    "glReadPixels(width=%d height=%d)", width, height );
  103.       return;
  104.    }
  105.  
  106.    if (!pixels) {
  107.       _mesa_error( ctx, GL_INVALID_VALUE, "glReadPixels(pixels)" );
  108.       return;
  109.    }
  110.  
  111.    if (ctx->NewState)
  112.       _mesa_update_state(ctx);
  113.  
  114.    ctx->Driver.ReadPixels(ctx, x, y, width, height,
  115.               format, type, &ctx->Pack, pixels);
  116. }
  117.  
  118.  
  119.  
  120. void
  121. _mesa_CopyPixels( GLint srcx, GLint srcy, GLsizei width, GLsizei height,
  122.                   GLenum type )
  123. {
  124.    GET_CURRENT_CONTEXT(ctx);
  125.    GLint destx, desty;
  126.    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
  127.  
  128.    if (width < 0 || height < 0) {
  129.       _mesa_error( ctx, GL_INVALID_VALUE, "glCopyPixels(width or height < 0)" );
  130.       return;
  131.    }
  132.  
  133.    if (ctx->NewState) {
  134.       _mesa_update_state(ctx);
  135.    }
  136.  
  137.    if (ctx->RenderMode==GL_RENDER) {
  138.       /* Destination of copy: */
  139.       if (!ctx->Current.RasterPosValid) {
  140.      return;
  141.       }
  142.  
  143.       /* Round, to satisfy conformance tests (matches SGI's OpenGL) */
  144.       destx = IROUND(ctx->Current.RasterPos[0]);
  145.       desty = IROUND(ctx->Current.RasterPos[1]);
  146.  
  147.       ctx->OcclusionResult = GL_TRUE;
  148.  
  149.       ctx->Driver.CopyPixels( ctx, srcx, srcy, width, height, destx, desty,
  150.                   type );
  151.    }
  152.    else if (ctx->RenderMode == GL_FEEDBACK) {
  153.       if (ctx->Current.RasterPosValid) {
  154.          FLUSH_CURRENT( ctx, 0 );
  155.          FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_COPY_PIXEL_TOKEN );
  156.          _mesa_feedback_vertex( ctx, 
  157.                                 ctx->Current.RasterPos,
  158.                                 ctx->Current.RasterColor,
  159.                                 ctx->Current.RasterIndex,
  160.                                 ctx->Current.RasterTexCoords[0] );
  161.       }
  162.    }
  163.    else if (ctx->RenderMode == GL_SELECT) {
  164.       _mesa_update_hitflag( ctx, ctx->Current.RasterPos[2] );
  165.    }
  166. }
  167.  
  168.  
  169.  
  170. void
  171. _mesa_Bitmap( GLsizei width, GLsizei height,
  172.               GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove,
  173.               const GLubyte *bitmap )
  174. {
  175.    GET_CURRENT_CONTEXT(ctx);
  176.    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
  177.  
  178.    if (width < 0 || height < 0) {
  179.       _mesa_error( ctx, GL_INVALID_VALUE, "glBitmap(width or height < 0)" );
  180.       return;
  181.    }
  182.  
  183.    if (ctx->Current.RasterPosValid == GL_FALSE) {
  184.       return;    /* do nothing */
  185.    }
  186.  
  187.    if (ctx->RenderMode==GL_RENDER) {
  188.       if (bitmap) {
  189.          /* Truncate, to satisfy conformance tests (matches SGI's OpenGL). */
  190.          GLint x = IFLOOR(ctx->Current.RasterPos[0] - xorig);
  191.          GLint y = IFLOOR(ctx->Current.RasterPos[1] - yorig);
  192.  
  193.          if (ctx->NewState) {
  194.             _mesa_update_state(ctx);
  195.          }
  196.  
  197.          ctx->OcclusionResult = GL_TRUE;
  198.      ctx->Driver.Bitmap( ctx, x, y, width, height, &ctx->Unpack, bitmap );
  199.       }
  200.    }
  201.    else if (ctx->RenderMode==GL_FEEDBACK) {
  202.       if (ctx->Current.RasterPosValid) {
  203.      FLUSH_CURRENT(ctx, 0);
  204.          FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_BITMAP_TOKEN );
  205.          _mesa_feedback_vertex( ctx,
  206.                 ctx->Current.RasterPos,
  207.                 ctx->Current.RasterColor,
  208.                 ctx->Current.RasterIndex, 
  209.                 ctx->Current.RasterTexCoords[0] );
  210.       }
  211.    }
  212.    else if (ctx->RenderMode==GL_SELECT) {
  213.       /* Bitmaps don't generate selection hits.  See appendix B of 1.1 spec. */
  214.    }
  215.  
  216.    /* update raster position */
  217.    ctx->Current.RasterPos[0] += xmove;
  218.    ctx->Current.RasterPos[1] += ymove;
  219. }
  220.  
  221.  
  222.  
  223. #if 0  /* experimental */
  224. /*
  225.  * Execute glDrawDepthPixelsMESA().  This function accepts both a color
  226.  * image and depth (Z) image.  Rasterization produces fragments with
  227.  * color and Z taken from these images.  This function is intended for
  228.  * Z-compositing.  Normally, this operation requires two glDrawPixels
  229.  * calls with stencil testing.
  230.  */
  231. void
  232. _mesa_DrawDepthPixelsMESA( GLsizei width, GLsizei height,
  233.                            GLenum colorFormat, GLenum colorType,
  234.                            const GLvoid *colors,
  235.                            GLenum depthType, const GLvoid *depths )
  236. {
  237.    GET_CURRENT_CONTEXT(ctx);
  238.    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
  239.  
  240.    if (width < 0 || height < 0) {
  241.       _mesa_error( ctx, GL_INVALID_VALUE,
  242.                    "glDrawDepthPixelsMESA(width or height < 0" );
  243.       return;
  244.    }
  245.  
  246.    if (ctx->RenderMode==GL_RENDER) {
  247.       GLint x, y;
  248.       if (!colors || !depths || !ctx->Current.RasterPosValid) {
  249.      return;
  250.       }
  251.  
  252.       if (ctx->NewState) {
  253.          _mesa_update_state(ctx);
  254.       }
  255.  
  256.       /* Round, to satisfy conformance tests (matches SGI's OpenGL) */
  257.       x = IROUND(ctx->Current.RasterPos[0]);
  258.       y = IROUND(ctx->Current.RasterPos[1]);
  259.  
  260.       ctx->OcclusionResult = GL_TRUE;
  261.       ctx->Driver.DrawDepthPixelsMESA(ctx, x, y, width, height,
  262.                                       colorFormat, colorType, colors,
  263.                                       depthType, depths, &ctx->Unpack);
  264.    }
  265.    else if (ctx->RenderMode==GL_FEEDBACK) {
  266.       /* Feedback the current raster pos info */
  267.       if (ctx->Current.RasterPosValid) {
  268.      FLUSH_CURRENT( ctx, 0 );
  269.          FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_DRAW_PIXEL_TOKEN );
  270.          _mesa_feedback_vertex( ctx,
  271.                 ctx->Current.RasterPos,
  272.                 ctx->Current.RasterColor,
  273.                 ctx->Current.RasterIndex,
  274.                 ctx->Current.RasterTexCoords[0] );
  275.       }
  276.    }
  277.    else if (ctx->RenderMode==GL_SELECT) {
  278.       if (ctx->Current.RasterPosValid) {
  279.          _mesa_update_hitflag( ctx, ctx->Current.RasterPos[2] );
  280.       }
  281.    }
  282. }
  283.  
  284. #endif
  285.