src/mesa/shader/shaderobjects_3dlabs.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  6.5
   4  *
   5  * Copyright (C) 2005-2006  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
  25 /**
  26  * \file shaderobjects_3dlabs.c
  27  * shader objects definitions for 3dlabs compiler
  28  * \author Michal Krol
  29  */
  30
  31 /* Set this to 1 when we are ready to use 3dlabs' front-end */
  32 #define USE_3DLABS_FRONTEND 0
  33
  34 #include "imports.h"
  35 #include "hash.h"
  36 #include "macros.h"
  37 #include "shaderobjects.h"
  38 #include "shaderobjects_3dlabs.h"
  39
  40 #if USE_3DLABS_FRONTEND
  41 #include "slang_mesa.h"
  42 #include "Public/ShaderLang.h"
  43 #else
  44 #include "slang_link.h"
  45 #endif
  46
  47 #if FEATURE_ARB_shader_objects
  48
  49 struct gl2_unknown_obj
  50 {
  51    GLuint reference_count;
  52    void (*_destructor) (struct gl2_unknown_intf **);
  53 };
  54
  55 struct gl2_unknown_impl
  56 {
  57    struct gl2_unknown_intf *_vftbl;
  58    struct gl2_unknown_obj _obj;
  59 };
  60
  61 static void
  62 _unknown_destructor(struct gl2_unknown_intf **intf)
  63 {
  64 }
  65
  66 static void
  67 _unknown_AddRef(struct gl2_unknown_intf **intf)
  68 {
  69    struct gl2_unknown_impl *impl = (struct gl2_unknown_impl *) intf;
  70
  71    impl->_obj.reference_count++;
  72 }
  73
  74 static void
  75 _unknown_Release(struct gl2_unknown_intf **intf)
  76 {
  77    struct gl2_unknown_impl *impl = (struct gl2_unknown_impl *) intf;
  78
  79    impl->_obj.reference_count--;
  80    if (impl->_obj.reference_count == 0) {
  81       impl->_obj._destructor(intf);
  82       _mesa_free((void *) intf);
  83    }
  84 }
  85
  86 static struct gl2_unknown_intf **
  87 _unknown_QueryInterface(struct gl2_unknown_intf **intf, enum gl2_uiid uiid)
  88 {
  89    if (uiid == UIID_UNKNOWN) {
  90       (**intf).AddRef(intf);
  91       return intf;
  92    }
  93    return NULL;
  94 }
  95
  96 static struct gl2_unknown_intf _unknown_vftbl = {
  97    _unknown_AddRef,
  98    _unknown_Release,
  99    _unknown_QueryInterface
 100 };
 101
 102 static void
 103 _unknown_constructor(struct gl2_unknown_impl *impl)
 104 {
 105    impl->_vftbl = &_unknown_vftbl;
 106    impl->_obj.reference_count = 1;
 107    impl->_obj._destructor = _unknown_destructor;
 108 }
 109
 110 struct gl2_unkinner_obj
 111 {
 112    struct gl2_unknown_intf **unkouter;
 113 };
 114
 115 struct gl2_unkinner_impl
 116 {
 117    struct gl2_unknown_intf *_vftbl;
 118    struct gl2_unkinner_obj _obj;
 119 };
 120
 121 static void
 122 _unkinner_destructor(struct gl2_unknown_intf **intf)
 123 {
 124 }
 125
 126 static void
 127 _unkinner_AddRef(struct gl2_unknown_intf **intf)
 128 {
 129    struct gl2_unkinner_impl *impl = (struct gl2_unkinner_impl *) intf;
 130
 131    (**impl->_obj.unkouter).AddRef(impl->_obj.unkouter);
 132 }
 133
 134 static void
 135 _unkinner_Release(struct gl2_unknown_intf **intf)
 136 {
 137    struct gl2_unkinner_impl *impl = (struct gl2_unkinner_impl *) intf;
 138
 139    (**impl->_obj.unkouter).Release(impl->_obj.unkouter);
 140 }
 141
 142 static struct gl2_unknown_intf **
 143 _unkinner_QueryInterface(struct gl2_unknown_intf **intf, enum gl2_uiid uiid)
 144 {
 145    struct gl2_unkinner_impl *impl = (struct gl2_unkinner_impl *) intf;
 146
 147    return (**impl->_obj.unkouter).QueryInterface(impl->_obj.unkouter, uiid);
 148 }
 149
 150 static struct gl2_unknown_intf _unkinner_vftbl = {
 151    _unkinner_AddRef,
 152    _unkinner_Release,
 153    _unkinner_QueryInterface
 154 };
 155
 156 static void
 157 _unkinner_constructor(struct gl2_unkinner_impl *impl,
 158                       struct gl2_unknown_intf **outer)
 159 {
 160    impl->_vftbl = &_unkinner_vftbl;
 161    impl->_obj.unkouter = outer;
 162 }
 163
 164 struct gl2_generic_obj
 165 {
 166    struct gl2_unknown_obj _unknown;
 167    GLhandleARB name;
 168    GLboolean delete_status;
 169    GLcharARB *info_log;
 170 };
 171
 172 struct gl2_generic_impl
 173 {
 174    struct gl2_generic_intf *_vftbl;
 175    struct gl2_generic_obj _obj;
 176 };
 177
 178 static void
 179 _generic_destructor(struct gl2_unknown_intf **intf)
 180 {
 181    GET_CURRENT_CONTEXT(ctx);
 182    struct gl2_generic_impl *impl = (struct gl2_generic_impl *) intf;
 183
 184    _mesa_free((void *) impl->_obj.info_log);
 185
 186    _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
 187    _mesa_HashRemove(ctx->Shared->GL2Objects, impl->_obj.name);
 188    _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
 189
 190    _unknown_destructor(intf);
 191 }
 192
 193 static struct gl2_unknown_intf **
 194 _generic_QueryInterface(struct gl2_unknown_intf **intf, enum gl2_uiid uiid)
 195 {
 196    if (uiid == UIID_GENERIC) {
 197       (**intf).AddRef(intf);
 198       return intf;
 199    }
 200    return _unknown_QueryInterface(intf, uiid);
 201 }
 202
 203 static void
 204 _generic_Delete(struct gl2_generic_intf **intf)
 205 {
 206    struct gl2_generic_impl *impl = (struct gl2_generic_impl *) intf;
 207
 208    if (impl->_obj.delete_status == GL_FALSE) {
 209       impl->_obj.delete_status = GL_TRUE;
 210       (**intf)._unknown.Release((struct gl2_unknown_intf **) intf);
 211    }
 212 }
 213
 214 static GLhandleARB
 215 _generic_GetName(struct gl2_generic_intf **intf)
 216 {
 217    struct gl2_generic_impl *impl = (struct gl2_generic_impl *) intf;
 218
 219    return impl->_obj.name;
 220 }
 221
 222 static GLboolean
 223 _generic_GetDeleteStatus(struct gl2_generic_intf **intf)
 224 {
 225    struct gl2_generic_impl *impl = (struct gl2_generic_impl *) intf;
 226
 227    return impl->_obj.delete_status;
 228 }
 229
 230 static GLvoid
 231 _generic_GetInfoLog(struct gl2_generic_intf **intf, GLsizei maxlen,
 232                     GLcharARB * infolog)
 233 {
 234    struct gl2_generic_impl *impl = (struct gl2_generic_impl *) (intf);
 235
 236    if (maxlen > 0) {
 237       _mesa_strncpy(infolog, impl->_obj.info_log, maxlen - 1);
 238       infolog[maxlen - 1] = '\0';
 239    }
 240 }
 241
 242 static GLsizei
 243 _generic_GetInfoLogLength(struct gl2_generic_intf **intf)
 244 {
 245    struct gl2_generic_impl *impl = (struct gl2_generic_impl *) (intf);
 246
 247    if (impl->_obj.info_log == NULL)
 248       return 1;
 249    return _mesa_strlen(impl->_obj.info_log) + 1;
 250 }
 251
 252 static struct gl2_generic_intf _generic_vftbl = {
 253    {
 254     _unknown_AddRef,
 255     _unknown_Release,
 256     _generic_QueryInterface},
 257    _generic_Delete,
 258    NULL,                        /* abstract GetType */
 259    _generic_GetName,
 260    _generic_GetDeleteStatus,
 261    _generic_GetInfoLog,
 262    _generic_GetInfoLogLength
 263 };
 264
 265 static void
 266 _generic_constructor(struct gl2_generic_impl *impl)
 267 {
 268    GET_CURRENT_CONTEXT(ctx);
 269
 270    _unknown_constructor((struct gl2_unknown_impl *) impl);
 271    impl->_vftbl = &_generic_vftbl;
 272    impl->_obj._unknown._destructor = _generic_destructor;
 273    impl->_obj.delete_status = GL_FALSE;
 274    impl->_obj.info_log = NULL;
 275
 276    _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
 277    impl->_obj.name = _mesa_HashFindFreeKeyBlock(ctx->Shared->GL2Objects, 1);
 278    _mesa_HashInsert(ctx->Shared->GL2Objects, impl->_obj.name, (void *) impl);
 279    _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
 280 }
 281
 282 struct gl2_container_obj
 283 {
 284    struct gl2_generic_obj _generic;
 285    struct gl2_generic_intf ***attached;
 286    GLuint attached_count;
 287 };
 288
 289 struct gl2_container_impl
 290 {
 291    struct gl2_container_intf *_vftbl;
 292    struct gl2_container_obj _obj;
 293 };
 294
 295 static void
 296 _container_destructor(struct gl2_unknown_intf **intf)
 297 {
 298    struct gl2_container_impl *impl = (struct gl2_container_impl *) intf;
 299    GLuint i;
 300
 301    for (i = 0; i < impl->_obj.attached_count; i++) {
 302       struct gl2_generic_intf **x = impl->_obj.attached[i];
 303       (**x)._unknown.Release((struct gl2_unknown_intf **) x);
 304    }
 305
 306    _generic_destructor(intf);
 307 }
 308
 309 static struct gl2_unknown_intf **
 310 _container_QueryInterface(struct gl2_unknown_intf **intf, enum gl2_uiid uiid)
 311 {
 312    if (uiid == UIID_CONTAINER) {
 313       (**intf).AddRef(intf);
 314       return intf;
 315    }
 316    return _generic_QueryInterface(intf, uiid);
 317 }
 318
 319 static GLboolean
 320 _container_Attach(struct gl2_container_intf **intf,
 321                   struct gl2_generic_intf **att)
 322 {
 323    GET_CURRENT_CONTEXT(ctx);
 324    struct gl2_container_impl *impl = (struct gl2_container_impl *) intf;
 325    GLuint i;
 326
 327    for (i = 0; i < impl->_obj.attached_count; i++)
 328       if (impl->_obj.attached[i] == att) {
 329          _mesa_error(ctx, GL_INVALID_OPERATION, "_container_Attach");
 330          return GL_FALSE;
 331       }
 332
 333    impl->_obj.attached = (struct gl2_generic_intf ***)
 334       _mesa_realloc(impl->_obj.attached,
 335                impl->_obj.attached_count * sizeof(*impl->_obj.attached),
 336                (impl->_obj.attached_count + 1) * sizeof(*impl->_obj.attached));
 337    if (impl->_obj.attached == NULL)
 338       return GL_FALSE;
 339
 340    impl->_obj.attached[impl->_obj.attached_count] = att;
 341    impl->_obj.attached_count++;
 342    (**att)._unknown.AddRef((struct gl2_unknown_intf **) att);
 343    return GL_TRUE;
 344 }
 345
 346 static GLboolean
 347 _container_Detach(struct gl2_container_intf **intf,
 348                   struct gl2_generic_intf **att)
 349 {
 350    GET_CURRENT_CONTEXT(ctx);
 351    struct gl2_container_impl *impl = (struct gl2_container_impl *) intf;
 352    GLuint i, j;
 353
 354    for (i = 0; i < impl->_obj.attached_count; i++)
 355       if (impl->_obj.attached[i] == att) {
 356          for (j = i; j < impl->_obj.attached_count - 1; j++)
 357             impl->_obj.attached[j] = impl->_obj.attached[j + 1];
 358          impl->_obj.attached = (struct gl2_generic_intf ***)
 359             _mesa_realloc(impl->_obj.attached,
 360                impl->_obj.attached_count * sizeof(*impl->_obj.attached),
 361                (impl->_obj.attached_count - 1) * sizeof(*impl->_obj.attached));
 362          impl->_obj.attached_count--;
 363          (**att)._unknown.Release((struct gl2_unknown_intf **) att);
 364          return GL_TRUE;
 365       }
 366
 367    _mesa_error(ctx, GL_INVALID_OPERATION, "_container_Detach");
 368    return GL_FALSE;
 369 }
 370
 371 static GLsizei
 372 _container_GetAttachedCount(struct gl2_container_intf **intf)
 373 {
 374    struct gl2_container_impl *impl = (struct gl2_container_impl *) intf;
 375
 376    return impl->_obj.attached_count;
 377 }
 378
 379 static struct gl2_generic_intf **
 380 _container_GetAttached(struct gl2_container_intf **intf, GLuint index)
 381 {
 382    struct gl2_container_impl *impl = (struct gl2_container_impl *) intf;
 383
 384    (**impl->_obj.attached[index])._unknown.AddRef((struct gl2_unknown_intf **)
 385                                                   impl->_obj.attached[index]);
 386    return impl->_obj.attached[index];
 387 }
 388
 389 static struct gl2_container_intf _container_vftbl = {
 390    {
 391       {
 392          _unknown_AddRef,
 393          _unknown_Release,
 394          _container_QueryInterface
 395       },
 396       _generic_Delete,
 397       NULL,                       /* abstract GetType */
 398       _generic_GetName,
 399       _generic_GetDeleteStatus,
 400       _generic_GetInfoLog,
 401       _generic_GetInfoLogLength
 402    },
 403    _container_Attach,
 404    _container_Detach,
 405    _container_GetAttachedCount,
 406    _container_GetAttached
 407 };
 408
 409 static void
 410 _container_constructor(struct gl2_container_impl *impl)
 411 {
 412    _generic_constructor((struct gl2_generic_impl *) impl);
 413    impl->_vftbl = &_container_vftbl;
 414    impl->_obj._generic._unknown._destructor = _container_destructor;
 415    impl->_obj.attached = NULL;
 416    impl->_obj.attached_count = 0;
 417 }
 418
 419 struct gl2_3dlabs_shhandle_obj
 420 {
 421    struct gl2_unkinner_obj _unknown;
 422 #if USE_3DLABS_FRONTEND
 423    ShHandle handle;
 424 #endif
 425 };
 426
 427 struct gl2_3dlabs_shhandle_impl
 428 {
 429    struct gl2_3dlabs_shhandle_intf *_vftbl;
 430    struct gl2_3dlabs_shhandle_obj _obj;
 431 };
 432
 433 static void
 434 _3dlabs_shhandle_destructor(struct gl2_unknown_intf **intf)
 435 {
 436 #if USE_3DLABS_FRONTEND
 437    struct gl2_3dlabs_shhandle_impl *impl =
 438       (struct gl2_3dlabs_shhandle_impl *) intf;
 439    ShDestruct(impl->_obj.handle);
 440 #endif
 441    _unkinner_destructor(intf);
 442 }
 443
 444 static GLvoid *
 445 _3dlabs_shhandle_GetShHandle(struct gl2_3dlabs_shhandle_intf **intf)
 446 {
 447 #if USE_3DLABS_FRONTEND
 448    struct gl2_3dlabs_shhandle_impl *impl =
 449       (struct gl2_3dlabs_shhandle_impl *) intf;
 450    return impl->_obj.handle;
 451 #else
 452    return NULL;
 453 #endif
 454 }
 455
 456 static struct gl2_3dlabs_shhandle_intf _3dlabs_shhandle_vftbl = {
 457    {
 458     _unkinner_AddRef,
 459     _unkinner_Release,
 460     _unkinner_QueryInterface},
 461    _3dlabs_shhandle_GetShHandle
 462 };
 463
 464 static void
 465 _3dlabs_shhandle_constructor(struct gl2_3dlabs_shhandle_impl *impl,
 466                              struct gl2_unknown_intf **outer)
 467 {
 468    _unkinner_constructor((struct gl2_unkinner_impl *) impl, outer);
 469    impl->_vftbl = &_3dlabs_shhandle_vftbl;
 470 #if USE_3DLABS_FRONTEND
 471    impl->_obj.handle = NULL;
 472 #endif
 473 }
 474
 475 struct gl2_shader_obj
 476 {
 477    struct gl2_generic_obj _generic;
 478    struct gl2_3dlabs_shhandle_impl _3dlabs_shhandle;
 479    GLboolean compile_status;
 480    GLcharARB *source;
 481    GLint *offsets;
 482    GLsizei offset_count;
 483    slang_code_object code;
 484 };
 485
 486 struct gl2_shader_impl
 487 {
 488    struct gl2_shader_intf *_vftbl;
 489    struct gl2_shader_obj _obj;
 490 };
 491
 492 static void
 493 _shader_destructor(struct gl2_unknown_intf **intf)
 494 {
 495    struct gl2_shader_impl *impl = (struct gl2_shader_impl *) intf;
 496
 497    _mesa_free((void *) impl->_obj.source);
 498    _mesa_free((void *) impl->_obj.offsets);
 499    _slang_code_object_dtr(&impl->_obj.code);
 500    _3dlabs_shhandle_destructor((struct gl2_unknown_intf **) &impl->_obj.
 501                                _3dlabs_shhandle._vftbl);
 502    _generic_destructor(intf);
 503 }
 504
 505 static struct gl2_unknown_intf **
 506 _shader_QueryInterface(struct gl2_unknown_intf **intf, enum gl2_uiid uiid)
 507 {
 508 #if USE_3DLABS_FRONTEND
 509    struct gl2_shader_impl *impl = (struct gl2_shader_impl *) intf;
 510 #endif
 511
 512    if (uiid == UIID_SHADER) {
 513       (**intf).AddRef(intf);
 514       return intf;
 515    }
 516 #if USE_3DLABS_FRONTEND
 517    if (uiid == UIID_3DLABS_SHHANDLE) {
 518       (**intf).AddRef(intf);
 519       return (struct gl2_unknown_intf **) &impl->_obj._3dlabs_shhandle._vftbl;
 520    }
 521 #endif
 522    return _generic_QueryInterface(intf, uiid);
 523 }
 524
 525 static GLenum
 526 _shader_GetType(struct gl2_generic_intf **intf)
 527 {
 528    return GL_SHADER_OBJECT_ARB;
 529 }
 530
 531 static GLvoid
 532 _shader_GetInfoLog(struct gl2_generic_intf **intf, GLsizei maxlen,
 533                    GLcharARB * infolog)
 534 {
 535    struct gl2_shader_impl *impl = (struct gl2_shader_impl *) (intf);
 536
 537    if (maxlen > 0) {
 538       if (impl->_obj._generic.info_log != NULL) {
 539          GLsizei len = _mesa_strlen(impl->_obj._generic.info_log);
 540          if (len > maxlen - 1)
 541             len = maxlen - 1;
 542          _mesa_memcpy(infolog, impl->_obj._generic.info_log, len);
 543          infolog += len;
 544          maxlen -= len;
 545       }
 546       if (impl->_obj.code.machine.infolog != NULL &&
 547           impl->_obj.code.machine.infolog->text != NULL) {
 548          GLsizei len = _mesa_strlen(impl->_obj.code.machine.infolog->text);
 549          if (len > maxlen - 1)
 550             len = maxlen - 1;
 551          _mesa_memcpy(infolog, impl->_obj.code.machine.infolog->text, len);
 552       }
 553       infolog[maxlen - 1] = '\0';
 554    }
 555 }
 556
 557 static GLsizei
 558 _shader_GetInfoLogLength(struct gl2_generic_intf **intf)
 559 {
 560    struct gl2_shader_impl *impl = (struct gl2_shader_impl *) (intf);
 561    GLsizei length = 1;
 562
 563    if (impl->_obj._generic.info_log != NULL)
 564       length += _mesa_strlen(impl->_obj._generic.info_log);
 565    if (impl->_obj.code.machine.infolog != NULL &&
 566        impl->_obj.code.machine.infolog->text != NULL)
 567       length += _mesa_strlen(impl->_obj.code.machine.infolog->text);
 568    return length;
 569 }
 570
 571 static GLboolean
 572 _shader_GetCompileStatus(struct gl2_shader_intf **intf)
 573 {
 574    struct gl2_shader_impl *impl = (struct gl2_shader_impl *) intf;
 575
 576    return impl->_obj.compile_status;
 577 }
 578
 579 static GLvoid
 580 _shader_SetSource(struct gl2_shader_intf **intf, GLcharARB * src, GLint * off,
 581                   GLsizei cnt)
 582 {
 583    struct gl2_shader_impl *impl = (struct gl2_shader_impl *) intf;
 584
 585    _mesa_free((void *) impl->_obj.source);
 586    impl->_obj.source = src;
 587    _mesa_free((void *) impl->_obj.offsets);
 588    impl->_obj.offsets = off;
 589    impl->_obj.offset_count = cnt;
 590 }
 591
 592 static const GLcharARB *
 593 _shader_GetSource(struct gl2_shader_intf **intf)
 594 {
 595    struct gl2_shader_impl *impl = (struct gl2_shader_impl *) intf;
 596
 597    return impl->_obj.source;
 598 }
 599
 600 static GLvoid
 601 _shader_Compile(struct gl2_shader_intf **intf)
 602 {
 603    struct gl2_shader_impl *impl = (struct gl2_shader_impl *) intf;
 604 #if USE_3DLABS_FRONTEND
 605    char **strings;
 606    TBuiltInResource res;
 607 #else
 608    slang_unit_type type;
 609    slang_info_log info_log;
 610 #endif
 611
 612    impl->_obj.compile_status = GL_FALSE;
 613    _mesa_free((void *) impl->_obj._generic.info_log);
 614    impl->_obj._generic.info_log = NULL;
 615
 616 #if USE_3DLABS_FRONTEND
 617    /* 3dlabs compiler expects us to feed it with null-terminated string array,
 618       we've got only one big string with offsets, so we must split it; but when
 619       there's only one string to deal with, we pass its address directly */
 620
 621    if (impl->_obj.offset_count <= 1)
 622       strings = &impl->_obj.source;
 623    else {
 624       GLsizei i, offset = 0;
 625
 626       strings =
 627          (char **) _mesa_malloc(impl->_obj.offset_count * sizeof(char *));
 628       if (strings == NULL)
 629          return;
 630
 631       for (i = 0; i < impl->_obj.offset_count; i++) {
 632          GLsizei size = impl->_obj.offsets[i] - offset;
 633
 634          strings[i] = (char *) _mesa_malloc((size + 1) * sizeof(char));
 635          if (strings[i] == NULL) {
 636             GLsizei j;
 637
 638             for (j = 0; j < i; j++)
 639                _mesa_free(strings[j]);
 640             _mesa_free(strings);
 641             return;
 642          }
 643
 644          _mesa_memcpy(strings[i], impl->_obj.source + offset,
 645                       size * sizeof(char));
 646          strings[i][size] = '\0';
 647          offset = impl->_obj.offsets[i];
 648       }
 649    }
 650
 651    /* TODO set these fields to some REAL numbers */
 652    res.maxLights = 8;
 653    res.maxClipPlanes = 6;
 654    res.maxTextureUnits = 2;
 655    res.maxTextureCoords = 2;
 656    res.maxVertexAttribs = 8;
 657    res.maxVertexUniformComponents = 64;
 658    res.maxVaryingFloats = 8;
 659    res.maxVertexTextureImageUnits = 2;
 660    res.maxCombinedTextureImageUnits = 2;
 661    res.maxTextureImageUnits = 2;
 662    res.maxFragmentUniformComponents = 64;
 663    res.maxDrawBuffers = 1;
 664
 665    if (ShCompile
 666        (impl->_obj._3dlabs_shhandle._obj.handle, strings,
 667         impl->_obj.offset_count, EShOptFull, &res, 0))
 668       impl->_obj.compile_status = GL_TRUE;
 669    if (impl->_obj.offset_count > 1) {
 670       GLsizei i;
 671
 672       for (i = 0; i < impl->_obj.offset_count; i++)
 673          _mesa_free(strings[i]);
 674       _mesa_free(strings);
 675    }
 676
 677    impl->_obj._generic.info_log =
 678       _mesa_strdup(ShGetInfoLog(impl->_obj._3dlabs_shhandle._obj.handle));
 679 #else
 680    if (impl->_vftbl->GetSubType(intf) == GL_FRAGMENT_SHADER)
 681       type = slang_unit_fragment_shader;
 682    else
 683       type = slang_unit_vertex_shader;
 684    slang_info_log_construct(&info_log);
 685    if (_slang_compile(impl->_obj.source, &impl->_obj.code, type, &info_log))
 686       impl->_obj.compile_status = GL_TRUE;
 687    if (info_log.text != NULL)
 688       impl->_obj._generic.info_log = _mesa_strdup(info_log.text);
 689    else if (impl->_obj.compile_status)
 690       impl->_obj._generic.info_log = _mesa_strdup("Compile OK.\n");
 691    else
 692       impl->_obj._generic.info_log = _mesa_strdup("Compile failed.\n");
 693    slang_info_log_destruct(&info_log);
 694 #endif
 695 }
 696
 697 static struct gl2_shader_intf _shader_vftbl = {
 698    {
 699       {
 700          _unknown_AddRef,
 701          _unknown_Release,
 702          _shader_QueryInterface
 703       },
 704       _generic_Delete,
 705       _shader_GetType,
 706       _generic_GetName,
 707       _generic_GetDeleteStatus,
 708       _shader_GetInfoLog,
 709       _shader_GetInfoLogLength
 710    },
 711    NULL,                        /* abstract GetSubType */
 712    _shader_GetCompileStatus,
 713    _shader_SetSource,
 714    _shader_GetSource,
 715    _shader_Compile
 716 };
 717
 718 static void
 719 _shader_constructor(struct gl2_shader_impl *impl)
 720 {
 721    _generic_constructor((struct gl2_generic_impl *) impl);
 722    _3dlabs_shhandle_constructor(&impl->_obj._3dlabs_shhandle,
 723                                 (struct gl2_unknown_intf **)
 724                                 &impl->_vftbl);
 725    impl->_vftbl = &_shader_vftbl;
 726    impl->_obj._generic._unknown._destructor = _shader_destructor;
 727    impl->_obj.compile_status = GL_FALSE;
 728    impl->_obj.source = NULL;
 729    impl->_obj.offsets = NULL;
 730    impl->_obj.offset_count = 0;
 731    _slang_code_object_ctr(&impl->_obj.code);
 732 }
 733
 734 struct gl2_program_obj
 735 {
 736    struct gl2_container_obj _container;
 737    GLboolean link_status;
 738    GLboolean validate_status;
 739 #if USE_3DLABS_FRONTEND
 740    ShHandle linker;
 741    ShHandle uniforms;
 742 #endif
 743    slang_program prog;
 744 };
 745
 746 struct gl2_program_impl
 747 {
 748    struct gl2_program_intf *_vftbl;
 749    struct gl2_program_obj _obj;
 750 };
 751
 752 static void
 753 _program_destructor(struct gl2_unknown_intf **intf)
 754 {
 755    struct gl2_program_impl *impl = (struct gl2_program_impl *) intf;
 756 #if USE_3DLABS_FRONTEND
 757    ShDestruct(impl->_obj.linker);
 758    ShDestruct(impl->_obj.uniforms);
 759 #endif
 760    _container_destructor(intf);
 761    _slang_program_dtr(&impl->_obj.prog);
 762 }
 763
 764 static struct gl2_unknown_intf **
 765 _program_QueryInterface(struct gl2_unknown_intf **intf, enum gl2_uiid uiid)
 766 {
 767    if (uiid == UIID_PROGRAM) {
 768       (**intf).AddRef(intf);
 769       return intf;
 770    }
 771    return _container_QueryInterface(intf, uiid);
 772 }
 773
 774 static GLenum
 775 _program_GetType(struct gl2_generic_intf **intf)
 776 {
 777    return GL_PROGRAM_OBJECT_ARB;
 778 }
 779
 780 static GLboolean
 781 _program_Attach(struct gl2_container_intf **intf,
 782                 struct gl2_generic_intf **att)
 783 {
 784    GET_CURRENT_CONTEXT(ctx);
 785    struct gl2_unknown_intf **sha;
 786
 787    sha =
 788       (**att)._unknown.QueryInterface((struct gl2_unknown_intf **) att,
 789                                       UIID_SHADER);
 790    if (sha == NULL) {
 791       _mesa_error(ctx, GL_INVALID_OPERATION, "_program_Attach");
 792       return GL_FALSE;
 793    }
 794
 795    (**sha).Release(sha);
 796    return _container_Attach(intf, att);
 797 }
 798
 799 static GLboolean
 800 _program_GetLinkStatus(struct gl2_program_intf **intf)
 801 {
 802    struct gl2_program_impl *impl = (struct gl2_program_impl *) intf;
 803
 804    return impl->_obj.link_status;
 805 }
 806
 807 static GLboolean
 808 _program_GetValidateStatus(struct gl2_program_intf **intf)
 809 {
 810    struct gl2_program_impl *impl = (struct gl2_program_impl *) intf;
 811
 812    return impl->_obj.validate_status;
 813 }
 814
 815 static GLvoid
 816 _program_Link(struct gl2_program_intf **intf)
 817 {
 818    struct gl2_program_impl *impl = (struct gl2_program_impl *) intf;
 819 #if USE_3DLABS_FRONTEND
 820    ShHandle *handles;
 821 #endif
 822    GLuint i, count;
 823    slang_code_object *code[2];
 824    GLboolean all_compiled = GL_TRUE;
 825
 826    impl->_obj.link_status = GL_FALSE;
 827    _mesa_free((void *) impl->_obj._container._generic.info_log);
 828    impl->_obj._container._generic.info_log = NULL;
 829    _slang_program_rst(&impl->_obj.prog);
 830
 831 #if USE_3DLABS_FRONTEND
 832    handles =
 833       (ShHandle *) _mesa_malloc(impl->_obj._container.attached_count *
 834                                 sizeof(ShHandle));
 835    if (handles == NULL)
 836       return;
 837
 838    for (i = 0; i < impl->_obj._container.attached_count; i++) {
 839       struct gl2_generic_intf **gen = impl->_obj._container.attached[i];
 840       struct gl2_3dlabs_shhandle_intf **sh;
 841
 842       sh =
 843          (struct gl2_3dlabs_shhandle_intf **) (**gen)._unknown.
 844          QueryInterface((struct gl2_unknown_intf **) gen,
 845                         UIID_3DLABS_SHHANDLE);
 846       if (sh != NULL) {
 847          handles[i] = (**sh).GetShHandle(sh);
 848          (**sh)._unknown.Release((struct gl2_unknown_intf **) sh);
 849       }
 850       else {
 851          _mesa_free(handles);
 852          return;
 853       }
 854    }
 855
 856    if (ShLink(impl->_obj.linker, handles, impl->_obj._container.attached_count,
 857               impl->_obj.uniforms, NULL, NULL))
 858       impl->_obj.link_status = GL_TRUE;
 859
 860    impl->_obj._container._generic.info_log =
 861       _mesa_strdup(ShGetInfoLog(impl->_obj.linker));
 862 #else
 863    count = impl->_obj._container.attached_count;
 864    if (count > 2)
 865       return;
 866
 867    for (i = 0; i < count; i++) {
 868       struct gl2_generic_intf **obj;
 869       struct gl2_unknown_intf **unk;
 870       struct gl2_shader_impl *sha;
 871
 872       obj = impl->_obj._container.attached[i];
 873       unk =
 874          (**obj)._unknown.QueryInterface((struct gl2_unknown_intf **) obj,
 875                                          UIID_SHADER);
 876       if (unk == NULL)
 877          return;
 878       sha = (struct gl2_shader_impl *) unk;
 879       code[i] = &sha->_obj.code;
 880       all_compiled = all_compiled && sha->_obj.compile_status;
 881       (**unk).Release(unk);
 882    }
 883
 884    impl->_obj.link_status = all_compiled;
 885    if (!impl->_obj.link_status) {
 886       impl->_obj._container._generic.info_log =
 887          _mesa_strdup
 888          ("Error: One or more shaders has not successfully compiled.\n");
 889       return;
 890    }
 891
 892    impl->_obj.link_status = _slang_link(&impl->_obj.prog, code, count);
 893    if (!impl->_obj.link_status) {
 894       impl->_obj._container._generic.info_log =
 895          _mesa_strdup("Link failed.\n");
 896       return;
 897    }
 898
 899    impl->_obj._container._generic.info_log = _mesa_strdup("Link OK.\n");
 900 #endif
 901 }
 902
 903 static GLvoid
 904 _program_Validate(struct gl2_program_intf **intf)
 905 {
 906    struct gl2_program_impl *impl = (struct gl2_program_impl *) intf;
 907
 908    impl->_obj.validate_status = GL_FALSE;
 909    _mesa_free((void *) impl->_obj._container._generic.info_log);
 910    impl->_obj._container._generic.info_log = NULL;
 911
 912    /* TODO validate */
 913 }
 914
 915 static GLvoid
 916 write_common_fixed(slang_program * pro, GLuint index, const GLvoid * src,
 917                    GLuint off, GLuint size)
 918 {
 919    GLuint i;
 920
 921    for (i = 0; i < SLANG_SHADER_MAX; i++) {
 922       GLuint addr;
 923
 924       addr = pro->common_fixed_entries[i][index];
 925       if (addr != ~0) {
 926          GLubyte *dst;
 927
 928          dst = (GLubyte *) pro->machines[i]->mem + addr + off * size;
 929          _mesa_memcpy(dst, src, size);
 930       }
 931    }
 932 }
 933
 934 static GLvoid
 935 write_common_fixed_mat4(slang_program * pro, GLmatrix * matrix, GLuint off,
 936                         GLuint i, GLuint ii, GLuint it, GLuint iit)
 937 {
 938    GLfloat mat[16];
 939
 940    /* we want inverse matrix */
 941    if (!matrix->inv) {
 942       /* allocate inverse matrix and make it dirty */
 943       _math_matrix_alloc_inv(matrix);
 944       _math_matrix_loadf(matrix, matrix->m);
 945    }
 946    _math_matrix_analyse(matrix);
 947
 948    write_common_fixed(pro, i, matrix->m, off, 16 * sizeof(GLfloat));
 949
 950    /* inverse */
 951    write_common_fixed(pro, ii, matrix->inv, off, 16 * sizeof(GLfloat));
 952
 953    /* transpose */
 954    _math_transposef(mat, matrix->m);
 955    write_common_fixed(pro, it, mat, off, 16 * sizeof(GLfloat));
 956
 957    /* inverse transpose */
 958    _math_transposef(mat, matrix->inv);
 959    write_common_fixed(pro, iit, mat, off, 16 * sizeof(GLfloat));
 960 }
 961
 962 static GLvoid
 963 write_common_fixed_material(GLcontext * ctx, slang_program * pro, GLuint i,
 964                             GLuint e, GLuint a, GLuint d, GLuint sp,
 965                             GLuint sh)
 966 {
 967    GLfloat v[17];
 968
 969    COPY_4FV(v, ctx->Light.Material.Attrib[e]);
 970    COPY_4FV((v + 4), ctx->Light.Material.Attrib[a]);
 971    COPY_4FV((v + 8), ctx->Light.Material.Attrib[d]);
 972    COPY_4FV((v + 12), ctx->Light.Material.Attrib[sp]);
 973    v[16] = ctx->Light.Material.Attrib[sh][0];
 974    write_common_fixed(pro, i, v, 0, 17 * sizeof(GLfloat));
 975 }
 976
 977 static GLvoid
 978 write_common_fixed_light_model_product(GLcontext * ctx, slang_program * pro,
 979                                        GLuint i, GLuint e, GLuint a)
 980 {
 981    GLfloat v[4];
 982
 983    SCALE_4V(v, ctx->Light.Material.Attrib[a], ctx->Light.Model.Ambient);
 984    ACC_4V(v, ctx->Light.Material.Attrib[e]);
 985    write_common_fixed(pro, i, v, 0, 4 * sizeof(GLfloat));
 986 }
 987
 988 static GLvoid
 989 write_common_fixed_light_product(GLcontext * ctx, slang_program * pro,
 990                                  GLuint off, GLuint i, GLuint a, GLuint d,
 991                                  GLuint s)
 992 {
 993    GLfloat v[12];
 994
 995    SCALE_4V(v, ctx->Light.Light[off].Ambient, ctx->Light.Material.Attrib[a]);
 996    SCALE_4V((v + 4), ctx->Light.Light[off].Diffuse,
 997             ctx->Light.Material.Attrib[d]);
 998    SCALE_4V((v + 8), ctx->Light.Light[off].Specular,
 999             ctx->Light.Material.Attrib[s]);
1000    write_common_fixed(pro, i, v, off, 12 * sizeof(GLfloat));
1001 }
1002
1003 static GLvoid
1004 _program_UpdateFixedUniforms(struct gl2_program_intf **intf)
1005 {
1006    GET_CURRENT_CONTEXT(ctx);
1007    struct gl2_program_impl *impl = (struct gl2_program_impl *) intf;
1008    slang_program *pro = &impl->_obj.prog;
1009    GLuint i;
1010    GLfloat v[29];
1011    GLfloat *p;
1012
1013    /* MODELVIEW matrix */
1014    write_common_fixed_mat4(pro, ctx->ModelviewMatrixStack.Top, 0,
1015                            SLANG_COMMON_FIXED_MODELVIEWMATRIX,
1016                            SLANG_COMMON_FIXED_MODELVIEWMATRIXINVERSE,
1017                            SLANG_COMMON_FIXED_MODELVIEWMATRIXTRANSPOSE,
1018                            SLANG_COMMON_FIXED_MODELVIEWMATRIXINVERSETRANSPOSE);
1019
1020    /* PROJECTION matrix */
1021    write_common_fixed_mat4(pro, ctx->ProjectionMatrixStack.Top, 0,
1022                            SLANG_COMMON_FIXED_PROJECTIONMATRIX,
1023                            SLANG_COMMON_FIXED_PROJECTIONMATRIXINVERSE,
1024                            SLANG_COMMON_FIXED_PROJECTIONMATRIXTRANSPOSE,
1025                            SLANG_COMMON_FIXED_PROJECTIONMATRIXINVERSETRANSPOSE);
1026
1027    /* MVP matrix */
1028    write_common_fixed_mat4(pro, &ctx->_ModelProjectMatrix, 0,
1029                            SLANG_COMMON_FIXED_MODELVIEWPROJECTIONMATRIX,
1030                            SLANG_COMMON_FIXED_MODELVIEWPROJECTIONMATRIXINVERSE,
1031                            SLANG_COMMON_FIXED_MODELVIEWPROJECTIONMATRIXTRANSPOSE,
1032                            SLANG_COMMON_FIXED_MODELVIEWPROJECTIONMATRIXINVERSETRANSPOSE);
1033
1034    for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) {
1035       /* TEXTURE matrix */
1036       write_common_fixed_mat4(pro, ctx->TextureMatrixStack[i].Top, i,
1037                               SLANG_COMMON_FIXED_TEXTUREMATRIX,
1038                               SLANG_COMMON_FIXED_TEXTUREMATRIXINVERSE,
1039                               SLANG_COMMON_FIXED_TEXTUREMATRIXTRANSPOSE,
1040                               SLANG_COMMON_FIXED_TEXTUREMATRIXINVERSETRANSPOSE);
1041
1042       /* EYE_PLANE texture-coordinate generation */
1043       write_common_fixed(pro, SLANG_COMMON_FIXED_EYEPLANES,
1044                          ctx->Texture.Unit[i].EyePlaneS, i,
1045                          4 * sizeof(GLfloat));
1046       write_common_fixed(pro, SLANG_COMMON_FIXED_EYEPLANET,
1047                          ctx->Texture.Unit[i].EyePlaneT, i,
1048                          4 * sizeof(GLfloat));
1049       write_common_fixed(pro, SLANG_COMMON_FIXED_EYEPLANER,
1050                          ctx->Texture.Unit[i].EyePlaneR, i,
1051                          4 * sizeof(GLfloat));
1052       write_common_fixed(pro, SLANG_COMMON_FIXED_EYEPLANEQ,
1053                          ctx->Texture.Unit[i].EyePlaneQ, i,
1054                          4 * sizeof(GLfloat));
1055
1056       /* OBJECT_PLANE texture-coordinate generation */
1057       write_common_fixed(pro, SLANG_COMMON_FIXED_OBJECTPLANES,
1058                          ctx->Texture.Unit[i].ObjectPlaneS, i,
1059                          4 * sizeof(GLfloat));
1060       write_common_fixed(pro, SLANG_COMMON_FIXED_OBJECTPLANET,
1061                          ctx->Texture.Unit[i].ObjectPlaneT, i,
1062                          4 * sizeof(GLfloat));
1063       write_common_fixed(pro, SLANG_COMMON_FIXED_OBJECTPLANER,
1064                          ctx->Texture.Unit[i].ObjectPlaneR, i,
1065                          4 * sizeof(GLfloat));
1066       write_common_fixed(pro, SLANG_COMMON_FIXED_OBJECTPLANEQ,
1067                          ctx->Texture.Unit[i].ObjectPlaneQ, i,
1068                          4 * sizeof(GLfloat));
1069    }
1070
1071    /* NORMAL matrix - upper 3x3 inverse transpose of MODELVIEW matrix */
1072    p = ctx->ModelviewMatrixStack.Top->inv;
1073    v[0] = p[0];
1074    v[1] = p[4];
1075    v[2] = p[8];
1076    v[3] = p[1];
1077    v[4] = p[5];
1078    v[5] = p[9];
1079    v[6] = p[2];
1080    v[7] = p[6];
1081    v[8] = p[10];
1082    write_common_fixed(pro, SLANG_COMMON_FIXED_NORMALMATRIX, v, 0,
1083                       9 * sizeof(GLfloat));
1084
1085    /* normal scale */
1086    write_common_fixed(pro, SLANG_COMMON_FIXED_NORMALSCALE,
1087                       &ctx->_ModelViewInvScale, 0, sizeof(GLfloat));
1088
1089    /* depth range parameters */
1090    v[0] = ctx->Viewport.Near;
1091    v[1] = ctx->Viewport.Far;
1092    v[2] = ctx->Viewport.Far - ctx->Viewport.Near;
1093    write_common_fixed(pro, SLANG_COMMON_FIXED_DEPTHRANGE, v, 0,
1094                       3 * sizeof(GLfloat));
1095
1096    /* CLIP_PLANEi */
1097    for (i = 0; i < ctx->Const.MaxClipPlanes; i++) {
1098       write_common_fixed(pro, SLANG_COMMON_FIXED_CLIPPLANE,
1099                          ctx->Transform.EyeUserPlane[i], i,
1100                          4 * sizeof(GLfloat));
1101    }
1102
1103    /* point parameters */
1104    v[0] = ctx->Point.Size;
1105    v[1] = ctx->Point.MinSize;
1106    v[2] = ctx->Point.MaxSize;
1107    v[3] = ctx->Point.Threshold;
1108    COPY_3FV((v + 4), ctx->Point.Params);
1109    write_common_fixed(pro, SLANG_COMMON_FIXED_POINT, v, 0,
1110                       7 * sizeof(GLfloat));
1111
1112    /* material parameters */
1113    write_common_fixed_material(ctx, pro, SLANG_COMMON_FIXED_FRONTMATERIAL,
1114                                MAT_ATTRIB_FRONT_EMISSION,
1115                                MAT_ATTRIB_FRONT_AMBIENT,
1116                                MAT_ATTRIB_FRONT_DIFFUSE,
1117                                MAT_ATTRIB_FRONT_SPECULAR,
1118                                MAT_ATTRIB_FRONT_SHININESS);
1119    write_common_fixed_material(ctx, pro, SLANG_COMMON_FIXED_BACKMATERIAL,
1120                                MAT_ATTRIB_BACK_EMISSION,
1121                                MAT_ATTRIB_BACK_AMBIENT,
1122                                MAT_ATTRIB_BACK_DIFFUSE,
1123                                MAT_ATTRIB_BACK_SPECULAR,
1124                                MAT_ATTRIB_BACK_SHININESS);
1125
1126    for (i = 0; i < ctx->Const.MaxLights; i++) {
1127       /* light source parameters */
1128       COPY_4FV(v, ctx->Light.Light[i].Ambient);
1129       COPY_4FV((v + 4), ctx->Light.Light[i].Diffuse);
1130       COPY_4FV((v + 8), ctx->Light.Light[i].Specular);
1131       COPY_4FV((v + 12), ctx->Light.Light[i].EyePosition);
1132       COPY_2FV((v + 16), ctx->Light.Light[i].EyePosition);
1133       v[18] = ctx->Light.Light[i].EyePosition[2] + 1.0f;
1134       NORMALIZE_3FV((v + 16));
1135       v[19] = 0.0f;
1136       COPY_3V((v + 20), ctx->Light.Light[i].EyeDirection);
1137       v[23] = ctx->Light.Light[i].SpotExponent;
1138       v[24] = ctx->Light.Light[i].SpotCutoff;
1139       v[25] = ctx->Light.Light[i]._CosCutoffNeg;
1140       v[26] = ctx->Light.Light[i].ConstantAttenuation;
1141       v[27] = ctx->Light.Light[i].LinearAttenuation;
1142       v[28] = ctx->Light.Light[i].QuadraticAttenuation;
1143       write_common_fixed(pro, SLANG_COMMON_FIXED_LIGHTSOURCE, v, i,
1144                          29 * sizeof(GLfloat));
1145
1146       /* light product */
1147       write_common_fixed_light_product(ctx, pro, i,
1148                                        SLANG_COMMON_FIXED_FRONTLIGHTPRODUCT,
1149                                        MAT_ATTRIB_FRONT_AMBIENT,
1150                                        MAT_ATTRIB_FRONT_DIFFUSE,
1151                                        MAT_ATTRIB_FRONT_SPECULAR);
1152       write_common_fixed_light_product(ctx, pro, i,
1153                                        SLANG_COMMON_FIXED_BACKLIGHTPRODUCT,
1154                                        MAT_ATTRIB_BACK_AMBIENT,
1155                                        MAT_ATTRIB_BACK_DIFFUSE,
1156                                        MAT_ATTRIB_BACK_SPECULAR);
1157    }
1158
1159    /* light model parameters */
1160    write_common_fixed(pro, SLANG_COMMON_FIXED_LIGHTMODEL,
1161                       ctx->Light.Model.Ambient, 0, 4 * sizeof(GLfloat));
1162
1163    /* light model product */
1164    write_common_fixed_light_model_product(ctx, pro,
1165                                           SLANG_COMMON_FIXED_FRONTLIGHTMODELPRODUCT,
1166                                           MAT_ATTRIB_FRONT_EMISSION,
1167                                           MAT_ATTRIB_FRONT_AMBIENT);
1168    write_common_fixed_light_model_product(ctx, pro,
1169                                           SLANG_COMMON_FIXED_BACKLIGHTMODELPRODUCT,
1170                                           MAT_ATTRIB_BACK_EMISSION,
1171                                           MAT_ATTRIB_BACK_AMBIENT);
1172
1173    /* TEXTURE_ENV_COLOR */
1174    for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) {
1175       write_common_fixed(pro, SLANG_COMMON_FIXED_TEXTUREENVCOLOR,
1176                          ctx->Texture.Unit[i].EnvColor, i,
1177                          4 * sizeof(GLfloat));
1178    }
1179
1180    /* fog parameters */
1181    COPY_4FV(v, ctx->Fog.Color);
1182    v[4] = ctx->Fog.Density;
1183    v[5] = ctx->Fog.Start;
1184    v[6] = ctx->Fog.End;
1185    v[7] = ctx->Fog._Scale;
1186    write_common_fixed(pro, SLANG_COMMON_FIXED_FOG, v, 0, 8 * sizeof(GLfloat));
1187 }
1188
1189 static GLvoid
1190 _program_UpdateFixedAttrib(struct gl2_program_intf **intf, GLuint index,
1191                            GLvoid * data, GLuint offset, GLuint size,
1192                            GLboolean write)
1193 {
1194    struct gl2_program_impl *impl = (struct gl2_program_impl *) intf;
1195    slang_program *pro = &impl->_obj.prog;
1196    GLuint addr;
1197
1198    addr = pro->vertex_fixed_entries[index];
1199    if (addr != ~0) {
1200       GLubyte *mem;
1201
1202       mem =
1203          (GLubyte *) pro->machines[SLANG_SHADER_VERTEX]->mem + addr +
1204          offset * size;
1205       if (write)
1206          _mesa_memcpy(mem, data, size);
1207       else
1208          _mesa_memcpy(data, mem, size);
1209    }
1210 }
1211
1212
1213 /**
1214  * Called during fragment shader execution to either load a varying
1215  * register with values, or fetch values from a varying register.
1216  * \param intf  the internal program?
1217  * \param index  which varying register, one of the SLANG_FRAGMENT_FIXED_*
1218  *               values for example.
1219  * \param data  source values to load (or dest to write to)
1220  * \param offset  indicates a texture unit or generic varying attribute
1221  * \param size  number of bytes to copy
1222  * \param write  if true, write to the varying register, else store values
1223  *               in 'data'
1224  */
1225 static GLvoid
1226 _program_UpdateFixedVarying(struct gl2_program_intf **intf, GLuint index,
1227                             GLvoid * data,
1228                             GLuint offset, GLuint size, GLboolean write)
1229 {
1230    struct gl2_program_impl *impl = (struct gl2_program_impl *) intf;
1231    slang_program *pro = &impl->_obj.prog;
1232    GLuint addr;
1233
1234    addr = pro->fragment_fixed_entries[index];
1235    if (addr != ~0) {
1236       GLubyte *mem;
1237
1238       mem =
1239          (GLubyte *) pro->machines[SLANG_SHADER_FRAGMENT]->mem + addr +
1240          offset * size;
1241       if (write)
1242          _mesa_memcpy(mem, data, size);
1243       else
1244          _mesa_memcpy(data, mem, size);
1245    }
1246 }
1247
1248 static GLvoid
1249 _program_GetTextureImageUsage(struct gl2_program_intf **intf,
1250                               GLbitfield * teximageusage)
1251 {
1252    GET_CURRENT_CONTEXT(ctx);
1253    struct gl2_program_impl *impl = (struct gl2_program_impl *) intf;
1254    slang_program *pro = &impl->_obj.prog;
1255    GLuint i;
1256
1257    for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++)
1258       teximageusage[i] = 0;
1259
1260    for (i = 0; i < pro->texture_usage.count; i++) {
1261       GLuint n, addr, j;
1262
1263       n = slang_export_data_quant_elements(pro->texture_usage.table[i].quant);
1264       addr = pro->texture_usage.table[i].frag_address;
1265       for (j = 0; j < n; j++) {
1266          GLubyte *mem;
1267          GLuint image;
1268
1269          mem =
1270             (GLubyte *) pro->machines[SLANG_SHADER_FRAGMENT]->mem + addr +
1271             j * 4;
1272          image = (GLuint) * ((GLfloat *) mem);
1273          if (image >= 0 && image < ctx->Const.MaxTextureImageUnits) {
1274             switch (slang_export_data_quant_type
1275                     (pro->texture_usage.table[i].quant)) {
1276             case GL_SAMPLER_1D_ARB:
1277             case GL_SAMPLER_1D_SHADOW_ARB:
1278                teximageusage[image] |= TEXTURE_1D_BIT;
1279                break;
1280             case GL_SAMPLER_2D_ARB:
1281             case GL_SAMPLER_2D_SHADOW_ARB:
1282                teximageusage[image] |= TEXTURE_2D_BIT;
1283                break;
1284             case GL_SAMPLER_3D_ARB:
1285                teximageusage[image] |= TEXTURE_3D_BIT;
1286                break;
1287             case GL_SAMPLER_CUBE_ARB:
1288                teximageusage[image] |= TEXTURE_CUBE_BIT;
1289                break;
1290             }
1291          }
1292       }
1293    }
1294
1295    /* TODO: make sure that for 0<=i<=MaxTextureImageUint bitcount(teximageuint[i])<=0 */
1296 }
1297
1298 static GLboolean
1299 _program_IsShaderPresent(struct gl2_program_intf **intf, GLenum subtype)
1300 {
1301    struct gl2_program_impl *impl = (struct gl2_program_impl *) intf;
1302    slang_program *pro = &impl->_obj.prog;
1303
1304    switch (subtype) {
1305    case GL_VERTEX_SHADER_ARB:
1306       return pro->machines[SLANG_SHADER_VERTEX] != NULL;
1307    case GL_FRAGMENT_SHADER_ARB:
1308       return pro->machines[SLANG_SHADER_FRAGMENT] != NULL;
1309    default:
1310       return GL_FALSE;
1311    }
1312 }
1313
1314 static GLvoid
1315 get_active_variable(slang_active_variable * var, GLsizei maxLength,
1316                     GLsizei * length, GLint * size, GLenum * type,
1317                     GLchar * name)
1318 {
1319    GLsizei len;
1320
1321    len = _mesa_strlen(var->name);
1322    if (len >= maxLength)
1323       len = maxLength - 1;
1324    if (length != NULL)
1325       *length = len;
1326    *size = slang_export_data_quant_elements(var->quant);
1327    *type = slang_export_data_quant_type(var->quant);
1328    _mesa_memcpy(name, var->name, len);
1329    name[len] = '\0';
1330 }
1331
1332 static GLuint
1333 get_active_variable_max_length(slang_active_variables * vars)
1334 {
1335    GLuint i, len = 0;
1336
1337    for (i = 0; i < vars->count; i++) {
1338       GLuint n = _mesa_strlen(vars->table[i].name);
1339       if (n > len)
1340          len = n;
1341    }
1342    return len;
1343 }
1344
1345 static GLvoid
1346 _program_GetActiveUniform(struct gl2_program_intf **intf, GLuint index,
1347                           GLsizei maxLength, GLsizei * length, GLint * size,
1348                           GLenum * type, GLchar * name)
1349 {
1350    struct gl2_program_impl *impl = (struct gl2_program_impl *) (intf);
1351    slang_active_variable *u = &impl->_obj.prog.active_uniforms.table[index];
1352
1353    get_active_variable(u, maxLength, length, size, type, name);
1354 }
1355
1356 static GLuint
1357 _program_GetActiveUniformMaxLength(struct gl2_program_intf **intf)
1358 {
1359    struct gl2_program_impl *impl = (struct gl2_program_impl *) (intf);
1360
1361    return get_active_variable_max_length(&impl->_obj.prog.active_uniforms);
1362 }
1363
1364 static GLuint
1365 _program_GetActiveUniformCount(struct gl2_program_intf **intf)
1366 {
1367    struct gl2_program_impl *impl = (struct gl2_program_impl *) (intf);
1368
1369    return impl->_obj.prog.active_uniforms.count;
1370 }
1371
1372 static GLint
1373 _program_GetUniformLocation(struct gl2_program_intf **intf,
1374                             const GLchar * name)
1375 {
1376    struct gl2_program_impl *impl = (struct gl2_program_impl *) (intf);
1377    slang_uniform_bindings *bind = &impl->_obj.prog.uniforms;
1378    GLuint i;
1379
1380    for (i = 0; i < bind->count; i++)
1381       if (_mesa_strcmp(bind->table[i].name, name) == 0)
1382          return i;
1383    return -1;
1384 }
1385
1386 static GLboolean
1387 _program_WriteUniform(struct gl2_program_intf **intf, GLint loc,
1388                       GLsizei count, const GLvoid * data, GLenum type)
1389 {
1390    struct gl2_program_impl *impl = (struct gl2_program_impl *) (intf);
1391    slang_uniform_bindings *uniforms = &impl->_obj.prog.uniforms;
1392    slang_uniform_binding *uniform;
1393    GLuint i;
1394    GLboolean convert_float_to_bool = GL_FALSE;
1395    GLboolean convert_int_to_bool = GL_FALSE;
1396    GLboolean convert_int_to_float = GL_FALSE;
1397    GLboolean types_match = GL_FALSE;
1398
1399    if (loc == -1)
1400       return GL_TRUE;
1401    if (loc >= uniforms->count)
1402       return GL_FALSE;
1403
1404    uniform = &uniforms->table[loc];
1405    /* TODO: check sizes */
1406    if (slang_export_data_quant_struct(uniform->quant))
1407       return GL_FALSE;
1408
1409    switch (slang_export_data_quant_type(uniform->quant)) {
1410    case GL_BOOL_ARB:
1411       types_match = (type == GL_FLOAT) || (type == GL_INT);
1412       if (type == GL_FLOAT)
1413          convert_float_to_bool = GL_TRUE;
1414       else
1415          convert_int_to_bool = GL_TRUE;
1416       break;
1417    case GL_BOOL_VEC2_ARB:
1418       types_match = (type == GL_FLOAT_VEC2_ARB) || (type == GL_INT_VEC2_ARB);
1419       if (type == GL_FLOAT_VEC2_ARB)
1420          convert_float_to_bool = GL_TRUE;
1421       else
1422          convert_int_to_bool = GL_TRUE;
1423       break;
1424    case GL_BOOL_VEC3_ARB:
1425       types_match = (type == GL_FLOAT_VEC3_ARB) || (type == GL_INT_VEC3_ARB);
1426       if (type == GL_FLOAT_VEC3_ARB)
1427          convert_float_to_bool = GL_TRUE;
1428       else
1429          convert_int_to_bool = GL_TRUE;
1430       break;
1431    case GL_BOOL_VEC4_ARB:
1432       types_match = (type == GL_FLOAT_VEC4_ARB) || (type == GL_INT_VEC4_ARB);
1433       if (type == GL_FLOAT_VEC4_ARB)
1434          convert_float_to_bool = GL_TRUE;
1435       else
1436          convert_int_to_bool = GL_TRUE;
1437       break;
1438    case GL_SAMPLER_1D_ARB:
1439    case GL_SAMPLER_2D_ARB:
1440    case GL_SAMPLER_3D_ARB:
1441    case GL_SAMPLER_CUBE_ARB:
1442    case GL_SAMPLER_1D_SHADOW_ARB:
1443    case GL_SAMPLER_2D_SHADOW_ARB:
1444       types_match = (type == GL_INT);
1445       break;
1446    default:
1447       types_match = (type == slang_export_data_quant_type(uniform->quant));
1448       break;
1449    }
1450
1451    if (!types_match)
1452       return GL_FALSE;
1453
1454    switch (type) {
1455    case GL_INT:
1456    case GL_INT_VEC2_ARB:
1457    case GL_INT_VEC3_ARB:
1458    case GL_INT_VEC4_ARB:
1459       convert_int_to_float = GL_TRUE;
1460       break;
1461    }
1462
1463    if (convert_float_to_bool) {
1464       for (i = 0; i < SLANG_SHADER_MAX; i++)
1465          if (uniform->address[i] != ~0) {
1466             const GLfloat *src = (GLfloat *) (data);
1467             GLfloat *dst = (GLfloat *)
1468                (&impl->_obj.prog.machines[i]->mem[uniform->address[i] / 4]);
1469             GLuint j;
1470             GLuint total =
1471                count * slang_export_data_quant_components(uniform->quant);
1472
1473             for (j = 0; j < total; j++)
1474                dst[j] = src[j] != 0.0f ? 1.0f : 0.0f;
1475          }
1476    }
1477    else if (convert_int_to_bool) {
1478       for (i = 0; i < SLANG_SHADER_MAX; i++)
1479          if (uniform->address[i] != ~0) {
1480             const GLuint *src = (GLuint *) (data);
1481             GLfloat *dst = (GLfloat *)
1482                (&impl->_obj.prog.machines[i]->mem[uniform->address[i] / 4]);
1483             GLuint j;
1484             GLuint total =
1485                count * slang_export_data_quant_components(uniform->quant);
1486
1487             for (j = 0; j < total; j++)
1488                dst[j] = src[j] ? 1.0f : 0.0f;
1489          }
1490    }
1491    else if (convert_int_to_float) {
1492       for (i = 0; i < SLANG_SHADER_MAX; i++)
1493          if (uniform->address[i] != ~0) {
1494             const GLuint *src = (GLuint *) (data);
1495             GLfloat *dst = (GLfloat *)
1496                (&impl->_obj.prog.machines[i]->mem[uniform->address[i] / 4]);
1497             GLuint j;
1498             GLuint total =
1499                count * slang_export_data_quant_components(uniform->quant);
1500
1501             for (j = 0; j < total; j++)
1502                dst[j] = (GLfloat) src[j];
1503          }
1504    }
1505    else {
1506       for (i = 0; i < SLANG_SHADER_MAX; i++)
1507          if (uniform->address[i] != ~0) {
1508             _mesa_memcpy(&impl->_obj.prog.machines[i]->
1509                          mem[uniform->address[i] / 4], data,
1510                          count *
1511                          slang_export_data_quant_size(uniform->quant));
1512          }
1513    }
1514    return GL_TRUE;
1515 }
1516
1517 static GLvoid
1518 _program_GetActiveAttrib(struct gl2_program_intf **intf, GLuint index,
1519                          GLsizei maxLength, GLsizei * length, GLint * size,
1520                          GLenum * type, GLchar * name)
1521 {
1522    struct gl2_program_impl *impl = (struct gl2_program_impl *) (intf);
1523    slang_active_variable *a = &impl->_obj.prog.active_attribs.table[index];
1524
1525    get_active_variable(a, maxLength, length, size, type, name);
1526 }
1527
1528 static GLuint
1529 _program_GetActiveAttribMaxLength(struct gl2_program_intf **intf)
1530 {
1531    struct gl2_program_impl *impl = (struct gl2_program_impl *) (intf);
1532
1533    return get_active_variable_max_length(&impl->_obj.prog.active_attribs);
1534 }
1535
1536 static GLuint
1537 _program_GetActiveAttribCount(struct gl2_program_intf **intf)
1538 {
1539    struct gl2_program_impl *impl = (struct gl2_program_impl *) (intf);
1540
1541    return impl->_obj.prog.active_attribs.count;
1542 }
1543
1544 static GLint
1545 _program_GetAttribLocation(struct gl2_program_intf **intf,
1546                            const GLchar * name)
1547 {
1548    struct gl2_program_impl *impl = (struct gl2_program_impl *) (intf);
1549    slang_attrib_bindings *attribs = &impl->_obj.prog.attribs;
1550    GLuint i;
1551
1552    for (i = 0; i < attribs->binding_count; i++)
1553       if (_mesa_strcmp(attribs->bindings[i].name, name) == 0)
1554          return attribs->bindings[i].first_slot_index;
1555    return -1;
1556 }
1557
1558 static GLvoid
1559 _program_OverrideAttribBinding(struct gl2_program_intf **intf, GLuint index,
1560                                const GLchar * name)
1561 {
1562    GET_CURRENT_CONTEXT(ctx);
1563    struct gl2_program_impl *impl = (struct gl2_program_impl *) (intf);
1564    slang_program *pro = &impl->_obj.prog;
1565
1566    if (!_slang_attrib_overrides_add(&pro->attrib_overrides, index, name))
1567       _mesa_error(ctx, GL_OUT_OF_MEMORY, "_program_OverrideAttribBinding");
1568 }
1569
1570 static GLvoid
1571 _program_WriteAttrib(struct gl2_program_intf **intf, GLuint index,
1572                      const GLfloat * value)
1573 {
1574    struct gl2_program_impl *impl = (struct gl2_program_impl *) (intf);
1575    slang_program *pro = &impl->_obj.prog;
1576    slang_attrib_slot *slot = &pro->attribs.slots[index];
1577
1578    /*
1579     * Generic attributes can be allocated in a shader with scalar, vec
1580     * or mat type.  For scalar and vec types (specifically float, vec2
1581     * and vec3) this is simple - just ignore the extra components. For
1582     * mat type this is more complicated - the vertex_shader spec
1583     * requires to store every column of a matrix in a separate attrib
1584     * slot.  To prvent from overwriting data from neighbouring matrix
1585     * columns, the "fill" information is kept to know how many
1586     * components to copy.
1587     */
1588
1589    if (slot->addr != ~0)
1590       _mesa_memcpy(&pro->machines[SLANG_SHADER_VERTEX]->mem[slot->addr / 4].
1591                    _float, value, slot->fill * sizeof(GLfloat));
1592 }
1593
1594 static GLvoid
1595 _program_UpdateVarying(struct gl2_program_intf **intf, GLuint index,
1596                        GLfloat * value, GLboolean vert)
1597 {
1598    struct gl2_program_impl *impl = (struct gl2_program_impl *) intf;
1599    slang_program *pro = &impl->_obj.prog;
1600    GLuint addr;
1601
1602    if (index >= pro->varyings.slot_count)
1603       return;
1604    if (vert)
1605       addr = pro->varyings.slots[index].vert_addr / 4;
1606    else
1607       addr = pro->varyings.slots[index].frag_addr / 4;
1608    if (addr != ~0) {
1609       if (vert)
1610          *value = pro->machines[SLANG_SHADER_VERTEX]->mem[addr]._float;
1611       else
1612          pro->machines[SLANG_SHADER_FRAGMENT]->mem[addr]._float = *value;
1613    }
1614 }
1615
1616 static struct gl2_program_intf _program_vftbl = {
1617    {
1618       {
1619          {
1620             _unknown_AddRef,
1621             _unknown_Release,
1622             _program_QueryInterface
1623          },
1624          _generic_Delete,
1625          _program_GetType,
1626          _generic_GetName,
1627          _generic_GetDeleteStatus,
1628          _generic_GetInfoLog,
1629          _generic_GetInfoLogLength
1630       },
1631       _program_Attach,
1632       _container_Detach,
1633       _container_GetAttachedCount,
1634       _container_GetAttached
1635    },
1636    _program_GetLinkStatus,
1637    _program_GetValidateStatus,
1638    _program_Link,
1639    _program_Validate,
1640    _program_UpdateFixedUniforms,
1641    _program_UpdateFixedAttrib,
1642    _program_UpdateFixedVarying,
1643    _program_GetTextureImageUsage,
1644    _program_IsShaderPresent,
1645    _program_GetActiveUniform,
1646    _program_GetActiveUniformMaxLength,
1647    _program_GetActiveUniformCount,
1648    _program_GetUniformLocation,
1649    _program_WriteUniform,
1650    _program_GetActiveAttrib,
1651    _program_GetActiveAttribMaxLength,
1652    _program_GetActiveAttribCount,
1653    _program_GetAttribLocation,
1654    _program_OverrideAttribBinding,
1655    _program_WriteAttrib,
1656    _program_UpdateVarying
1657 };
1658
1659 static void
1660 _program_constructor(struct gl2_program_impl *impl)
1661 {
1662    _container_constructor((struct gl2_container_impl *) impl);
1663    impl->_vftbl = &_program_vftbl;
1664    impl->_obj._container._generic._unknown._destructor = _program_destructor;
1665    impl->_obj.link_status = GL_FALSE;
1666    impl->_obj.validate_status = GL_FALSE;
1667 #if USE_3DLABS_FRONTEND
1668    impl->_obj.linker = ShConstructLinker(EShExVertexFragment, 0);
1669    impl->_obj.uniforms = ShConstructUniformMap();
1670 #endif
1671    _slang_program_ctr(&impl->_obj.prog);
1672 }
1673
1674 struct gl2_fragment_shader_obj
1675 {
1676    struct gl2_shader_obj _shader;
1677 };
1678
1679 struct gl2_fragment_shader_impl
1680 {
1681    struct gl2_fragment_shader_intf *_vftbl;
1682    struct gl2_fragment_shader_obj _obj;
1683 };
1684
1685 static void
1686 _fragment_shader_destructor(struct gl2_unknown_intf **intf)
1687 {
1688    struct gl2_fragment_shader_impl *impl =
1689       (struct gl2_fragment_shader_impl *) intf;
1690
1691    (void) impl;
1692    /* TODO free fragment shader data */
1693
1694    _shader_destructor(intf);
1695 }
1696
1697 static struct gl2_unknown_intf **
1698 _fragment_shader_QueryInterface(struct gl2_unknown_intf **intf,
1699                                 enum gl2_uiid uiid)
1700 {
1701    if (uiid == UIID_FRAGMENT_SHADER) {
1702       (**intf).AddRef(intf);
1703       return intf;
1704    }
1705    return _shader_QueryInterface(intf, uiid);
1706 }
1707
1708 static GLenum
1709 _fragment_shader_GetSubType(struct gl2_shader_intf **intf)
1710 {
1711    return GL_FRAGMENT_SHADER_ARB;
1712 }
1713
1714 static struct gl2_fragment_shader_intf _fragment_shader_vftbl = {
1715    {
1716       {
1717          {
1718             _unknown_AddRef,
1719             _unknown_Release,
1720             _fragment_shader_QueryInterface
1721          },
1722          _generic_Delete,
1723          _shader_GetType,
1724          _generic_GetName,
1725          _generic_GetDeleteStatus,
1726          _shader_GetInfoLog,
1727          _shader_GetInfoLogLength
1728       },
1729       _fragment_shader_GetSubType,
1730       _shader_GetCompileStatus,
1731       _shader_SetSource,
1732       _shader_GetSource,
1733       _shader_Compile
1734    }
1735 };
1736
1737 static void
1738 _fragment_shader_constructor(struct gl2_fragment_shader_impl *impl)
1739 {
1740    _shader_constructor((struct gl2_shader_impl *) impl);
1741    impl->_vftbl = &_fragment_shader_vftbl;
1742    impl->_obj._shader._generic._unknown._destructor =
1743       _fragment_shader_destructor;
1744 #if USE_3DLABS_FRONTEND
1745    impl->_obj._shader._3dlabs_shhandle._obj.handle =
1746       ShConstructCompiler(EShLangFragment, 0);
1747 #endif
1748 }
1749
1750 struct gl2_vertex_shader_obj
1751 {
1752    struct gl2_shader_obj _shader;
1753 };
1754
1755 struct gl2_vertex_shader_impl
1756 {
1757    struct gl2_vertex_shader_intf *_vftbl;
1758    struct gl2_vertex_shader_obj _obj;
1759 };
1760
1761 static void
1762 _vertex_shader_destructor(struct gl2_unknown_intf **intf)
1763 {
1764    struct gl2_vertex_shader_impl *impl =
1765       (struct gl2_vertex_shader_impl *) intf;
1766
1767    (void) impl;
1768    /* TODO free vertex shader data */
1769
1770    _shader_destructor(intf);
1771 }
1772
1773 static struct gl2_unknown_intf **
1774 _vertex_shader_QueryInterface(struct gl2_unknown_intf **intf,
1775                               enum gl2_uiid uiid)
1776 {
1777    if (uiid == UIID_VERTEX_SHADER) {
1778       (**intf).AddRef(intf);
1779       return intf;
1780    }
1781    return _shader_QueryInterface(intf, uiid);
1782 }
1783
1784 static GLenum
1785 _vertex_shader_GetSubType(struct gl2_shader_intf **intf)
1786 {
1787    return GL_VERTEX_SHADER_ARB;
1788 }
1789
1790 static struct gl2_vertex_shader_intf _vertex_shader_vftbl = {
1791    {
1792       {
1793          {
1794             _unknown_AddRef,
1795             _unknown_Release,
1796             _vertex_shader_QueryInterface
1797          },
1798          _generic_Delete,
1799          _shader_GetType,
1800          _generic_GetName,
1801          _generic_GetDeleteStatus,
1802          _shader_GetInfoLog,
1803          _shader_GetInfoLogLength
1804       },
1805       _vertex_shader_GetSubType,
1806       _shader_GetCompileStatus,
1807       _shader_SetSource,
1808       _shader_GetSource,
1809       _shader_Compile
1810    }
1811 };
1812
1813 static void
1814 _vertex_shader_constructor(struct gl2_vertex_shader_impl *impl)
1815 {
1816    _shader_constructor((struct gl2_shader_impl *) impl);
1817    impl->_vftbl = &_vertex_shader_vftbl;
1818    impl->_obj._shader._generic._unknown._destructor =
1819       _vertex_shader_destructor;
1820 #if USE_3DLABS_FRONTEND
1821    impl->_obj._shader._3dlabs_shhandle._obj.handle =
1822       ShConstructCompiler(EShLangVertex, 0);
1823 #endif
1824 }
1825
1826 struct gl2_debug_obj
1827 {
1828    struct gl2_generic_obj _generic;
1829 };
1830
1831 struct gl2_debug_impl
1832 {
1833    struct gl2_debug_intf *_vftbl;
1834    struct gl2_debug_obj _obj;
1835 };
1836
1837 static GLvoid
1838 _debug_destructor(struct gl2_unknown_intf **intf)
1839 {
1840    struct gl2_debug_impl *impl = (struct gl2_debug_impl *) (intf);
1841
1842    (void) (impl);
1843    /* TODO */
1844
1845    _generic_destructor(intf);
1846 }
1847
1848 static struct gl2_unknown_intf **
1849 _debug_QueryInterface(struct gl2_unknown_intf **intf, enum gl2_uiid uiid)
1850 {
1851    if (uiid == UIID_DEBUG) {
1852       (**intf).AddRef(intf);
1853       return intf;
1854    }
1855    return _generic_QueryInterface(intf, uiid);
1856 }
1857
1858 static GLenum
1859 _debug_GetType(struct gl2_generic_intf **intf)
1860 {
1861    return /*GL_DEBUG_OBJECT_MESA */ 0;
1862 }
1863
1864 static GLvoid
1865 _debug_ClearDebugLog(struct gl2_debug_intf **intf, GLenum logType,
1866                      GLenum shaderType)
1867 {
1868    struct gl2_debug_impl *impl = (struct gl2_debug_impl *) (intf);
1869
1870    (void) (impl);
1871    /* TODO */
1872 }
1873
1874 static GLvoid
1875 _debug_GetDebugLog(struct gl2_debug_intf **intf, GLenum logType,
1876                    GLenum shaderType, GLsizei maxLength, GLsizei * length,
1877                    GLcharARB * infoLog)
1878 {
1879    struct gl2_debug_impl *impl = (struct gl2_debug_impl *) (intf);
1880
1881    (void) (impl);
1882    /* TODO */
1883 }
1884
1885 static GLsizei
1886 _debug_GetDebugLogLength(struct gl2_debug_intf **intf, GLenum logType,
1887                          GLenum shaderType)
1888 {
1889    struct gl2_debug_impl *impl = (struct gl2_debug_impl *) (intf);
1890
1891    (void) (impl);
1892    /* TODO */
1893
1894    return 0;
1895 }
1896
1897 static struct gl2_debug_intf _debug_vftbl = {
1898    {
1899       {
1900          _unknown_AddRef,
1901          _unknown_Release,
1902          _debug_QueryInterface
1903       },
1904       _generic_Delete,
1905       _debug_GetType,
1906       _generic_GetName,
1907       _generic_GetDeleteStatus,
1908       _generic_GetInfoLog,
1909       _generic_GetInfoLogLength
1910    },
1911    _debug_ClearDebugLog,
1912    _debug_GetDebugLog,
1913    _debug_GetDebugLogLength
1914 };
1915
1916 static GLvoid
1917 _debug_constructor(struct gl2_debug_impl *impl)
1918 {
1919    _generic_constructor((struct gl2_generic_impl *) (impl));
1920    impl->_vftbl = &_debug_vftbl;
1921    impl->_obj._generic._unknown._destructor = _debug_destructor;
1922 }
1923
1924 GLhandleARB
1925 _mesa_3dlabs_create_shader_object(GLenum shaderType)
1926 {
1927    switch (shaderType) {
1928    case GL_FRAGMENT_SHADER_ARB:
1929       {
1930          struct gl2_fragment_shader_impl *x =
1931             (struct gl2_fragment_shader_impl *)
1932             _mesa_malloc(sizeof(struct gl2_fragment_shader_impl));
1933
1934          if (x != NULL) {
1935             _fragment_shader_constructor(x);
1936             return x->_obj._shader._generic.name;
1937          }
1938       }
1939       break;
1940    case GL_VERTEX_SHADER_ARB:
1941       {
1942          struct gl2_vertex_shader_impl *x = (struct gl2_vertex_shader_impl *)
1943             _mesa_malloc(sizeof(struct gl2_vertex_shader_impl));
1944
1945          if (x != NULL) {
1946             _vertex_shader_constructor(x);
1947             return x->_obj._shader._generic.name;
1948          }
1949       }
1950       break;
1951    }
1952
1953    return 0;
1954 }
1955
1956 GLhandleARB
1957 _mesa_3dlabs_create_program_object(void)
1958 {
1959    struct gl2_program_impl *x = (struct gl2_program_impl *)
1960       _mesa_malloc(sizeof(struct gl2_program_impl));
1961
1962    if (x != NULL) {
1963       _program_constructor(x);
1964       return x->_obj._container._generic.name;
1965    }
1966
1967    return 0;
1968 }
1969
1970 GLhandleARB
1971 _mesa_3dlabs_create_debug_object(GLvoid)
1972 {
1973    struct gl2_debug_impl *obj;
1974
1975    obj =
1976       (struct gl2_debug_impl *) (_mesa_malloc(sizeof(struct gl2_debug_impl)));
1977    if (obj != NULL) {
1978       _debug_constructor(obj);
1979       return obj->_obj._generic.name;
1980    }
1981    return 0;
1982 }
1983
1984 #include "slang_assemble.h"
1985 #include "slang_execute.h"
1986
1987 int
1988 _slang_fetch_discard(struct gl2_program_intf **pro, GLboolean * val)
1989 {
1990    struct gl2_program_impl *impl;
1991
1992    impl = (struct gl2_program_impl *) pro;
1993    *val =
1994       impl->_obj.prog.machines[SLANG_SHADER_FRAGMENT]->
1995       kill ? GL_TRUE : GL_FALSE;
1996    return 1;
1997 }
1998
1999 static GLvoid
2000 exec_shader(struct gl2_program_intf **pro, GLuint i)
2001 {
2002    struct gl2_program_impl *impl;
2003    slang_program *p;
2004
2005    impl = (struct gl2_program_impl *) pro;
2006    p = &impl->_obj.prog;
2007
2008    slang_machine_init(p->machines[i]);
2009    p->machines[i]->ip = p->code[i][SLANG_COMMON_CODE_MAIN];
2010
2011    _slang_execute2(p->assemblies[i], p->machines[i]);
2012 }
2013
2014 GLvoid
2015 _slang_exec_fragment_shader(struct gl2_program_intf **pro)
2016 {
2017    exec_shader(pro, SLANG_SHADER_FRAGMENT);
2018 }
2019
2020 GLvoid
2021 _slang_exec_vertex_shader(struct gl2_program_intf **pro)
2022 {
2023    exec_shader(pro, SLANG_SHADER_VERTEX);
2024 }
2025
2026 #endif
2027
2028 void
2029 _mesa_init_shaderobjects_3dlabs(GLcontext * ctx)
2030 {
2031 #if USE_3DLABS_FRONTEND
2032    _glslang_3dlabs_InitProcess();
2033    _glslang_3dlabs_ShInitialize();
2034 #endif
2035 }