Source/System/State/Base/OSGPolygonChunk.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 "OSGConfig.h"
  47
  48 #include "OSGGL.h"
  49
  50 #include "OSGPolygonChunk.h"
  51 #include "OSGDrawEnv.h"
  52
  53 OSG_USING_NAMESPACE
  54
  55 // Documentation for this class is emited in the
  56 // OSGPolygonChunkBase.cpp file.
  57 // To modify it, please change the .fcd file (OSGPolygonChunk.fcd) and
  58 // regenerate the base file.
  59
  60 /***************************************************************************\
  61  *                           Class variables                               *
  62 \***************************************************************************/
  63
  64 #ifndef OSG_OGL_ES2
  65 StateChunkClass PolygonChunk::_class("Polygon", 1, 50);
  66 #else
  67 StateChunkClass PolygonChunk::_class("Polygon", 1, 110);
  68 #endif
  69
  70 /***************************************************************************\
  71  *                           Class methods                                 *
  72 \***************************************************************************/
  73
  74 void PolygonChunk::initMethod(InitPhase ePhase)
  75 {
  76     Inherited::initMethod(ePhase);
  77 }
  78
  79 /***************************************************************************\
  80  *                           Instance methods                              *
  81 \***************************************************************************/
  82
  83 /*-------------------------------------------------------------------------*\
  84  -  private                                                                 -
  85 \*-------------------------------------------------------------------------*/
  86
  87
  88 /*------------- constructors & destructors --------------------------------*/
  89
  90 PolygonChunk::PolygonChunk(void) :
  91     Inherited()
  92 {
  93 }
  94
  95 PolygonChunk::PolygonChunk(const PolygonChunk &source) :
  96     Inherited(source)
  97 {
  98 }
  99
 100 PolygonChunk::~PolygonChunk(void)
 101 {
 102 }
 103
 104 /*------------------------- Chunk Class Access ---------------------------*/
 105
 106 const StateChunkClass *PolygonChunk::getClass(void) const
 107 {
 108     return &_class;
 109 }
 110
 111 /*------------------------------- Sync -----------------------------------*/
 112
 113 void PolygonChunk::changed(ConstFieldMaskArg whichField,
 114                            UInt32            origin,
 115                            BitVector         details)
 116 {
 117     Inherited::changed(whichField, origin, details);
 118 }
 119
 120 /*------------------------------ Output ----------------------------------*/
 121
 122 void PolygonChunk::dump(      UInt32    uiIndent,
 123                         const BitVector bvFlags) const
 124 {
 125    Inherited::dump(uiIndent, bvFlags);
 126 }
 127
 128
 129 /*------------------------------ State ------------------------------------*/
 130
 131 void PolygonChunk::activate(DrawEnv *pEnv, UInt32)
 132 {
 133 // cullFace
 134     pEnv->incNumChunkChanges();
 135
 136     if(_sfCullFace.getValue() != GL_NONE)
 137     {
 138         glCullFace(_sfCullFace.getValue());
 139         glEnable(GL_CULL_FACE);
 140     }
 141
 142 // frontFace
 143
 144     if(_sfFrontFace.getValue() != GL_CCW)
 145         glFrontFace(_sfFrontFace.getValue());
 146
 147 #ifndef OSG_OGL_ES2
 148 // smooth
 149
 150     if(_sfSmooth.getValue())
 151         glEnable(GL_POLYGON_SMOOTH);
 152 #endif
 153
 154 #ifndef OSG_OGL_ES2
 155 // mode
 156
 157 # if !defined(OSG_OGL_COREONLY)
 158     if(_sfFrontMode.getValue() != GL_FILL)
 159         glPolygonMode(GL_FRONT, _sfFrontMode.getValue());
 160
 161     if(_sfBackMode.getValue() != GL_FILL)
 162         glPolygonMode(GL_BACK, _sfBackMode.getValue());
 163 # else
 164     if(_sfFrontMode.getValue() != GL_FILL)
 165         glPolygonMode(GL_FRONT_AND_BACK, _sfFrontMode.getValue());
 166 # endif
 167 #endif
 168
 169 #ifndef OSG_OGL_ES2
 170 // offset
 171
 172     if(_sfOffsetFactor.getValue() != 0.f || _sfOffsetBias.getValue() != 0.f)
 173         glPolygonOffset(_sfOffsetFactor.getValue(), _sfOffsetBias.getValue());
 174
 175     if(_sfOffsetPoint.getValue())
 176         glEnable(GL_POLYGON_OFFSET_POINT);
 177
 178     if(_sfOffsetLine.getValue())
 179         glEnable(GL_POLYGON_OFFSET_LINE);
 180
 181     if(_sfOffsetFill.getValue())
 182         glEnable(GL_POLYGON_OFFSET_FILL);
 183 #endif
 184
 185 #if !defined(OSG_OGL_COREONLY)
 186 // stipple
 187
 188     if(_mfStipple.size() == 32)
 189     {
 190         glPolygonStipple(reinterpret_cast<const GLubyte *>(&(_mfStipple[0])));
 191         glEnable(GL_POLYGON_STIPPLE);
 192     }
 193 #endif
 194 }
 195
 196
 197 void PolygonChunk::changeFrom(DrawEnv *pEnv, StateChunk *old_chunk, UInt32)
 198 {
 199     PolygonChunk const *old = dynamic_cast<PolygonChunk const*>(old_chunk);
 200
 201     // change from me to me?
 202     // this assumes I haven't changed in the meantime. is that a valid
 203     // assumption?
 204
 205     if(old == this)
 206         return;
 207
 208     pEnv->incNumChunkChanges();
 209
 210 // cullFace
 211
 212     if(_sfCullFace.getValue() != old->_sfCullFace.getValue())
 213     {
 214         if(_sfCullFace.getValue() != GL_NONE)
 215         {
 216             glCullFace(_sfCullFace.getValue());
 217             glEnable(GL_CULL_FACE);
 218         }
 219         else
 220         {
 221             glDisable(GL_CULL_FACE);
 222         }
 223     }
 224
 225 // frontFace
 226
 227     if(_sfFrontFace.getValue() != old->_sfFrontFace.getValue())
 228     {
 229         glFrontFace(_sfFrontFace.getValue());
 230     }
 231
 232 #ifndef OSG_OGL_ES2
 233 // smooth
 234
 235     if(_sfSmooth.getValue() != old->_sfSmooth.getValue())
 236     {
 237         if(_sfSmooth.getValue())
 238         {
 239             glEnable(GL_POLYGON_SMOOTH);
 240         }
 241         else
 242         {
 243             glDisable(GL_POLYGON_SMOOTH);
 244         }
 245     }
 246 #endif
 247
 248 #ifndef OSG_OGL_ES2
 249 // mode
 250
 251 # if !defined(OSG_OGL_COREONLY)
 252     if(_sfFrontMode.getValue() !=  old->_sfFrontMode.getValue())
 253         glPolygonMode(GL_FRONT, _sfFrontMode.getValue());
 254
 255     if(_sfBackMode.getValue() !=  old->_sfBackMode.getValue())
 256         glPolygonMode(GL_BACK, _sfBackMode.getValue());
 257 # else
 258     if(_sfFrontMode.getValue() !=  old->_sfFrontMode.getValue())
 259         glPolygonMode(GL_FRONT_AND_BACK, _sfFrontMode.getValue());
 260 # endif
 261 #endif
 262
 263 #ifndef OSG_OGL_ES2
 264 // offset
 265
 266     if(_sfOffsetFactor.getValue() != old->_sfOffsetFactor.getValue() ||
 267        _sfOffsetBias.getValue()   != old->_sfOffsetBias.getValue())
 268     {
 269         glPolygonOffset(_sfOffsetFactor.getValue(), _sfOffsetBias.getValue());
 270     }
 271
 272     if(_sfOffsetPoint.getValue() != old->_sfOffsetPoint.getValue())
 273     {
 274         if(_sfOffsetPoint.getValue())
 275         {
 276             glEnable(GL_POLYGON_OFFSET_POINT);
 277         }
 278         else
 279         {
 280             glDisable(GL_POLYGON_OFFSET_POINT);
 281         }
 282     }
 283
 284     if(_sfOffsetLine.getValue() != old->_sfOffsetLine.getValue())
 285     {
 286         if(_sfOffsetLine.getValue())
 287         {
 288             glEnable(GL_POLYGON_OFFSET_LINE);
 289         }
 290         else
 291         {
 292             glDisable(GL_POLYGON_OFFSET_LINE);
 293         }
 294     }
 295
 296     if(_sfOffsetFill.getValue() != old->_sfOffsetFill.getValue())
 297     {
 298         if(_sfOffsetFill.getValue())
 299         {
 300             glEnable(GL_POLYGON_OFFSET_FILL);
 301         }
 302         else
 303         {
 304             glDisable(GL_POLYGON_OFFSET_FILL);
 305         }
 306     }
 307 #endif
 308
 309 #if !defined(OSG_OGL_COREONLY)
 310 // stipple
 311
 312     if(_mfStipple.getValues() != old->_mfStipple.getValues())
 313     {
 314         if(_mfStipple.size() == 32)
 315         {
 316             glPolygonStipple(
 317                 reinterpret_cast<const GLubyte *>(&(_mfStipple[0])));
 318             glEnable(GL_POLYGON_STIPPLE);
 319         }
 320         else glDisable(GL_POLYGON_STIPPLE);
 321     }
 322 #endif
 323 }
 324
 325 void PolygonChunk::deactivate(DrawEnv *, UInt32)
 326 {
 327
 328 // cullFace
 329
 330     if(_sfCullFace.getValue() != GL_NONE)
 331         glDisable(GL_CULL_FACE);
 332
 333 // frontFace
 334
 335     if(_sfFrontFace.getValue() != GL_CCW)
 336         glFrontFace(GL_CCW);
 337
 338 #ifndef OSG_OGL_ES2
 339 // smooth
 340
 341     if(_sfSmooth.getValue())
 342         glDisable(GL_POLYGON_SMOOTH);
 343 #endif
 344
 345 #ifndef OSG_OGL_ES2
 346 // mode
 347
 348 # if !defined(OSG_OGL_COREONLY)
 349     if(_sfFrontMode.getValue() != GL_FILL)
 350         glPolygonMode(GL_FRONT, GL_FILL);
 351
 352     if(_sfBackMode.getValue() != GL_FILL)
 353         glPolygonMode(GL_BACK, GL_FILL);
 354 # else
 355     if(_sfFrontMode.getValue() != GL_FILL)
 356         glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 357 # endif
 358 #endif
 359
 360 #ifndef OSG_OGL_ES2
 361 // offset
 362
 363     if(_sfOffsetPoint.getValue())
 364         glDisable(GL_POLYGON_OFFSET_POINT);
 365
 366     if(_sfOffsetLine.getValue())
 367         glDisable(GL_POLYGON_OFFSET_LINE);
 368
 369     if(_sfOffsetFill.getValue())
 370         glDisable(GL_POLYGON_OFFSET_FILL);
 371 #endif
 372
 373 #if !defined(OSG_OGL_COREONLY)
 374 // stipple
 375
 376     if(_mfStipple.size() == 32)
 377         glDisable(GL_POLYGON_STIPPLE);
 378 #endif
 379 }
 380
 381
 382 /*-------------------------- Comparison -----------------------------------*/
 383
 384 Real32 PolygonChunk::switchCost(StateChunk *OSG_CHECK_ARG(chunk))
 385 {
 386     return 0;
 387 }
 388
 389 bool PolygonChunk::operator <(const StateChunk &other) const
 390 {
 391     return this < &other;
 392 }
 393
 394 bool PolygonChunk::operator ==(const StateChunk &other) const
 395 {
 396     PolygonChunk const *tother = dynamic_cast<PolygonChunk const*>(&other);
 397
 398     if(!tother)
 399         return false;
 400
 401     if(tother == this)
 402         return true;
 403
 404     if(getCullFace()          != tother->getCullFace()      ||
 405        getFrontFace()         != tother->getFrontFace()     ||
 406        getSmooth()            != tother->getSmooth()        ||
 407        getFrontMode()         != tother->getFrontMode()     ||
 408        getBackMode()          != tother->getBackMode()      ||
 409        getOffsetPoint()       != tother->getOffsetPoint()   ||
 410        getOffsetLine()        != tother->getOffsetLine()    ||
 411        getOffsetFill()        != tother->getOffsetFill()    ||
 412        getOffsetFactor()      != tother->getOffsetFactor()  ||
 413        getOffsetBias()        != tother->getOffsetBias()    ||
 414        getMFStipple()->size() != tother->getMFStipple()->size()
 415       )
 416         return false;
 417
 418     // would need to compare the whole stipple data
 419     // cheap trick: if != 0 take as different
 420
 421     if(        getMFStipple()->size() != 0 ||
 422        tother->getMFStipple()->size() != 0
 423       )
 424         return false;
 425
 426     return true;
 427 }
 428
 429 bool PolygonChunk::operator !=(const StateChunk &other) const
 430 {
 431     return !(*this == other);
 432 }