DtOsgUtils.h

Go to the documentation of this file.

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


#pragma once

#include <osg/Quat>
#include <osg/Texture2DArray>
#include <osg/Depth>
#include <osg/Camera>
#include <osg/MatrixTransform>
#include <osg/Geometry>

#include <vrvOsg/DtOsgShaderUtils.h>
#include <vrvGraphicsUtils/DtCameraFwdDeclare.h>

class DtTaitBryan;

namespace makVrv
{
   class DtGlSimpleTexture;

   class DtOsgDebugFrustum : public osg::Referenced
   {
   public:
       DtOsgDebugFrustum(const osg::Vec4 & color);
       void updateDebugFrustum(osg::Vec3d * frustumVertices);

       osg::ref_ptr<osg::MatrixTransform> myTransform;
       osg::ref_ptr<osg::Geometry> myGeometry;
   };

   class DT_DLL_VRVOSG DtOsgOverlayUtils
   {
   public:
      static osg::Camera* CreateTextureQuadOverlay(DtGlSimpleTexture* texture,
         float x, float y, float w, float h);

      static osg::Camera* CreateTextureQuadOverlay(osg::Texture* texture,
         float x, float y, float w, float h);

      static osg::Camera* CreateTextureQuadOverlay(const std::string& shader_root, osg::Texture2DArray* textureArray,
         float x, float y, float w, float h);
   };

   class DT_DLL_VRVOSG DtOsgUtils
   {
   public:
       static void makeRotate(osg::Quat& q, const double& angle, const double& x, const double& y, const double& z);

       static osg::Matrixf toOsgRotation(const DtTaitBryan& orientation);

       static void quatMult(osg::Quat& lhs, const osg::Quat& rhs);

       static osg::MatrixTransform * create_axis_primitive();


       static osg::Matrix getOrthoMatrix(bool useReverseZ, double left, double right, 
          double bottom, double top, double zNear, double zFar);

       static osg::Matrix getProjMatrix(bool useReverseZ, double left, double right,
          double bottom, double top, double zNear, double zFar);

       static osg::Matrixd getRevZOrthoMatrix(double left, double right, double bottom,
          double top, double zNear, double zFar);

       static bool getRevZPerspectiveMatrixAsFrustum(const osg::Matrix& mat, double& left,
          double& right, double& bottom, double& top, double& zNear, double& zFar);

       static bool getRevZOrthoMatrixAsFrustum(const osg::Matrix& orthoMat, double& left,
          double& right, double& bottom, double& top, double& zNear, double& zFar);

       static bool getRevZPerspective(const osg::Matrix& mat, double& fovy,
          double& aspectRatio, double& zNear, double& zFar);

       static osg::Matrix makeRevZPerspective(double fovy, double aspectRatio,
          double zNear, double zFar);

       static void getYPR(const osg::Matrix& m, double& yaw, double& pitch, double& roll);

       static void osgPolytopeToFrustum(Frustum_64& frustum, const osg::Polytope& polytope, bool hasNearFar);
       
       static void computeOsgCameraFrustumPlanes(std::vector<osg::Vec4d>& planes, const osg::Camera* camera);

       static void debugDumpShaderState(osg::State* state);

       static void debugDumpUniformState(const osg::Node* node);


       static osg::Vec2 rotateVec2( const osg::Vec2& v, double rad );

       static osg::Vec2 translateVec2( const osg::Vec2& v, const osg::Vec2& translation );

       static osg::Vec2 scaleVec2( const osg::Vec2& v, double s );

       static osg::Vec2 scaleVec2( const osg::Vec2& v, double xScale, double yScale );

       static bool clipLine( double xMin, double xMax, double yMin, double yMax,
          double x0src, double y0src, double x1src, double y1src,
          double &x0clip, double &y0clip, double &x1clip, double &y1clip );

       static void clipPolygon( double xMin, double xMax, double yMin, double yMax, 
          std::vector<osg::Vec2>& vertices );

       // Adapted from VR-Link DtModPerLo [matrix/modper.cxx]
       template <class VecType> static VecType DtModPerLoVec3( const VecType& in, double min, double max )
       {
          VecType result;
          double per = max - min;

          for( int i = 0; i < 3; ++i )
          {
             if( min <= in[i] && in[i] < max )
             {
                result[i] = in[i];
             }
             else
             {
                result[i] = fmod( in[i] - min, per );

                if( result[i] < 0.0 )
                {
                   result[i] += per;
                }

                result[i] += min;
             }
          }
          return result;
       }
      
      static bool insideTriangulate( const std::vector<osg::Vec2>& contour, std::vector<int>& results );

      static osg::Matrixd calculateRevZProjectionMatrix(double left, double right
         , double bottom, double top
         , double zNear, double zFar);

      static osg::Matrixd calculateOrthoMatrix(double left, double right
         , double bottom, double top
         , double zNear, double zFar);

      static osg::Matrixd calculateRevZProjectionMatrixWithRevZAsNegativeOneForRttCamera(double left, double right
         , double bottom, double top
         , double zNear, double zFar);

   protected:
      static bool snipTriangle( const std::vector<osg::Vec2>& contour, int u, int v, int w, int n, int *V );
      static bool insideTriangle( float Ax, float Ay, float Bx, float By, float Cx, float Cy, float Px, float Py );
      static float triangulateAreaSize( const std::vector<osg::Vec2> &contour );


   };
}