Source/System/State/OpenGL/OSGTextureEnvChunk.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *             Copyright (C) 2000-2002 by the OpenSG Forum                   *
   6  *                                                                           *
   7  *                            www.opensg.org                                 *
   8  *                                                                           *
   9  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
  10  *                                                                           *
  11 \*---------------------------------------------------------------------------*/
  12 /*---------------------------------------------------------------------------*\
  13  *                                License                                    *
  14  *                                                                           *
  15  * This library is free software; you can redistribute it and/or modify it   *
  16  * under the terms of the GNU Library General Public License as published    *
  17  * by the Free Software Foundation, version 2.                               *
  18  *                                                                           *
  19  * This library is distributed in the hope that it will be useful, but       *
  20  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  22  * Library General Public License for more details.                          *
  23  *                                                                           *
  24  * You should have received a copy of the GNU Library General Public         *
  25  * License along with this library; if not, write to the Free Software       *
  26  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
  27  *                                                                           *
  28 \*---------------------------------------------------------------------------*/
  29 /*---------------------------------------------------------------------------*\
  30  *                                Changes                                    *
  31  *                                                                           *
  32  *                                                                           *
  33  *                                                                           *
  34  *                                                                           *
  35  *                                                                           *
  36  *                                                                           *
  37 \*---------------------------------------------------------------------------*/
  38
  39 //---------------------------------------------------------------------------
  40 //  Includes
  41 //---------------------------------------------------------------------------
  42
  43 #include <cstdlib>
  44 #include <cstdio>
  45
  46 #include <boost/bind.hpp>
  47
  48 #include "OSGConfig.h"
  49
  50 #include "OSGGL.h"
  51 #include "OSGGLU.h"
  52 #include "OSGGLEXT.h"
  53 #include "OSGImage.h"
  54
  55 #include "OSGDrawEnv.h"
  56
  57 #include "OSGTextureEnvChunk.h"
  58 #include "OSGTextureBaseChunk.h"
  59
  60 //#define OSG_DUMP_TEX
  61
  62 OSG_USING_NAMESPACE
  63
  64 // Documentation for this class is emited in the
  65 // OSGTextureEnvChunkBase.cpp file.
  66 // To modify it, please change the .fcd file (OSGTextureEnvChunk.fcd) and
  67 // regenerate the base file.
  68
  69 /***************************************************************************\
  70  *                           Class variables                               *
  71 \***************************************************************************/
  72
  73 StateChunkClass TextureEnvChunk::_class("TextureEnv", osgMaxTexImages, 120);
  74
  75 UInt32 TextureEnvChunk::_extPointSprite          = Window::invalidExtensionID;
  76 UInt32 TextureEnvChunk::_extTextureShader        = Window::invalidExtensionID;
  77 UInt32 TextureEnvChunk::_extTextureShader2       = Window::invalidExtensionID;
  78 UInt32 TextureEnvChunk::_extTextureShader3       = Window::invalidExtensionID;
  79 UInt32 TextureEnvChunk::_extTextureLodBias       = Window::invalidExtensionID;
  80
  81 /***************************************************************************\
  82  *                           Class methods                                 *
  83 \***************************************************************************/
  84
  85 /*-------------------------------------------------------------------------*\
  86  -  private                                                                -
  87 \*-------------------------------------------------------------------------*/
  88
  89 void TextureEnvChunk::initMethod(InitPhase ePhase)
  90 {
  91     Inherited::initMethod(ePhase);
  92
  93     if(ePhase == TypeObject::SystemPost)
  94     {
  95         _extPointSprite     =
  96             Window::registerExtension("GL_ARB_point_sprite"    );
  97         _extTextureShader   =
  98             Window::registerExtension("GL_NV_texture_shader"   );
  99         _extTextureShader2  =
 100             Window::registerExtension("GL_NV_texture_shader2"  );
 101         _extTextureShader3  =
 102             Window::registerExtension("GL_NV_texture_shader3"  );
 103         _extTextureLodBias  =
 104             Window::registerExtension("GL_EXT_texture_lod_bias");
 105
 106         Window::registerConstant(GL_MAX_TEXTURE_UNITS_ARB      );
 107         Window::registerConstant(GL_MAX_TEXTURE_IMAGE_UNITS_ARB);
 108         Window::registerConstant(GL_MAX_TEXTURE_COORDS_ARB     );
 109     }
 110 }
 111
 112 /***************************************************************************\
 113  *                           Instance methods                              *
 114 \***************************************************************************/
 115
 116 /*-------------------------------------------------------------------------*\
 117  -  private                                                                 -
 118 \*-------------------------------------------------------------------------*/
 119
 120
 121 /*------------- constructors & destructors --------------------------------*/
 122
 123 TextureEnvChunk::TextureEnvChunk(void) :
 124     Inherited()
 125 {
 126 }
 127
 128 TextureEnvChunk::TextureEnvChunk(const TextureEnvChunk &source) :
 129     Inherited(source)
 130 {
 131 }
 132
 133 TextureEnvChunk::~TextureEnvChunk(void)
 134 {
 135 }
 136
 137 /*------------------------- Chunk Class Access ---------------------------*/
 138
 139 const StateChunkClass *TextureEnvChunk::getClass(void) const
 140 {
 141     return &_class;
 142 }
 143
 144 /*------------------------------ State ------------------------------------*/
 145
 146 /*! Texture handler. Create/update a single texture.
 147   Also used by derived CubeMap chunk.
 148 */
 149
 150 void TextureEnvChunk::handleTextureShader(Window *win, GLenum bindtarget)
 151 {
 152 #if !defined(OSG_OGL_COREONLY) || defined(OSG_CHECK_COREONLY)
 153     if(!win->hasExtension(_extTextureShader))
 154     {
 155         if(getShaderOperation() != GL_NONE)
 156             FINFO(("NV Texture Shaders not supported on Window %p!\n", win));
 157         return;
 158     }
 159
 160     glErr("textureShader precheck");
 161
 162     glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV,
 163               getShaderOperation());
 164
 165     glErr("textureShader setup: operation");
 166
 167     if(getShaderOperation() == GL_NONE)
 168         return;
 169
 170     if(bindtarget == GL_TEXTURE_3D && !win->hasExtension(_extTextureShader2))
 171     {
 172         FINFO(("NV Texture Shaders 2 not supported on Window %p!\n", win));
 173         return;
 174     }
 175
 176     if(getShaderInput() != GL_NONE)
 177     {
 178         glTexEnvi(GL_TEXTURE_SHADER_NV, GL_PREVIOUS_TEXTURE_INPUT_NV,
 179                   getShaderInput());
 180     }
 181
 182     glErr("textureShader setup: input");
 183
 184     if(getShaderRGBADotProduct() != GL_NONE)
 185     {
 186         glTexEnvi(GL_TEXTURE_SHADER_NV,
 187                   GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV,
 188                   getShaderRGBADotProduct());
 189     }
 190
 191     glErr("textureShader setup: rgba dotprod");
 192
 193     if(getMFShaderOffsetMatrix()->size() == 4)
 194     {
 195         glTexEnvfv(GL_TEXTURE_SHADER_NV, GL_OFFSET_TEXTURE_MATRIX_NV,
 196                    &((*getMFShaderOffsetMatrix())[0]));
 197
 198         glErr("textureShader setup: offset matrix");
 199     }
 200     else if(getMFShaderOffsetMatrix()->size() != 0)
 201     {
 202         FWARNING(("TextureEnvChunk::handleTextureShader: shaderOffsetMatrix "
 203                   "has to have 4 entries, not %" PRISize "!\n",
 204                   getMFShaderOffsetMatrix()->size() ));
 205     }
 206
 207     glTexEnvf(GL_TEXTURE_SHADER_NV, GL_OFFSET_TEXTURE_SCALE_NV,
 208               getShaderOffsetScale());
 209
 210     glErr("textureShader setup: offset scale");
 211
 212     glTexEnvf(GL_TEXTURE_SHADER_NV, GL_OFFSET_TEXTURE_BIAS_NV,
 213               getShaderOffsetBias());
 214
 215     glErr("textureShader setup: offset bias");
 216
 217     GLint cullmodes[4];
 218
 219     if(getShaderCullModes() & 0x1)
 220     {
 221         cullmodes[0] = GL_GEQUAL;
 222     }
 223     else
 224     {
 225         cullmodes[0] = GL_LESS;
 226     }
 227
 228     if(getShaderCullModes() & 0x2)
 229     {
 230         cullmodes[1] = GL_GEQUAL;
 231     }
 232     else
 233     {
 234         cullmodes[1] = GL_LESS;
 235     }
 236
 237     if(getShaderCullModes() & 0x4)
 238     {
 239         cullmodes[2] = GL_GEQUAL;
 240     }
 241     else
 242     {
 243         cullmodes[2] = GL_LESS;
 244     }
 245
 246     if(getShaderCullModes() & 0x8)
 247     {
 248         cullmodes[3] = GL_GEQUAL;
 249     }
 250     else
 251     {
 252         cullmodes[3] = GL_LESS;
 253     }
 254
 255     glTexEnviv(GL_TEXTURE_SHADER_NV, GL_CULL_MODES_NV,
 256                cullmodes);
 257
 258     glErr("textureShader setup: cull modes");
 259
 260     glTexEnvfv(GL_TEXTURE_SHADER_NV, GL_CONST_EYE_NV,
 261                getShaderConstEye().getValues());
 262
 263     glErr("textureShader setup: const eye");
 264
 265
 266
 267 #ifdef OSG_DEBUG
 268     GLint consistent;
 269     glGetTexEnviv(GL_TEXTURE_SHADER_NV, GL_SHADER_CONSISTENT_NV,
 270                   &consistent);
 271     if(!consistent)
 272     {
 273         FWARNING(("Texture shaders not consistent!\n"));
 274     }
 275 #endif
 276 #endif
 277 }
 278
 279 /*------------------------------- Sync -----------------------------------*/
 280
 281 /*! React to field changes.
 282   Note: this function also handles CubeTexture changes, make sure to keep
 283   it consistent with the cubeTexture specifics
 284 */
 285
 286 void TextureEnvChunk::changed(ConstFieldMaskArg whichField,
 287                               UInt32            origin,
 288                               BitVector         details)
 289 {
 290     Inherited::changed(whichField, origin, details);
 291 }
 292
 293 bool TextureEnvChunk::isTransparent(void) const
 294 {
 295     // Even if the texture has alpha, the Blending is makes the sorting
 296     // important, thus textures per se are not transparent
 297     return false;
 298 }
 299
 300
 301 /*----------------------------- onCreate --------------------------------*/
 302
 303 void TextureEnvChunk::onCreate(const TextureEnvChunk *source)
 304 {
 305     Inherited::onCreate(source);
 306 }
 307
 308 void TextureEnvChunk::onCreateAspect(const TextureEnvChunk *createAspect,
 309                                      const TextureEnvChunk *source      )
 310 {
 311     Inherited::onCreateAspect(createAspect, source);
 312 }
 313
 314 /*------------------------------ Output ----------------------------------*/
 315
 316 void TextureEnvChunk::dump(      UInt32    uiIndent,
 317                            const BitVector bvFlags  ) const
 318 {
 319     Inherited::dump(uiIndent, bvFlags);
 320
 321     if((bvFlags & EnvModeFieldMask) != 0)
 322     {
 323         indentLog(uiIndent, PLOG);
 324         PLOG << "envMode "
 325              << GLDefineMapper::the()->toString(_sfEnvMode.getValue())
 326              << "\n";
 327     }
 328
 329     if((bvFlags & EnvColorFieldMask) != 0)
 330     {
 331         indentLog(uiIndent, PLOG);
 332         PLOG << "envColor " << _sfEnvColor.getValue() << "\n";
 333     }
 334
 335     if((bvFlags & EnvCombineRGBFieldMask) != 0)
 336     {
 337         indentLog(uiIndent, PLOG);
 338         PLOG << "envCombineRGB "
 339              << GLDefineMapper::the()->toString(_sfEnvCombineRGB.getValue())
 340              << "\n";
 341     }
 342
 343     if((bvFlags & EnvCombineAlphaFieldMask) != 0)
 344     {
 345         indentLog(uiIndent, PLOG);
 346         PLOG << "envCombineAlpha "
 347              << GLDefineMapper::the()->toString(_sfEnvCombineAlpha.getValue())
 348              << "\n";
 349     }
 350
 351     if((bvFlags & EnvScaleRGBFieldMask) != 0)
 352     {
 353         indentLog(uiIndent, PLOG);
 354         PLOG << "envScaleRGB "
 355              << _sfEnvScaleRGB.getValue()
 356              << "\n";
 357     }
 358
 359     if((bvFlags & EnvScaleAlphaFieldMask) != 0)
 360     {
 361         indentLog(uiIndent, PLOG);
 362         PLOG << "envScaleAlpha "
 363              << _sfEnvScaleAlpha.getValue()
 364              << "\n";
 365     }
 366
 367     if((bvFlags & EnvSource0RGBFieldMask) != 0)
 368     {
 369         indentLog(uiIndent, PLOG);
 370         PLOG << "envSource0RGB "
 371              << GLDefineMapper::the()->toString(_sfEnvSource0RGB.getValue())
 372              << "\n";
 373     }
 374
 375     if((bvFlags & EnvSource1RGBFieldMask) != 0)
 376     {
 377         indentLog(uiIndent, PLOG);
 378         PLOG << "envSource1RGB "
 379              << GLDefineMapper::the()->toString(_sfEnvSource1RGB.getValue())
 380              << "\n";
 381     }
 382
 383     if((bvFlags & EnvSource2RGBFieldMask) != 0)
 384     {
 385         indentLog(uiIndent, PLOG);
 386         PLOG << "envSource2RGB "
 387              << GLDefineMapper::the()->toString(_sfEnvSource2RGB.getValue())
 388              << "\n";
 389     }
 390
 391     if((bvFlags & EnvSource0AlphaFieldMask) != 0)
 392     {
 393         indentLog(uiIndent, PLOG);
 394         PLOG << "envSource0Alpha "
 395              << GLDefineMapper::the()->toString(_sfEnvSource0Alpha.getValue())
 396              << "\n";
 397     }
 398
 399     if((bvFlags & EnvSource1AlphaFieldMask) != 0)
 400     {
 401         indentLog(uiIndent, PLOG);
 402         PLOG << "envSource1Alpha "
 403              << GLDefineMapper::the()->toString(_sfEnvSource1Alpha.getValue())
 404              << "\n";
 405     }
 406
 407     if((bvFlags & EnvSource2AlphaFieldMask) != 0)
 408     {
 409         indentLog(uiIndent, PLOG);
 410         PLOG << "envSource2Alpha "
 411              << GLDefineMapper::the()->toString(_sfEnvSource2Alpha.getValue())
 412              << "\n";
 413     }
 414
 415     if((bvFlags & EnvOperand0RGBFieldMask) != 0)
 416     {
 417         indentLog(uiIndent, PLOG);
 418         PLOG << "envOperand0RGB "
 419              << GLDefineMapper::the()->toString(_sfEnvOperand0RGB.getValue())
 420              << "\n";
 421     }
 422
 423     if((bvFlags & EnvOperand1RGBFieldMask) != 0)
 424     {
 425         indentLog(uiIndent, PLOG);
 426         PLOG << "envOperand1RGB "
 427              << GLDefineMapper::the()->toString(_sfEnvOperand1RGB.getValue())
 428              << "\n";
 429     }
 430
 431     if((bvFlags & EnvOperand2RGBFieldMask) != 0)
 432     {
 433         indentLog(uiIndent, PLOG);
 434         PLOG << "envOperand2RGB "
 435              << GLDefineMapper::the()->toString(_sfEnvOperand2RGB.getValue())
 436              << "\n";
 437     }
 438
 439     if((bvFlags & EnvOperand0AlphaFieldMask) != 0)
 440     {
 441         indentLog(uiIndent, PLOG);
 442         PLOG << "envOperand0Alpha "
 443              << GLDefineMapper::the()->toString(_sfEnvOperand0Alpha.getValue())
 444              << "\n";
 445     }
 446
 447     if((bvFlags & EnvOperand1AlphaFieldMask) != 0)
 448     {
 449         indentLog(uiIndent, PLOG);
 450         PLOG << "envOperand1Alpha "
 451              << GLDefineMapper::the()->toString(_sfEnvOperand1Alpha.getValue())
 452              << "\n";
 453     }
 454
 455     if((bvFlags & EnvOperand2AlphaFieldMask) != 0)
 456     {
 457         indentLog(uiIndent, PLOG);
 458         PLOG << "envOperand2Alpha "
 459              << GLDefineMapper::the()->toString(_sfEnvOperand2Alpha.getValue())
 460              << "\n";
 461     }
 462
 463     if((bvFlags & PointSpriteFieldMask) != 0)
 464     {
 465         indentLog(uiIndent, PLOG);
 466         PLOG << "pointSprite " << _sfPointSprite.getValue() << "\n";
 467     }
 468
 469     if((bvFlags & ShaderOperationFieldMask) != 0)
 470     {
 471         indentLog(uiIndent, PLOG);
 472         PLOG << "shaderOperationAlpha "
 473              << GLDefineMapper::the()->toString(_sfShaderOperation.getValue())
 474              << "\n";
 475     }
 476
 477     if((bvFlags & ShaderInputFieldMask) != 0)
 478     {
 479         indentLog(uiIndent, PLOG);
 480         PLOG << "shaderInputAlpha "
 481              << GLDefineMapper::the()->toString(_sfShaderInput.getValue())
 482              << "\n";
 483     }
 484
 485     if((bvFlags & ShaderOffsetMatrixFieldMask) != 0)
 486     {
 487         indentLog(uiIndent, PLOG);
 488         PLOG << "shaderOffsetMatrix " << "NIY" << "\n";
 489     }
 490
 491     if((bvFlags & ShaderOffsetScaleFieldMask) != 0)
 492     {
 493         indentLog(uiIndent, PLOG);
 494         PLOG << "shaderOffsetScale " << _sfShaderOffsetScale.getValue() << "\n";
 495     }
 496
 497     if((bvFlags & ShaderOffsetBiasFieldMask) != 0)
 498     {
 499         indentLog(uiIndent, PLOG);
 500         PLOG << "shaderOffsetBias " << _sfShaderOffsetBias.getValue() << "\n";
 501     }
 502
 503     if((bvFlags & ShaderRGBADotProductFieldMask) != 0)
 504     {
 505         indentLog(uiIndent, PLOG);
 506         PLOG << "shaderRGBADotProduct "
 507              << GLDefineMapper::the()->toString(_sfShaderRGBADotProduct.getValue())
 508              << "\n";
 509     }
 510
 511     if((bvFlags & ShaderCullModesFieldMask) != 0)
 512     {
 513         indentLog(uiIndent, PLOG);
 514         PLOG << "shaderCullModes " << _sfShaderCullModes.getValue() << "\n";
 515     }
 516
 517     if((bvFlags & ShaderConstEyeFieldMask) != 0)
 518     {
 519         indentLog(uiIndent, PLOG);
 520         PLOG << "shaderConstEye " << _sfShaderConstEye.getValue() << "\n";
 521     }
 522
 523     if((bvFlags & LodBiasFieldMask) != 0)
 524     {
 525         indentLog(uiIndent, PLOG);
 526         PLOG << "lodBias " << _sfLodBias.getValue() << "\n";
 527     }
 528 }
 529
 530
 531 /*------------------------------ State ------------------------------------*/
 532
 533
 534 void TextureEnvChunk::activate(DrawEnv *pEnv, UInt32 idx)
 535 {
 536 #if !defined(OSG_OGL_COREONLY) || defined(OSG_CHECK_COREONLY)
 537     pEnv->incNumChunkChanges();
 538
 539     Window *win = pEnv->getWindow();
 540
 541     Real32 nteximages, ntexcoords;
 542
 543     if((nteximages = win->getConstantValue(GL_MAX_TEXTURE_IMAGE_UNITS_ARB)) ==
 544        Window::unknownConstant)
 545     {
 546         nteximages = win->getConstantValue(GL_MAX_TEXTURE_UNITS_ARB);
 547
 548         // sgi doesn't support GL_MAX_TEXTURE_UNITS_ARB!
 549         if(nteximages == Window::unknownConstant)
 550             nteximages = 1.0f;
 551     }
 552
 553     if((ntexcoords = win->getConstantValue(GL_MAX_TEXTURE_COORDS_ARB)) ==
 554        Window::unknownConstant)
 555     {
 556         ntexcoords = win->getConstantValue(GL_MAX_TEXTURE_UNITS_ARB);
 557
 558         // sgi doesn't support GL_MAX_TEXTURE_UNITS_ARB!
 559         if(ntexcoords == Window::unknownConstant)
 560             ntexcoords = 1.0f;
 561     }
 562
 563     if(idx >= static_cast<UInt32>(nteximages))
 564     {
 565 #ifdef OSG_DEBUG
 566         FWARNING(("TextureEnvChunk::activate: Trying to bind image unit %d,"
 567                   " but Window %p only supports %lf!\n",
 568                   idx, win, nteximages));
 569 #endif
 570         return;
 571     }
 572
 573     if(TextureBaseChunk::activateTexture(win, idx) == true)
 574         return;
 575
 576 #ifdef GL_ARB_point_sprite
 577     if(getPointSprite() && win->hasExtOrVersion(_extPointSprite, 0x0200))
 578     {
 579         if(idx < static_cast<UInt32>(ntexcoords))
 580         {
 581             glTexEnvi(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE);
 582         }
 583     }
 584 #endif
 585
 586     if(getLodBias() != 0.0f && win->hasExtOrVersion(_extTextureLodBias, 0x0104))
 587     {
 588         glTexEnvf(GL_TEXTURE_FILTER_CONTROL_EXT,
 589                   GL_TEXTURE_LOD_BIAS_EXT,
 590                   getLodBias());
 591     }
 592
 593     Real32 ntexunits = win->getConstantValue(GL_MAX_TEXTURE_UNITS_ARB);
 594
 595     // sgi doesn't support GL_MAX_TEXTURE_UNITS_ARB!
 596     if(ntexunits == Window::unknownConstant)
 597         ntexunits = 1.0f;
 598
 599     if(idx < static_cast<UInt32>(ntexunits))
 600     {
 601         // texture env
 602         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, getEnvMode());
 603
 604         glTexEnvfv(GL_TEXTURE_ENV,
 605                    GL_TEXTURE_ENV_COLOR,
 606                    getEnvColor().getValuesRGBA());
 607
 608         if(getEnvMode() == GL_COMBINE_EXT)
 609         {
 610             glTexEnvi(GL_TEXTURE_ENV,
 611                       GL_COMBINE_RGB_EXT,
 612                       getEnvCombineRGB ());
 613
 614             glTexEnvf(GL_TEXTURE_ENV,
 615                       GL_RGB_SCALE_EXT,
 616                       getEnvScaleRGB   ());
 617
 618             glTexEnvi(GL_TEXTURE_ENV,
 619                       GL_SOURCE0_RGB_EXT,
 620                       getEnvSource0RGB ());
 621
 622             glTexEnvi(GL_TEXTURE_ENV,
 623                       GL_SOURCE1_RGB_EXT,
 624                       getEnvSource1RGB ());
 625
 626             glTexEnvi(GL_TEXTURE_ENV,
 627                       GL_SOURCE2_RGB_EXT,
 628                       getEnvSource2RGB ());
 629
 630             glTexEnvi(GL_TEXTURE_ENV,
 631                       GL_OPERAND0_RGB_EXT,
 632                       getEnvOperand0RGB());
 633
 634             glTexEnvi(GL_TEXTURE_ENV,
 635                       GL_OPERAND1_RGB_EXT,
 636                       getEnvOperand1RGB());
 637
 638             glTexEnvi(GL_TEXTURE_ENV,
 639                       GL_OPERAND2_RGB_EXT,
 640                       getEnvOperand2RGB());
 641
 642
 643             glTexEnvi(GL_TEXTURE_ENV,
 644                       GL_COMBINE_ALPHA_EXT,
 645                       getEnvCombineAlpha ());
 646
 647             glTexEnvf(GL_TEXTURE_ENV,
 648                       GL_ALPHA_SCALE,
 649                       getEnvScaleAlpha   ());
 650
 651             glTexEnvi(GL_TEXTURE_ENV,
 652                       GL_SOURCE0_ALPHA_EXT,
 653                       getEnvSource0Alpha ());
 654
 655             glTexEnvi(GL_TEXTURE_ENV,
 656                       GL_SOURCE1_ALPHA_EXT,
 657                       getEnvSource1Alpha ());
 658
 659             glTexEnvi(GL_TEXTURE_ENV,
 660                       GL_SOURCE2_ALPHA_EXT,
 661                       getEnvSource2Alpha ());
 662
 663             glTexEnvi(GL_TEXTURE_ENV,
 664                       GL_OPERAND0_ALPHA_EXT,
 665                       getEnvOperand0Alpha());
 666
 667             glTexEnvi(GL_TEXTURE_ENV,
 668                       GL_OPERAND1_ALPHA_EXT,
 669                       getEnvOperand1Alpha());
 670
 671             glTexEnvi(GL_TEXTURE_ENV,
 672                       GL_OPERAND2_ALPHA_EXT,
 673                       getEnvOperand2Alpha());
 674         }
 675
 676         TextureEnvChunk::handleTextureShader(
 677             win,
 678             pEnv->getActiveTexTarget(idx));
 679
 680         if(idx                                 == 0       &&
 681            getShaderOperation()                != GL_NONE &&
 682            win->hasExtension(_extTextureShader) == true      )
 683         {
 684             glEnable(GL_TEXTURE_SHADER_NV);
 685         }
 686     }
 687 #else
 688     OSG_ASSERT(false);
 689 #endif
 690
 691     glErr("TextureEnvChunk::activate");
 692 }
 693
 694 void TextureEnvChunk::changeFrom(DrawEnv    *pEnv,
 695                                  StateChunk *old   ,
 696                                  UInt32      idx   )
 697 {
 698 #if !defined(OSG_OGL_COREONLY) || defined(OSG_CHECK_COREONLY)
 699     // change from me to me?
 700     // this assumes I haven't changed in the meantime.
 701     // is that a valid assumption?
 702     if(old == this)
 703         return;
 704
 705     pEnv->incNumChunkChanges();
 706
 707     TextureEnvChunk *oldp = dynamic_cast<TextureEnvChunk *>(old);
 708
 709     glErr("TextureEnvChunk::changeFrom precheck");
 710
 711     Window *win = pEnv->getWindow();
 712
 713     Real32 nteximages, ntexcoords;
 714
 715     if((nteximages = win->getConstantValue(GL_MAX_TEXTURE_IMAGE_UNITS_ARB)) ==
 716        Window::unknownConstant)
 717     {
 718         nteximages = win->getConstantValue(GL_MAX_TEXTURE_UNITS_ARB);
 719
 720         // sgi doesn't support GL_MAX_TEXTURE_UNITS_ARB!
 721         if(nteximages == Window::unknownConstant)
 722             nteximages = 1.0f;
 723     }
 724
 725     if((ntexcoords = win->getConstantValue(GL_MAX_TEXTURE_COORDS_ARB)) ==
 726        Window::unknownConstant)
 727     {
 728         ntexcoords = win->getConstantValue(GL_MAX_TEXTURE_UNITS_ARB);
 729
 730         // sgi doesn't support GL_MAX_TEXTURE_UNITS_ARB!
 731         if(ntexcoords == Window::unknownConstant)
 732             ntexcoords = 1.0f;
 733     }
 734
 735     if(idx >= nteximages)
 736     {
 737 #ifdef OSG_DEBUG
 738         FWARNING(("TextureEnvChunk::changeFrom: Trying to bind image unit %d,"
 739                   " but Window %p only supports %lf!\n",
 740                   idx, win, nteximages));
 741 #endif
 742         return;
 743     }
 744
 745     if(TextureBaseChunk::activateTexture(win, idx))
 746         return; // trying to use too many textures
 747
 748 #ifdef GL_ARB_point_sprite
 749     if(idx < ntexcoords)
 750     {
 751         if(oldp->getPointSprite() != getPointSprite() &&
 752            win->hasExtOrVersion(_extPointSprite, 0x0200))
 753         {
 754             glTexEnvi(GL_POINT_SPRITE_ARB,
 755                       GL_COORD_REPLACE_ARB,
 756                       getPointSprite());
 757         }
 758     }
 759 #endif
 760
 761     if(oldp->getLodBias() != getLodBias() &&
 762        win->hasExtOrVersion(_extTextureLodBias, 0x0104))
 763     {
 764         glTexEnvf(GL_TEXTURE_FILTER_CONTROL_EXT,
 765                   GL_TEXTURE_LOD_BIAS_EXT,
 766                   getLodBias());
 767     }
 768
 769     Real32 ntexunits = win->getConstantValue(GL_MAX_TEXTURE_UNITS_ARB);
 770
 771     // sgi doesn't support GL_MAX_TEXTURE_UNITS_ARB!
 772     if(ntexunits == Window::unknownConstant)
 773         ntexunits = 1.0f;
 774
 775     if(idx < ntexunits)
 776     {
 777         if(oldp->getEnvMode() != getEnvMode())
 778         {
 779             glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, getEnvMode());
 780         }
 781
 782         glTexEnvfv(GL_TEXTURE_ENV,
 783                    GL_TEXTURE_ENV_COLOR,
 784                    getEnvColor().getValuesRGBA());
 785
 786         if(getEnvMode() == GL_COMBINE_EXT)
 787         {
 788             glTexEnvi(GL_TEXTURE_ENV,
 789                       GL_COMBINE_RGB_EXT,
 790                       getEnvCombineRGB ());
 791
 792             glTexEnvf(GL_TEXTURE_ENV,
 793                       GL_RGB_SCALE_EXT,
 794                       getEnvScaleRGB   ());
 795
 796             glTexEnvi(GL_TEXTURE_ENV,
 797                       GL_SOURCE0_RGB_EXT,
 798                       getEnvSource0RGB ());
 799
 800             glTexEnvi(GL_TEXTURE_ENV,
 801                       GL_SOURCE1_RGB_EXT,
 802                       getEnvSource1RGB ());
 803
 804             glTexEnvi(GL_TEXTURE_ENV,
 805                       GL_SOURCE2_RGB_EXT,
 806                       getEnvSource2RGB ());
 807
 808             glTexEnvi(GL_TEXTURE_ENV,
 809                       GL_OPERAND0_RGB_EXT,
 810                       getEnvOperand0RGB());
 811
 812             glTexEnvi(GL_TEXTURE_ENV,
 813                       GL_OPERAND1_RGB_EXT,
 814                       getEnvOperand1RGB());
 815
 816             glTexEnvi(GL_TEXTURE_ENV,
 817                       GL_OPERAND2_RGB_EXT,
 818                       getEnvOperand2RGB());
 819
 820
 821
 822             glTexEnvi(GL_TEXTURE_ENV,
 823                       GL_COMBINE_ALPHA_EXT,
 824                       getEnvCombineAlpha ());
 825
 826             glTexEnvf(GL_TEXTURE_ENV,
 827                       GL_ALPHA_SCALE,
 828                       getEnvScaleAlpha   ());
 829
 830             glTexEnvi(GL_TEXTURE_ENV,
 831                       GL_SOURCE0_ALPHA_EXT,
 832                       getEnvSource0Alpha ());
 833
 834             glTexEnvi(GL_TEXTURE_ENV,
 835                       GL_SOURCE1_ALPHA_EXT,
 836                       getEnvSource1Alpha ());
 837
 838             glTexEnvi(GL_TEXTURE_ENV,
 839                       GL_SOURCE2_ALPHA_EXT,
 840                       getEnvSource2Alpha ());
 841
 842             glTexEnvi(GL_TEXTURE_ENV,
 843                       GL_OPERAND0_ALPHA_EXT,
 844                       getEnvOperand0Alpha());
 845
 846             glTexEnvi(GL_TEXTURE_ENV,
 847                       GL_OPERAND1_ALPHA_EXT,
 848                       getEnvOperand1Alpha());
 849
 850             glTexEnvi(GL_TEXTURE_ENV,
 851                       GL_OPERAND2_ALPHA_EXT,
 852                       getEnvOperand2Alpha());
 853         }
 854
 855         if(win->hasExtension(_extTextureShader))
 856         {
 857             if(      getShaderOperation() != GL_NONE &&
 858                      oldp->getShaderOperation() == GL_NONE   )
 859             {
 860                 handleTextureShader(win,
 861                                     pEnv->getActiveTexTarget(idx));
 862
 863                 if(idx == 0)
 864                     glEnable(GL_TEXTURE_SHADER_NV);
 865             }
 866             else if(      getShaderOperation() == GL_NONE &&
 867                           oldp->getShaderOperation() != GL_NONE   )
 868             {
 869                 glTexEnvi(GL_TEXTURE_SHADER_NV,
 870                           GL_SHADER_OPERATION_NV,
 871                           GL_NONE);
 872
 873                 if(idx == 0)
 874                 {
 875                     glDisable(GL_TEXTURE_SHADER_NV);
 876                 }
 877             }
 878         }
 879     }
 880 #else
 881     OSG_ASSERT(false);
 882 #endif
 883
 884     glErr("TextureEnvChunk::changeFrom");
 885 }
 886
 887
 888 void TextureEnvChunk::deactivate(DrawEnv *pEnv, UInt32 idx)
 889 {
 890 #if !defined(OSG_OGL_COREONLY) || defined(OSG_CHECK_COREONLY)
 891     Window *win = pEnv->getWindow();
 892
 893     Real32 nteximages, ntexcoords;
 894
 895     if((nteximages = win->getConstantValue(GL_MAX_TEXTURE_IMAGE_UNITS_ARB)) ==
 896        Window::unknownConstant )
 897     {
 898         nteximages = win->getConstantValue(GL_MAX_TEXTURE_UNITS_ARB);
 899
 900         // sgi doesn't support GL_MAX_TEXTURE_UNITS_ARB!
 901         if(nteximages == Window::unknownConstant)
 902             nteximages = 1.0f;
 903     }
 904
 905     if((ntexcoords = win->getConstantValue(GL_MAX_TEXTURE_COORDS_ARB)) ==
 906        Window::unknownConstant )
 907     {
 908         ntexcoords = win->getConstantValue(GL_MAX_TEXTURE_UNITS_ARB);
 909
 910         // sgi doesn't support GL_MAX_TEXTURE_UNITS_ARB!
 911         if(ntexcoords == Window::unknownConstant)
 912             ntexcoords = 1.0f;
 913     }
 914
 915     if(idx >= static_cast<UInt32>(nteximages))
 916     {
 917 #ifdef OSG_DEBUG
 918         FWARNING(("CubeTextureEnvChunk::deactivate: Trying to bind image unit "
 919                   "%d, but Window %p only supports %lf!\n",
 920                   idx, win, nteximages));
 921 #endif
 922         return;
 923     }
 924
 925     bool isActive = false;
 926
 927 #ifdef GL_ARB_point_sprite
 928     if(getPointSprite() &&
 929        win->hasExtOrVersion(_extPointSprite, 0x0200) &&
 930        idx < static_cast<UInt32>(ntexcoords) )
 931     {
 932         if(!isActive)
 933         {
 934             TextureBaseChunk::activateTexture(win, idx);
 935             isActive = true;
 936         }
 937
 938         glTexEnvi(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_FALSE);
 939     }
 940 #endif
 941
 942     if(getLodBias() != 0.0f && win->hasExtOrVersion(_extTextureLodBias, 0x0104))
 943     {
 944         if(!isActive)
 945         {
 946             TextureBaseChunk::activateTexture(win, idx);
 947             isActive = true;
 948         }
 949
 950         glTexEnvf(GL_TEXTURE_FILTER_CONTROL_EXT,
 951                   GL_TEXTURE_LOD_BIAS_EXT,
 952                   0.0f);
 953
 954     }
 955
 956     Real32 ntexunits = win->getConstantValue(GL_MAX_TEXTURE_UNITS_ARB);
 957
 958     if(ntexunits == Window::unknownConstant)
 959         ntexunits = 1.0f;
 960
 961     if(idx >= static_cast<UInt32>(ntexunits))
 962     {
 963         return; // tetxures >= MTU are not enabled and don't have an env
 964     }
 965
 966     if(!isActive)
 967         TextureBaseChunk::activateTexture(win, idx);
 968
 969
 970     glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
 971
 972     glTexEnvfv(GL_TEXTURE_ENV,
 973                GL_TEXTURE_ENV_COLOR,
 974                Vec4f::Null.getValues());
 975
 976     if(getShaderOperation() != GL_NONE &&
 977        win->hasExtension(_extTextureShader))
 978     {
 979         glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_NONE);
 980
 981         if(idx == 0)
 982             glDisable(GL_TEXTURE_SHADER_NV);
 983     }
 984 #else
 985     OSG_ASSERT(false);
 986 #endif
 987
 988     glErr("TextureEnvChunk::deactivate");
 989 }
 990
 991 /*-------------------------- Comparison -----------------------------------*/
 992
 993 Real32 TextureEnvChunk::switchCost(StateChunk *OSG_CHECK_ARG(chunk))
 994 {
 995     return 0;
 996 }
 997
 998 bool TextureEnvChunk::operator < (const StateChunk &other) const
 999 {
1000     return this < &other;
1001 }
1002
1003 bool TextureEnvChunk::operator == (const StateChunk &other) const
1004 {
1005     TextureEnvChunk const *tother =
1006         dynamic_cast<TextureEnvChunk const*>(&other);
1007
1008     if(!tother)
1009         return false;
1010
1011     if(tother == this)
1012         return true;
1013
1014     bool returnValue =
1015         getEnvMode  () == tother->getEnvMode  ();
1016
1017     if(returnValue == true && getEnvMode() == GL_COMBINE_EXT)
1018     {
1019         returnValue =
1020             getEnvCombineRGB ()   == tother->getEnvCombineRGB   () &&
1021
1022             getEnvSource0RGB ()   == tother->getEnvSource0RGB   () &&
1023             getEnvSource1RGB ()   == tother->getEnvSource1RGB   () &&
1024             getEnvSource2RGB ()   == tother->getEnvSource2RGB   () &&
1025
1026             getEnvOperand0RGB()   == tother->getEnvOperand0RGB  () &&
1027             getEnvOperand1RGB()   == tother->getEnvOperand1RGB  () &&
1028             getEnvOperand2RGB()   == tother->getEnvOperand2RGB  () &&
1029
1030             getEnvCombineAlpha () == tother->getEnvCombineAlpha () &&
1031
1032             getEnvSource0Alpha () == tother->getEnvSource0Alpha () &&
1033             getEnvSource1Alpha () == tother->getEnvSource1Alpha () &&
1034             getEnvSource2Alpha () == tother->getEnvSource2Alpha () &&
1035
1036             getEnvOperand0Alpha() == tother->getEnvOperand0Alpha() &&
1037             getEnvOperand1Alpha() == tother->getEnvOperand1Alpha() &&
1038             getEnvOperand2Alpha() == tother->getEnvOperand2Alpha();
1039
1040
1041         returnValue &=
1042             ((        getEnvScaleRGB  () - tother->getEnvScaleRGB  ()) <
1043              TypeTraits<Real32>::getDefaultEps()                        ) &&
1044             ((tother->getEnvScaleRGB  () -         getEnvScaleRGB  ()) <
1045              TypeTraits<Real32>::getDefaultEps()                        ) &&
1046             ((        getEnvScaleAlpha() - tother->getEnvScaleAlpha()) <
1047              TypeTraits<Real32>::getDefaultEps()                        ) &&
1048             ((tother->getEnvScaleAlpha() -         getEnvScaleAlpha()) <
1049              TypeTraits<Real32>::getDefaultEps()                        );
1050     }
1051
1052     return returnValue;
1053 }
1054
1055 bool TextureEnvChunk::operator != (const StateChunk &other) const
1056 {
1057     return ! (*this == other);
1058 }
1059