TransparencyUtils.h

Go to the documentation of this file.

/*
Copyright 2007-2025. Algoryx Simulation AB.
 
All AGX source code, intellectual property, documentation, sample code,
tutorials, scene files and technical white papers, are copyrighted, proprietary
and confidential material of Algoryx Simulation AB. You may not download, read,
store, distribute, publish, copy or otherwise disseminate, use or expose this
material unless having a written signed agreement with Algoryx Simulation AB, or having been
advised so by Algoryx Simulation AB for a time limited evaluation, or having purchased a
valid commercial license from Algoryx Simulation AB.
 
Algoryx Simulation AB disclaims all responsibilities for loss or damage caused
from using this software, unless otherwise stated in written agreements with
Algoryx Simulation AB.
*/
 
#pragma once
 
#include <agxOSG/export.h>
 
#include <osg/Array>
#include <osg/Matrixf>
#include <osg/Drawable>
#include <osg/PrimitiveSet>
 
#include <array>
#include <numeric>
#include <algorithm>
#include <functional>
 
namespace osg
{
  class Geometry;
}
 
namespace agxOSG
{
  template<typename M1, typename M2>
  bool matrix4x4ExactlyEqual( const M1& m1, const M2& m2 )
  {
    static_assert( sizeof( M1 ) == sizeof( M2 ), "Expecting 4x4 matrices with the same value type." );
    for ( int r = 0; r < 4; ++r )
      for ( int c = 0; c < 4; ++c )
        if ( m1( r, c ) != m2( r, c ) )
          return false;
    return true;
  }
 
  class AGXOSG_EXPORT PrimitiveSetTriangleSorter
  {
    public:
      using TriangleVertexDepths = const std::array<float, 3u>&;
      using DepthReduceFunc = std::function<float( TriangleVertexDepths )>;
 
      template<typename TriangleBuffer>
      struct TriangleDepth
      {
        using Index = typename TriangleBuffer::value_type;
        using Indices = std::array<Index, 3u>;
 
        Indices indices;
        float depth;
      };
 
      static float minOf( TriangleVertexDepths depths );
 
      static float midOf( TriangleVertexDepths depths );
 
      static float maxOf( TriangleVertexDepths depths );
 
      static bool sort( osg::Geometry& geometry,
                        const osg::Matrixf& modelViewMatrix,
                        DepthReduceFunc depthReduce = midOf );
 
      template<typename TriangleBuffer>
      static bool impl( TriangleBuffer& triangles,
                        const osg::Vec3Array& vertices,
                        const osg::Matrixf& modelViewMatrix,
                        const DepthReduceFunc& depthReduce )
      {
        if ( triangles.empty() || ( triangles.size() % 3 ) != 0 || !depthReduce )
          return false;
 
        using TriangleType = TriangleDepth<TriangleBuffer>;
        using Triangles = std::vector<TriangleType>;
 
        const auto getDepth = [&modelViewMatrix, &vertices]( typename TriangleType::Index index ) -> float
        {
          return ( vertices[ index ] * modelViewMatrix ).z();
        };
 
        Triangles triangleDepths;
        triangleDepths.reserve( triangles.size() / 3 );
        for ( size_t i = 0u; i < triangles.size(); i += 3 ) {
          std::array indices{
            triangles[ i + 0 ],
            triangles[ i + 1 ],
            triangles[ i + 2 ],
          };
          triangleDepths.push_back( {
            indices,
            depthReduce( {
              getDepth( indices[ 0 ] ),
              getDepth( indices[ 1 ] ),
              getDepth( indices[ 2 ] )
            } )
          } );
        }
 
        std::stable_sort( triangleDepths.begin(),
                          triangleDepths.end(),
                          []( const TriangleType& t1, const TriangleType& t2 ) -> bool
                          {
                            return t1.depth < t2.depth;
                          } );
 
        for ( size_t t = 0u; t < triangleDepths.size(); ++t )
          for ( size_t i = 0u; i < 3u; ++i )
            triangles[ 3 * t + i ] = triangleDepths[ t ].indices[ i ];
 
        return true;
      }
  };
 
  inline float PrimitiveSetTriangleSorter::minOf( TriangleVertexDepths depths )
  {
    float min = std::numeric_limits<float>::infinity();
    for ( const auto depth : depths )
      min = std::min( depth, min );
    return min;
  }
 
  inline float PrimitiveSetTriangleSorter::midOf( TriangleVertexDepths depths )
  {
    return ( 1.0f / 3.0f ) * ( depths[ 0 ] + depths[ 1 ] + depths[ 2 ] );
  }
 
  inline float PrimitiveSetTriangleSorter::maxOf( TriangleVertexDepths depths )
  {
    float max = -std::numeric_limits<float>::infinity();
    for ( const auto depth : depths )
      max = std::max( depth, max );
    return max;
  }
 
 
  struct AGXOSG_EXPORT ModelViewMatrixFinder : osg::Drawable::CullCallback
  {
    using OnModelViewUpdated = std::function<void( const osg::Matrixf& )>;
 
    ModelViewMatrixFinder( OnModelViewUpdated onUpdated );
 
    ModelViewMatrixFinder() = default;
 
    virtual ~ModelViewMatrixFinder() = default;
 
    using osg::Drawable::CullCallback::cull;
 
    virtual bool cull( osg::NodeVisitor* visitor, osg::Drawable* drawable, osg::RenderInfo* renderInfo ) const override;
 
    OnModelViewUpdated onUpdated{};
    mutable bool isUpdated = false;
    mutable osg::Matrixf prevModelViewMatrix{};
    mutable osg::Matrixf modelViewMatrix{};
  };
 
  AGXOSG_EXPORT osg::StateSet& configureStateSet( osg::StateSet& stateSet, bool isTransparent );
}