Public API Reference

csgfx/textureformatstrings.h

Go to the documentation of this file.

/*
    Copyright (C) 2006 by Jorrit Tyberghein

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#ifndef __CS_CSGFX_TEXTUREFORMATSTRINGS_H__
#define __CS_CSGFX_TEXTUREFORMATSTRINGS_H__

#include "csextern.h"

#include "csutil/csstring.h"

namespace CS
{
  class CS_CRYSTALSPACE_EXPORT StructuredTextureFormat
  {
  public:
    enum TextureFormat
    {
      Invalid = '-',
      Integer = 'i',
      Float = 'f',
      Special = '*'
    };
  private:
    // Component data
    struct CompData
    {
      // Must be first entry. Will be '*' in case of special formats...
      unsigned char format;
      union
      {
        uint64 coded_components;
        char* specialStrPtr;
      };
    };
    enum
    {
      SpecialStrExtern = 0x80,
      SpecialStrMax = sizeof (CompData)
    };
    union
    {
      CompData cd;
      // Store 'small' special formats inline.
      char specialStr[SpecialStrMax];
    };

    void FreeSpecialStr ();
  public:
    StructuredTextureFormat ()
    {
      cd.coded_components = CONST_UINT64 (0);
      cd.format = Invalid;
    }
    StructuredTextureFormat (TextureFormat fmt)
    {
      cd.coded_components = CONST_UINT64 (0);
      cd.format = fmt;
    }

    StructuredTextureFormat (char cmp1, int size1,
      TextureFormat fmt = Integer)
    {
      cd.coded_components = CONST_UINT64 (0);
      cd.format = fmt;
      if (cmp1 != 0) AddComponent (cmp1, size1);
    }
    StructuredTextureFormat (char cmp1, int size1,
      char cmp2, int size2,
      TextureFormat fmt = Integer)
    {
      cd.coded_components = CONST_UINT64 (0);
      cd.format = fmt;
      if (cmp1 != 0) AddComponent (cmp1, size1);
      if (cmp2 != 0) AddComponent (cmp2, size2);
    }
    StructuredTextureFormat (char cmp1, int size1,
      char cmp2, int size2,
      char cmp3, int size3,
      TextureFormat fmt = Integer)
    {
      cd.coded_components = CONST_UINT64 (0);
      cd.format = fmt;
      if (cmp1 != 0) AddComponent (cmp1, size1);
      if (cmp2 != 0) AddComponent (cmp2, size2);
      if (cmp3 != 0) AddComponent (cmp3, size3);
    }
    StructuredTextureFormat (char cmp1, int size1,
      char cmp2, int size2,
      char cmp3, int size3,
      char cmp4, int size4,
      TextureFormat fmt = Integer)
    {
      cd.coded_components = CONST_UINT64 (0);
      cd.format = fmt;
      if (cmp1 != 0) AddComponent (cmp1, size1);
      if (cmp2 != 0) AddComponent (cmp2, size2);
      if (cmp3 != 0) AddComponent (cmp3, size3);
      if (cmp4 != 0) AddComponent (cmp4, size4);
    }

    StructuredTextureFormat (const StructuredTextureFormat& other);
    ~StructuredTextureFormat ();

    void SetSpecial (const char* special);

    bool AddComponent (char cmp, int size)
    {
      if (GetFormat() == Special) return false;
      uint64 shifted = cd.coded_components << 16;
      if ((shifted >> 16) != cd.coded_components)
        return false;
      cd.coded_components = shifted + (CONST_UINT64 (256) * cmp) + size;
      return true;
    }

    void SetFormat (TextureFormat format)
    {
      CS_ASSERT_MSG ("Use SetSpecial() to set special formats", format != Special);
      if (format == Special) return;
      FreeSpecialStr ();
      if (cd.format == Special) cd.coded_components = 0;
      cd.format = format;
    }

    void FixSizes (int size);
    void FixSizes ();

    csString GetCanonical () const;

    bool operator== (const StructuredTextureFormat& other) const
    {
      if (GetFormat() != other.GetFormat()) return false;
      if (GetFormat() == Special)
      {
        const char* s1 = GetSpecial();
        const char* s2 = GetSpecial();
        if ((s1 == static_cast<const char*>(nullptr)) && (s2 == static_cast<const char*>(nullptr))) return true;
        if (s1 == static_cast<const char*>(nullptr)) return false;
        if (s1 == static_cast<const char*>(nullptr)) return false;
        return strcmp (s1, s2) == 0;
      }
      else
      {
        return (cd.coded_components == other.cd.coded_components);
      }
    }

    bool operator!= (const StructuredTextureFormat& other) const
    {
      if (GetFormat() != other.GetFormat()) return true;
      if (GetFormat() == Special)
      {
        const char* s1 = GetSpecial();
        const char* s2 = GetSpecial();
        if ((s1 == static_cast<const char*>(nullptr)) && (s2 == static_cast<const char*>(nullptr))) return false;
        if (s1 == static_cast<const char*>(nullptr)) return true;
        if (s1 == static_cast<const char*>(nullptr)) return true;
        return strcmp (s1, s2) != 0;
      }
      else
      {
        return (cd.coded_components != other.cd.coded_components);
      }
    }

    bool IsValid () const { return cd.format != Invalid; }

    int GetComponentCount () const
    {
      if (((cd.format & ~SpecialStrExtern) == Special)
          || (cd.format == Invalid))
        return 0;
      int n = 0;
      uint64 comp = cd.coded_components;
      while (comp != 0) 
      {
        comp >>= 16;
        n++;
      }
      return n;
    }

    char GetComponent (int n) const
    {
      int num = GetComponentCount ();
      if ((n < 0) || (n >= num)) return 0;
      return (cd.coded_components >> (16 * (num - 1 - n) + 8)) & 255;
    }

    char GetComponentSize (int n) const
    {
      int num = GetComponentCount ();
      if ((n < 0) || (n >= num)) return 0;
      return (cd.coded_components >> (16 * (num - 1 - n))) & 255;
    }

    TextureFormat GetFormat() const
    { return static_cast<TextureFormat> (cd.format & ~SpecialStrExtern); }

    const char* GetSpecial() const
    {
      if ((cd.format & ~SpecialStrExtern) != Special) return 0;
      if (cd.format & SpecialStrExtern)
        return cd.specialStrPtr;
      else
        return specialStr;
    }

    enum
    {
      compR = 0x01,
      compG = 0x02,
      compB = 0x04,
      compA = 0x08,
      compX = 0x10,
      compL = 0x20,
      compD = 0x40,
      compS = 0x80,

      compRGB = compR | compB | compG,
      compRGBA = compR | compB | compG | compA,
      compLumA = compL | compA,
      compDepthStencil = compD | compS,

      compUnknown = 0x80000000
    };

    uint GetComponentMask () const;
  };
  
  class CS_CRYSTALSPACE_EXPORT TextureFormatStrings
  {
  public:
    static csString ConvertCanonical (const char* in);

    static StructuredTextureFormat ConvertStructured (const char* in);
  };
}

#endif // __CS_CSGFX_TEXTUREFORMATSTRINGS_H__

---