Source/System/State/OpenGL/OSGLightModelChunk.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 "OSGGLEXT.h"
  49
  50 #include "OSGLightModelChunk.h"
  51 #include "OSGDrawEnv.h"
  52
  53 OSG_USING_NAMESPACE
  54
  55 // Documentation for this class is emited in the
  56 // OSGLightModelChunkBase.cpp file.
  57 // To modify it, please change the .fcd file (OSGLightModelChunk.fcd) and
  58 // regenerate the base file.
  59
  60 /***************************************************************************\
  61  *                           Class variables                               *
  62 \***************************************************************************/
  63 StateChunkClass LightModelChunk::_class("LightModel", 1, 100);
  64
  65 /***************************************************************************\
  66  *                           Class methods                                 *
  67 \***************************************************************************/
  68
  69 void LightModelChunk::initMethod(InitPhase ePhase)
  70 {
  71     Inherited::initMethod(ePhase);
  72 }
  73
  74
  75 /***************************************************************************\
  76  *                           Instance methods                              *
  77 \***************************************************************************/
  78
  79 /*-------------------------------------------------------------------------*\
  80  -  private                                                                 -
  81 \*-------------------------------------------------------------------------*/
  82
  83 /*----------------------- constructors & destructors ----------------------*/
  84
  85 LightModelChunk::LightModelChunk(void) :
  86     Inherited()
  87 {
  88 }
  89
  90 LightModelChunk::LightModelChunk(const LightModelChunk &source) :
  91     Inherited(source)
  92 {
  93 }
  94
  95 LightModelChunk::~LightModelChunk(void)
  96 {
  97 }
  98
  99 /*----------------------------- class specific ----------------------------*/
 100
 101 const StateChunkClass *LightModelChunk::getClass(void) const
 102 {
 103     return &_class;
 104 }
 105
 106 void LightModelChunk::changed(ConstFieldMaskArg whichField,
 107                               UInt32            origin,
 108                               BitVector         details)
 109 {
 110     Inherited::changed(whichField, origin, details);
 111 }
 112
 113 void LightModelChunk::dump(      UInt32    uiIndent,
 114                            const BitVector bvFlags  ) const
 115 {
 116     Inherited::dump(uiIndent, bvFlags);
 117
 118     if((bvFlags & AmbientFieldMask) != 0)
 119     {
 120         indentLog(uiIndent, PLOG);
 121         PLOG << "ambient " << _sfAmbient.getValue() << "\n";
 122     }
 123
 124     if((bvFlags & ColorControlFieldMask) != 0)
 125     {
 126         indentLog(uiIndent, PLOG);
 127         PLOG << "colorControl "
 128              << GLDefineMapper::the()->toString(_sfColorControl.getValue())
 129              << "\n";
 130     }
 131
 132     if((bvFlags & LocalViewerFieldMask) != 0)
 133     {
 134         indentLog(uiIndent, PLOG);
 135         PLOG << "localViewer " << _sfLocalViewer.getValue() << "\n";
 136     }
 137 }
 138
 139 /*------------------------------ State ------------------------------------*/
 140
 141 void LightModelChunk::activate(DrawEnv *pEnv, UInt32)
 142 {
 143 #if !defined(OSG_OGL_COREONLY) || defined(OSG_CHECK_COREONLY)
 144     pEnv->incNumChunkChanges();
 145
 146     glLightModelfv(GL_LIGHT_MODEL_AMBIENT,
 147                    _sfAmbient.getValue().getValuesRGBA());
 148
 149     if(_sfColorControl.getValue() != GL_SINGLE_COLOR)
 150     {
 151         glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, _sfColorControl.getValue());
 152     }
 153
 154     if(_sfLocalViewer.getValue())
 155     {
 156         glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1);
 157     }
 158     else
 159     {
 160         glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 0);
 161     }
 162 #else
 163     OSG_ASSERT(false);
 164 #endif
 165 }
 166
 167 void LightModelChunk::changeFrom(DrawEnv    *pEnv,
 168                                  StateChunk *old_chunk,
 169                                  UInt32               )
 170 {
 171 #if !defined(OSG_OGL_COREONLY) || defined(OSG_CHECK_COREONLY)
 172     LightModelChunk *old = dynamic_cast<LightModelChunk *>(old_chunk);
 173
 174     if(old == NULL)
 175     {
 176         FWARNING(( "LightModelChunk::changeFrom: caught "
 177                    "non-LightModelChunk!\n"));
 178         return;
 179     }
 180
 181     // LightModelChunk didn't change so do nothing.
 182     if(old == this)
 183         return;
 184
 185     pEnv->incNumChunkChanges();
 186
 187     if(old->_sfAmbient.getValue() != _sfAmbient.getValue())
 188     {
 189        glLightModelfv(GL_LIGHT_MODEL_AMBIENT,
 190                       _sfAmbient.getValue().getValuesRGBA());
 191     }
 192
 193     if(_sfColorControl.getValue() != old->_sfColorControl.getValue())
 194     {
 195         glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, _sfColorControl.getValue());
 196     }
 197
 198     if(_sfLocalViewer.getValue() != old->_sfLocalViewer.getValue())
 199     {
 200         if(_sfLocalViewer.getValue())
 201         {
 202             glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1);
 203         }
 204         else
 205         {
 206             glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 0);
 207         }
 208     }
 209 #else
 210     OSG_ASSERT(false);
 211 #endif
 212 }
 213
 214 void LightModelChunk::deactivate(DrawEnv *pEnv, UInt32 )
 215 {
 216 #if !defined(OSG_OGL_COREONLY) || defined(OSG_CHECK_COREONLY)
 217     GLfloat ambient[] = {0.2f, 0.2f, 0.2f, 1.0f};
 218     glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient);
 219
 220     if(_sfColorControl.getValue() != GL_SINGLE_COLOR)
 221     {
 222         glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SINGLE_COLOR);
 223     }
 224
 225     if(_sfLocalViewer.getValue())
 226     {
 227        glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 0);
 228     }
 229 #else
 230     OSG_ASSERT(false);
 231 #endif
 232 }
 233
 234 /*-------------------------- Comparison -----------------------------------*/
 235
 236 Real32 LightModelChunk::switchCost(StateChunk *)
 237 {
 238     return 0;
 239 }
 240
 241 bool LightModelChunk::operator < (const StateChunk &other) const
 242 {
 243     return this < &other;
 244 }
 245
 246 bool LightModelChunk::operator == (const StateChunk &other) const
 247 {
 248     LightModelChunk const *tother = dynamic_cast<LightModelChunk const*>(&other);
 249
 250     if(!tother)
 251         return false;
 252
 253     if(tother == this)
 254         return true;
 255
 256     if(getAmbient     () != tother->getAmbient     () ||
 257        getColorControl() != tother->getColorControl() ||
 258        getLocalViewer () != tother->getLocalViewer ()   )
 259         return false;
 260
 261     return true;
 262 }
 263
 264 bool LightModelChunk::operator != (const StateChunk &other) const
 265 {
 266     return ! (*this == other);
 267 }