examples/rendering-basic-pbr/ktx-loader.cpp

   1 /*
   2  * Copyright (c) 2023 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // FILE HEADER
  19 #include "ktx-loader.h"
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/devel-api/adaptor-framework/file-stream.h>
  23 #include <dali/integration-api/debug.h>
  24 #include <memory.h>
  25 #include <stdint.h>
  26 #include <stdio.h>
  27
  28 namespace PbrDemo
  29 {
  30 struct KtxFileHeader
  31 {
  32   char     identifier[12];
  33   uint32_t endianness;
  34   uint32_t glType; //(UNSIGNED_BYTE, UNSIGNED_SHORT_5_6_5, etc.)
  35   uint32_t glTypeSize;
  36   uint32_t glFormat;         //(RGB, RGBA, BGRA, etc.)
  37   uint32_t glInternalFormat; //For uncompressed textures, specifies the internalformat parameter passed to glTexStorage*D or glTexImage*D
  38   uint32_t glBaseInternalFormat;
  39   uint32_t pixelWidth;
  40   uint32_t pixelHeight;
  41   uint32_t pixelDepth;
  42   uint32_t numberOfArrayElements;
  43   uint32_t numberOfFaces; //Cube map faces are stored in the order: +X, -X, +Y, -Y, +Z, -Z.
  44   uint32_t numberOfMipmapLevels;
  45   uint32_t bytesOfKeyValueData;
  46 };
  47
  48 /**
  49  * Convert KTX format to Dali::Pixel::Format
  50  */
  51 bool ConvertPixelFormat(const uint32_t ktxPixelFormat, Dali::Pixel::Format& format)
  52 {
  53   switch(ktxPixelFormat)
  54   {
  55     case 0x93B0: // GL_COMPRESSED_RGBA_ASTC_4x4_KHR
  56     {
  57       format = Dali::Pixel::COMPRESSED_RGBA_ASTC_4x4_KHR;
  58       break;
  59     }
  60     case 0x881B: // GL_RGB16F
  61     {
  62       format = Dali::Pixel::RGB16F;
  63       break;
  64     }
  65     case 0x8815: // GL_RGB32F
  66     {
  67       format = Dali::Pixel::RGB32F;
  68       break;
  69     }
  70     case 0x8C3A: // GL_R11F_G11F_B10F
  71     {
  72       format = Dali::Pixel::R11G11B10F;
  73       break;
  74     }
  75     case 0x8D7C: // GL_RGBA8UI
  76     {
  77       format = Dali::Pixel::RGBA8888;
  78       break;
  79     }
  80     case 0x8D7D: // GL_RGB8UI
  81     {
  82       format = Dali::Pixel::RGB888;
  83       break;
  84     }
  85     default:
  86     {
  87       return false;
  88     }
  89   }
  90
  91   return true;
  92 }
  93
  94 bool LoadCubeMapFromKtxFile(const std::string& path, CubeData& cubedata)
  95 {
  96   Dali::FileStream daliFileStream(path);
  97   FILE*            fp(daliFileStream.GetFile());
  98   if(!fp)
  99   {
 100     return false;
 101   }
 102
 103   KtxFileHeader header;
 104   int           result = fread(&header, sizeof(KtxFileHeader), 1u, fp);
 105   if(0 == result)
 106   {
 107     return false;
 108   }
 109
 110   // Skip the key-values:
 111   if(fseek(fp, (long int)(header.bytesOfKeyValueData), SEEK_CUR))
 112   {
 113     return false;
 114   }
 115
 116   cubedata.img.resize(header.numberOfFaces);
 117
 118   for(unsigned int face = 0; face < header.numberOfFaces; ++face) //array_element must be 0 or 1
 119   {
 120     cubedata.img[face].resize(header.numberOfMipmapLevels);
 121   }
 122
 123   if(0 == header.numberOfMipmapLevels)
 124   {
 125     header.numberOfMipmapLevels = 1u;
 126   }
 127
 128   if(0 == header.numberOfArrayElements)
 129   {
 130     header.numberOfArrayElements = 1u;
 131   }
 132
 133   if(0 == header.pixelDepth)
 134   {
 135     header.pixelDepth = 1u;
 136   }
 137
 138   if(0 == header.pixelHeight)
 139   {
 140     header.pixelHeight = 1u;
 141   }
 142
 143   Dali::Pixel::Format daliformat = Pixel::RGB888;
 144
 145   ConvertPixelFormat(header.glInternalFormat, daliformat);
 146
 147   for(unsigned int mipmapLevel = 0; mipmapLevel < header.numberOfMipmapLevels; ++mipmapLevel)
 148   {
 149     uint32_t byteSize = 0;
 150     if(fread(&byteSize, sizeof(byteSize), 1u, fp) != 1)
 151     {
 152       return false;
 153     }
 154
 155     if(0 != byteSize % 4u)
 156     {
 157       byteSize += 4u - byteSize % 4u;
 158     }
 159
 160     for(unsigned int arrayElement = 0; arrayElement < header.numberOfArrayElements; ++arrayElement) // arrayElement must be 0 or 1
 161     {
 162       for(unsigned int face = 0; face < header.numberOfFaces; ++face)
 163       {
 164         std::unique_ptr<uint8_t, void (*)(void*)> img(static_cast<unsigned char*>(malloc(byteSize)), free); // resources will be freed when the PixelData is destroyed.
 165         if(fread(img.get(), byteSize, 1u, fp) != 1)
 166         {
 167           return false;
 168         }
 169         cubedata.img[face][mipmapLevel] = PixelData::New(img.release(), byteSize, header.pixelWidth, header.pixelHeight, daliformat, PixelData::FREE);
 170       }
 171     }
 172
 173     header.pixelHeight /= 2u;
 174     header.pixelWidth /= 2u;
 175   }
 176
 177   return true;
 178 }
 179
 180 } // namespace PbrDemo