DtTextureCollection.h

Go to the documentation of this file.

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

#pragma once

#include <vrvOsg/vrvOsg.h>

#include <osg/Referenced>
#include <osg/Texture>

#include <vector>

namespace makVrv
{
   class DT_DLL_VRVOSG DtTextureCollection : public osg::Referenced
   {
   public:
      union KeyType
      {
         unsigned short key;
         struct
         {
            unsigned int min : 3;
            unsigned int compressed : 1;
            unsigned int max : 4;
            unsigned int wrap_s : 4;
            unsigned int wrap_t : 4;
         };
      };

      // \Returns true if the entire texture collection should be flushed.
      bool flush()
      {
         TextureList replacementList;

         TextureList::iterator i = myTextures.begin();
         TextureList::iterator e = myTextures.end();
         for (; i != e; ++i)
         {
            if (i->second->referenceCount() > 1)
            {
               replacementList.push_back(*i);
            }
         }
         if (replacementList.size() != myTextures.size())
         {
            myTextures.swap(replacementList);
         }
         return myTextures.size() == 0;
      }

      void releaseGLObjects(osg::State * state)
      {
         TextureList::iterator i = myTextures.begin();
         TextureList::iterator e = myTextures.end();
         for (; i != e; ++i)
         {
            i->second->releaseGLObjects(state);
         }
      }

      bool findTexture(unsigned int minFilter, unsigned int magFilter,
         unsigned int wrapS, unsigned wrapT, bool compressed, osg::ref_ptr<osg::Texture>& texture)
      {
         KeyType k;

         k.min = ((minFilter ^ 0x2600) & 0x3) + ((minFilter ^ 0x2600) >> 7);
         k.max = ((magFilter ^ 0x2600) & 0x3) + ((magFilter ^ 0x2600) >> 7);
         k.wrap_s = (wrapS & 0x0F) | ((wrapS & 0x10) >> 3);
         k.wrap_t = (wrapT & 0x0F) | ((wrapT & 0x10) >> 3);
         k.compressed = compressed;

         TextureList::iterator i = myTextures.begin();
         TextureList::iterator e = myTextures.end();
         for (; i != e; ++i)
         {
            if (i->first.key == k.key)
            {
               texture = i->second;
               return true;
            }
         }
         return false;
      }

      void addTexture(osg::Texture* texture, bool compressed)
      {
         KeyTexturePair pair;

         pair.first.min = ((texture->getFilter(osg::Texture::MIN_FILTER) ^ 0x2600) & 0x3) +
            ((texture->getFilter(osg::Texture::MIN_FILTER) ^ 0x2600) >> 7);

         pair.first.max = ((texture->getFilter(osg::Texture::MAG_FILTER) ^ 0x2600) & 0x3) +
            ((texture->getFilter(osg::Texture::MAG_FILTER) ^ 0x2600) >> 7);

         pair.first.wrap_s = (texture->getWrap(osg::Texture::WRAP_S) & 0x0F) |
            ((texture->getWrap(osg::Texture::WRAP_S) & 0x10) >> 3);

         pair.first.wrap_t = (texture->getWrap(osg::Texture::WRAP_T) & 0x0F) |
            ((texture->getWrap(osg::Texture::WRAP_T) & 0x10) >> 3);

         pair.first.compressed = compressed;

         pair.second = texture;
         myTextures.push_back(pair);
      }

      typedef std::pair<KeyType, osg::ref_ptr<osg::Texture> > KeyTexturePair;
      typedef std::vector<KeyTexturePair> TextureList;
      TextureList myTextures;
   };
}