global_light_mgr.h

Go to the documentation of this file.

/*! \file
  \brief  The disti::GlobalLightMgr.
 
  \par Copyright Information
 
  Copyright (c) 2017 by The DiSTI Corporation.<br>
  11301 Corporate Blvd; Suite 100<br>
  Orlando, Florida 32817<br>
  USA<br>
  <br>
  All rights reserved.<br>
 
  This Software contains proprietary trade secrets of DiSTI and may not be
reproduced, in whole or part, in any form, or by any means of electronic,
mechanical, or otherwise, without the written permission of DiSTI.  Said
permission may be derived through the purchase of applicable DiSTI product
licenses which detail the distribution rights of this content and any
Derivative Works based on this or other copyrighted DiSTI Software.
 
  NO WARRANTY. THE SOFTWARE IS PROVIDED "AS-IS," WITHOUT WARRANTY OF ANY KIND,
AND ANY USE OF THIS SOFTWARE PRODUCT IS AT YOUR OWN RISK. TO THE MAXIMUM EXTENT
PERMITTED BY APPLICABLE LAW, DISTI AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES
AND CONDITIONS, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
IMPLIED WARRANTIES AND CONDITIONS OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE, TITLE, AND NON-INFRINGEMENT, WITH REGARD TO THE SOFTWARE.
 
  LIMITATION OF LIABILITY. TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW,
IN NO EVENT SHALL DISTI OR ITS SUPPLIERS BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
INDIRECT, OR CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION,
DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS
INFORMATION, OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE USE OF OR
INABILITY TO USE THE SOFTWARE, EVEN IF DISTI HAS BEEN ADVISED OF THE POSSIBILITY
OF SUCH DAMAGES.  DISTI'S ENTIRE LIABILITY AND YOUR EXCLUSIVE REMEDY SHALL NOT
EXCEED FIVE DOLLARS (US$5.00).
 
  The aforementioned terms and restrictions are governed by the laws of the
State of Florida and the United States of America.
 
*/
#ifndef INCLUDED_DISTI_GLOBAL_LIGHT_MGR_H
#define INCLUDED_DISTI_GLOBAL_LIGHT_MGR_H
 
#include "dynamic_array.h"
#include "gls_cpp_lang_support.h"
#include "gls_include.h"
#include "util.h"
 
namespace disti
{
class GlsLightSource;
class GlsEyePoint;
class GlobalLightMgrThreadMap;
 
/// \details This singleton class is responsible for keeping track of the GlsLightSource objects
/// currently affecting the OpenGL lighting state and changing the state when needed.
class GlobalLightMgr DISTI_FINAL
{
public:
    /** List of the currently active lights
      * The number of the light is equal to it's array index.
      * (i.e. The light at index 0 is GL_LIGHT0) */
    typedef DynamicArray<GlsLightSource*> LightingState;
 
protected:
    /** helper class for maintaining one global light mgr per calling thread */
    friend class GlobalLightMgrThreadMap;
 
    static GLS_EXPORT unsigned int MAX_OPENGL_LIGHTS;   ///< The value of glGetIntegerv(GL_MAX_LIGHTS);
    LightingState                  _currentOpenGLState; ///< The current OpenGL lighting state.
    LightingState                  _currentState;       ///< This will become the _currentOpenglState when a lit object draws.
    DynamicArray<GlsLightSource*>  _tempOpenGLLights;   ///< Store temporary light source pointers (only used in InitializeStateFromOpenGL).
    DynamicArray<LightingState>    _lightingStateStack; ///< As each component draws it will push it's lighting state on the stack.
 
    bool  _reapplyLights;   ///< If true, the lighting state will be recalculated.
    bool  _enableNormalize; ///< If true, GL_NORMALIZE will be enabled during lighting.
    bool* _activeLights;    ///< An array storing the current on/off state for each light.
 
    GLS_EXPORT GlobalLightMgr();
 
public:
    GLS_EXPORT ~GlobalLightMgr();
 
    /** \return  The singleton to the one instance of GlobalLightMgr*/
    static GLS_EXPORT GlobalLightMgr& Instance();
 
    /** \return The value of GL_MAX_LIGHTS */
    static unsigned int GlMaxLights() { return MAX_OPENGL_LIGHTS; }
 
    /** Push the current lighting state onto the stack */
    GLS_EXPORT void PushLightingState();
 
    /** Push the current lighting state off the stack */
    GLS_EXPORT void PopLightingState();
 
    /** Flags the need to reapply the lights.  This may
      * be necessary for special cases where the OpenGL matrices
      * have changed during a traversel.  This can
      * happen when drawing multiple views of the same
      * geometry.
      */
    void ReapplyLights() { _reapplyLights = true; }
 
    /** Set whether or not GL_NORMALIZE is enabled
      * \param enableNormalize  Set GL_NORMALIZE to true or false
      */
    static GLS_EXPORT void EnableNormalize( bool enableNormalize );
 
    /** Get the state of whether GL_NORMALIZE is enabled
      * \return Whether or not GL_NORMALIZE is enabled
      */
    static GLS_EXPORT bool EnableNormalize();
 
    /** Set the current lighting state to a new state
      * \param newState  The new lighting state
      */
    GLS_EXPORT void SetLightingState( const LightingState& newState );
 
#if defined( DISTI_HAS_RVAL_REFS )
    /** Set the current lighting state to a new state
      * \param newState  The new lighting state
      */
    void SetLightingState( LightingState&& newState )
    {
        _currentState = std::move( newState );
    }
#endif
 
    /** Get the current lighting state
      * \return  The current lighting state
      */
    GLS_EXPORT const LightingState& GetLightingState() const;
 
    /// Set OpenGL lighting state to match the current state.
    /// If relativeToEyepoint is set, the light will be applied
    /// using the modelview matrix calculated from the eyepoint to the light.
    /// \param relativeToEyepoint Optional eyepoint used to calculate modelview matrix to apply with the light.
    GLS_EXPORT void SetupLighting( GlsEyePoint* relativeToEyepoint = NULL /*(Top Level)*/ );
 
    /** Clear the lighting stack, create GlsLightSource objects based on the current
      * OpenGL lighting state and store them as the current state.
      */
    GLS_EXPORT void InitializeStateFromOpenGL();
 
    /** Restore the OpenGL state to what it was at the last call to InitializeStateFromOpenGL() */
    GLS_EXPORT void RestoreOpenGLState();
 
    /** Get a boolean mask of the active lights
      * \return A boolean array with a bitmask of the currently active lights
      */
    GLS_EXPORT bool* GetActiveLightsMask();
 
    /** Get a bitmask of the active lights
      * \return An unsigned integer with each bit representing a light turned on/off
      */
    GLS_EXPORT unsigned int GetActiveLightsBitMask();
 
    /** Get the number of active lights.  Really is the max index(+1) of lights that
      * you need to cycle through to have taken all of them into account (in case of
      * holes in the list created by an outside party).
      * \return An integer representing the (max) number of currently active lights
      */
    GLS_EXPORT unsigned int GetNumActiveLights();
};
 
} // namespace disti
 
#endif