Source/System/State/OpenGL/OSGClipPlaneChunk.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 "OSGCamera.h"
  51 #include "OSGDrawEnv.h"
  52 #include "OSGNode.h"
  53
  54 #include "OSGClipPlaneChunk.h"
  55
  56 OSG_USING_NAMESPACE
  57
  58 // Documentation for this class is emited in the
  59 // OSGClipPlaneChunkBase.cpp file.
  60 // To modify it, please change the .fcd file (OSGClipPlaneChunk.fcd) and
  61 // regenerate the base file.
  62
  63 /***************************************************************************\
  64  *                           Class variables                               *
  65 \***************************************************************************/
  66
  67 StateChunkClass ClipPlaneChunk::_class("ClipPlane", 6, 140);
  68
  69 void ClipPlaneChunk::initMethod(InitPhase ePhase)
  70 {
  71     Inherited::initMethod(ePhase);
  72 }
  73
  74 /***************************************************************************\
  75  *                           Instance methods                              *
  76 \***************************************************************************/
  77
  78 /*-------------------------------------------------------------------------*\
  79  -  private                                                                 -
  80 \*-------------------------------------------------------------------------*/
  81
  82 /*----------------------- constructors & destructors ----------------------*/
  83
  84 ClipPlaneChunk::ClipPlaneChunk(void) :
  85     Inherited()
  86 {
  87 }
  88
  89 ClipPlaneChunk::ClipPlaneChunk(const ClipPlaneChunk &source) :
  90     Inherited(source)
  91 {
  92 }
  93
  94 ClipPlaneChunk::~ClipPlaneChunk(void)
  95 {
  96 }
  97
  98 /*----------------------- Chunk Class Access -----------------------------*/
  99
 100 const StateChunkClass *ClipPlaneChunk::getClass(void) const
 101 {
 102      return &_class;
 103 }
 104
 105 /*------------------------------- Sync -----------------------------------*/
 106
 107 void ClipPlaneChunk::changed(ConstFieldMaskArg whichField,
 108                              UInt32            origin,
 109                              BitVector         details)
 110 {
 111     Inherited::changed(whichField, origin, details);
 112 }
 113
 114 /*------------------------------ Output ----------------------------------*/
 115
 116 void ClipPlaneChunk::dump(      UInt32    ,
 117                           const BitVector) const
 118 {
 119     SLOG << "Dump ClipPlaneChunk NI" << std::endl;
 120 }
 121
 122
 123 /*------------------------------ State ------------------------------------*/
 124
 125 void ClipPlaneChunk::activate(DrawEnv *pEnv, UInt32 idx)
 126 {
 127 #if !defined(OSG_OGL_COREONLY) || defined(OSG_CHECK_COREONLY)
 128     pEnv->incNumChunkChanges();
 129
 130     Matrix beaconMat;
 131
 132     Matrix cameraMat = pEnv->getCameraViewing();
 133
 134     if(getBeacon() != NULL)
 135     {
 136         getBeacon()->getToWorld(beaconMat);
 137     }
 138     else
 139     {
 140         beaconMat.setIdentity();
 141
 142         SWARNING << "NO beacon" << std::endl;
 143     }
 144
 145     cameraMat.mult(beaconMat);
 146
 147     if(getEnable() == true)
 148     {
 149               GLdouble  glEq[4];
 150         const Vec4f    &eq = getEquation();
 151
 152         glEq[0] = eq[0];
 153         glEq[1] = eq[1];
 154         glEq[2] = eq[2];
 155         glEq[3] = eq[3];
 156
 157         glPushMatrix();
 158         glLoadMatrixf(cameraMat.getValues());
 159
 160         glClipPlane( GL_CLIP_PLANE0 + idx, glEq);
 161         glEnable( GL_CLIP_PLANE0 + idx);
 162
 163         glPopMatrix();
 164     }
 165 #else
 166     OSG_ASSERT(false);
 167 #endif
 168 }
 169
 170
 171
 172
 173 void ClipPlaneChunk::changeFrom(DrawEnv    *pEnv,
 174                                 StateChunk *old_chunk,
 175                                 UInt32      idx)
 176 {
 177 #if !defined(OSG_OGL_COREONLY) || defined(OSG_CHECK_COREONLY)
 178     ClipPlaneChunk const *old = dynamic_cast<ClipPlaneChunk const*>(old_chunk);
 179
 180     // change from me to me?
 181     // this assumes I haven't changed in the meantime.
 182     // is that a valid assumption?
 183
 184     if(old == this)
 185         return;
 186
 187     pEnv->incNumChunkChanges();
 188
 189     Matrix beaconMat;
 190
 191     Matrix cameraMat = pEnv->getCameraViewing();
 192
 193     if(getBeacon() != NULL)
 194     {
 195         getBeacon()->getToWorld(beaconMat);
 196     }
 197     else
 198     {
 199         beaconMat.setIdentity();
 200
 201         SWARNING << "ClipPlaneChunk::changeFrom: NO beacon" << std::endl;
 202     }
 203
 204     cameraMat.mult(beaconMat);
 205
 206     if(getEquation() != old->getEquation() ||
 207        getEnable  () != old->getEnable  () ||
 208        getBeacon  () != old->getBeacon  ()   )
 209     {
 210         if(getEnable() == true)
 211         {
 212             GLdouble     glEq[4];
 213             const Vec4f &eq = getEquation();
 214
 215             glEq[0] = eq[0];
 216             glEq[1] = eq[1];
 217             glEq[2] = eq[2];
 218             glEq[3] = eq[3];
 219
 220             glPushMatrix();
 221             glLoadMatrixf(cameraMat.getValues());
 222
 223             glClipPlane(GL_CLIP_PLANE0 + idx, glEq);
 224             glEnable   (GL_CLIP_PLANE0 + idx      );
 225
 226             glPopMatrix();
 227         }
 228         else
 229         {
 230             glDisable(GL_CLIP_PLANE0 + idx);
 231         }
 232     }
 233 #else
 234     OSG_ASSERT(false);
 235 #endif
 236 }
 237
 238
 239 void ClipPlaneChunk::deactivate(DrawEnv *, UInt32 idx)
 240 {
 241 #if !defined(OSG_OGL_COREONLY) || defined(OSG_CHECK_COREONLY)
 242     if(getEnable() == true)
 243     {
 244         glDisable( GL_CLIP_PLANE0 + idx);
 245     }
 246 #else
 247     OSG_ASSERT(false);
 248 #endif
 249 }
 250
 251
 252 /*-------------------------- Comparison -----------------------------------*/
 253
 254 Real32 ClipPlaneChunk::switchCost(StateChunk *OSG_CHECK_ARG(chunk))
 255 {
 256     return 0;
 257 }
 258
 259 bool ClipPlaneChunk::operator < (const StateChunk &other) const
 260 {
 261     return this < &other;
 262 }
 263
 264 bool ClipPlaneChunk::operator == (const StateChunk &other) const
 265 {
 266     ClipPlaneChunk const *tother = dynamic_cast<ClipPlaneChunk const*>(&other);
 267
 268     if(!tother)
 269         return false;
 270
 271     if(getEnable() != tother->getEnable())
 272         return false;
 273
 274     if(getEquation() != tother->getEquation())
 275         return false;
 276
 277     if(getBeacon() != tother->getBeacon())
 278         return false;
 279
 280     return true;
 281 }
 282
 283 bool ClipPlaneChunk::operator != (const StateChunk &other) const
 284 {
 285     return ! (*this == other);
 286 }