[occt.git] / src / OpenGl / OpenGl_TextureFormat.cxx

// Copyright (c) 2017-2019 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.

#include <OpenGl_TextureFormat.hxx>

#include <Image_SupportedFormats.hxx>
#include <OpenGl_Context.hxx>

// =======================================================================
// function : FormatFormat
// purpose  :
// =======================================================================
TCollection_AsciiString OpenGl_TextureFormat::FormatFormat (GLint theInternalFormat)
{
  switch (theInternalFormat)
  {
    // RED variations (GL_RED, OpenGL 3.0+)
    case GL_RED:      return "GL_RED";
    case GL_R8:       return "GL_R8";
    case 0x822A:      return "GL_R16";
    case GL_R16F:     return "GL_R16F"; // half-float
    case GL_R32F:     return "GL_R32F"; // float
    case GL_R32I:     return "GL_R32I";
    case GL_RED_INTEGER: return "GL_RED_INTEGER";
    //
    case GL_RG:       return "GL_RG";
    case GL_RG8:      return "GL_RG8";
    case 0x822C:      return "GL_RG16";
    case GL_RG16F:    return "GL_RG16F";
    case GL_RG32F:    return "GL_RG32F";
    case GL_RG32I:    return "GL_RG32I";
    case GL_RG_INTEGER: return "GL_RG_INTEGER";
    // RGB variations
    case GL_RGB:      return "GL_RGB";
    case 0x804F:      return "GL_RGB4";
    case 0x8050:      return "GL_RGB5";
    case GL_RGB8:     return "GL_RGB8";
    case GL_SRGB8:    return "GL_SRGB8";
    case 0x8052:      return "GL_RGB10";
    case 0x8053:      return "GL_RGB12";
    case 0x8054:      return "GL_RGB16";
    case GL_RGB16F:   return "GL_RGB16F"; // half-float
    case GL_RGB32F:   return "GL_RGB32F"; // float
    case GL_RGB32I:   return "GL_RGB32I";
    // RGBA variations
    case GL_RGBA:     return "GL_RGBA";
    case GL_RGBA8:    return "GL_RGBA8";
    case GL_SRGB8_ALPHA8: return "GL_SRGB8_ALPHA8";
    case GL_RGB10_A2: return "GL_RGB10_A2";
    case 0x805A:      return "GL_RGBA12";
    case 0x805B:      return "GL_RGBA16";
    case GL_RGBA16F:  return "GL_RGBA16F"; // half-float
    case GL_RGBA32F:  return "GL_RGBA32F"; // float
    case GL_RGBA32I:  return "GL_RGBA32I";
    //
    case 0x80E0:       return "GL_BGR";
    case GL_BGRA_EXT:  return "GL_BGRA";
    // ALPHA variations (deprecated)
    case GL_ALPHA:     return "GL_ALPHA";
    case 0x803C:       return "GL_ALPHA8";
    case 0x803E:       return "GL_ALPHA16";
    case GL_LUMINANCE: return "GL_LUMINANCE";
    case GL_LUMINANCE_ALPHA: return "GL_LUMINANCE_ALPHA";
    //
    case GL_DEPTH_COMPONENT:    return "GL_DEPTH_COMPONENT";
    case GL_DEPTH_COMPONENT16:  return "GL_DEPTH_COMPONENT16";
    case GL_DEPTH_COMPONENT24:  return "GL_DEPTH_COMPONENT24";
    case GL_DEPTH_COMPONENT32F: return "GL_DEPTH_COMPONENT32F";
    case GL_DEPTH_STENCIL:      return "GL_DEPTH_STENCIL";
    case GL_DEPTH24_STENCIL8:   return "GL_DEPTH24_STENCIL8";
    case GL_DEPTH32F_STENCIL8:  return "GL_DEPTH32F_STENCIL8";
    //
    case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:        return "GL_COMPRESSED_RGB_S3TC_DXT1_EXT";
    case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:       return "GL_COMPRESSED_SRGB_S3TC_DXT1_EXT";
    case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:       return "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT";
    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: return "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT";
    case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:       return "GL_COMPRESSED_RGBA_S3TC_DXT3_EXT";
    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: return "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT";
    case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:       return "GL_COMPRESSED_RGBA_S3TC_DXT5_EXT";
    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: return "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT";
  }
  return OpenGl_Context::FormatGlEnumHex (theInternalFormat);
}

// =======================================================================
// function : FormatDataType
// purpose  :
// =======================================================================
TCollection_AsciiString OpenGl_TextureFormat::FormatDataType (GLint theDataType)
{
  switch (theDataType)
  {
    case GL_UNSIGNED_BYTE:     return "GL_UNSIGNED_BYTE";
    case GL_UNSIGNED_SHORT:    return "GL_UNSIGNED_SHORT";
    case GL_INT:               return "GL_INT";
    case GL_UNSIGNED_INT:      return "GL_UNSIGNED_INT";
    case GL_FLOAT:             return "GL_FLOAT";
    case GL_HALF_FLOAT:        return "GL_HALF_FLOAT";
    case 0x8D61:               return "GL_HALF_FLOAT_OES";
    case GL_UNSIGNED_INT_24_8: return "GL_UNSIGNED_INT_24_8";
    case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: return "GL_FLOAT_32_UNSIGNED_INT_24_8_REV";
  }
  return OpenGl_Context::FormatGlEnumHex (theDataType);
}

// =======================================================================
// function : FindFormat
// purpose  :
// =======================================================================
OpenGl_TextureFormat OpenGl_TextureFormat::FindFormat (const Handle(OpenGl_Context)& theCtx,
                                                       Image_Format theFormat,
                                                       bool theIsColorMap)
{
  OpenGl_TextureFormat aFormat;
  aFormat.SetImageFormat (theFormat);
#if defined(GL_ES_VERSION_2_0)
  const bool useRedRedAlpha = false;
#else
  const bool useRedRedAlpha = (theCtx->core11ffp == NULL);
#endif
  switch (theFormat)
  {
    case Image_Format_GrayF:
    {
      aFormat.SetNbComponents (1);
      if (useRedRedAlpha)
      {
        aFormat.SetInternalFormat (theCtx->arbTexFloat ? GL_R32F : GL_R8);
        aFormat.SetPixelFormat (GL_RED);
      }
      else
      {
      #if !defined(GL_ES_VERSION_2_0)
        aFormat.SetInternalFormat (GL_LUMINANCE8);
      #else
        aFormat.SetInternalFormat (GL_LUMINANCE);
      #endif
        aFormat.SetPixelFormat (GL_LUMINANCE);
      }
      aFormat.SetDataType (GL_FLOAT);
      return aFormat;
    }
    case Image_Format_AlphaF:
    {
      aFormat.SetNbComponents (1);
      if (useRedRedAlpha)
      {
        aFormat.SetInternalFormat (theCtx->arbTexFloat ? GL_R32F : GL_R8);
        aFormat.SetPixelFormat (GL_RED);
      }
      else
      {
      #if !defined(GL_ES_VERSION_2_0)
        aFormat.SetInternalFormat (GL_ALPHA8);
      #else
        aFormat.SetInternalFormat (GL_ALPHA);
      #endif
        aFormat.SetPixelFormat (GL_ALPHA);
      }
      aFormat.SetDataType (GL_FLOAT);
      return aFormat;
    }
    case Image_Format_RGF:
    {
      if (!theCtx->arbTexRG)
      {
        return OpenGl_TextureFormat();
      }
      aFormat.SetNbComponents (2);
      aFormat.SetInternalFormat (theCtx->arbTexFloat ? GL_RG32F : GL_RG8);
      aFormat.SetPixelFormat (GL_RG);
      aFormat.SetDataType (GL_FLOAT);
      return aFormat;
    }
    case Image_Format_RGBAF:
    {
      aFormat.SetNbComponents (4);
      aFormat.SetInternalFormat (theCtx->arbTexFloat ? GL_RGBA32F : GL_RGBA8);
      aFormat.SetPixelFormat (GL_RGBA);
      aFormat.SetDataType (GL_FLOAT);
      return aFormat;
    }
    case Image_Format_BGRAF:
    {
      if (!theCtx->IsGlGreaterEqual (1, 2) && !theCtx->extBgra)
      {
        return OpenGl_TextureFormat();
      }
      aFormat.SetNbComponents (4);
      aFormat.SetInternalFormat (theCtx->arbTexFloat ? GL_RGBA32F : GL_RGBA8);
      aFormat.SetPixelFormat (GL_BGRA_EXT); // equals to GL_BGRA
      aFormat.SetDataType (GL_FLOAT);
      return aFormat;
    }
    case Image_Format_RGBF:
    {
      aFormat.SetNbComponents (3);
      aFormat.SetInternalFormat (theCtx->arbTexFloat ? GL_RGB32F : GL_RGB8);
      aFormat.SetPixelFormat (GL_RGB);
      aFormat.SetDataType (GL_FLOAT);
      return aFormat;
    }
    case Image_Format_BGRF:
    {
    #if !defined(GL_ES_VERSION_2_0)
      aFormat.SetNbComponents (3);
      aFormat.SetInternalFormat (theCtx->arbTexFloat ? GL_RGB32F : GL_RGB8);
      aFormat.SetPixelFormat (GL_BGR);     // equals to GL_BGR_EXT
      aFormat.SetDataType (GL_FLOAT);
      return aFormat;
    #else
      return OpenGl_TextureFormat();
    #endif
    }
    case Image_Format_RGF_half:
    {
      aFormat.SetNbComponents (2);
      aFormat.SetInternalFormat (GL_RG16F);
      aFormat.SetPixelFormat (GL_RG);
      aFormat.SetDataType (GL_HALF_FLOAT);
      if (theCtx->hasHalfFloatBuffer == OpenGl_FeatureInExtensions)
      {
      #if defined(GL_ES_VERSION_2_0)
        aFormat.SetDataType (GL_HALF_FLOAT_OES);
      #endif
      }
      return aFormat;
    }
    case Image_Format_RGBAF_half:
    {
      aFormat.SetNbComponents (4);
      aFormat.SetInternalFormat (GL_RGBA16F);
      aFormat.SetPixelFormat (GL_RGBA);
      aFormat.SetDataType (GL_HALF_FLOAT);
      if (theCtx->hasHalfFloatBuffer == OpenGl_FeatureInExtensions)
      {
      #if defined(GL_ES_VERSION_2_0)
        aFormat.SetDataType (GL_HALF_FLOAT_OES);
      #endif
      }
      return aFormat;
    }
    case Image_Format_RGBA:
    {
      aFormat.SetNbComponents (4);
      aFormat.SetInternalFormat (GL_RGBA8);
      aFormat.SetPixelFormat (GL_RGBA);
      aFormat.SetDataType (GL_UNSIGNED_BYTE);
      if (theIsColorMap
       && theCtx->ToRenderSRGB())
      {
        aFormat.SetInternalFormat (GL_SRGB8_ALPHA8);
      }
      return aFormat;
    }
    case Image_Format_BGRA:
    {
    #if !defined(GL_ES_VERSION_2_0)
      if (!theCtx->IsGlGreaterEqual (1, 2)
       && !theCtx->extBgra)
      {
        return OpenGl_TextureFormat();
      }
      aFormat.SetNbComponents (4);
      aFormat.SetInternalFormat (GL_RGBA8);
      if (theIsColorMap
       && theCtx->ToRenderSRGB())
      {
        aFormat.SetInternalFormat (GL_SRGB8_ALPHA8);
      }
    #else
      if (theIsColorMap
       && theCtx->ToRenderSRGB())
      {
        // GL_SRGB8_ALPHA8 with texture swizzling would be better
      }
      if (!theCtx->extBgra)
      {
        return OpenGl_TextureFormat();
      }
      aFormat.SetNbComponents (4);
      aFormat.SetInternalFormat (GL_BGRA_EXT);
    #endif
      aFormat.SetPixelFormat (GL_BGRA_EXT); // equals to GL_BGRA
      aFormat.SetDataType (GL_UNSIGNED_BYTE);
      return aFormat;
    }
    case Image_Format_RGB32:
    {
    #if !defined(GL_ES_VERSION_2_0)
      // ask driver to convert data to RGB8 to save memory
      aFormat.SetNbComponents (3);
      aFormat.SetInternalFormat (GL_RGB8);
      if (theIsColorMap
       && theCtx->ToRenderSRGB())
      {
        aFormat.SetInternalFormat (GL_SRGB8);
      }
    #else
      // conversion is not supported
      aFormat.SetNbComponents (4);
      aFormat.SetInternalFormat (GL_RGBA8);
      if (theIsColorMap
       && theCtx->ToRenderSRGB())
      {
        aFormat.SetInternalFormat (GL_SRGB8_ALPHA8);
      }
    #endif
      aFormat.SetPixelFormat (GL_RGBA);
      aFormat.SetDataType (GL_UNSIGNED_BYTE);
      return aFormat;
    }
    case Image_Format_BGR32:
    {
    #if !defined(GL_ES_VERSION_2_0)
      if (!theCtx->IsGlGreaterEqual(1, 2) && !theCtx->extBgra)
      {
        return OpenGl_TextureFormat();
      }
      aFormat.SetNbComponents (3);
      aFormat.SetInternalFormat (GL_RGB8);
      if (theIsColorMap
       && theCtx->ToRenderSRGB())
      {
        aFormat.SetInternalFormat (GL_SRGB8);
      }
    #else
      if (theIsColorMap
       && theCtx->ToRenderSRGB())
      {
        // GL_SRGB8_ALPHA8 with texture swizzling would be better
      }
      if (!theCtx->extBgra)
      {
        return OpenGl_TextureFormat();
      }
      aFormat.SetNbComponents (4);
      aFormat.SetInternalFormat (GL_BGRA_EXT);
    #endif
      aFormat.SetPixelFormat (GL_BGRA_EXT); // equals to GL_BGRA
      aFormat.SetDataType (GL_UNSIGNED_BYTE);
      return aFormat;
    }
    case Image_Format_RGB:
    {
      aFormat.SetNbComponents (3);
      aFormat.SetInternalFormat (GL_RGB8);
      aFormat.SetPixelFormat (GL_RGB);
      aFormat.SetDataType (GL_UNSIGNED_BYTE);
      if (theIsColorMap
       && theCtx->ToRenderSRGB())
      {
        aFormat.SetInternalFormat (GL_SRGB8);
      }
      return aFormat;
    }
    case Image_Format_BGR:
    {
    #if !defined(GL_ES_VERSION_2_0)
      if (!theCtx->IsGlGreaterEqual (1, 2)
       && !theCtx->extBgra)
      {
        return OpenGl_TextureFormat();
      }
      aFormat.SetNbComponents (3);
      aFormat.SetInternalFormat (GL_RGB8);
      if (theIsColorMap
       && theCtx->ToRenderSRGB())
      {
        aFormat.SetInternalFormat (GL_SRGB8);
      }
      aFormat.SetPixelFormat (GL_BGR); // equals to GL_BGR_EXT
      aFormat.SetDataType (GL_UNSIGNED_BYTE);
    #endif
      return aFormat;
    }
    case Image_Format_Gray:
    {
      aFormat.SetNbComponents (1);
      if (useRedRedAlpha)
      {
        aFormat.SetInternalFormat (GL_R8);
        aFormat.SetPixelFormat (GL_RED);
      }
      else
      {
      #if !defined(GL_ES_VERSION_2_0)
        aFormat.SetInternalFormat (GL_LUMINANCE8);
      #else
        aFormat.SetInternalFormat (GL_LUMINANCE);
      #endif
        aFormat.SetPixelFormat (GL_LUMINANCE);
      }
      aFormat.SetDataType (GL_UNSIGNED_BYTE);
      return aFormat;
    }
    case Image_Format_Alpha:
    {
      aFormat.SetNbComponents (1);
      if (useRedRedAlpha)
      {
        aFormat.SetInternalFormat (GL_R8);
        aFormat.SetPixelFormat (GL_RED);
      }
      else
      {
      #if !defined(GL_ES_VERSION_2_0)
        aFormat.SetInternalFormat (GL_ALPHA8);
      #else
        aFormat.SetInternalFormat (GL_ALPHA);
      #endif
        aFormat.SetPixelFormat (GL_ALPHA);
      }
      aFormat.SetDataType (GL_UNSIGNED_BYTE);
      return aFormat;
    }
    case Image_Format_UNKNOWN:
    {
      return OpenGl_TextureFormat();
    }
  }
  return OpenGl_TextureFormat();
}

// =======================================================================
// function : FindSizedFormat
// purpose  :
// =======================================================================
OpenGl_TextureFormat OpenGl_TextureFormat::FindSizedFormat (const Handle(OpenGl_Context)& theCtx,
                                                            GLint theSizedFormat)
{
  OpenGl_TextureFormat aFormat;
  switch (theSizedFormat)
  {
    case GL_RGBA32F:
    {
      aFormat.SetNbComponents (4);
      aFormat.SetInternalFormat (theSizedFormat);
      aFormat.SetPixelFormat (GL_RGBA);
      aFormat.SetDataType (GL_FLOAT);
      aFormat.SetImageFormat (Image_Format_RGBAF);
      return aFormat;
    }
    case GL_R32F:
    {
      aFormat.SetNbComponents (1);
      aFormat.SetInternalFormat (theSizedFormat);
      aFormat.SetPixelFormat (GL_RED);
      aFormat.SetDataType (GL_FLOAT);
      aFormat.SetImageFormat (Image_Format_GrayF);
      return aFormat;
    }
    case GL_RG32F:
    {
      aFormat.SetNbComponents (1);
      aFormat.SetInternalFormat (theSizedFormat);
      aFormat.SetPixelFormat (GL_RG);
      aFormat.SetDataType (GL_FLOAT);
      aFormat.SetImageFormat (Image_Format_RGF);
      return aFormat;
    }
    case GL_RGBA16F:
    {
      aFormat.SetNbComponents (4);
      aFormat.SetInternalFormat (theSizedFormat);
      aFormat.SetPixelFormat (GL_RGBA);
      aFormat.SetDataType (GL_HALF_FLOAT);
      aFormat.SetImageFormat (Image_Format_RGBAF_half);
      if (theCtx->hasHalfFloatBuffer == OpenGl_FeatureInExtensions)
      {
      #if defined(GL_ES_VERSION_2_0)
        aFormat.SetDataType (GL_HALF_FLOAT_OES);
      #else
        aFormat.SetDataType (GL_FLOAT);
      #endif
      }
      return aFormat;
    }
    case GL_R16F:
    {
      aFormat.SetNbComponents (1);
      aFormat.SetInternalFormat (theSizedFormat);
      aFormat.SetPixelFormat (GL_RED);
      aFormat.SetDataType (GL_HALF_FLOAT);
      aFormat.SetImageFormat (Image_Format_GrayF);
      if (theCtx->hasHalfFloatBuffer == OpenGl_FeatureInExtensions)
      {
      #if defined(GL_ES_VERSION_2_0)
        aFormat.SetDataType (GL_HALF_FLOAT_OES);
      #else
        aFormat.SetDataType (GL_FLOAT);
      #endif
      }
      return aFormat;
    }
    case GL_RG16F:
    {
      aFormat.SetNbComponents (2);
      aFormat.SetInternalFormat (theSizedFormat);
      aFormat.SetPixelFormat (GL_RG);
      aFormat.SetDataType (GL_HALF_FLOAT);
      aFormat.SetImageFormat (Image_Format_RGF_half);
      if (theCtx->hasHalfFloatBuffer == OpenGl_FeatureInExtensions)
      {
      #if defined(GL_ES_VERSION_2_0)
        aFormat.SetDataType (GL_HALF_FLOAT_OES);
      #else
        aFormat.SetDataType (GL_FLOAT);
      #endif
      }
      return aFormat;
    }
    case GL_SRGB8_ALPHA8:
    case GL_RGBA8:
    case GL_RGBA:
    {
      aFormat.SetNbComponents (4);
      aFormat.SetInternalFormat (theSizedFormat);
      aFormat.SetPixelFormat (GL_RGBA);
      aFormat.SetDataType (GL_UNSIGNED_BYTE);
      aFormat.SetImageFormat (Image_Format_RGBA);
      if (theSizedFormat == GL_SRGB8_ALPHA8
      && !theCtx->ToRenderSRGB())
      {
        aFormat.SetInternalFormat (GL_RGBA8); // fallback format
      }
      return aFormat;
    }
    case GL_SRGB8:
    case GL_RGB8:
    case GL_RGB:
    {
      aFormat.SetNbComponents (3);
      aFormat.SetInternalFormat (theSizedFormat);
      aFormat.SetPixelFormat (GL_RGB);
      aFormat.SetDataType (GL_UNSIGNED_BYTE);
      aFormat.SetImageFormat (Image_Format_RGB);
      if (theSizedFormat == GL_SRGB8
      && !theCtx->ToRenderSRGB())
      {
        aFormat.SetInternalFormat (GL_RGB8); // fallback format
      }
      return aFormat;
    }
    // integer types
    case GL_R32I:
    {
      aFormat.SetNbComponents (1);
      aFormat.SetInternalFormat (theSizedFormat);
      aFormat.SetPixelFormat (GL_RED_INTEGER);
      aFormat.SetDataType (GL_INT);
      return aFormat;
    }
    case GL_RG32I:
    {
      aFormat.SetNbComponents (2);
      aFormat.SetInternalFormat (theSizedFormat);
      aFormat.SetPixelFormat (GL_RG_INTEGER);
      aFormat.SetDataType (GL_INT);
      return aFormat;
    }
    // depth formats
    case GL_DEPTH24_STENCIL8:
    {
      aFormat.SetNbComponents (2);
      aFormat.SetInternalFormat (theSizedFormat);
      aFormat.SetPixelFormat (GL_DEPTH_STENCIL);
      aFormat.SetDataType (GL_UNSIGNED_INT_24_8);
      return aFormat;
    }
    case GL_DEPTH32F_STENCIL8:
    {
      aFormat.SetNbComponents (2);
      aFormat.SetInternalFormat (theSizedFormat);
      aFormat.SetPixelFormat (GL_DEPTH_STENCIL);
      aFormat.SetDataType (GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
      return aFormat;
    }
    case GL_DEPTH_COMPONENT16:
    {
      aFormat.SetNbComponents (1);
      aFormat.SetInternalFormat (theSizedFormat);
      aFormat.SetPixelFormat (GL_DEPTH_COMPONENT);
      aFormat.SetDataType (GL_UNSIGNED_SHORT);
      return aFormat;
    }
    case GL_DEPTH_COMPONENT24:
    {
      aFormat.SetNbComponents (1);
      aFormat.SetInternalFormat (theSizedFormat);
      aFormat.SetPixelFormat (GL_DEPTH_COMPONENT);
      aFormat.SetDataType (GL_UNSIGNED_INT);
      return aFormat;
    }
    case GL_DEPTH_COMPONENT32F:
    {
      aFormat.SetNbComponents (1);
      aFormat.SetInternalFormat (theSizedFormat);
      aFormat.SetPixelFormat (GL_DEPTH_COMPONENT);
      aFormat.SetDataType (GL_FLOAT);
      return aFormat;
    }
  }
  return aFormat;
}

// =======================================================================
// function : FindCompressedFormat
// purpose  :
// =======================================================================
OpenGl_TextureFormat OpenGl_TextureFormat::FindCompressedFormat (const Handle(OpenGl_Context)& theCtx,
                                                                 Image_CompressedFormat theFormat,
                                                                 bool theIsColorMap)
{
  OpenGl_TextureFormat aFormat;
  if (!theCtx->SupportedTextureFormats()->IsSupported (theFormat))
  {
    return aFormat;
  }

  switch (theFormat)
  {
    case Image_CompressedFormat_UNKNOWN:
    {
      return aFormat;
    }
    case Image_CompressedFormat_RGB_S3TC_DXT1:
    {
      aFormat.SetNbComponents (3);
      aFormat.SetPixelFormat (GL_RGB);
      aFormat.SetDataType (GL_UNSIGNED_BYTE);
      aFormat.SetInternalFormat (GL_COMPRESSED_RGB_S3TC_DXT1_EXT);
      if (theIsColorMap
       && theCtx->ToRenderSRGB())
      {
        aFormat.SetInternalFormat (GL_COMPRESSED_SRGB_S3TC_DXT1_EXT);
      }
      return aFormat;
    }
    case Image_CompressedFormat_RGBA_S3TC_DXT1:
    {
      aFormat.SetNbComponents (4);
      aFormat.SetPixelFormat (GL_RGBA);
      aFormat.SetDataType (GL_UNSIGNED_BYTE);
      aFormat.SetInternalFormat (GL_COMPRESSED_RGBA_S3TC_DXT1_EXT);
      if (theIsColorMap
       && theCtx->ToRenderSRGB())
      {
        aFormat.SetInternalFormat (GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT);
      }
      return aFormat;
    }
    case Image_CompressedFormat_RGBA_S3TC_DXT3:
    {
      aFormat.SetNbComponents (4);
      aFormat.SetPixelFormat (GL_RGBA);
      aFormat.SetDataType (GL_UNSIGNED_BYTE);
      aFormat.SetInternalFormat (GL_COMPRESSED_RGBA_S3TC_DXT3_EXT);
      if (theIsColorMap
       && theCtx->ToRenderSRGB())
      {
        aFormat.SetInternalFormat (GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT);
      }
      return aFormat;
    }
    case Image_CompressedFormat_RGBA_S3TC_DXT5:
    {
      aFormat.SetNbComponents (4);
      aFormat.SetPixelFormat (GL_RGBA);
      aFormat.SetDataType (GL_UNSIGNED_BYTE);
      aFormat.SetInternalFormat (GL_COMPRESSED_RGBA_S3TC_DXT5_EXT);
      if (theIsColorMap
       && theCtx->ToRenderSRGB())
      {
        aFormat.SetInternalFormat (GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT);
      }
      return aFormat;
    }
  }
  return aFormat;
}
Commit	Line	Data
ba00aab7	1	// Copyright (c) 2017-2019 OPEN CASCADE SAS
	2	//
	3	// This file is part of Open CASCADE Technology software library.
	4	//
	5	// This library is free software; you can redistribute it and/or modify it under
	6	// the terms of the GNU Lesser General Public License version 2.1 as published
	7	// by the Free Software Foundation, with special exception defined in the file
	8	// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
	9	// distribution for complete text of the license and disclaimer of any warranty.
	10	//
	11	// Alternatively, this file may be used under the terms of Open CASCADE
	12	// commercial license or contractual agreement.
	13
	14	#include <OpenGl_TextureFormat.hxx>
	15
faff3767	16	#include <Image_SupportedFormats.hxx>
ba00aab7	17	#include <OpenGl_Context.hxx>
ba00aab7	18
a46ab511	19	// =======================================================================
	20	// function : FormatFormat
	21	// purpose :
	22	// =======================================================================
	23	TCollection_AsciiString OpenGl_TextureFormat::FormatFormat (GLint theInternalFormat)
	24	{
	25	switch (theInternalFormat)
	26	{
	27	// RED variations (GL_RED, OpenGL 3.0+)
	28	case GL_RED: return "GL_RED";
	29	case GL_R8: return "GL_R8";
	30	case 0x822A: return "GL_R16";
	31	case GL_R16F: return "GL_R16F"; // half-float
	32	case GL_R32F: return "GL_R32F"; // float
	33	case GL_R32I: return "GL_R32I";
	34	case GL_RED_INTEGER: return "GL_RED_INTEGER";
	35	//
	36	case GL_RG: return "GL_RG";
	37	case GL_RG8: return "GL_RG8";
	38	case 0x822C: return "GL_RG16";
	39	case GL_RG16F: return "GL_RG16F";
	40	case GL_RG32F: return "GL_RG32F";
	41	case GL_RG32I: return "GL_RG32I";
	42	case GL_RG_INTEGER: return "GL_RG_INTEGER";
	43	// RGB variations
	44	case GL_RGB: return "GL_RGB";
	45	case 0x804F: return "GL_RGB4";
	46	case 0x8050: return "GL_RGB5";
	47	case GL_RGB8: return "GL_RGB8";
	48	case GL_SRGB8: return "GL_SRGB8";
	49	case 0x8052: return "GL_RGB10";
	50	case 0x8053: return "GL_RGB12";
	51	case 0x8054: return "GL_RGB16";
	52	case GL_RGB16F: return "GL_RGB16F"; // half-float
	53	case GL_RGB32F: return "GL_RGB32F"; // float
	54	case GL_RGB32I: return "GL_RGB32I";
	55	// RGBA variations
	56	case GL_RGBA: return "GL_RGBA";
	57	case GL_RGBA8: return "GL_RGBA8";
	58	case GL_SRGB8_ALPHA8: return "GL_SRGB8_ALPHA8";
	59	case GL_RGB10_A2: return "GL_RGB10_A2";
	60	case 0x805A: return "GL_RGBA12";
	61	case 0x805B: return "GL_RGBA16";
	62	case GL_RGBA16F: return "GL_RGBA16F"; // half-float
	63	case GL_RGBA32F: return "GL_RGBA32F"; // float
	64	case GL_RGBA32I: return "GL_RGBA32I";
	65	//
	66	case 0x80E0: return "GL_BGR";
	67	case GL_BGRA_EXT: return "GL_BGRA";
	68	// ALPHA variations (deprecated)
	69	case GL_ALPHA: return "GL_ALPHA";
	70	case 0x803C: return "GL_ALPHA8";
	71	case 0x803E: return "GL_ALPHA16";
	72	case GL_LUMINANCE: return "GL_LUMINANCE";
	73	case GL_LUMINANCE_ALPHA: return "GL_LUMINANCE_ALPHA";
	74	//
	75	case GL_DEPTH_COMPONENT: return "GL_DEPTH_COMPONENT";
	76	case GL_DEPTH_COMPONENT16: return "GL_DEPTH_COMPONENT16";
	77	case GL_DEPTH_COMPONENT24: return "GL_DEPTH_COMPONENT24";
	78	case GL_DEPTH_COMPONENT32F: return "GL_DEPTH_COMPONENT32F";
	79	case GL_DEPTH_STENCIL: return "GL_DEPTH_STENCIL";
	80	case GL_DEPTH24_STENCIL8: return "GL_DEPTH24_STENCIL8";
	81	case GL_DEPTH32F_STENCIL8: return "GL_DEPTH32F_STENCIL8";
	82	//
83	case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: return "GL_COMPRESSED_RGB_S3TC_DXT1_EXT";
84	case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT: return "GL_COMPRESSED_SRGB_S3TC_DXT1_EXT";
85	case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: return "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT";
86	case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: return "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT";
87	case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT: return "GL_COMPRESSED_RGBA_S3TC_DXT3_EXT";
88	case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: return "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT";
89	case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT: return "GL_COMPRESSED_RGBA_S3TC_DXT5_EXT";
90	case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: return "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT";
91	}
92	return OpenGl_Context::FormatGlEnumHex (theInternalFormat);
93	}
94
95	// =======================================================================
96	// function : FormatDataType
97	// purpose :
98	// =======================================================================
99	TCollection_AsciiString OpenGl_TextureFormat::FormatDataType (GLint theDataType)
100	{
101	switch (theDataType)
102	{
103	case GL_UNSIGNED_BYTE: return "GL_UNSIGNED_BYTE";
104	case GL_UNSIGNED_SHORT: return "GL_UNSIGNED_SHORT";
105	case GL_INT: return "GL_INT";
106	case GL_UNSIGNED_INT: return "GL_UNSIGNED_INT";
107	case GL_FLOAT: return "GL_FLOAT";
108	case GL_HALF_FLOAT: return "GL_HALF_FLOAT";
109	case 0x8D61: return "GL_HALF_FLOAT_OES";
110	case GL_UNSIGNED_INT_24_8: return "GL_UNSIGNED_INT_24_8";
111	case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: return "GL_FLOAT_32_UNSIGNED_INT_24_8_REV";
112	}
113	return OpenGl_Context::FormatGlEnumHex (theDataType);
114	}
115
ba00aab7	116	// =======================================================================
	117	// function : FindFormat
	118	// purpose :
	119	// =======================================================================
	120	OpenGl_TextureFormat OpenGl_TextureFormat::FindFormat (const Handle(OpenGl_Context)& theCtx,
	121	Image_Format theFormat,
	122	bool theIsColorMap)
	123	{
	124	OpenGl_TextureFormat aFormat;
8f8fe4a9	125	aFormat.SetImageFormat (theFormat);
92996979	126	#if defined(GL_ES_VERSION_2_0)
	127	const bool useRedRedAlpha = false;
	128	#else
43eddb47	129	const bool useRedRedAlpha = (theCtx->core11ffp == NULL);
92996979	130	#endif
ba00aab7	131	switch (theFormat)
	132	{
	133	case Image_Format_GrayF:
	134	{
	135	aFormat.SetNbComponents (1);
92996979	136	if (useRedRedAlpha)
ba00aab7	137	{
67312b79	138	aFormat.SetInternalFormat (theCtx->arbTexFloat ? GL_R32F : GL_R8);
ba00aab7	139	aFormat.SetPixelFormat (GL_RED);
	140	}
	141	else
	142	{
	143	#if !defined(GL_ES_VERSION_2_0)
	144	aFormat.SetInternalFormat (GL_LUMINANCE8);
	145	#else
	146	aFormat.SetInternalFormat (GL_LUMINANCE);
	147	#endif
	148	aFormat.SetPixelFormat (GL_LUMINANCE);
	149	}
	150	aFormat.SetDataType (GL_FLOAT);
	151	return aFormat;
	152	}
	153	case Image_Format_AlphaF:
	154	{
	155	aFormat.SetNbComponents (1);
92996979	156	if (useRedRedAlpha)
ba00aab7	157	{
67312b79	158	aFormat.SetInternalFormat (theCtx->arbTexFloat ? GL_R32F : GL_R8);
ba00aab7	159	aFormat.SetPixelFormat (GL_RED);
	160	}
	161	else
	162	{
	163	#if !defined(GL_ES_VERSION_2_0)
	164	aFormat.SetInternalFormat (GL_ALPHA8);
	165	#else
	166	aFormat.SetInternalFormat (GL_ALPHA);
	167	#endif
	168	aFormat.SetPixelFormat (GL_ALPHA);
	169	}
	170	aFormat.SetDataType (GL_FLOAT);
	171	return aFormat;
	172	}
67312b79	173	case Image_Format_RGF:
	174	{
	175	if (!theCtx->arbTexRG)
	176	{
	177	return OpenGl_TextureFormat();
	178	}
	179	aFormat.SetNbComponents (2);
	180	aFormat.SetInternalFormat (theCtx->arbTexFloat ? GL_RG32F : GL_RG8);
	181	aFormat.SetPixelFormat (GL_RG);
	182	aFormat.SetDataType (GL_FLOAT);
	183	return aFormat;
	184	}
ba00aab7	185	case Image_Format_RGBAF:
	186	{
	187	aFormat.SetNbComponents (4);
67312b79	188	aFormat.SetInternalFormat (theCtx->arbTexFloat ? GL_RGBA32F : GL_RGBA8);
ba00aab7	189	aFormat.SetPixelFormat (GL_RGBA);
	190	aFormat.SetDataType (GL_FLOAT);
	191	return aFormat;
	192	}
	193	case Image_Format_BGRAF:
	194	{
	195	if (!theCtx->IsGlGreaterEqual (1, 2) && !theCtx->extBgra)
	196	{
	197	return OpenGl_TextureFormat();
	198	}
	199	aFormat.SetNbComponents (4);
67312b79	200	aFormat.SetInternalFormat (theCtx->arbTexFloat ? GL_RGBA32F : GL_RGBA8);
ba00aab7	201	aFormat.SetPixelFormat (GL_BGRA_EXT); // equals to GL_BGRA
	202	aFormat.SetDataType (GL_FLOAT);
	203	return aFormat;
	204	}
	205	case Image_Format_RGBF:
	206	{
	207	aFormat.SetNbComponents (3);
67312b79	208	aFormat.SetInternalFormat (theCtx->arbTexFloat ? GL_RGB32F : GL_RGB8);
ba00aab7	209	aFormat.SetPixelFormat (GL_RGB);
	210	aFormat.SetDataType (GL_FLOAT);
	211	return aFormat;
	212	}
	213	case Image_Format_BGRF:
	214	{
	215	#if !defined(GL_ES_VERSION_2_0)
	216	aFormat.SetNbComponents (3);
67312b79	217	aFormat.SetInternalFormat (theCtx->arbTexFloat ? GL_RGB32F : GL_RGB8);
ba00aab7	218	aFormat.SetPixelFormat (GL_BGR); // equals to GL_BGR_EXT
	219	aFormat.SetDataType (GL_FLOAT);
	220	return aFormat;
	221	#else
	222	return OpenGl_TextureFormat();
	223	#endif
	224	}
1ac837b2	225	case Image_Format_RGF_half:
	226	{
	227	aFormat.SetNbComponents (2);
	228	aFormat.SetInternalFormat (GL_RG16F);
	229	aFormat.SetPixelFormat (GL_RG);
	230	aFormat.SetDataType (GL_HALF_FLOAT);
	231	if (theCtx->hasHalfFloatBuffer == OpenGl_FeatureInExtensions)
	232	{
	233	#if defined(GL_ES_VERSION_2_0)
	234	aFormat.SetDataType (GL_HALF_FLOAT_OES);
	235	#endif
	236	}
	237	return aFormat;
	238	}
	239	case Image_Format_RGBAF_half:
	240	{
	241	aFormat.SetNbComponents (4);
	242	aFormat.SetInternalFormat (GL_RGBA16F);
	243	aFormat.SetPixelFormat (GL_RGBA);
	244	aFormat.SetDataType (GL_HALF_FLOAT);
	245	if (theCtx->hasHalfFloatBuffer == OpenGl_FeatureInExtensions)
	246	{
	247	#if defined(GL_ES_VERSION_2_0)
	248	aFormat.SetDataType (GL_HALF_FLOAT_OES);
	249	#endif
	250	}
	251	return aFormat;
	252	}
ba00aab7	253	case Image_Format_RGBA:
	254	{
	255	aFormat.SetNbComponents (4);
	256	aFormat.SetInternalFormat (GL_RGBA8);
	257	aFormat.SetPixelFormat (GL_RGBA);
	258	aFormat.SetDataType (GL_UNSIGNED_BYTE);
	259	if (theIsColorMap
	260	&& theCtx->ToRenderSRGB())
	261	{
	262	aFormat.SetInternalFormat (GL_SRGB8_ALPHA8);
	263	}
	264	return aFormat;
	265	}
	266	case Image_Format_BGRA:
	267	{
	268	#if !defined(GL_ES_VERSION_2_0)
	269	if (!theCtx->IsGlGreaterEqual (1, 2)
	270	&& !theCtx->extBgra)
	271	{
	272	return OpenGl_TextureFormat();
	273	}
	274	aFormat.SetNbComponents (4);
	275	aFormat.SetInternalFormat (GL_RGBA8);
	276	if (theIsColorMap
	277	&& theCtx->ToRenderSRGB())
	278	{
	279	aFormat.SetInternalFormat (GL_SRGB8_ALPHA8);
	280	}
	281	#else
	282	if (theIsColorMap
	283	&& theCtx->ToRenderSRGB())
	284	{
	285	// GL_SRGB8_ALPHA8 with texture swizzling would be better
	286	}
	287	if (!theCtx->extBgra)
	288	{
	289	return OpenGl_TextureFormat();
	290	}
	291	aFormat.SetNbComponents (4);
faff3767	292	aFormat.SetInternalFormat (GL_BGRA_EXT);
ba00aab7	293	#endif
	294	aFormat.SetPixelFormat (GL_BGRA_EXT); // equals to GL_BGRA
	295	aFormat.SetDataType (GL_UNSIGNED_BYTE);
	296	return aFormat;
	297	}
	298	case Image_Format_RGB32:
	299	{
	300	#if !defined(GL_ES_VERSION_2_0)
	301	// ask driver to convert data to RGB8 to save memory
	302	aFormat.SetNbComponents (3);
	303	aFormat.SetInternalFormat (GL_RGB8);
	304	if (theIsColorMap
	305	&& theCtx->ToRenderSRGB())
	306	{
	307	aFormat.SetInternalFormat (GL_SRGB8);
	308	}
	309	#else
	310	// conversion is not supported
	311	aFormat.SetNbComponents (4);
	312	aFormat.SetInternalFormat (GL_RGBA8);
	313	if (theIsColorMap
	314	&& theCtx->ToRenderSRGB())
	315	{
	316	aFormat.SetInternalFormat (GL_SRGB8_ALPHA8);
	317	}
	318	#endif
	319	aFormat.SetPixelFormat (GL_RGBA);
	320	aFormat.SetDataType (GL_UNSIGNED_BYTE);
	321	return aFormat;
	322	}
	323	case Image_Format_BGR32:
	324	{
	325	#if !defined(GL_ES_VERSION_2_0)
	326	if (!theCtx->IsGlGreaterEqual(1, 2) && !theCtx->extBgra)
	327	{
	328	return OpenGl_TextureFormat();
	329	}
	330	aFormat.SetNbComponents (3);
	331	aFormat.SetInternalFormat (GL_RGB8);
	332	if (theIsColorMap
	333	&& theCtx->ToRenderSRGB())
	334	{
	335	aFormat.SetInternalFormat (GL_SRGB8);
	336	}
	337	#else
	338	if (theIsColorMap
	339	&& theCtx->ToRenderSRGB())
	340	{
	341	// GL_SRGB8_ALPHA8 with texture swizzling would be better
	342	}
	343	if (!theCtx->extBgra)
	344	{
	345	return OpenGl_TextureFormat();
	346	}
	347	aFormat.SetNbComponents (4);
	348	aFormat.SetInternalFormat (GL_BGRA_EXT);
	349	#endif
	350	aFormat.SetPixelFormat (GL_BGRA_EXT); // equals to GL_BGRA
	351	aFormat.SetDataType (GL_UNSIGNED_BYTE);
	352	return aFormat;
	353	}
	354	case Image_Format_RGB:
	355	{
	356	aFormat.SetNbComponents (3);
357	aFormat.SetInternalFormat (GL_RGB8);
358	aFormat.SetPixelFormat (GL_RGB);
359	aFormat.SetDataType (GL_UNSIGNED_BYTE);
360	if (theIsColorMap
361	&& theCtx->ToRenderSRGB())
362	{
363	aFormat.SetInternalFormat (GL_SRGB8);
364	}
365	return aFormat;
366	}
367	case Image_Format_BGR:
368	{
369	#if !defined(GL_ES_VERSION_2_0)
370	if (!theCtx->IsGlGreaterEqual (1, 2)
371	&& !theCtx->extBgra)
372	{
373	return OpenGl_TextureFormat();
374	}
375	aFormat.SetNbComponents (3);
376	aFormat.SetInternalFormat (GL_RGB8);
377	if (theIsColorMap
378	&& theCtx->ToRenderSRGB())
379	{
380	aFormat.SetInternalFormat (GL_SRGB8);
381	}
382	aFormat.SetPixelFormat (GL_BGR); // equals to GL_BGR_EXT
383	aFormat.SetDataType (GL_UNSIGNED_BYTE);
384	#endif
385	return aFormat;
386	}
387	case Image_Format_Gray:
388	{
389	aFormat.SetNbComponents (1);
92996979	390	if (useRedRedAlpha)
ba00aab7	391	{
	392	aFormat.SetInternalFormat (GL_R8);
	393	aFormat.SetPixelFormat (GL_RED);
	394	}
	395	else
	396	{
	397	#if !defined(GL_ES_VERSION_2_0)
	398	aFormat.SetInternalFormat (GL_LUMINANCE8);
	399	#else
	400	aFormat.SetInternalFormat (GL_LUMINANCE);
	401	#endif
	402	aFormat.SetPixelFormat (GL_LUMINANCE);
	403	}
	404	aFormat.SetDataType (GL_UNSIGNED_BYTE);
	405	return aFormat;
	406	}
	407	case Image_Format_Alpha:
	408	{
	409	aFormat.SetNbComponents (1);
92996979	410	if (useRedRedAlpha)
ba00aab7	411	{
	412	aFormat.SetInternalFormat (GL_R8);
	413	aFormat.SetPixelFormat (GL_RED);
	414	}
	415	else
	416	{
	417	#if !defined(GL_ES_VERSION_2_0)
	418	aFormat.SetInternalFormat (GL_ALPHA8);
	419	#else
	420	aFormat.SetInternalFormat (GL_ALPHA);
	421	#endif
	422	aFormat.SetPixelFormat (GL_ALPHA);
	423	}
	424	aFormat.SetDataType (GL_UNSIGNED_BYTE);
	425	return aFormat;
	426	}
	427	case Image_Format_UNKNOWN:
	428	{
	429	return OpenGl_TextureFormat();
	430	}
	431	}
	432	return OpenGl_TextureFormat();
	433	}
	434
	435	// =======================================================================
	436	// function : FindSizedFormat
	437	// purpose :
	438	// =======================================================================
	439	OpenGl_TextureFormat OpenGl_TextureFormat::FindSizedFormat (const Handle(OpenGl_Context)& theCtx,
	440	GLint theSizedFormat)
	441	{
	442	OpenGl_TextureFormat aFormat;
	443	switch (theSizedFormat)
	444	{
	445	case GL_RGBA32F:
	446	{
	447	aFormat.SetNbComponents (4);
	448	aFormat.SetInternalFormat (theSizedFormat);
	449	aFormat.SetPixelFormat (GL_RGBA);
	450	aFormat.SetDataType (GL_FLOAT);
8f8fe4a9	451	aFormat.SetImageFormat (Image_Format_RGBAF);
ba00aab7	452	return aFormat;
	453	}
	454	case GL_R32F:
	455	{
	456	aFormat.SetNbComponents (1);
	457	aFormat.SetInternalFormat (theSizedFormat);
	458	aFormat.SetPixelFormat (GL_RED);
	459	aFormat.SetDataType (GL_FLOAT);
8f8fe4a9	460	aFormat.SetImageFormat (Image_Format_GrayF);
ba00aab7	461	return aFormat;
ba00aab7	462	}
78c4e836	463	case GL_RG32F:
	464	{
	465	aFormat.SetNbComponents (1);
	466	aFormat.SetInternalFormat (theSizedFormat);
	467	aFormat.SetPixelFormat (GL_RG);
	468	aFormat.SetDataType (GL_FLOAT);
8f8fe4a9	469	aFormat.SetImageFormat (Image_Format_RGF);
78c4e836	470	return aFormat;
78c4e836	471	}
ba00aab7	472	case GL_RGBA16F:
	473	{
	474	aFormat.SetNbComponents (4);
	475	aFormat.SetInternalFormat (theSizedFormat);
	476	aFormat.SetPixelFormat (GL_RGBA);
	477	aFormat.SetDataType (GL_HALF_FLOAT);
1ac837b2	478	aFormat.SetImageFormat (Image_Format_RGBAF_half);
ba00aab7	479	if (theCtx->hasHalfFloatBuffer == OpenGl_FeatureInExtensions)
	480	{
	481	#if defined(GL_ES_VERSION_2_0)
	482	aFormat.SetDataType (GL_HALF_FLOAT_OES);
	483	#else
	484	aFormat.SetDataType (GL_FLOAT);
	485	#endif
	486	}
	487	return aFormat;
	488	}
	489	case GL_R16F:
	490	{
	491	aFormat.SetNbComponents (1);
	492	aFormat.SetInternalFormat (theSizedFormat);
	493	aFormat.SetPixelFormat (GL_RED);
	494	aFormat.SetDataType (GL_HALF_FLOAT);
8f8fe4a9	495	aFormat.SetImageFormat (Image_Format_GrayF);
ba00aab7	496	if (theCtx->hasHalfFloatBuffer == OpenGl_FeatureInExtensions)
	497	{
	498	#if defined(GL_ES_VERSION_2_0)
	499	aFormat.SetDataType (GL_HALF_FLOAT_OES);
	500	#else
	501	aFormat.SetDataType (GL_FLOAT);
	502	#endif
	503	}
	504	return aFormat;
1ac837b2	505	}
	506	case GL_RG16F:
	507	{
	508	aFormat.SetNbComponents (2);
	509	aFormat.SetInternalFormat (theSizedFormat);
	510	aFormat.SetPixelFormat (GL_RG);
	511	aFormat.SetDataType (GL_HALF_FLOAT);
	512	aFormat.SetImageFormat (Image_Format_RGF_half);
	513	if (theCtx->hasHalfFloatBuffer == OpenGl_FeatureInExtensions)
	514	{
	515	#if defined(GL_ES_VERSION_2_0)
	516	aFormat.SetDataType (GL_HALF_FLOAT_OES);
	517	#else
	518	aFormat.SetDataType (GL_FLOAT);
	519	#endif
	520	}
	521	return aFormat;
ba00aab7	522	}
	523	case GL_SRGB8_ALPHA8:
	524	case GL_RGBA8:
	525	case GL_RGBA:
	526	{
	527	aFormat.SetNbComponents (4);
	528	aFormat.SetInternalFormat (theSizedFormat);
	529	aFormat.SetPixelFormat (GL_RGBA);
	530	aFormat.SetDataType (GL_UNSIGNED_BYTE);
8f8fe4a9	531	aFormat.SetImageFormat (Image_Format_RGBA);
ba00aab7	532	if (theSizedFormat == GL_SRGB8_ALPHA8
	533	&& !theCtx->ToRenderSRGB())
	534	{
	535	aFormat.SetInternalFormat (GL_RGBA8); // fallback format
	536	}
	537	return aFormat;
	538	}
	539	case GL_SRGB8:
	540	case GL_RGB8:
	541	case GL_RGB:
	542	{
	543	aFormat.SetNbComponents (3);
	544	aFormat.SetInternalFormat (theSizedFormat);
	545	aFormat.SetPixelFormat (GL_RGB);
	546	aFormat.SetDataType (GL_UNSIGNED_BYTE);
8f8fe4a9	547	aFormat.SetImageFormat (Image_Format_RGB);
ba00aab7	548	if (theSizedFormat == GL_SRGB8
	549	&& !theCtx->ToRenderSRGB())
	550	{
	551	aFormat.SetInternalFormat (GL_RGB8); // fallback format
	552	}
	553	return aFormat;
	554	}
	555	// integer types
	556	case GL_R32I:
	557	{
	558	aFormat.SetNbComponents (1);
	559	aFormat.SetInternalFormat (theSizedFormat);
	560	aFormat.SetPixelFormat (GL_RED_INTEGER);
	561	aFormat.SetDataType (GL_INT);
	562	return aFormat;
	563	}
	564	case GL_RG32I:
	565	{
	566	aFormat.SetNbComponents (2);
	567	aFormat.SetInternalFormat (theSizedFormat);
	568	aFormat.SetPixelFormat (GL_RG_INTEGER);
	569	aFormat.SetDataType (GL_INT);
	570	return aFormat;
	571	}
	572	// depth formats
	573	case GL_DEPTH24_STENCIL8:
	574	{
	575	aFormat.SetNbComponents (2);
	576	aFormat.SetInternalFormat (theSizedFormat);
	577	aFormat.SetPixelFormat (GL_DEPTH_STENCIL);
	578	aFormat.SetDataType (GL_UNSIGNED_INT_24_8);
	579	return aFormat;
	580	}
	581	case GL_DEPTH32F_STENCIL8:
	582	{
	583	aFormat.SetNbComponents (2);
	584	aFormat.SetInternalFormat (theSizedFormat);
	585	aFormat.SetPixelFormat (GL_DEPTH_STENCIL);
	586	aFormat.SetDataType (GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
	587	return aFormat;
	588	}
	589	case GL_DEPTH_COMPONENT16:
	590	{
	591	aFormat.SetNbComponents (1);
	592	aFormat.SetInternalFormat (theSizedFormat);
	593	aFormat.SetPixelFormat (GL_DEPTH_COMPONENT);
	594	aFormat.SetDataType (GL_UNSIGNED_SHORT);
	595	return aFormat;
	596	}
	597	case GL_DEPTH_COMPONENT24:
	598	{
	599	aFormat.SetNbComponents (1);
	600	aFormat.SetInternalFormat (theSizedFormat);
	601	aFormat.SetPixelFormat (GL_DEPTH_COMPONENT);
	602	aFormat.SetDataType (GL_UNSIGNED_INT);
	603	return aFormat;
	604	}
	605	case GL_DEPTH_COMPONENT32F:
	606	{
	607	aFormat.SetNbComponents (1);
	608	aFormat.SetInternalFormat (theSizedFormat);
	609	aFormat.SetPixelFormat (GL_DEPTH_COMPONENT);
	610	aFormat.SetDataType (GL_FLOAT);
	611	return aFormat;
612	}
613	}
614	return aFormat;
615	}
faff3767	616
	617	// =======================================================================
	618	// function : FindCompressedFormat
	619	// purpose :
	620	// =======================================================================
	621	OpenGl_TextureFormat OpenGl_TextureFormat::FindCompressedFormat (const Handle(OpenGl_Context)& theCtx,
	622	Image_CompressedFormat theFormat,
	623	bool theIsColorMap)
	624	{
	625	OpenGl_TextureFormat aFormat;
	626	if (!theCtx->SupportedTextureFormats()->IsSupported (theFormat))
	627	{
	628	return aFormat;
	629	}
	630
	631	switch (theFormat)
	632	{
	633	case Image_CompressedFormat_UNKNOWN:
	634	{
	635	return aFormat;
	636	}
	637	case Image_CompressedFormat_RGB_S3TC_DXT1:
	638	{
	639	aFormat.SetNbComponents (3);
	640	aFormat.SetPixelFormat (GL_RGB);
	641	aFormat.SetDataType (GL_UNSIGNED_BYTE);
	642	aFormat.SetInternalFormat (GL_COMPRESSED_RGB_S3TC_DXT1_EXT);
	643	if (theIsColorMap
	644	&& theCtx->ToRenderSRGB())
	645	{
	646	aFormat.SetInternalFormat (GL_COMPRESSED_SRGB_S3TC_DXT1_EXT);
	647	}
	648	return aFormat;
	649	}
	650	case Image_CompressedFormat_RGBA_S3TC_DXT1:
	651	{
	652	aFormat.SetNbComponents (4);
	653	aFormat.SetPixelFormat (GL_RGBA);
	654	aFormat.SetDataType (GL_UNSIGNED_BYTE);
	655	aFormat.SetInternalFormat (GL_COMPRESSED_RGBA_S3TC_DXT1_EXT);
	656	if (theIsColorMap
	657	&& theCtx->ToRenderSRGB())
	658	{
	659	aFormat.SetInternalFormat (GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT);
	660	}
	661	return aFormat;
	662	}
	663	case Image_CompressedFormat_RGBA_S3TC_DXT3:
	664	{
	665	aFormat.SetNbComponents (4);
	666	aFormat.SetPixelFormat (GL_RGBA);
	667	aFormat.SetDataType (GL_UNSIGNED_BYTE);
	668	aFormat.SetInternalFormat (GL_COMPRESSED_RGBA_S3TC_DXT3_EXT);
	669	if (theIsColorMap
	670	&& theCtx->ToRenderSRGB())
	671	{
	672	aFormat.SetInternalFormat (GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT);
	673	}
	674	return aFormat;
	675	}
	676	case Image_CompressedFormat_RGBA_S3TC_DXT5:
	677	{
	678	aFormat.SetNbComponents (4);
	679	aFormat.SetPixelFormat (GL_RGBA);
680	aFormat.SetDataType (GL_UNSIGNED_BYTE);
681	aFormat.SetInternalFormat (GL_COMPRESSED_RGBA_S3TC_DXT5_EXT);
682	if (theIsColorMap
683	&& theCtx->ToRenderSRGB())
684	{
685	aFormat.SetInternalFormat (GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT);
686	}
687	return aFormat;
688	}
689	}
690	return aFormat;
691	}