DtIndirectOpenGLState.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2021 VT-MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/


#pragma once

#include <vrvOsg/vrvOsg.h>

#include <vrvOsg/DtIndirectPolygonOffset.h>
#include <vrvOsg/DtIndirectBlendFunction.h>
#include <vrvOsg/DtIndirectBlendEquation.h>

#include <vrvGraphicsUtils/DtCommonTypes.h>

namespace makVrv
{
   class DT_DLL_VRVOSG DtIndirectOpenGLState
   {
   public:
      DtIndirectOpenGLState(bool cullFaceEnabled
         , bool blendingEnabled, bool alphaToCoverageEnabled
         , const DtIndirectBlendFunction& blendFunction, const DtIndirectBlendEquation& blendEquation
         , const DtIndirectPolygonOffset& polyOffset, GLenum primitiveType
         , bool depthOnly);
  
      ~DtIndirectOpenGLState();

      DtIndirectOpenGLState();

      DtIndirectOpenGLState &operator=(const DtIndirectOpenGLState& other);

      DtIndirectOpenGLState(const DtIndirectOpenGLState& other);
     
   public:
      virtual bool cullFaceEnabled(void) const;
      virtual void setCullFaceEnabled(bool val);

      virtual void setPolygonOffset(const DtIndirectPolygonOffset& polyOffset);
      virtual const DtIndirectPolygonOffset& polygonOffset(void) const;

      virtual bool blendingEnabled(void) const;
      virtual void setBlendingEnabled(bool val);

      virtual bool alphaToCoverageEnabled(void) const;
      virtual void setAlphaToCoverageEnabled(bool val);

      virtual void setBlendFunction(const DtIndirectBlendFunction& blendFunction);
      virtual const DtIndirectBlendFunction& blendFunction(void) const;

      virtual void setBlendEquation(const DtIndirectBlendEquation& blendEquation);
      virtual const DtIndirectBlendEquation& blendEquation(void) const;

      virtual void setDepthOnly(bool val);
      virtual const bool depthOnly(void) const;
      
      virtual void apply() const;

      virtual const SetInts& modes(void) const;

      virtual const SetInts& attributes(void) const;

      virtual bool operator==(const DtIndirectOpenGLState& rhs) const;

      virtual bool operator!=(const DtIndirectOpenGLState& rhs) const;
      
      virtual GLenum primitiveType() const;

   public:
      
      //Sets up a DtIndirectOpenGLState object to use for light sources since it is constant and needs to match in a few places.
      static DtIndirectOpenGLState lightSourceState();

   protected:
      bool myCullFaceEnabled;

      bool myBlendingEnabled;

      bool myAlphaToCoverageEnabled;

      DtIndirectBlendFunction myBlendFunction;

      DtIndirectBlendEquation myBlendEquation;

      DtIndirectPolygonOffset myPolygonOffset;

      GLenum myPrimitiveType;

      // pseudo-state
      // this isn't really a depth only bin, it just says, that transparent polygons
      // are drawn with alpha testing off (alpha func set such that alpha testing is off)
      // are drawn _after_ regular stuff and before the ocean, with
      bool myDepthOnly;

      SetInts mySetModes;
      SetInts mySetAttributes;
   };

   std::ostream& operator <<(std::ostream& o, const DtIndirectOpenGLState& stateset);

   struct DtIndirectOpenGLStateHasher
   {
      size_t operator()(const DtIndirectOpenGLState& key) const;
   };
  
}