Source/System/Window/Base/OSGWindow.inl

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *                     Copyright 2000-2002 by OpenSG Forum                   *
   6  *                                                                           *
   7  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
   8  *                                                                           *
   9 \*---------------------------------------------------------------------------*/
  10 /*---------------------------------------------------------------------------*\
  11  *                                License                                    *
  12  *                                                                           *
  13  * This library is free software; you can redistribute it and/or modify it   *
  14  * under the terms of the GNU Library General Public License as published    *
  15  * by the Free Software Foundation, version 2.                               *
  16  *                                                                           *
  17  * This library is distributed in the hope that it will be useful, but       *
  18  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  20  * Library General Public License for more details.                          *
  21  *                                                                           *
  22  * You should have received a copy of the GNU Library General Public         *
  23  * License along with this library; if not, write to the Free Software       *
  24  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
  25  *                                                                           *
  26 \*---------------------------------------------------------------------------*/
  27 /*---------------------------------------------------------------------------*\
  28  *                                Changes                                    *
  29  *                                                                           *
  30  *                                                                           *
  31  *                                                                           *
  32  *                                                                           *
  33  *                                                                           *
  34  *                                                                           *
  35 \*---------------------------------------------------------------------------*/
  36
  37 OSG_BEGIN_NAMESPACE
  38
  39 /*------------------------------- size ----------------------------------*/
  40
  41 /*! Set the width and height of the Window. Only use if you really know what
  42     you're doing. In most cases resize() is a better choice.
  43  */
  44
  45 inline
  46 void Window::setSize(UInt16 width, UInt16 height)
  47 {
  48     setHeight(height);
  49     setWidth(width);
  50 }
  51
  52 /*! Check if the window has the indicated extension.
  53     \warning No error checks are done on the passed index!
  54  */
  55
  56 inline
  57 bool Window::hasExtension(UInt32 extId)
  58 {
  59     return (_availExtensions[extId] & !_sfIgnoreAllExtensions.getValue());
  60 }
  61
  62 inline
  63 bool Window::hasExtOrVersion(UInt32 extId,
  64                              UInt32 uiGLVersion,
  65                              UInt32 uiGLESVersion)
  66 {
  67 #if defined(OSG_OGL_ES2)
  68     return
  69         ((uiGLESVersion <= _glVersion) ||
  70         (_availExtensions[extId] & !_sfIgnoreAllExtensions.getValue()));
  71 #else
  72     return
  73         ((uiGLVersion <= _glVersion) ||
  74          (_availExtensions[extId] & !_sfIgnoreAllExtensions.getValue()));
  75 #endif
  76 }
  77
  78 /*! Check if the window has the indicated extension.
  79     If extId is out of range, then automatically returns false.
  80  */
  81 inline
  82 bool Window::hasCommonExtension(UInt32 extId)
  83 {
  84     if(extId >= _commonExtensions.size())
  85         return false;
  86
  87     return _commonExtensions[extId];
  88 }
  89
  90 /*! Get the indicated extension function.
  91     The id and the returned functions are checked for sanity and a warning is
  92     issued if there are problems. Use getFunctionNoCheck if you're sure you
  93     don't need them.
  94  */
  95
  96 inline
  97 Window::GLExtensionFunction Window::getFunction(UInt32 funcId)
  98 {
  99     if(_sfIgnoreAllExtensions.getValue() == true)
 100     {
 101         return NULL;
 102     }
 103
 104     if(funcId >= _extFunctions.size())
 105     {
 106         FINFO(("Window::getFunction: illegal id %d!\n", funcId));
 107         return NULL;
 108     }
 109
 110     if(_extFunctions[funcId] == NULL)
 111     {
 112         FINFO(("Window::getFunction: function \"%s\" is NULL!\n",
 113                     _registeredFunctions[funcId].c_str()));
 114         return NULL;
 115     }
 116
 117     return _extFunctions[funcId];
 118 }
 119
 120 /*! Get the indicated extension function.
 121     \warning No error checks are done on the passed index nor on the returned
 122     function!
 123  */
 124
 125 inline
 126 Window::GLExtensionFunction Window::getFunctionNoCheck(UInt32 funcId)
 127 {
 128     if(_sfIgnoreAllExtensions.getValue() == true)
 129         return NULL;
 130
 131     return _extFunctions[ funcId ];
 132 }
 133
 134 /*! Return the value of the registered constant, Inf if not registered
 135     or no value received yet.
 136 */
 137
 138 inline
 139 Real32 Window::getConstantValue(GLenum val)
 140 {
 141     return getConstantValuev(val)[0];
 142 }
 143
 144 /*! Set the library name where to find OpenGL extension functions. This has
 145     to be called before the first extension function is accessed, and it's
 146     safe to call it before osgInit().
 147  */
 148
 149 inline
 150 void Window::setGLLibraryName(const Char8 *s)
 151 {
 152     _glLibraryName = s;
 153 }
 154
 155 /*! Return the version of OpenGL running in the Window in the form
 156     0x&lt;major&gt;&lt;major&gt;&lt;minor&gt;&lt;minor&gt;, e.g. 0x0201 for
 157     version 2.1.
 158  */
 159
 160 inline
 161 UInt32 Window::getGLVersion(void)
 162 {
 163     return _glVersion;
 164 }
 165
 166 /*! Return the id of a registered extension. Return -1 if extension not
 167     registered.
 168  */
 169 inline
 170 Int32 Window::getExtensionIdX(const Char8  *s)
 171 {
 172     std::vector<std::string>::iterator it;
 173
 174     it = std::find(_registeredExtensions.begin(),
 175                    _registeredExtensions.end(),
 176                     s);
 177
 178     if(it == _registeredExtensions.end())
 179         return -1;
 180
 181     return Int32(it -_registeredExtensions.begin());
 182 }
 183
 184 /*! Access the available extensions.
 185  */
 186
 187 inline
 188 const std::vector<std::string> &Window::getExtensions(void)
 189 {
 190     return _extensions;
 191 }
 192
 193 /*! Reutrn the list of registered extensions.
 194  */
 195 inline
 196 const std::vector<std::string> &Window::getRegisteredExtensions(void)
 197 {
 198     return _registeredExtensions;
 199 }
 200
 201 /*! Access the registered functions.
 202  */
 203 inline
 204 const std::vector<std::string> &Window::getRegisteredFunctions(void)
 205 {
 206     return _registeredFunctions;
 207 }
 208
 209 /*! Access the ignored extensions.
 210 */
 211 inline
 212 const std::vector<std::string> &Window::getIgnoredExtensions(void)
 213 {
 214     return _ignoredExtensions;
 215 }
 216
 217 inline
 218 void Window::setGLObjectId(UInt32 osgId, GLObjectId id2)
 219 {
 220     if(osgId < _ids.size())
 221     {
 222         _ids[osgId] = id2;
 223     }
 224     else
 225     {
 226         _ids.resize(_glObjects.size(), 0);
 227
 228         if(osgId < _ids.size())
 229         {
 230             _ids[osgId] = id2;
 231         }
 232         else
 233         {
 234             SWARNING << "Window::setGLObjectId: id ("
 235                      << osgId
 236                      << ") is not valid!"
 237                      << std::endl;
 238         }
 239     }
 240 }
 241
 242 inline
 243 Window::GLObjectId Window::getGLObjectId(UInt32 osgId)
 244 {
 245     if(osgId < _ids.size())
 246         return _ids[osgId];
 247
 248     return 0;
 249 }
 250
 251 inline
 252 void Window::setGLObjectInfo(UInt32 osgId, GLObjectId info)
 253 {
 254     if(osgId < _idInfo.size())
 255     {
 256         _idInfo[osgId] = info;
 257     }
 258     else
 259     {
 260         _idInfo.resize(_glObjects.size(), 0);
 261
 262         if(osgId < _idInfo.size())
 263         {
 264             _idInfo[osgId] = info;
 265         }
 266         else
 267         {
 268             SWARNING << "Window::setGLObjectId: id ("
 269                      << osgId
 270                      << ") is not valid!"
 271                      << std::endl;
 272         }
 273     }
 274 }
 275
 276 inline
 277 Window::GLObjectId Window::getGLObjectInfo(UInt32 osgId)
 278 {
 279     if(osgId < _idInfo.size())
 280         return _idInfo[osgId];
 281
 282     return 0;
 283 }
 284
 285 inline
 286 UInt32 Window::getGLObjectsSize(void)
 287 {
 288     return UInt32(_glObjects.size());
 289 }
 290
 291 /* GLObject helper class */
 292
 293 inline
 294 Window::GLObject::GLObject(GLObjectFunctor        funct,
 295                            GLObjectDestroyFunctor destroy) :
 296     _functor     (funct  ),
 297     _destroy     (destroy),
 298     _refCounter  (      0)
 299 {
 300 }
 301
 302 inline
 303 void Window::GLObject::acquireLock(void)
 304 {
 305     if(! _GLObjectLock)
 306     {
 307         _GLObjectLock =
 308             ThreadManager::the()->getLock("OSG::Window::_GLObjectLock", false);
 309     }
 310
 311     _GLObjectLock->acquire();
 312 }
 313
 314 inline
 315 void Window::GLObject::releaseLock(void)
 316 {
 317     OSG_ASSERT(_GLObjectLock != NULL);
 318
 319     _GLObjectLock->release();
 320 }
 321
 322 inline
 323 Window::GLObjectFunctor &Window::GLObject::getFunctor(void)
 324 {
 325     return _functor;
 326 }
 327
 328 inline
 329 void Window::GLObject::setFunctor(GLObjectFunctor funct)
 330 {
 331     _functor = funct;
 332 }
 333
 334 inline
 335 Window::GLObjectDestroyFunctor &Window::GLObject::getDestroyFunctor(void)
 336 {
 337     return _destroy;
 338 }
 339
 340 inline
 341 void Window::GLObject::setDestroyFunctor(GLObjectDestroyFunctor funct)
 342 {
 343     _destroy = funct;
 344 }
 345
 346 inline
 347 UInt32 Window::GLObject::getRefCounter(void)
 348 {
 349     return _refCounter;
 350 }
 351
 352 inline
 353 UInt32 Window::GLObject::incRefCounter(void)
 354 {
 355     UInt32 val;
 356
 357     acquireLock();
 358
 359     val = _refCounter = _refCounter + 1;
 360
 361     releaseLock();
 362
 363     return val;
 364 }
 365
 366 inline
 367 UInt32 Window::GLObject::decRefCounter(void)
 368 {
 369     UInt32 val;
 370
 371     acquireLock();
 372
 373     if(_refCounter)
 374     {
 375         val = _refCounter = _refCounter - 1;
 376     }
 377     else
 378     {
 379         val = 0;
 380     }
 381
 382     releaseLock();
 383
 384     return val;
 385 }
 386
 387 inline
 388 TraversalValidator *Window::getTravValidator(void)
 389 {
 390     return _pTravValidator;
 391 }
 392
 393 inline
 394 ShaderCache *Window::getShaderCache(void)
 395 {
 396     return _pShaderCache;
 397 }
 398
 399 inline
 400 void Window::setPartitionDrawMode(UInt32 uiMode)
 401 {
 402     if(0x0000 == (uiMode & PartitionDrawMask))
 403     {
 404         FWARNING(("Window: invalid draw mode\n"));
 405         return;
 406     }
 407
 408     editSField(DrawModeFieldMask);
 409
 410     _sfDrawMode.setValue(
 411         (_sfDrawMode.getValue() & ~PartitionDrawMask) |
 412         (uiMode                 &  PartitionDrawMask) );
 413 }
 414
 415 inline
 416 void Window::setDrawerType(UInt32 uiDrawerType)
 417 {
 418     if(0x0000 == (uiDrawerType & DrawerMask))
 419     {
 420         FWARNING(("Window: invalid drawer type\n"));
 421         return;
 422     }
 423
 424     editSField(DrawModeFieldMask);
 425
 426     _sfDrawMode.setValue((_sfDrawMode.getValue() & ~DrawerMask) |
 427                          (uiDrawerType           &  DrawerMask) );
 428 }
 429
 430 inline
 431 UInt32 Window::getPartitionDrawMode(void) const
 432 {
 433     return _sfDrawMode.getValue() & PartitionDrawMask;
 434 }
 435
 436 inline
 437 UInt32 Window::getDrawerType(void) const
 438 {
 439     return _sfDrawMode.getValue() & DrawerMask;
 440 }
 441
 442 inline
 443 void DrawTask::setupContext(Window *pWindow)
 444 {
 445 }
 446
 447 inline
 448 void DrawTask::finalizeContext(Window *pWindow)
 449 {
 450 }
 451
 452 OSG_END_NAMESPACE