src/mesa/main/feedback.c

   1 /* $Id: feedback.c,v 1.3 1999/09/19 02:03:19 tjump Exp $ */
   2
   3 /*
   4  * Mesa 3-D graphics library
   5  * Version:  3.1
   6  *
   7  * Copyright (C) 1999  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
  28
  29
  30
  31 #ifdef PC_HEADER
  32 #include "all.h"
  33 #else
  34 #include <assert.h>
  35 #include <stdio.h>
  36 #include "context.h"
  37 #include "enums.h"
  38 #include "feedback.h"
  39 #include "macros.h"
  40 #include "mmath.h"
  41 #include "types.h"
  42 #include "triangle.h"
  43 #ifdef XFree86Server
  44 #include "GL/xf86glx.h"
  45 #endif
  46 #endif
  47
  48
  49
  50 #define FB_3D           0x01
  51 #define FB_4D           0x02
  52 #define FB_INDEX        0x04
  53 #define FB_COLOR        0x08
  54 #define FB_TEXTURE      0X10
  55
  56
  57
  58 void
  59 gl_FeedbackBuffer( GLcontext *ctx, GLsizei size, GLenum type, GLfloat *buffer )
  60 {
  61    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH( ctx, "glFeedbackBuffer" );
  62
  63    if (ctx->RenderMode==GL_FEEDBACK) {
  64       gl_error( ctx, GL_INVALID_OPERATION, "glFeedbackBuffer" );
  65       return;
  66    }
  67
  68    if (size<0) {
  69       gl_error( ctx, GL_INVALID_VALUE, "glFeedbackBuffer(size<0)" );
  70       return;
  71    }
  72    if (!buffer) {
  73       gl_error( ctx, GL_INVALID_VALUE, "glFeedbackBuffer(buffer==NULL)" );
  74       ctx->Feedback.BufferSize = 0;
  75       return;
  76    }
  77
  78    switch (type) {
  79       case GL_2D:
  80          ctx->Feedback.Mask = 0;
  81          ctx->Feedback.Type = type;
  82          break;
  83       case GL_3D:
  84          ctx->Feedback.Mask = FB_3D;
  85          ctx->Feedback.Type = type;
  86          break;
  87       case GL_3D_COLOR:
  88          ctx->Feedback.Mask = FB_3D
  89                            | (ctx->Visual->RGBAflag ? FB_COLOR : FB_INDEX);
  90          ctx->Feedback.Type = type;
  91          break;
  92       case GL_3D_COLOR_TEXTURE:
  93          ctx->Feedback.Mask = FB_3D
  94                            | (ctx->Visual->RGBAflag ? FB_COLOR : FB_INDEX)
  95                            | FB_TEXTURE;
  96          ctx->Feedback.Type = type;
  97          break;
  98       case GL_4D_COLOR_TEXTURE:
  99          ctx->Feedback.Mask = FB_3D | FB_4D
 100                            | (ctx->Visual->RGBAflag ? FB_COLOR : FB_INDEX)
 101                            | FB_TEXTURE;
 102          ctx->Feedback.Type = type;
 103          break;
 104       default:
 105          ctx->Feedback.Mask = 0;
 106          gl_error( ctx, GL_INVALID_ENUM, "glFeedbackBuffer" );
 107    }
 108
 109    ctx->Feedback.BufferSize = size;
 110    ctx->Feedback.Buffer = buffer;
 111    ctx->Feedback.Count = 0;
 112 }
 113
 114
 115
 116 void gl_PassThrough( GLcontext *ctx, GLfloat token )
 117 {
 118    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPassThrough");
 119
 120    if (ctx->RenderMode==GL_FEEDBACK) {
 121       FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_PASS_THROUGH_TOKEN );
 122       FEEDBACK_TOKEN( ctx, token );
 123    }
 124 }
 125
 126
 127
 128 /*
 129  * Put a vertex into the feedback buffer.
 130  */
 131 void gl_feedback_vertex( GLcontext *ctx,
 132                          const GLfloat win[4],
 133                          const GLfloat color[4],
 134                          GLuint index,
 135                          const GLfloat texcoord[4] )
 136 {
 137    FEEDBACK_TOKEN( ctx, win[0] );
 138    FEEDBACK_TOKEN( ctx, win[1] );
 139    if (ctx->Feedback.Mask & FB_3D) {
 140       FEEDBACK_TOKEN( ctx, win[2] );
 141    }
 142    if (ctx->Feedback.Mask & FB_4D) {
 143       FEEDBACK_TOKEN( ctx, win[3] );
 144    }
 145    if (ctx->Feedback.Mask & FB_INDEX) {
 146       FEEDBACK_TOKEN( ctx, (GLfloat) index );
 147    }
 148    if (ctx->Feedback.Mask & FB_COLOR) {
 149       FEEDBACK_TOKEN( ctx, color[0] );
 150       FEEDBACK_TOKEN( ctx, color[1] );
 151       FEEDBACK_TOKEN( ctx, color[2] );
 152       FEEDBACK_TOKEN( ctx, color[3] );
 153    }
 154    if (ctx->Feedback.Mask & FB_TEXTURE) {
 155       FEEDBACK_TOKEN( ctx, texcoord[0] );
 156       FEEDBACK_TOKEN( ctx, texcoord[1] );
 157       FEEDBACK_TOKEN( ctx, texcoord[2] );
 158       FEEDBACK_TOKEN( ctx, texcoord[3] );
 159    }
 160 }
 161
 162
 163
 164 static void gl_do_feedback_vertex( GLcontext *ctx, GLuint v, GLuint pv )
 165 {
 166    GLfloat win[4];
 167    GLfloat color[4];
 168    GLfloat tc[4];
 169    GLuint texUnit = ctx->Texture.CurrentTransformUnit;
 170    struct vertex_buffer *VB = ctx->VB;
 171
 172    win[0] = VB->Win.data[v][0];
 173    win[1] = VB->Win.data[v][1];
 174    win[2] = VB->Win.data[v][2] / DEPTH_SCALE;
 175    win[3] = 1.0 / VB->Win.data[v][3];
 176
 177    if (ctx->Light.ShadeModel==GL_SMOOTH) pv = v;
 178
 179    UBYTE_RGBA_TO_FLOAT_RGBA( color, VB->ColorPtr->data[pv] );
 180
 181    if (VB->TexCoordPtr[texUnit]->size == 4 &&
 182        VB->TexCoordPtr[texUnit]->data[v][3]!=0.0)
 183    {
 184       GLfloat invq = 1.0F / VB->TexCoordPtr[texUnit]->data[v][3];
 185       tc[0] = VB->TexCoordPtr[texUnit]->data[v][0] * invq;
 186       tc[1] = VB->TexCoordPtr[texUnit]->data[v][1] * invq;
 187       tc[2] = VB->TexCoordPtr[texUnit]->data[v][2] * invq;
 188       tc[3] = VB->TexCoordPtr[texUnit]->data[v][3];
 189    } else {
 190       ASSIGN_4V(tc, 0,0,0,1);
 191       COPY_SZ_4V(tc,
 192                  VB->TexCoordPtr[texUnit]->size,
 193                  VB->TexCoordPtr[texUnit]->data[v]);
 194    }
 195
 196    gl_feedback_vertex( ctx, win, color, VB->IndexPtr->data[v], tc );
 197 }
 198
 199
 200
 201 /*
 202  * Put triangle in feedback buffer.
 203  */
 204 void gl_feedback_triangle( GLcontext *ctx,
 205                            GLuint v0, GLuint v1, GLuint v2, GLuint pv )
 206 {
 207    if (gl_cull_triangle( ctx, v0, v1, v2, 0 )) {
 208       FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_POLYGON_TOKEN );
 209       FEEDBACK_TOKEN( ctx, (GLfloat) 3 );        /* three vertices */
 210
 211       gl_do_feedback_vertex( ctx, v0, pv );
 212       gl_do_feedback_vertex( ctx, v1, pv );
 213       gl_do_feedback_vertex( ctx, v2, pv );
 214    }
 215 }
 216
 217
 218 void gl_feedback_line( GLcontext *ctx, GLuint v1, GLuint v2, GLuint pv )
 219 {
 220    GLenum token = GL_LINE_TOKEN;
 221
 222    if (ctx->StippleCounter==0)
 223       token = GL_LINE_RESET_TOKEN;
 224
 225    FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) token );
 226
 227    gl_do_feedback_vertex( ctx, v1, pv );
 228    gl_do_feedback_vertex( ctx, v2, pv );
 229
 230    ctx->StippleCounter++;
 231 }
 232
 233
 234 void gl_feedback_points( GLcontext *ctx, GLuint first, GLuint last )
 235 {
 236    struct vertex_buffer *VB = ctx->VB;
 237    GLuint i;
 238
 239    for (i=first;i<=last;i++)
 240       if (VB->ClipMask[i]==0) {
 241          FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_POINT_TOKEN );
 242          gl_do_feedback_vertex( ctx, i, i );
 243       }
 244 }
 245
 246
 247
 248
 249
 250 /**********************************************************************/
 251 /*                              Selection                             */
 252 /**********************************************************************/
 253
 254
 255 /*
 256  * NOTE: this function can't be put in a display list.
 257  */
 258 void gl_SelectBuffer( GLcontext *ctx, GLsizei size, GLuint *buffer )
 259 {
 260    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glSelectBuffer");
 261    if (ctx->RenderMode==GL_SELECT) {
 262       gl_error( ctx, GL_INVALID_OPERATION, "glSelectBuffer" );
 263    }
 264    ctx->Select.Buffer = buffer;
 265    ctx->Select.BufferSize = size;
 266    ctx->Select.BufferCount = 0;
 267
 268    ctx->Select.HitFlag = GL_FALSE;
 269    ctx->Select.HitMinZ = 1.0;
 270    ctx->Select.HitMaxZ = 0.0;
 271 }
 272
 273
 274 #define WRITE_RECORD( CTX, V )                                  \
 275         if (CTX->Select.BufferCount < CTX->Select.BufferSize) { \
 276            CTX->Select.Buffer[CTX->Select.BufferCount] = (V);   \
 277         }                                                       \
 278         CTX->Select.BufferCount++;
 279
 280
 281
 282 void gl_update_hitflag( GLcontext *ctx, GLfloat z )
 283 {
 284    ctx->Select.HitFlag = GL_TRUE;
 285    if (z < ctx->Select.HitMinZ) {
 286       ctx->Select.HitMinZ = z;
 287    }
 288    if (z > ctx->Select.HitMaxZ) {
 289       ctx->Select.HitMaxZ = z;
 290    }
 291 }
 292
 293 void gl_select_triangle( GLcontext *ctx,
 294                          GLuint v0, GLuint v1, GLuint v2, GLuint pv )
 295 {
 296    struct vertex_buffer *VB = ctx->VB;
 297
 298    if (gl_cull_triangle( ctx, v0, v1, v2, 0 )) {
 299       gl_update_hitflag( ctx, VB->Win.data[v0][3] / DEPTH_SCALE );
 300       gl_update_hitflag( ctx, VB->Win.data[v1][3] / DEPTH_SCALE );
 301       gl_update_hitflag( ctx, VB->Win.data[v2][3] / DEPTH_SCALE );
 302    }
 303 }
 304
 305
 306 void gl_select_line( GLcontext *ctx,
 307                      GLuint v0, GLuint v1, GLuint pv )
 308 {
 309    struct vertex_buffer *VB = ctx->VB;
 310
 311    gl_update_hitflag( ctx, VB->Win.data[v0][3] / DEPTH_SCALE );
 312    gl_update_hitflag( ctx, VB->Win.data[v1][3] / DEPTH_SCALE );
 313 }
 314
 315 void gl_select_points( GLcontext *ctx, GLuint first, GLuint last )
 316 {
 317    struct vertex_buffer *VB = ctx->VB;
 318    GLuint i;
 319
 320    for (i=first;i<=last;i++)
 321       if (VB->ClipMask[i]==0)
 322          gl_update_hitflag( ctx, VB->Win.data[i][3] / DEPTH_SCALE);
 323 }
 324
 325
 326 static void write_hit_record( GLcontext *ctx )
 327 {
 328    GLuint i;
 329    GLuint zmin, zmax, zscale = (~0u);
 330
 331    /* HitMinZ and HitMaxZ are in [0,1].  Multiply these values by */
 332    /* 2^32-1 and round to nearest unsigned integer. */
 333
 334    assert( ctx != NULL ); /* this line magically fixes a SunOS 5.x/gcc bug */
 335    zmin = (GLuint) ((GLfloat) zscale * ctx->Select.HitMinZ);
 336    zmax = (GLuint) ((GLfloat) zscale * ctx->Select.HitMaxZ);
 337
 338    WRITE_RECORD( ctx, ctx->Select.NameStackDepth );
 339    WRITE_RECORD( ctx, zmin );
 340    WRITE_RECORD( ctx, zmax );
 341    for (i=0;i<ctx->Select.NameStackDepth;i++) {
 342       WRITE_RECORD( ctx, ctx->Select.NameStack[i] );
 343    }
 344
 345    ctx->Select.Hits++;
 346    ctx->Select.HitFlag = GL_FALSE;
 347    ctx->Select.HitMinZ = 1.0;
 348    ctx->Select.HitMaxZ = -1.0;
 349 }
 350
 351
 352
 353 void gl_InitNames( GLcontext *ctx )
 354 {
 355    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glInitNames");
 356    /* Record the hit before the HitFlag is wiped out again. */
 357    if (ctx->RenderMode==GL_SELECT) {
 358       if (ctx->Select.HitFlag) {
 359          write_hit_record( ctx );
 360       }
 361    }
 362    ctx->Select.NameStackDepth = 0;
 363    ctx->Select.HitFlag = GL_FALSE;
 364    ctx->Select.HitMinZ = 1.0;
 365    ctx->Select.HitMaxZ = 0.0;
 366 }
 367
 368
 369
 370 void gl_LoadName( GLcontext *ctx, GLuint name )
 371 {
 372    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glLoadName");
 373    if (ctx->RenderMode!=GL_SELECT) {
 374       return;
 375    }
 376    if (ctx->Select.NameStackDepth==0) {
 377       gl_error( ctx, GL_INVALID_OPERATION, "glLoadName" );
 378       return;
 379    }
 380    if (ctx->Select.HitFlag) {
 381       write_hit_record( ctx );
 382    }
 383    if (ctx->Select.NameStackDepth<MAX_NAME_STACK_DEPTH) {
 384       ctx->Select.NameStack[ctx->Select.NameStackDepth-1] = name;
 385    }
 386    else {
 387       ctx->Select.NameStack[MAX_NAME_STACK_DEPTH-1] = name;
 388    }
 389 }
 390
 391
 392 void gl_PushName( GLcontext *ctx, GLuint name )
 393 {
 394    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPushName");
 395    if (ctx->RenderMode!=GL_SELECT) {
 396       return;
 397    }
 398    if (ctx->Select.HitFlag) {
 399       write_hit_record( ctx );
 400    }
 401    if (ctx->Select.NameStackDepth<MAX_NAME_STACK_DEPTH) {
 402       ctx->Select.NameStack[ctx->Select.NameStackDepth++] = name;
 403    }
 404    else {
 405       gl_error( ctx, GL_STACK_OVERFLOW, "glPushName" );
 406    }
 407 }
 408
 409
 410
 411 void gl_PopName( GLcontext *ctx )
 412 {
 413    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPopName");
 414    if (ctx->RenderMode!=GL_SELECT) {
 415       return;
 416    }
 417    if (ctx->Select.HitFlag) {
 418       write_hit_record( ctx );
 419    }
 420    if (ctx->Select.NameStackDepth>0) {
 421       ctx->Select.NameStackDepth--;
 422    }
 423    else {
 424       gl_error( ctx, GL_STACK_UNDERFLOW, "glPopName" );
 425    }
 426 }
 427
 428
 429
 430 /**********************************************************************/
 431 /*                           Render Mode                              */
 432 /**********************************************************************/
 433
 434
 435
 436 /*
 437  * NOTE: this function can't be put in a display list.
 438  */
 439 GLint gl_RenderMode( GLcontext *ctx, GLenum mode )
 440 {
 441    GLint result;
 442
 443    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH_WITH_RETVAL(ctx, "glRenderMode", 0);
 444
 445    if (MESA_VERBOSE & VERBOSE_API)
 446       fprintf(stderr, "glRenderMode %s\n", gl_lookup_enum_by_nr(mode));
 447
 448    ctx->TriangleCaps &= ~(DD_FEEDBACK|DD_SELECT);
 449
 450    switch (ctx->RenderMode) {
 451       case GL_RENDER:
 452          result = 0;
 453          break;
 454       case GL_SELECT:
 455          if (ctx->Select.HitFlag) {
 456             write_hit_record( ctx );
 457          }
 458          if (ctx->Select.BufferCount > ctx->Select.BufferSize) {
 459             /* overflow */
 460 #ifdef DEBUG
 461             gl_warning(ctx, "Feedback buffer overflow");
 462 #endif
 463             result = -1;
 464          }
 465          else {
 466             result = ctx->Select.Hits;
 467          }
 468          ctx->Select.BufferCount = 0;
 469          ctx->Select.Hits = 0;
 470          ctx->Select.NameStackDepth = 0;
 471          break;
 472       case GL_FEEDBACK:
 473          if (ctx->Feedback.Count > ctx->Feedback.BufferSize) {
 474             /* overflow */
 475             result = -1;
 476          }
 477          else {
 478             result = ctx->Feedback.Count;
 479          }
 480          ctx->Feedback.Count = 0;
 481          break;
 482       default:
 483          gl_error( ctx, GL_INVALID_ENUM, "glRenderMode" );
 484          return 0;
 485    }
 486
 487    switch (mode) {
 488       case GL_RENDER:
 489          break;
 490       case GL_SELECT:
 491          ctx->TriangleCaps |= DD_SELECT;
 492          if (ctx->Select.BufferSize==0) {
 493             /* haven't called glSelectBuffer yet */
 494             gl_error( ctx, GL_INVALID_OPERATION, "glRenderMode" );
 495          }
 496          break;
 497       case GL_FEEDBACK:
 498          ctx->TriangleCaps |= DD_FEEDBACK;
 499          if (ctx->Feedback.BufferSize==0) {
 500             /* haven't called glFeedbackBuffer yet */
 501             gl_error( ctx, GL_INVALID_OPERATION, "glRenderMode" );
 502          }
 503          break;
 504       default:
 505          gl_error( ctx, GL_INVALID_ENUM, "glRenderMode" );
 506          return 0;
 507    }
 508
 509
 510    ctx->RenderMode = mode;
 511    ctx->NewState |= NEW_ALL;
 512
 513    return result;
 514 }
 515