DtIndirectAggregateIndicesHelper.h

Go to the documentation of this file.

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


#pragma once

#include <vrvOsg/vrvOsg.h>

#include <vrvGraphicsUtils/DtAssert.h>

#include <vlutil/vlPrint.h>

#include <osg/Geometry>

#include <string>
#include <vector>

#include <tbb/atomic.h>

namespace osg
{
   class Geometry;
}

namespace makVrv
{
   class DT_DLL_VRVOSG DtIndirectAggregateIndicesHelper
   {
   public:
      DtIndirectAggregateIndicesHelper(const std::string& modelName, const osg::ref_ptr<osg::Geometry>& aggregatedGeometry);

      virtual ~DtIndirectAggregateIndicesHelper();
   private:
      DtIndirectAggregateIndicesHelper() = delete;

      DtIndirectAggregateIndicesHelper(const DtIndirectAggregateIndicesHelper&) = delete;

      DtIndirectAggregateIndicesHelper& operator=(const DtIndirectAggregateIndicesHelper&) = delete;
   public:

      virtual bool checkSrcAndDstIndicesOk(const osg::Geometry& geometry);

      virtual void copyIndices(std::vector<int>& indices, const osg::Geometry& geometry);
      
      virtual void cancel();

      virtual bool isModeSupported(GLenum mode);

      virtual std::string toModeString(GLenum mode);

   public:
      static int calculateNumIndices(const osg::PrimitiveSet* primitiveSet);

   protected:

      virtual bool checkAndCopyIndicesIfTriangleElements(std::vector<int>& indices, const osg::PrimitiveSet* primitiveSet);

      virtual bool checkAndCopyIndicesIfDrawArrays(std::vector<int>& indices, const osg::PrimitiveSet* primitiveSet);

      virtual void printDetailsPrimitiveSets(const osg::Geometry& geometry);

   protected:

      template <class T>
      bool copyIndicesOnMatch(std::vector<int>& indices, const osg::PrimitiveSet* primitiveSet);


   protected:
      // used only for outputting debug messages
      const std::string myModelFileName;

      osg::ref_ptr<osg::Geometry> myAggregatedGeometry;

      tbb::atomic<int> myCancelTask;
   };

   template <class T>
   bool DtIndirectAggregateIndicesHelper::copyIndicesOnMatch(std::vector<int>& indices, const osg::PrimitiveSet* primitiveSet)
   {
      const T* primitiveSetT = dynamic_cast<const T*>(primitiveSet);
      if (primitiveSetT == 0)
      {
         return false;
      }

      GLenum mode = primitiveSetT->getMode();
      if (isModeSupported(mode) == false)
      {
         DtWarn << "Info: " << __FILE__ << " +" << __LINE__ << " " << __FUNCTION__ << " mode is: " << toModeString(mode) << ", skipping" << std::endl;
         return false;
      }
      // avoid lots of resizing
      indices.reserve(indices.size() + primitiveSetT->size());
      if (mode == GL_TRIANGLES)
      {
         indices.insert(indices.end(), primitiveSetT->begin(), primitiveSetT->end());

      }
      else if (mode == GL_TRIANGLE_FAN)
      {
         ASSERT_PREDICATE(primitiveSetT->size() >= 3);

         int numTriangles = primitiveSetT->size() - 2;

         int i0 = primitiveSetT->at(0);

         for (int i = 0; i < numTriangles; ++i)
         {
            int i1 = primitiveSetT->at(i + 1);
            int i2 = primitiveSetT->at(i + 2);

            indices.push_back(i0);
            indices.push_back(i1);
            indices.push_back(i2);
         }
      }
      else if (mode == GL_TRIANGLE_STRIP)
      {
         ASSERT_PREDICATE(primitiveSetT->size() >= 3);
         int numTriangles = primitiveSetT->size() - 2;
         for (int i = 0; i < numTriangles; ++i)
         {
            int i0 = primitiveSetT->at(i);
            int i1 = primitiveSetT->at(i + 1);
            int i2 = primitiveSetT->at(i + 2);

            if (i % 2 == 0)
            {
               indices.push_back(i0);
               indices.push_back(i1);
               indices.push_back(i2);
            }
            else
            {
               indices.push_back(i1);
               indices.push_back(i0);
               indices.push_back(i2);
            }
         }
      }
      else if (mode == GL_QUADS)
      {
         int count = primitiveSetT->size();
         ASSERT_PREDICATE(count % 4 == 0);
         int numQuads = count / 4;
         for (int quad = 0; quad < numQuads; ++quad)
         {
            int q0 = primitiveSetT->at(quad) * 4 + 0;
            int q1 = primitiveSetT->at(quad) * 4 + 1;
            int q2 = primitiveSetT->at(quad) * 4 + 2;
            int q3 = primitiveSetT->at(quad) * 4 + 3;

            indices.push_back(q0);
            indices.push_back(q1);
            indices.push_back(q2);

            indices.push_back(q0);
            indices.push_back(q2);
            indices.push_back(q3);
         }
      }
      else
      {
         ASSERT_PREDICATE(false);
         return false;
      }
      return true;
   }
}