simgear/canvas/ODGauge.cxx

   1 // Owner Drawn Gauge helper class
   2 //
   3 // Written by Harald JOHNSEN, started May 2005.
   4 //
   5 // Copyright (C) 2005  Harald JOHNSEN
   6 //
   7 // Ported to OSG by Tim Moore - Jun 2007
   8 //
   9 // Heavily modified to be usable for the 2d Canvas by Thomas Geymayer - April 2012
  10 // Supports now multisampling/mipmapping, usage of the stencil buffer and placing
  11 // the texture in the scene by certain filter criteria
  12 //
  13 // This library is free software; you can redistribute it and/or
  14 // modify it under the terms of the GNU Library General Public
  15 // License as published by the Free Software Foundation; either
  16 // version 2 of the License, or (at your option) any later version.
  17 //
  18 // This library is distributed in the hope that it will be useful,
  19 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  20 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21 // Library General Public License for more details.
  22 //
  23 // You should have received a copy of the GNU Library General Public
  24 // License along with this library; if not, write to the Free Software
  25 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  26
  27 #ifdef HAVE_CONFIG_H
  28 #  include <simgear_config.h>
  29 #endif
  30
  31 #include "ODGauge.hxx"
  32 #include "CanvasSystemAdapter.hxx"
  33
  34 #include <simgear/debug/logstream.hxx>
  35 #include <simgear/scene/util/RenderConstants.hxx>
  36
  37 #include <osg/Texture2D>
  38 #include <osg/AlphaFunc>
  39 #include <osg/BlendFunc>
  40 #include <osg/Camera>
  41 #include <osg/Matrix>
  42 #include <osg/PolygonMode>
  43 #include <osg/ShadeModel>
  44 #include <osg/StateSet>
  45 #include <osg/FrameBufferObject> // for GL_DEPTH_STENCIL_EXT on Windows
  46
  47 #include <cassert>
  48
  49 namespace simgear
  50 {
  51 namespace canvas
  52 {
  53
  54   //----------------------------------------------------------------------------
  55   ODGauge::ODGauge():
  56     _size_x( -1 ),
  57     _size_y( -1 ),
  58     _view_width( -1 ),
  59     _view_height( -1 ),
  60     _use_image_coords( false ),
  61     _use_stencil( false ),
  62     _use_mipmapping( false ),
  63     _coverage_samples( 0 ),
  64     _color_samples( 0 ),
  65     rtAvailable( false )
  66   {
  67
  68   }
  69
  70   //----------------------------------------------------------------------------
  71   ODGauge::~ODGauge()
  72   {
  73     clear();
  74   }
  75
  76   //----------------------------------------------------------------------------
  77   void ODGauge::setSystemAdapter(const SystemAdapterPtr& system_adapter)
  78   {
  79     _system_adapter = system_adapter;
  80   }
  81
  82   //----------------------------------------------------------------------------
  83   void ODGauge::setSize(int size_x, int size_y)
  84   {
  85     _size_x = size_x;
  86     _size_y = size_y < 0 ? size_x : size_y;
  87
  88     if( serviceable() )
  89       reinit();
  90     else if( texture )
  91       texture->setTextureSize(_size_x, _size_y);
  92   }
  93
  94   //----------------------------------------------------------------------------
  95   void ODGauge::setViewSize(int width, int height)
  96   {
  97     _view_width = width;
  98     _view_height = height < 0 ? width : height;
  99
 100     if( camera )
 101       updateCoordinateFrame();
 102   }
 103
 104   //----------------------------------------------------------------------------
 105   void ODGauge::useImageCoords(bool use)
 106   {
 107     if( use == _use_image_coords )
 108       return;
 109
 110     _use_image_coords = use;
 111
 112     if( texture )
 113       updateCoordinateFrame();
 114   }
 115
 116   //----------------------------------------------------------------------------
 117   void ODGauge::useStencil(bool use)
 118   {
 119     if( use == _use_stencil )
 120       return;
 121
 122     _use_stencil = use;
 123
 124     if( texture )
 125       updateStencil();
 126   }
 127
 128   //----------------------------------------------------------------------------
 129   void ODGauge::setSampling( bool mipmapping,
 130                                int coverage_samples,
 131                                int color_samples )
 132   {
 133     if(    _use_mipmapping == mipmapping
 134         && _coverage_samples == coverage_samples
 135         && _color_samples == color_samples )
 136       return;
 137
 138     _use_mipmapping = mipmapping;
 139
 140     if( color_samples > coverage_samples )
 141     {
 142       SG_LOG
 143       (
 144         SG_GL,
 145         SG_WARN,
 146         "ODGauge::setSampling: color_samples > coverage_samples not allowed!"
 147       );
 148       color_samples = coverage_samples;
 149     }
 150
 151     _coverage_samples = coverage_samples;
 152     _color_samples = color_samples;
 153
 154     updateSampling();
 155   }
 156
 157   //----------------------------------------------------------------------------
 158   void ODGauge::setRender(bool render)
 159   {
 160     // Only the far camera should trigger this texture to be rendered.
 161     camera->setNodeMask(render ? simgear::BACKGROUND_BIT : 0);
 162   }
 163
 164   //----------------------------------------------------------------------------
 165   bool ODGauge::serviceable(void)
 166   {
 167     return rtAvailable;
 168   }
 169
 170   //----------------------------------------------------------------------------
 171   void ODGauge::allocRT(osg::NodeCallback* camera_cull_callback)
 172   {
 173     camera = new osg::Camera;
 174     camera->setDataVariance(osg::Object::DYNAMIC);
 175     camera->setReferenceFrame(osg::Transform::ABSOLUTE_RF);
 176     camera->setRenderOrder(osg::Camera::PRE_RENDER);
 177     camera->setClearColor(osg::Vec4(0.0f, 0.0f, 0.0f , 0.0f));
 178     camera->setClearStencil(0);
 179     camera->setRenderTargetImplementation( osg::Camera::FRAME_BUFFER_OBJECT,
 180                                                osg::Camera::FRAME_BUFFER );
 181
 182     if( camera_cull_callback )
 183       camera->setCullCallback(camera_cull_callback);
 184
 185     setRender(true);
 186     updateCoordinateFrame();
 187     updateStencil();
 188
 189     osg::StateSet* stateSet = camera->getOrCreateStateSet();
 190     stateSet->setMode(GL_LIGHTING, osg::StateAttribute::OFF);
 191     stateSet->setMode(GL_CULL_FACE, osg::StateAttribute::OFF);
 192     stateSet->setMode(GL_FOG, osg::StateAttribute::OFF);
 193     stateSet->setMode(GL_DEPTH_TEST, osg::StateAttribute::OFF);
 194     stateSet->setAttributeAndModes(
 195       new osg::PolygonMode( osg::PolygonMode::FRONT_AND_BACK,
 196                             osg::PolygonMode::FILL ),
 197       osg::StateAttribute::ON );
 198     stateSet->setAttributeAndModes(
 199       new osg::AlphaFunc(osg::AlphaFunc::GREATER, 0.0f),
 200       osg::StateAttribute::ON );
 201     stateSet->setAttribute(new osg::ShadeModel(osg::ShadeModel::FLAT));
 202     stateSet->setAttributeAndModes(
 203       new osg::BlendFunc( osg::BlendFunc::SRC_ALPHA,
 204                           osg::BlendFunc::ONE_MINUS_SRC_ALPHA),
 205       osg::StateAttribute::ON );
 206     if( !texture )
 207     {
 208       texture = new osg::Texture2D;
 209       texture->setTextureSize(_size_x, _size_y);
 210       texture->setInternalFormat(GL_RGBA);
 211     }
 212
 213     updateSampling();
 214
 215     if( _system_adapter )
 216       _system_adapter->addCamera(camera.get());
 217
 218     rtAvailable = true;
 219   }
 220
 221   //----------------------------------------------------------------------------
 222   void ODGauge::reinit()
 223   {
 224     osg::NodeCallback* cull_callback = camera ? camera->getCullCallback() : 0;
 225     clear();
 226     allocRT(cull_callback);
 227   }
 228
 229   //----------------------------------------------------------------------------
 230   void ODGauge::clear()
 231   {
 232     if( camera.valid() && _system_adapter )
 233       _system_adapter->removeCamera(camera.get());
 234     camera.release();
 235     texture.release();
 236
 237     rtAvailable = false;
 238   }
 239
 240   //----------------------------------------------------------------------------
 241   void ODGauge::updateCoordinateFrame()
 242   {
 243     assert( camera );
 244
 245     if( _view_width < 0 )
 246       _view_width = _size_x;
 247     if( _view_height < 0 )
 248       _view_height = _size_y;
 249
 250     camera->setViewport(0, 0, _size_x, _size_y);
 251
 252     if( _use_image_coords )
 253       camera->setProjectionMatrix(
 254         osg::Matrix::ortho2D(0, _view_width, _view_height, 0)
 255       );
 256     else
 257       camera->setProjectionMatrix(
 258         osg::Matrix::ortho2D( -_view_width/2.,  _view_width/2.,
 259                               -_view_height/2., _view_height/2. )
 260       );
 261   }
 262
 263   //----------------------------------------------------------------------------
 264   void ODGauge::updateStencil()
 265   {
 266     assert( camera );
 267
 268     GLbitfield mask = GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT;
 269
 270     if( _use_stencil)
 271     {
 272       camera->attach( osg::Camera::PACKED_DEPTH_STENCIL_BUFFER,
 273                        GL_DEPTH_STENCIL_EXT );
 274       mask |= GL_STENCIL_BUFFER_BIT;
 275     }
 276     else
 277     {
 278       camera->detach(osg::Camera::PACKED_DEPTH_STENCIL_BUFFER);
 279     }
 280
 281     camera->setClearMask(mask);
 282   }
 283
 284   //----------------------------------------------------------------------------
 285   void ODGauge::updateSampling()
 286   {
 287     assert( camera );
 288     assert( texture );
 289
 290     texture->setFilter(
 291       osg::Texture2D::MIN_FILTER,
 292       _use_mipmapping ? osg::Texture2D::LINEAR_MIPMAP_LINEAR
 293                       : osg::Texture2D::LINEAR
 294     );
 295     camera->attach(
 296       osg::Camera::COLOR_BUFFER,
 297       texture.get(),
 298       0, 0,
 299       _use_mipmapping,
 300       _coverage_samples,
 301       _color_samples
 302     );
 303   }
 304
 305 } // namespace canvas
 306 } // namespace simgear