reactos/dll/opengl/mesa/src/mesa/tnl/t_draw.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  7.1
   4  *
   5  * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  *
  24  * Authors:
  25  *    Keith Whitwell <keith@tungstengraphics.com>
  26  */
  27
  28 #include "main/glheader.h"
  29 #include "main/bufferobj.h"
  30 #include "main/context.h"
  31 #include "main/imports.h"
  32 #include "main/mtypes.h"
  33 #include "main/macros.h"
  34 #include "main/enums.h"
  35
  36 #include "t_context.h"
  37 #include "tnl.h"
  38
  39
  40
  41 static GLubyte *get_space(struct gl_context *ctx, GLuint bytes)
  42 {
  43    TNLcontext *tnl = TNL_CONTEXT(ctx);
  44    GLubyte *space = malloc(bytes);
  45
  46    tnl->block[tnl->nr_blocks++] = space;
  47    return space;
  48 }
  49
  50
  51 static void free_space(struct gl_context *ctx)
  52 {
  53    TNLcontext *tnl = TNL_CONTEXT(ctx);
  54    GLuint i;
  55    for (i = 0; i < tnl->nr_blocks; i++)
  56       free(tnl->block[i]);
  57    tnl->nr_blocks = 0;
  58 }
  59
  60
  61 /* Convert the incoming array to GLfloats.  Understands the
  62  * array->Normalized flag and selects the correct conversion method.
  63  */
  64 #define CONVERT( TYPE, MACRO ) do {             \
  65    GLuint i, j;                                 \
  66    if (input->Normalized) {                     \
  67       for (i = 0; i < count; i++) {             \
  68          const TYPE *in = (TYPE *)ptr;          \
  69          for (j = 0; j < sz; j++) {             \
  70             *fptr++ = MACRO(*in);               \
  71             in++;                               \
  72          }                                      \
  73          ptr += input->StrideB;                 \
  74       }                                         \
  75    } else {                                     \
  76       for (i = 0; i < count; i++) {             \
  77          const TYPE *in = (TYPE *)ptr;          \
  78          for (j = 0; j < sz; j++) {             \
  79             *fptr++ = (GLfloat)(*in);           \
  80             in++;                               \
  81          }                                      \
  82          ptr += input->StrideB;                 \
  83       }                                         \
  84    }                                            \
  85 } while (0)
  86
  87
  88 static void
  89 convert_half_to_float(const struct gl_client_array *input,
  90                       const GLubyte *ptr, GLfloat *fptr,
  91                       GLuint count, GLuint sz)
  92 {
  93    GLuint i, j;
  94
  95    for (i = 0; i < count; i++) {
  96       GLhalfARB *in = (GLhalfARB *)ptr;
  97
  98       for (j = 0; j < sz; j++) {
  99          *fptr++ = _mesa_half_to_float(in[j]);
 100       }
 101       ptr += input->StrideB;
 102    }
 103 }
 104
 105 /**
 106  * \brief Convert fixed-point to floating-point.
 107  *
 108  * In OpenGL, a fixed-point number is a "signed 2's complement 16.16 scaled
 109  * integer" (Table 2.2 of the OpenGL ES 2.0 spec).
 110  *
 111  * If the buffer has the \c normalized flag set, the formula
 112  *     \code normalize(x) := (2*x + 1) / (2^16 - 1) \endcode
 113  * is used to map the fixed-point numbers into the range [-1, 1].
 114  */
 115 static void
 116 convert_fixed_to_float(const struct gl_client_array *input,
 117                        const GLubyte *ptr, GLfloat *fptr,
 118                        GLuint count)
 119 {
 120    GLuint i, j;
 121    const GLint size = input->Size;
 122
 123    if (input->Normalized) {
 124       for (i = 0; i < count; ++i) {
 125          const GLfixed *in = (GLfixed *) ptr;
 126          for (j = 0; j < size; ++j) {
 127             *fptr++ = (GLfloat) (2 * in[j] + 1) / (GLfloat) ((1 << 16) - 1);
 128          }
 129          ptr += input->StrideB;
 130       }
 131    } else {
 132       for (i = 0; i < count; ++i) {
 133          const GLfixed *in = (GLfixed *) ptr;
 134          for (j = 0; j < size; ++j) {
 135             *fptr++ = in[j] / (GLfloat) (1 << 16);
 136          }
 137          ptr += input->StrideB;
 138       }
 139    }
 140 }
 141
 142 /* Adjust pointer to point at first requested element, convert to
 143  * floating point, populate VB->AttribPtr[].
 144  */
 145 static void _tnl_import_array( struct gl_context *ctx,
 146                                GLuint attrib,
 147                                GLuint count,
 148                                const struct gl_client_array *input,
 149                                const GLubyte *ptr )
 150 {
 151    TNLcontext *tnl = TNL_CONTEXT(ctx);
 152    struct vertex_buffer *VB = &tnl->vb;
 153    GLuint stride = input->StrideB;
 154
 155    if (input->Type != GL_FLOAT) {
 156       const GLuint sz = input->Size;
 157       GLubyte *buf = get_space(ctx, count * sz * sizeof(GLfloat));
 158       GLfloat *fptr = (GLfloat *)buf;
 159
 160       switch (input->Type) {
 161       case GL_BYTE:
 162          CONVERT(GLbyte, BYTE_TO_FLOAT);
 163          break;
 164       case GL_UNSIGNED_BYTE:
 165          CONVERT(GLubyte, UBYTE_TO_FLOAT);
 166          break;
 167       case GL_SHORT:
 168          CONVERT(GLshort, SHORT_TO_FLOAT);
 169          break;
 170       case GL_UNSIGNED_SHORT:
 171          CONVERT(GLushort, USHORT_TO_FLOAT);
 172          break;
 173       case GL_INT:
 174          CONVERT(GLint, INT_TO_FLOAT);
 175          break;
 176       case GL_UNSIGNED_INT:
 177          CONVERT(GLuint, UINT_TO_FLOAT);
 178          break;
 179       case GL_DOUBLE:
 180          CONVERT(GLdouble, (GLfloat));
 181          break;
 182       case GL_HALF_FLOAT:
 183          convert_half_to_float(input, ptr, fptr, count, sz);
 184          break;
 185       case GL_FIXED:
 186          convert_fixed_to_float(input, ptr, fptr, count);
 187          break;
 188       default:
 189          assert(0);
 190          break;
 191       }
 192
 193       ptr = buf;
 194       stride = sz * sizeof(GLfloat);
 195    }
 196
 197    VB->AttribPtr[attrib] = &tnl->tmp_inputs[attrib];
 198    VB->AttribPtr[attrib]->data = (GLfloat (*)[4])ptr;
 199    VB->AttribPtr[attrib]->start = (GLfloat *)ptr;
 200    VB->AttribPtr[attrib]->count = count;
 201    VB->AttribPtr[attrib]->stride = stride;
 202    VB->AttribPtr[attrib]->size = input->Size;
 203
 204    /* This should die, but so should the whole GLvector4f concept:
 205     */
 206    VB->AttribPtr[attrib]->flags = (((1<<input->Size)-1) |
 207                                    VEC_NOT_WRITEABLE |
 208                                    (stride == 4*sizeof(GLfloat) ? 0 : VEC_BAD_STRIDE));
 209
 210    VB->AttribPtr[attrib]->storage = NULL;
 211 }
 212
 213 #define CLIPVERTS  ((6 + MAX_CLIP_PLANES) * 2)
 214
 215
 216 static GLboolean *_tnl_import_edgeflag( struct gl_context *ctx,
 217                                         const GLvector4f *input,
 218                                         GLuint count)
 219 {
 220    const GLubyte *ptr = (const GLubyte *)input->data;
 221    const GLuint stride = input->stride;
 222    GLboolean *space = (GLboolean *)get_space(ctx, count + CLIPVERTS);
 223    GLboolean *bptr = space;
 224    GLuint i;
 225
 226    for (i = 0; i < count; i++) {
 227       *bptr++ = ((GLfloat *)ptr)[0] == 1.0;
 228       ptr += stride;
 229    }
 230
 231    return space;
 232 }
 233
 234
 235 static void bind_inputs( struct gl_context *ctx,
 236                          const struct gl_client_array *inputs[],
 237                          GLint count,
 238                          struct gl_buffer_object **bo,
 239                          GLuint *nr_bo )
 240 {
 241    TNLcontext *tnl = TNL_CONTEXT(ctx);
 242    struct vertex_buffer *VB = &tnl->vb;
 243    GLuint i;
 244
 245    /* Map all the VBOs
 246     */
 247    for (i = 0; i < VERT_ATTRIB_MAX; i++) {
 248       const void *ptr;
 249
 250       if (inputs[i]->BufferObj->Name) {
 251          if (!inputs[i]->BufferObj->Pointer) {
 252             bo[*nr_bo] = inputs[i]->BufferObj;
 253             (*nr_bo)++;
 254             ctx->Driver.MapBufferRange(ctx, 0, inputs[i]->BufferObj->Size,
 255                                        GL_MAP_READ_BIT,
 256                                        inputs[i]->BufferObj);
 257
 258             assert(inputs[i]->BufferObj->Pointer);
 259          }
 260
 261          ptr = ADD_POINTERS(inputs[i]->BufferObj->Pointer,
 262                             inputs[i]->Ptr);
 263       }
 264       else
 265          ptr = inputs[i]->Ptr;
 266
 267       /* Just make sure the array is floating point, otherwise convert to
 268        * temporary storage.
 269        *
 270        * XXX: remove the GLvector4f type at some stage and just use
 271        * client arrays.
 272        */
 273       _tnl_import_array(ctx, i, count, inputs[i], ptr);
 274    }
 275
 276    /* We process only the vertices between min & max index:
 277     */
 278    VB->Count = count;
 279
 280    /* These should perhaps be part of _TNL_ATTRIB_* */
 281    VB->BackfaceColorPtr = NULL;
 282    VB->BackfaceIndexPtr = NULL;
 283    VB->BackfaceSecondaryColorPtr = NULL;
 284
 285    /* Clipping and drawing code still requires this to be a packed
 286     * array of ubytes which can be written into.  TODO: Fix and
 287     * remove.
 288     */
 289    if (ctx->Polygon.FrontMode != GL_FILL ||
 290        ctx->Polygon.BackMode != GL_FILL)
 291    {
 292       VB->EdgeFlag = _tnl_import_edgeflag( ctx,
 293                                            VB->AttribPtr[_TNL_ATTRIB_EDGEFLAG],
 294                                            VB->Count );
 295    }
 296    else {
 297       /* the data previously pointed to by EdgeFlag may have been freed */
 298       VB->EdgeFlag = NULL;
 299    }
 300 }
 301
 302
 303 /* Translate indices to GLuints and store in VB->Elts.
 304  */
 305 static void bind_indices( struct gl_context *ctx,
 306                           const struct _mesa_index_buffer *ib,
 307                           struct gl_buffer_object **bo,
 308                           GLuint *nr_bo)
 309 {
 310    TNLcontext *tnl = TNL_CONTEXT(ctx);
 311    struct vertex_buffer *VB = &tnl->vb;
 312    GLuint i;
 313    const void *ptr;
 314
 315    if (!ib) {
 316       VB->Elts = NULL;
 317       return;
 318    }
 319
 320    if (_mesa_is_bufferobj(ib->obj) && !_mesa_bufferobj_mapped(ib->obj)) {
 321       /* if the buffer object isn't mapped yet, map it now */
 322       bo[*nr_bo] = ib->obj;
 323       (*nr_bo)++;
 324       ptr = ctx->Driver.MapBufferRange(ctx, (GLsizeiptr) ib->ptr,
 325                                        ib->count * vbo_sizeof_ib_type(ib->type),
 326                                        GL_MAP_READ_BIT, ib->obj);
 327       assert(ib->obj->Pointer);
 328    } else {
 329       /* user-space elements, or buffer already mapped */
 330       ptr = ADD_POINTERS(ib->obj->Pointer, ib->ptr);
 331    }
 332
 333    if (ib->type == GL_UNSIGNED_INT) {
 334       VB->Elts = (GLuint *) ptr;
 335    }
 336    else {
 337       GLuint *elts = (GLuint *)get_space(ctx, ib->count * sizeof(GLuint));
 338       VB->Elts = elts;
 339
 340       if (ib->type == GL_UNSIGNED_SHORT) {
 341          const GLushort *in = (GLushort *)ptr;
 342          for (i = 0; i < ib->count; i++)
 343             *elts++ = (GLuint)(*in++);
 344       }
 345       else {
 346          const GLubyte *in = (GLubyte *)ptr;
 347          for (i = 0; i < ib->count; i++)
 348             *elts++ = (GLuint)(*in++);
 349       }
 350    }
 351 }
 352
 353 static void bind_prims( struct gl_context *ctx,
 354                         const struct _mesa_prim *prim,
 355                         GLuint nr_prims )
 356 {
 357    TNLcontext *tnl = TNL_CONTEXT(ctx);
 358    struct vertex_buffer *VB = &tnl->vb;
 359
 360    VB->Primitive = prim;
 361    VB->PrimitiveCount = nr_prims;
 362 }
 363
 364 static void unmap_vbos( struct gl_context *ctx,
 365                         struct gl_buffer_object **bo,
 366                         GLuint nr_bo )
 367 {
 368    GLuint i;
 369    for (i = 0; i < nr_bo; i++) {
 370       ctx->Driver.UnmapBuffer(ctx, bo[i]);
 371    }
 372 }
 373
 374
 375 void _tnl_vbo_draw_prims(struct gl_context *ctx,
 376                          const struct gl_client_array *arrays[],
 377                          const struct _mesa_prim *prim,
 378                          GLuint nr_prims,
 379                          const struct _mesa_index_buffer *ib,
 380                          GLboolean index_bounds_valid,
 381                          GLuint min_index,
 382                          GLuint max_index)
 383 {
 384    if (!index_bounds_valid)
 385       vbo_get_minmax_index(ctx, prim, ib, &min_index, &max_index);
 386
 387    _tnl_draw_prims(ctx, arrays, prim, nr_prims, ib, min_index, max_index);
 388 }
 389
 390 /* This is the main entrypoint into the slimmed-down software tnl
 391  * module.  In a regular swtnl driver, this can be plugged straight
 392  * into the vbo->Driver.DrawPrims() callback.
 393  */
 394 void _tnl_draw_prims( struct gl_context *ctx,
 395                       const struct gl_client_array *arrays[],
 396                       const struct _mesa_prim *prim,
 397                       GLuint nr_prims,
 398                       const struct _mesa_index_buffer *ib,
 399                       GLuint min_index,
 400                       GLuint max_index)
 401 {
 402    TNLcontext *tnl = TNL_CONTEXT(ctx);
 403    const GLuint TEST_SPLIT = 0;
 404    const GLint max = TEST_SPLIT ? 8 : tnl->vb.Size - MAX_CLIPPED_VERTICES;
 405
 406    /* Mesa core state should have been validated already */
 407    assert(ctx->NewState == 0x0);
 408
 409    if (0)
 410    {
 411       GLuint i;
 412       printf("%s %d..%d\n", __FUNCTION__, min_index, max_index);
 413       for (i = 0; i < nr_prims; i++)
 414          printf("prim %d: %s start %d count %d\n", i,
 415                 _mesa_lookup_enum_by_nr(prim[i].mode),
 416                 prim[i].start,
 417                 prim[i].count);
 418    }
 419
 420    if (min_index) {
 421       /* We always translate away calls with min_index != 0.
 422        */
 423       vbo_rebase_prims( ctx, arrays, prim, nr_prims, ib,
 424                         min_index, max_index,
 425                         _tnl_vbo_draw_prims );
 426       return;
 427    }
 428    else if (max_index > max) {
 429       /* The software TNL pipeline has a fixed amount of storage for
 430        * vertices and it is necessary to split incoming drawing commands
 431        * if they exceed that limit.
 432        */
 433       struct split_limits limits;
 434       limits.max_verts = max;
 435       limits.max_vb_size = ~0;
 436       limits.max_indices = ~0;
 437
 438       /* This will split the buffers one way or another and
 439        * recursively call back into this function.
 440        */
 441       vbo_split_prims( ctx, arrays, prim, nr_prims, ib,
 442                        0, max_index,
 443                        _tnl_vbo_draw_prims,
 444                        &limits );
 445    }
 446    else {
 447       /* May need to map a vertex buffer object for every attribute plus
 448        * one for the index buffer.
 449        */
 450       struct gl_buffer_object *bo[VERT_ATTRIB_MAX + 1];
 451       GLuint nr_bo = 0;
 452       GLuint inst;
 453
 454          /* Binding inputs may imply mapping some vertex buffer objects.
 455           * They will need to be unmapped below.
 456           */
 457       for (inst = 0; inst < prim[0].num_instances; inst++) {
 458
 459          bind_prims(ctx, prim, nr_prims);
 460          bind_inputs(ctx, arrays, max_index + 1,
 461                      bo, &nr_bo);
 462          bind_indices(ctx, ib, bo, &nr_bo);
 463
 464          tnl->CurInstance = inst;
 465          TNL_CONTEXT(ctx)->Driver.RunPipeline(ctx);
 466
 467          unmap_vbos(ctx, bo, nr_bo);
 468          free_space(ctx);
 469       }
 470    }
 471 }
 472