Function DecodePixelData

renderdoc/maths/formatpacking.cpp:576–877

}

void DecodePixelData(const ResourceFormat &fmt, const byte *data, PixelValue &out, bool *success)
{
  out.floatValue = {0.0f, 0.0f, 0.0f, 1.0f};

  if(fmt.compType == CompType::UInt || fmt.compType == CompType::SInt || fmt.compCount == 4)
    out.floatValue[3] = 0.0f;

  const uint64_t dummy[2] = {0, 0};
  if(!data)
    data = (const byte *)dummy;

  // assume success, we'll set it to false if we hit an error
  if(success)
    *success = true;

  if(fmt.type == ResourceFormatType::R10G10B10A2)
  {
    if(fmt.compType == CompType::SNorm)
    {
      Vec4f v = ConvertFromR10G10B10A2SNorm(*(const uint32_t *)data);
      out.floatValue = {v.x, v.y, v.z, v.w};
    }
    else if(fmt.compType == CompType::UInt)
    {
      Vec4u v = ConvertFromR10G10B10A2UInt(*(const uint32_t *)data);
      out.uintValue = {v.x, v.y, v.z, v.w};
    }
    else
    {
      Vec4f v = ConvertFromR10G10B10A2(*(const uint32_t *)data);
      if(fmt.compType == CompType::SInt)
      {
        out.intValue = {(int32_t)v.x, (int32_t)v.y, (int32_t)v.z, (int32_t)v.w};
      }
      else
      {
        out.floatValue = {v.x, v.y, v.z, v.w};
      }
    }

    // the different types are a union so we can ignore format and just treat it as a data swap
    if(fmt.BGRAOrder())
      std::swap(out.uintValue[0], out.uintValue[2]);
  }
  else if(fmt.type == ResourceFormatType::R11G11B10)
  {
    Vec3f v = ConvertFromR11G11B10(*(const uint32_t *)data);
    out.floatValue = {v.x, v.y, v.z};
  }
  else if(fmt.type == ResourceFormatType::R5G5B5A1)
  {
    Vec4f v = ConvertFromB5G5R5A1(*(const uint16_t *)data);
    out.floatValue = {v.x, v.y, v.z, v.w};

    // conversely we *expect* BGRA order for this format and the above conversion implicitly flips
    // when bit-unpacking. So if the format wasn't BGRA order, flip it back
    if(!fmt.BGRAOrder())
      std::swap(out.floatValue[0], out.floatValue[2]);