PropertyMaps.h

Go to the documentation of this file.

/*-------------------------------------------------------------------------------------
Copyright (c) 2006 John Judnich
 
This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.
Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
-------------------------------------------------------------------------------------*/
#ifndef __PropertyMaps_H__
#define __PropertyMaps_H__
 
#include <OgrePrerequisites.h>
#include <OgrePixelFormat.h>
#include <OgreColourValue.h>
#include <OgreRoot.h>
#include <OgreRenderSystem.h>
 
namespace Forests
{
 
   enum MapChannel
   {
      CHANNEL_RED,
      CHANNEL_GREEN,
      CHANNEL_BLUE,
      CHANNEL_ALPHA,
      CHANNEL_COLOR
   };
 
   enum MapFilter
   {
      MAPFILTER_NONE,
      MAPFILTER_BILINEAR
   };
 
   class DensityMap
   {
   public:
      static DensityMap *load(const Ogre::String &fileName, MapChannel channel = CHANNEL_COLOR);
      static DensityMap *load(Ogre::TexturePtr texture, MapChannel channel = CHANNEL_COLOR);
      void unload();
 
      void setFilter(MapFilter filter) { this->filter = filter; }
 
      MapFilter getFilter() { return filter; }
 
      Ogre::PixelBox getPixelBox()
      {
         assert(pixels);
         return *pixels;
      }
 
      Ogre::Real getDensityAt(Ogre::Real x, Ogre::Real z, const Ogre::TRect<Ogre::Real> &mapBounds)
      {
         if (filter == MAPFILTER_NONE)
            return _getDensityAt_Unfiltered(x, z, mapBounds);
         else
            return _getDensityAt_Bilinear(x, z, mapBounds);
      }
 
      Ogre::Real _getDensityAt_Unfiltered(Ogre::Real x, Ogre::Real z, const Ogre::TRect<Ogre::Real> &mapBounds);
      Ogre::Real _getDensityAt_Bilinear(Ogre::Real x, Ogre::Real z, const Ogre::TRect<Ogre::Real> &mapBounds);
 
   private:
      DensityMap(Ogre::TexturePtr texture, MapChannel channel);
      ~DensityMap();
 
      static std::map<Ogre::String, DensityMap*> selfList;
      Ogre::String selfKey;
      Ogre::uint32 refCount;
 
      MapFilter filter;
      Ogre::PixelBox *pixels;
   };
 
   class ColorMap
   {
   public:
      static ColorMap *load(const Ogre::String &fileName, MapChannel channel = CHANNEL_COLOR);
      static ColorMap *load(Ogre::TexturePtr texture, MapChannel channel = CHANNEL_COLOR);
      void unload();
 
      void setFilter(MapFilter filter) { this->filter = filter; }
 
      MapFilter getFilter() { return filter; }
 
      Ogre::PixelBox getPixelBox()
      {
         assert(pixels);
         return *pixels;
      }
 
      Ogre::uint32 getColorAt(Ogre::Real x, Ogre::Real z, const Ogre::TRect<Ogre::Real> &mapBounds)
      {
         return filter == MAPFILTER_NONE ? _getColorAt(x, z, mapBounds) : _getColorAt_Bilinear(x, z, mapBounds);
      }
 
      Ogre::ColourValue getColorAt_Unpacked(Ogre::Real x, Ogre::Real z, const Ogre::TRect<Ogre::Real> &mapBounds)
      {
         Ogre::uint32 c = filter == MAPFILTER_NONE ? _getColorAt(x, z, mapBounds) : _getColorAt_Bilinear(x, z, mapBounds);
         float r, g, b, a;
         static Ogre::VertexElementType format = Ogre::Root::getSingleton().getRenderSystem()->getColourVertexElementType();
         if (format == Ogre::VET_COLOUR_ARGB)
         {
            // 1/255 = 0,0039215686274509803921568627451
            b = ((c) & 0xFF) * 0.0039215686f;
            g = ((c >> 8) & 0xFF) * 0.0039215686f;
            r = ((c >> 16) & 0xFF) * 0.0039215686f;
            a = ((c >> 24) & 0xFF) * 0.0039215686f;
         }
         else
         {
            r = ((c) & 0xFF) * 0.0039215686f;
            g = ((c >> 8) & 0xFF) * 0.0039215686f;
            b = ((c >> 16) & 0xFF) * 0.0039215686f;
            a = ((c >> 24) & 0xFF) * 0.0039215686f;
         }
 
         return Ogre::ColourValue(r, g, b, a);
      }
 
   private:
      ColorMap(Ogre::TexturePtr map, MapChannel channel);
      ~ColorMap();
 
      static std::map<Ogre::String, ColorMap*> selfList;
      Ogre::String selfKey;
      Ogre::uint32 refCount;
 
      //Directly interpolates two Ogre::uint32 colors
      Ogre::uint32 _interpolateColor(Ogre::uint32 color1, Ogre::uint32 color2, Ogre::Real ratio, Ogre::Real ratioInv);
 
      //Returns the color map value at the given location
      Ogre::uint32 _getColorAt(Ogre::Real x, Ogre::Real z, const Ogre::TRect<Ogre::Real> &mapBounds);
 
      //Returns the color map value at the given location with bilinear filtering
      Ogre::uint32 _getColorAt_Bilinear(Ogre::Real x, Ogre::Real z, const Ogre::TRect<Ogre::Real> &mapBounds);
 
      MapFilter filter;
      Ogre::PixelBox *pixels;
      Ogre::TRect<Ogre::Real> mapBounds;
   };
 
}
 
#endif