src/mesa/main/polygon.c

   1 /**
   2  * \file polygon.c
   3  * Polygon operations.
   4  */
   5
   6 /*
   7  * Mesa 3-D graphics library
   8  *
   9  * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
  10  *
  11  * Permission is hereby granted, free of charge, to any person obtaining a
  12  * copy of this software and associated documentation files (the "Software"),
  13  * to deal in the Software without restriction, including without limitation
  14  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  15  * and/or sell copies of the Software, and to permit persons to whom the
  16  * Software is furnished to do so, subject to the following conditions:
  17  *
  18  * The above copyright notice and this permission notice shall be included
  19  * in all copies or substantial portions of the Software.
  20  *
  21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  22  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  23  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  24  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  25  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  26  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  27  * OTHER DEALINGS IN THE SOFTWARE.
  28  */
  29
  30
  31 #include "glheader.h"
  32 #include "imports.h"
  33 #include "context.h"
  34 #include "image.h"
  35 #include "enums.h"
  36 #include "pack.h"
  37 #include "pbo.h"
  38 #include "polygon.h"
  39 #include "mtypes.h"
  40
  41
  42 /**
  43  * Specify whether to cull front- or back-facing facets.
  44  *
  45  * \param mode culling mode.
  46  *
  47  * \sa glCullFace().
  48  *
  49  * Verifies the parameter and updates gl_polygon_attrib::CullFaceMode. On
  50  * change, flushes the vertices and notifies the driver via
  51  * the dd_function_table::CullFace callback.
  52  */
  53 void GLAPIENTRY
  54 _mesa_CullFace( GLenum mode )
  55 {
  56    GET_CURRENT_CONTEXT(ctx);
  57
  58    if (MESA_VERBOSE&VERBOSE_API)
  59       _mesa_debug(ctx, "glCullFace %s\n", _mesa_enum_to_string(mode));
  60
  61    if (mode!=GL_FRONT && mode!=GL_BACK && mode!=GL_FRONT_AND_BACK) {
  62       _mesa_error( ctx, GL_INVALID_ENUM, "glCullFace" );
  63       return;
  64    }
  65
  66    if (ctx->Polygon.CullFaceMode == mode)
  67       return;
  68
  69    FLUSH_VERTICES(ctx, _NEW_POLYGON);
  70    ctx->Polygon.CullFaceMode = mode;
  71
  72    if (ctx->Driver.CullFace)
  73       ctx->Driver.CullFace( ctx, mode );
  74 }
  75
  76
  77 /**
  78  * Define front- and back-facing
  79  *
  80  * \param mode orientation of front-facing polygons.
  81  *
  82  * \sa glFrontFace().
  83  *
  84  * Verifies the parameter and updates gl_polygon_attrib::FrontFace. On change
  85  * flushes the vertices and notifies the driver via
  86  * the dd_function_table::FrontFace callback.
  87  */
  88 void GLAPIENTRY
  89 _mesa_FrontFace( GLenum mode )
  90 {
  91    GET_CURRENT_CONTEXT(ctx);
  92
  93    if (MESA_VERBOSE&VERBOSE_API)
  94       _mesa_debug(ctx, "glFrontFace %s\n", _mesa_enum_to_string(mode));
  95
  96    if (ctx->Polygon.FrontFace == mode)
  97       return;
  98
  99    if (mode!=GL_CW && mode!=GL_CCW) {
 100       _mesa_error( ctx, GL_INVALID_ENUM, "glFrontFace" );
 101       return;
 102    }
 103
 104    FLUSH_VERTICES(ctx, _NEW_POLYGON);
 105    ctx->Polygon.FrontFace = mode;
 106
 107    if (ctx->Driver.FrontFace)
 108       ctx->Driver.FrontFace( ctx, mode );
 109 }
 110
 111
 112 /**
 113  * Set the polygon rasterization mode.
 114  *
 115  * \param face the polygons which \p mode applies to.
 116  * \param mode how polygons should be rasterized.
 117  *
 118  * \sa glPolygonMode().
 119  *
 120  * Verifies the parameters and updates gl_polygon_attrib::FrontMode and
 121  * gl_polygon_attrib::BackMode. On change flushes the vertices and notifies the
 122  * driver via the dd_function_table::PolygonMode callback.
 123  */
 124 void GLAPIENTRY
 125 _mesa_PolygonMode( GLenum face, GLenum mode )
 126 {
 127    GET_CURRENT_CONTEXT(ctx);
 128
 129    if (MESA_VERBOSE&VERBOSE_API)
 130       _mesa_debug(ctx, "glPolygonMode %s %s\n",
 131                   _mesa_enum_to_string(face),
 132                   _mesa_enum_to_string(mode));
 133
 134    switch (mode) {
 135    case GL_POINT:
 136    case GL_LINE:
 137    case GL_FILL:
 138       break;
 139    case GL_FILL_RECTANGLE_NV:
 140       if (ctx->Extensions.NV_fill_rectangle)
 141          break;
 142       /* fall-through */
 143    default:
 144       _mesa_error(ctx, GL_INVALID_ENUM, "glPolygonMode(mode)");
 145       return;
 146    }
 147
 148    switch (face) {
 149    case GL_FRONT:
 150       if (ctx->API == API_OPENGL_CORE) {
 151          _mesa_error( ctx, GL_INVALID_ENUM, "glPolygonMode(face)" );
 152          return;
 153       }
 154       if (ctx->Polygon.FrontMode == mode)
 155          return;
 156       FLUSH_VERTICES(ctx, _NEW_POLYGON);
 157       ctx->Polygon.FrontMode = mode;
 158       break;
 159    case GL_FRONT_AND_BACK:
 160       if (ctx->Polygon.FrontMode == mode && ctx->Polygon.BackMode == mode)
 161          return;
 162       FLUSH_VERTICES(ctx, _NEW_POLYGON);
 163       ctx->Polygon.FrontMode = mode;
 164       ctx->Polygon.BackMode = mode;
 165       break;
 166    case GL_BACK:
 167       if (ctx->API == API_OPENGL_CORE) {
 168          _mesa_error( ctx, GL_INVALID_ENUM, "glPolygonMode(face)" );
 169          return;
 170       }
 171       if (ctx->Polygon.BackMode == mode)
 172          return;
 173       FLUSH_VERTICES(ctx, _NEW_POLYGON);
 174       ctx->Polygon.BackMode = mode;
 175       break;
 176    default:
 177       _mesa_error( ctx, GL_INVALID_ENUM, "glPolygonMode(face)" );
 178       return;
 179    }
 180
 181    if (ctx->Driver.PolygonMode)
 182       ctx->Driver.PolygonMode(ctx, face, mode);
 183 }
 184
 185
 186 /**
 187  * Called by glPolygonStipple.
 188  */
 189 void GLAPIENTRY
 190 _mesa_PolygonStipple(const GLubyte *pattern)
 191 {
 192    GET_CURRENT_CONTEXT(ctx);
 193
 194    if (MESA_VERBOSE & VERBOSE_API)
 195       _mesa_debug(ctx, "glPolygonStipple\n");
 196
 197    FLUSH_VERTICES(ctx, _NEW_POLYGONSTIPPLE);
 198
 199    pattern = _mesa_map_validate_pbo_source(ctx, 2,
 200                                            &ctx->Unpack, 32, 32, 1,
 201                                            GL_COLOR_INDEX, GL_BITMAP,
 202                                            INT_MAX, pattern,
 203                                            "glPolygonStipple");
 204    if (!pattern)
 205       return;
 206
 207    _mesa_unpack_polygon_stipple(pattern, ctx->PolygonStipple, &ctx->Unpack);
 208
 209    _mesa_unmap_pbo_source(ctx, &ctx->Unpack);
 210
 211    if (ctx->Driver.PolygonStipple)
 212       ctx->Driver.PolygonStipple(ctx, pattern);
 213 }
 214
 215
 216 /**
 217  * Called by glPolygonStipple.
 218  */
 219 void GLAPIENTRY
 220 _mesa_GetnPolygonStippleARB( GLsizei bufSize, GLubyte *dest )
 221 {
 222    GET_CURRENT_CONTEXT(ctx);
 223
 224    if (MESA_VERBOSE&VERBOSE_API)
 225       _mesa_debug(ctx, "glGetPolygonStipple\n");
 226
 227    dest = _mesa_map_validate_pbo_dest(ctx, 2,
 228                                       &ctx->Pack, 32, 32, 1,
 229                                       GL_COLOR_INDEX, GL_BITMAP,
 230                                       bufSize, dest, "glGetPolygonStipple");
 231    if (!dest)
 232       return;
 233
 234    _mesa_pack_polygon_stipple(ctx->PolygonStipple, dest, &ctx->Pack);
 235
 236    _mesa_unmap_pbo_dest(ctx, &ctx->Pack);
 237 }
 238
 239
 240 void GLAPIENTRY
 241 _mesa_GetPolygonStipple( GLubyte *dest )
 242 {
 243    _mesa_GetnPolygonStippleARB(INT_MAX, dest);
 244 }
 245
 246 void
 247 _mesa_polygon_offset_clamp(struct gl_context *ctx,
 248                            GLfloat factor, GLfloat units, GLfloat clamp)
 249 {
 250    if (ctx->Polygon.OffsetFactor == factor &&
 251        ctx->Polygon.OffsetUnits == units &&
 252        ctx->Polygon.OffsetClamp == clamp)
 253       return;
 254
 255    FLUSH_VERTICES(ctx, _NEW_POLYGON);
 256    ctx->Polygon.OffsetFactor = factor;
 257    ctx->Polygon.OffsetUnits = units;
 258    ctx->Polygon.OffsetClamp = clamp;
 259
 260    if (ctx->Driver.PolygonOffset)
 261       ctx->Driver.PolygonOffset( ctx, factor, units, clamp );
 262 }
 263
 264 void GLAPIENTRY
 265 _mesa_PolygonOffset( GLfloat factor, GLfloat units )
 266 {
 267    GET_CURRENT_CONTEXT(ctx);
 268
 269    if (MESA_VERBOSE&VERBOSE_API)
 270       _mesa_debug(ctx, "glPolygonOffset %f %f\n", factor, units);
 271
 272    _mesa_polygon_offset_clamp(ctx, factor, units, 0.0);
 273 }
 274
 275
 276 void GLAPIENTRY
 277 _mesa_PolygonOffsetEXT( GLfloat factor, GLfloat bias )
 278 {
 279    GET_CURRENT_CONTEXT(ctx);
 280    /* XXX mult by DepthMaxF here??? */
 281    _mesa_PolygonOffset(factor, bias * ctx->DrawBuffer->_DepthMaxF );
 282 }
 283
 284 void GLAPIENTRY
 285 _mesa_PolygonOffsetClampEXT( GLfloat factor, GLfloat units, GLfloat clamp )
 286 {
 287    GET_CURRENT_CONTEXT(ctx);
 288
 289    if (!ctx->Extensions.EXT_polygon_offset_clamp) {
 290       _mesa_error(ctx, GL_INVALID_OPERATION,
 291                   "unsupported function (glPolygonOffsetClampEXT) called");
 292       return;
 293    }
 294
 295    if (MESA_VERBOSE&VERBOSE_API)
 296       _mesa_debug(ctx, "glPolygonOffsetClampEXT %f %f %f\n", factor, units, clamp);
 297
 298    _mesa_polygon_offset_clamp(ctx, factor, units, clamp);
 299 }
 300
 301
 302
 303 /**********************************************************************/
 304 /** \name Initialization */
 305 /*@{*/
 306
 307 /**
 308  * Initialize the context polygon state.
 309  *
 310  * \param ctx GL context.
 311  *
 312  * Initializes __struct gl_contextRec::Polygon and __struct gl_contextRec::PolygonStipple
 313  * attribute groups.
 314  */
 315 void _mesa_init_polygon( struct gl_context * ctx )
 316 {
 317    /* Polygon group */
 318    ctx->Polygon.CullFlag = GL_FALSE;
 319    ctx->Polygon.CullFaceMode = GL_BACK;
 320    ctx->Polygon.FrontFace = GL_CCW;
 321    ctx->Polygon.FrontMode = GL_FILL;
 322    ctx->Polygon.BackMode = GL_FILL;
 323    ctx->Polygon.SmoothFlag = GL_FALSE;
 324    ctx->Polygon.StippleFlag = GL_FALSE;
 325    ctx->Polygon.OffsetFactor = 0.0F;
 326    ctx->Polygon.OffsetUnits = 0.0F;
 327    ctx->Polygon.OffsetClamp = 0.0F;
 328    ctx->Polygon.OffsetPoint = GL_FALSE;
 329    ctx->Polygon.OffsetLine = GL_FALSE;
 330    ctx->Polygon.OffsetFill = GL_FALSE;
 331
 332
 333    /* Polygon Stipple group */
 334    memset( ctx->PolygonStipple, 0xff, 32*sizeof(GLuint) );
 335 }
 336
 337 /*@}*/