ExrLoader.cpp

Go to the documentation of this file.

#include "Engine/Texture/Texture.h"
#include "plog/Log.h"
 
#include <Engine/Texture/ExrLoader.h>
#include <complex>
#include <tinyexr.h>
 
namespace EngineCore {
    ExrHeader::ExrHeader(EXRHeader header) :
        valid(true),
        name(header.name),
        num_channels(header.num_channels),
        compression_type(header.compression_type)
    {
        // Deep copy channel information
        channels.reserve(header.num_channels);
        for (int i = 0; i < header.num_channels; ++i) {
            ExrChannelInfo channelInfo;
            channelInfo.name = std::string(header.channels[i].name);
            channelInfo.pixel_type = header.channels[i].pixel_type;
            channelInfo.x_sampling = header.channels[i].x_sampling;
            channelInfo.y_sampling = header.channels[i].y_sampling;
            channelInfo.p_linear = header.channels[i].p_linear;
            channels.push_back(channelInfo);
        }
    }

    tinygltf::Image ExrLoader::load(const std::filesystem::path &filename) {
        TRACY_ZONE_SCOPED_NAMED("ExrLoader::load");
        EXRImage exrImage;
        InitEXRImage(&exrImage);
 
        const char *err = nullptr; // Pointer to an error string
 
        const std::filesystem::path abs_path = std::filesystem::absolute(filename);
        const std::string file_str = abs_path.string(); // Store the string to ensure lifetime
        const char *file_c_str = file_str.c_str(); // Use c_str() from the owned string
 
        PLOGI << "ExrLoader: input=" << filename << " absolute=" << abs_path
              << " exists=" << std::filesystem::exists(abs_path);
 
        // Load the actual EXR header for image loading
        EXRHeader header;
        InitEXRHeader(&header);
        const EXRVersion version = {};
        
        int parseResult = ParseEXRHeaderFromFile(&header, &version, file_c_str, &err);
        if (parseResult != TINYEXR_SUCCESS) {
            if (err) {
                PLOGE << "Error parsing EXR header: " << err;
                FreeEXRErrorMessage(err);
            } else {
                PLOGE << "Unknown error while parsing EXR file";
            }
            FreeEXRImage(&exrImage);
            FreeEXRHeader(&header);
            return {};
        }
 
        // load the actual image data
        int result = LoadEXRImageFromFile(&exrImage, &header, file_c_str, &err);
        if (result != TINYEXR_SUCCESS) {
            if (err) {
                PLOGE << "Error parsing EXR file: " << err;
                FreeEXRErrorMessage(err);
            } else {
                PLOGE << "Unknown error while parsing EXR file";
            }
            FreeEXRImage(&exrImage);
            FreeEXRHeader(&header);
            return {};
        }
 
        PLOGI << "Loaded EXR: " << exrImage.width << "x" << exrImage.height
          << " with " << exrImage.num_channels << " channels.";
 
        tinygltf::Image image;
        image.width = exrImage.width;
        image.height = exrImage.height;
        image.mimeType = "image/x-exr"; // Custom MIME type for EXR
        image.uri = filename.string(); // Store the string directly
        image.name = file_str;
 
        // tinyexr's LoadEXRImageFromFile typically converts channels to 32-bit float
        // (TINYEXR_PIXELTYPE_FLOAT) and stores them as `float*` in `exrImage_struct.images`.
        image.bits = 32;
        image.pixel_type = TINYGLTF_COMPONENT_TYPE_FLOAT;
        image.component = exrImage.num_channels; // Use actual number of channels
 
        // Check if we have at least 3 channels (RGB) for common glTF usage
        if (image.component < 3) {
            PLOGW << "EXR has less than 3 channels (" << image.component << "). glTF might expect RGB.";
            // You might want to pad with zeros or return an error here depending on requirements.
            // For now, we'll copy existing channels and pad implicitly with zero bytes if component > num_channels.
        }
 
        // Calculate total bytes for the interleaved image data
        // Each component is 32 bits (4 bytes)
        const size_t bytes_per_component = image.bits / 8; // Should be 4
        const size_t totalPixels = static_cast<size_t>(image.width) * image.height;
        const size_t totalBytes = totalPixels * image.component * bytes_per_component;
        image.image.resize(totalBytes);
 
        // Prepare pointers to source channels (they are planar in exrImage_struct.images)
        // Assuming up to 4 channels (RGBA) for convenience
        float *src_channels[4] = {nullptr, nullptr, nullptr, nullptr};
        for (int c = 0; c < std::min(exrImage.num_channels, 4); ++c) {
            src_channels[c] = reinterpret_cast<float *>(exrImage.images[c]);
        }
 
        // Interleave the planar float data into the tinygltf::Image's byte vector
        unsigned char *dest_ptr = image.image.data();
        for (int y = 0; y < image.height; ++y) {
            for (int x = 0; x < image.width; ++x) {
                int pixel_idx = y * image.width + x;
                for (int c = 0; c < image.component; ++c) {
                    float value = 0.0f; // Default value for padding missing channels
                    if (c == 3) {
                        // Default alpha to 1.0 if not present
                        value = 1.0f;
                    }
 
                    // Determine the actual source channel index for the current destination channel (c)
                    int actual_src_channel_idx = c;
                    if (image.component >= 3) {
                        // Only swap if we have at least RGB channels
                        if (c == 0) {
                            // If current destination is Red (channel 0)
                            actual_src_channel_idx = 2; // Get data from source's Blue channel (channel 2)
                        } else if (c == 2) {
                            // If current destination is Blue (channel 2)
                            actual_src_channel_idx = 0; // Get data from source's Red channel (channel 0)
                        }
                        // Green (channel 1) remains Green (channel 1 from source)
                        // Alpha (channel 3) remains Alpha (channel 3 from source, if present)
                    }
 
                    // If source channel exists, use its value
                    if (actual_src_channel_idx < std::min(exrImage.num_channels, 4) && src_channels[
                            actual_src_channel_idx] != nullptr) {
                        value = src_channels[actual_src_channel_idx][pixel_idx];
                    }
 
                    // Copy the raw bytes of the float value
                    memcpy(dest_ptr, &value, bytes_per_component);
                    dest_ptr += bytes_per_component;
                }
            }
        }
 
        // 3. Clean up tinyexr memory
        FreeEXRImage(&exrImage);
        FreeEXRHeader(&header);
 
        return image;
    }

    ExrHeader ExrLoader::loadHeader(std::filesystem::path path) {
        TRACY_ZONE_SCOPED_NAMED("Parse EXR Header information");
        EXRHeader header;
        InitEXRHeader(&header);
        const EXRVersion version = {};
 
        const char *err = nullptr; // Pointer to an error string
 
        const std::string file_str = path.string(); // Store the string to ensure lifetime
        const char *file_c_str = file_str.c_str(); // Use c_str() from the owned string
 
        // 1. parse exr header
        int result = ParseEXRHeaderFromFile(&header, &version, file_c_str, &err);
        if (result != TINYEXR_SUCCESS) {
            if (err) {
                PLOGE << "Error parsing EXR header: " << err;
                FreeEXRErrorMessage(err);
            } else {
                PLOGE << "Unknown error while parsing EXR file";
            }
            FreeEXRHeader(&header);
            return ExrHeader();
        }
        ExrHeader headerWrapper = ExrHeader(header);
        FreeEXRHeader(&header);
        return headerWrapper;
    }
} // namespace EngineCore