Merge pull request #15264 from Zvork/hdr

Case 22045: Added support for OpenEXR files (mostly for skyboxes)

assignment-client/src/assets/AssetServer.cpp

@@ -33,7 +33,7 @@
 #include <NodeType.h>
 #include <SharedUtil.h>
 #include <PathUtils.h>
-#include <image/Image.h>
+#include <image/TextureProcessing.h>
 
 #include "AssetServerLogging.h"
 #include "BakeAssetTask.h"

cmake/macros/TargetOpenEXR.cmake

@@ -0,0 +1,74 @@
+#
+#  Copyright 2015 High Fidelity, Inc.
+#  Created by Olivier Prat on 2019/03/26
+#
+#  Distributed under the Apache License, Version 2.0.
+#  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+#
+macro(TARGET_OPENEXR)
+    if (NOT ANDROID)
+        set(openexr_config_file "${VCPKG_INSTALL_ROOT}/include/OpenEXR/OpenEXRConfig.h")
+        if(EXISTS ${openexr_config_file})
+            file(STRINGS
+                ${openexr_config_file}
+                TMP
+                REGEX "#define OPENEXR_VERSION_STRING.*$")
+            string(REGEX MATCHALL "[0-9.]+" OPENEXR_VERSION ${TMP})
+    
+            file(STRINGS
+                ${openexr_config_file}
+                TMP
+                REGEX "#define OPENEXR_VERSION_MAJOR.*$")
+            string(REGEX MATCHALL "[0-9]" OPENEXR_MAJOR_VERSION ${TMP})
+    
+            file(STRINGS
+                ${openexr_config_file}
+                TMP
+                REGEX "#define OPENEXR_VERSION_MINOR.*$")
+            string(REGEX MATCHALL "[0-9]" OPENEXR_MINOR_VERSION ${TMP})
+        endif()
+
+        foreach(OPENEXR_LIB
+            IlmImf
+            IlmImfUtil
+            Half
+            Iex
+            IexMath
+            Imath
+            IlmThread)
+
+            # OpenEXR libraries may be suffixed with the version number, so we search
+            # using both versioned and unversioned names.
+            find_library(OPENEXR_${OPENEXR_LIB}_LIBRARY_RELEASE
+                NAMES
+                    ${OPENEXR_LIB}-${OPENEXR_MAJOR_VERSION}_${OPENEXR_MINOR_VERSION}_s
+                    ${OPENEXR_LIB}_s
+
+                PATHS ${VCPKG_INSTALL_ROOT}/lib NO_DEFAULT_PATH
+            )
+            #mark_as_advanced(OPENEXR_${OPENEXR_LIB}_LIBRARY)
+
+            if(OPENEXR_${OPENEXR_LIB}_LIBRARY_RELEASE)
+                list(APPEND OPENEXR_LIBRARY_RELEASE ${OPENEXR_${OPENEXR_LIB}_LIBRARY_RELEASE})
+            endif()
+
+            # OpenEXR libraries may be suffixed with the version number, so we search
+            # using both versioned and unversioned names.
+            find_library(OPENEXR_${OPENEXR_LIB}_LIBRARY_DEBUG
+                NAMES
+                    ${OPENEXR_LIB}-${OPENEXR_MAJOR_VERSION}_${OPENEXR_MINOR_VERSION}_s_d
+                    ${OPENEXR_LIB}_s_d
+
+                PATHS ${VCPKG_INSTALL_ROOT}/debug/lib NO_DEFAULT_PATH
+            )
+            #mark_as_advanced(OPENEXR_${OPENEXR_LIB}_DEBUG_LIBRARY)
+
+            if(OPENEXR_${OPENEXR_LIB}_LIBRARY_DEBUG)
+                list(APPEND OPENEXR_LIBRARY_DEBUG ${OPENEXR_${OPENEXR_LIB}_LIBRARY_DEBUG})
+            endif()
+        endforeach(OPENEXR_LIB)
+
+        select_library_configurations(OPENEXR)
+        target_link_libraries(${TARGET_NAME} ${OPENEXR_LIBRARY})
+    endif()
+endmacro()

cmake/ports/hifi-deps/CONTROL

@@ -1,4 +1,4 @@
 Source: hifi-deps
-Version: 0
+Version: 0.1
 Description: Collected dependencies for High Fidelity applications
-Build-Depends: bullet3, draco, etc2comp, glm, nvtt, openssl (windows), tbb (!android&!osx), zlib
+Build-Depends: bullet3, draco, etc2comp, glm, nvtt, openexr (!android), openssl (windows), tbb (!android&!osx), zlib

cmake/ports/openexr/CONTROL

@@ -0,0 +1,4 @@
+Source: openexr
+Version: 2.3.0-2
+Description: OpenEXR is a high dynamic-range (HDR) image file format developed by Industrial Light & Magic for use in computer imaging applications
+Build-Depends: zlib

cmake/ports/openexr/FindOpenEXR.cmake

@@ -0,0 +1,87 @@
+include(FindPackageHandleStandardArgs)
+
+find_path(OpenEXR_INCLUDE_DIRS OpenEXR/OpenEXRConfig.h)
+find_path(OPENEXR_INCLUDE_PATHS NAMES ImfRgbaFile.h PATH_SUFFIXES OpenEXR)
+
+file(STRINGS "${OpenEXR_INCLUDE_DIRS}/OpenEXR/OpenEXRConfig.h" OPENEXR_CONFIG_H)
+
+string(REGEX REPLACE "^.*define OPENEXR_VERSION_MAJOR ([0-9]+).*$" "\\1" OpenEXR_VERSION_MAJOR "${OPENEXR_CONFIG_H}")
+string(REGEX REPLACE "^.*define OPENEXR_VERSION_MINOR ([0-9]+).*$" "\\1" OpenEXR_VERSION_MINOR "${OPENEXR_CONFIG_H}")
+set(OpenEXR_LIB_SUFFIX "${OpenEXR_VERSION_MAJOR}_${OpenEXR_VERSION_MINOR}")
+
+include(SelectLibraryConfigurations)
+
+if(NOT OpenEXR_BASE_LIBRARY)
+  find_library(OpenEXR_BASE_LIBRARY_RELEASE NAMES IlmImf-${OpenEXR_LIB_SUFFIX})
+  find_library(OpenEXR_BASE_LIBRARY_DEBUG NAMES IlmImf-${OpenEXR_LIB_SUFFIX}_d)
+  select_library_configurations(OpenEXR_BASE)
+endif()
+
+if(NOT OpenEXR_UTIL_LIBRARY)
+  find_library(OpenEXR_UTIL_LIBRARY_RELEASE NAMES IlmImfUtil-${OpenEXR_LIB_SUFFIX})
+  find_library(OpenEXR_UTIL_LIBRARY_DEBUG NAMES IlmImfUtil-${OpenEXR_LIB_SUFFIX}_d)
+  select_library_configurations(OpenEXR_UTIL)
+endif()
+
+if(NOT OpenEXR_HALF_LIBRARY)
+  find_library(OpenEXR_HALF_LIBRARY_RELEASE NAMES Half-${OpenEXR_LIB_SUFFIX})
+  find_library(OpenEXR_HALF_LIBRARY_DEBUG NAMES Half-${OpenEXR_LIB_SUFFIX}_d)
+  select_library_configurations(OpenEXR_HALF)
+endif()
+
+if(NOT OpenEXR_IEX_LIBRARY)
+  find_library(OpenEXR_IEX_LIBRARY_RELEASE NAMES Iex-${OpenEXR_LIB_SUFFIX})
+  find_library(OpenEXR_IEX_LIBRARY_DEBUG NAMES Iex-${OpenEXR_LIB_SUFFIX}_d)
+  select_library_configurations(OpenEXR_IEX)
+endif()
+
+if(NOT OpenEXR_MATH_LIBRARY)
+  find_library(OpenEXR_MATH_LIBRARY_RELEASE NAMES Imath-${OpenEXR_LIB_SUFFIX})
+  find_library(OpenEXR_MATH_LIBRARY_DEBUG NAMES Imath-${OpenEXR_LIB_SUFFIX}_d)
+  select_library_configurations(OpenEXR_MATH)
+endif()
+
+if(NOT OpenEXR_THREAD_LIBRARY)
+  find_library(OpenEXR_THREAD_LIBRARY_RELEASE NAMES IlmThread-${OpenEXR_LIB_SUFFIX})
+  find_library(OpenEXR_THREAD_LIBRARY_DEBUG NAMES IlmThread-${OpenEXR_LIB_SUFFIX}_d)
+  select_library_configurations(OpenEXR_THREAD)
+endif()
+
+if(NOT OpenEXR_IEXMATH_LIBRARY)
+  find_library(OpenEXR_IEXMATH_LIBRARY_RELEASE NAMES IexMath-${OpenEXR_LIB_SUFFIX})
+  find_library(OpenEXR_IEXMATH_LIBRARY_DEBUG NAMES IexMath-${OpenEXR_LIB_SUFFIX}d)
+  select_library_configurations(OpenEXR_IEXMATH)
+endif()
+
+set(OPENEXR_HALF_LIBRARY "${OpenEXR_HALF_LIBRARY}")
+set(OPENEXR_IEX_LIBRARY "${OpenEXR_IEX_LIBRARY}")
+set(OPENEXR_IMATH_LIBRARY "${OpenEXR_MATH_LIBRARY}")
+set(OPENEXR_ILMIMF_LIBRARY "${OpenEXR_BASE_LIBRARY}")
+set(OPENEXR_ILMIMFUTIL_LIBRARY "${OpenEXR_UTIL_LIBRARY}")
+set(OPENEXR_ILMTHREAD_LIBRARY "${OpenEXR_THREAD_LIBRARY}")
+
+set(OpenEXR_LIBRARY "${OpenEXR_BASE_LIBRARY}")
+
+set(OpenEXR_LIBRARIES
+    ${OpenEXR_LIBRARY}
+    ${OpenEXR_MATH_LIBRARY}
+    ${OpenEXR_IEXMATH_LIBRARY}
+    ${OpenEXR_UTIL_LIBRARY}
+    ${OpenEXR_HALF_LIBRARY}
+    ${OpenEXR_IEX_LIBRARY}
+    ${OpenEXR_THREAD_LIBRARY}
+)
+
+set(OPENEXR_LIBRARIES
+    ${OPENEXR_HALF_LIBRARY}
+    ${OPENEXR_IEX_LIBRARY}
+    ${OPENEXR_IMATH_LIBRARY}
+    ${OPENEXR_ILMIMF_LIBRARY}
+    ${OPENEXR_ILMTHREAD_LIBRARY}
+)
+
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(OpenEXR REQUIRED_VARS OpenEXR_LIBRARIES OpenEXR_INCLUDE_DIRS)
+
+if(OpenEXR_FOUND)
+    set(OPENEXR_FOUND 1)
+endif()

cmake/ports/openexr/fix_install_ilmimf.patch

@@ -0,0 +1,19 @@
+diff --git a/OpenEXR/IlmImf/CMakeLists.txt b/OpenEXR/IlmImf/CMakeLists.txt
+index e1a8740..d31cf68 100644
+--- a/OpenEXR/IlmImf/CMakeLists.txt
++++ b/OpenEXR/IlmImf/CMakeLists.txt
+@@ -2,14 +2,6 @@
+ 
+ SET(CMAKE_INCLUDE_CURRENT_DIR 1)
+ 
+-IF (WIN32)
+-  SET(RUNTIME_DIR ${OPENEXR_PACKAGE_PREFIX}/bin)
+-  SET(WORKING_DIR ${RUNTIME_DIR})
+-ELSE ()
+-  SET(RUNTIME_DIR ${OPENEXR_PACKAGE_PREFIX}/lib)
+-  SET(WORKING_DIR .)
+-ENDIF ()
+-
+ SET(BUILD_B44EXPLOGTABLE OFF)
+ IF (NOT EXISTS "${CMAKE_CURRENT_BINARY_DIR}/b44ExpLogTable.h")
+   SET(BUILD_B44EXPLOGTABLE ON)

cmake/ports/openexr/portfile.cmake

@@ -0,0 +1,74 @@
+include(vcpkg_common_functions)
+
+set(OPENEXR_VERSION 2.3.0)
+set(OPENEXR_HASH 268ae64b40d21d662f405fba97c307dad1456b7d996a447aadafd41b640ca736d4851d9544b4741a94e7b7c335fe6e9d3b16180e710671abfc0c8b2740b147b2)
+
+vcpkg_from_github(
+  OUT_SOURCE_PATH SOURCE_PATH
+  REPO openexr/openexr
+  REF v${OPENEXR_VERSION}
+  SHA512 ${OPENEXR_HASH}
+  HEAD_REF master
+  PATCHES "fix_install_ilmimf.patch"
+)
+
+set(OPENEXR_STATIC ON)
+set(OPENEXR_SHARED OFF)
+
+vcpkg_configure_cmake(SOURCE_PATH ${SOURCE_PATH}
+  PREFER_NINJA
+  OPTIONS
+    -DOPENEXR_BUILD_PYTHON_LIBS=OFF
+    -DOPENEXR_BUILD_VIEWERS=OFF
+    -DOPENEXR_ENABLE_TESTS=OFF
+    -DOPENEXR_RUN_FUZZ_TESTS=OFF
+    -DOPENEXR_BUILD_SHARED=${OPENEXR_SHARED}
+    -DOPENEXR_BUILD_STATIC=${OPENEXR_STATIC}
+  OPTIONS_DEBUG
+    -DILMBASE_PACKAGE_PREFIX=${CURRENT_INSTALLED_DIR}/debug
+  OPTIONS_RELEASE
+    -DILMBASE_PACKAGE_PREFIX=${CURRENT_INSTALLED_DIR})
+
+vcpkg_install_cmake()
+
+file(REMOVE_RECURSE ${CURRENT_PACKAGES_DIR}/debug/include)
+file(REMOVE_RECURSE ${CURRENT_PACKAGES_DIR}/debug/share)
+
+# NOTE: Only use ".exe" extension on Windows executables.
+# Is there a cleaner way to do this?
+if(WIN32)
+    set(EXECUTABLE_SUFFIX ".exe")
+else()
+    set(EXECUTABLE_SUFFIX "")
+endif()
+file(REMOVE ${CURRENT_PACKAGES_DIR}/debug/bin/exrenvmap${EXECUTABLE_SUFFIX})
+file(REMOVE ${CURRENT_PACKAGES_DIR}/debug/bin/exrheader${EXECUTABLE_SUFFIX})
+file(REMOVE ${CURRENT_PACKAGES_DIR}/debug/bin/exrmakepreview${EXECUTABLE_SUFFIX})
+file(REMOVE ${CURRENT_PACKAGES_DIR}/debug/bin/exrmaketiled${EXECUTABLE_SUFFIX})
+file(REMOVE ${CURRENT_PACKAGES_DIR}/debug/bin/exrmultipart${EXECUTABLE_SUFFIX})
+file(REMOVE ${CURRENT_PACKAGES_DIR}/debug/bin/exrmultiview${EXECUTABLE_SUFFIX})
+file(REMOVE ${CURRENT_PACKAGES_DIR}/debug/bin/exrstdattr${EXECUTABLE_SUFFIX})
+file(REMOVE ${CURRENT_PACKAGES_DIR}/bin/exrenvmap${EXECUTABLE_SUFFIX})
+file(REMOVE ${CURRENT_PACKAGES_DIR}/bin/exrheader${EXECUTABLE_SUFFIX})
+file(REMOVE ${CURRENT_PACKAGES_DIR}/bin/exrmakepreview${EXECUTABLE_SUFFIX})
+file(REMOVE ${CURRENT_PACKAGES_DIR}/bin/exrmaketiled${EXECUTABLE_SUFFIX})
+file(REMOVE ${CURRENT_PACKAGES_DIR}/bin/exrmultipart${EXECUTABLE_SUFFIX})
+file(REMOVE ${CURRENT_PACKAGES_DIR}/bin/exrmultiview${EXECUTABLE_SUFFIX})
+file(REMOVE ${CURRENT_PACKAGES_DIR}/bin/exrstdattr${EXECUTABLE_SUFFIX})
+
+vcpkg_copy_pdbs()
+
+if (OPENEXR_STATIC)
+  file(REMOVE_RECURSE ${CURRENT_PACKAGES_DIR}/bin ${CURRENT_PACKAGES_DIR}/debug/bin)
+endif()
+
+if (VCPKG_CMAKE_SYSTEM_NAME STREQUAL "Linux")
+  set(OPENEXR_PORT_DIR "openexr")
+else()
+  set(OPENEXR_PORT_DIR "OpenEXR")
+endif()
+
+file(COPY ${SOURCE_PATH}/LICENSE DESTINATION ${CURRENT_PACKAGES_DIR}/share/${OPENEXR_PORT_DIR})
+file(RENAME ${CURRENT_PACKAGES_DIR}/share/${OPENEXR_PORT_DIR}/LICENSE ${CURRENT_PACKAGES_DIR}/share/${OPENEXR_PORT_DIR}/copyright)
+
+file(COPY ${CMAKE_CURRENT_LIST_DIR}/FindOpenEXR.cmake DESTINATION ${CURRENT_PACKAGES_DIR}/share/${OPENEXR_PORT_DIR})

libraries/baking/src/TextureBaker.cpp

@@ -16,7 +16,7 @@
 #include <QtCore/QFile>
 #include <QtNetwork/QNetworkReply>
 
-#include <image/Image.h>
+#include <image/TextureProcessing.h>
 #include <ktx/KTX.h>
 #include <NetworkAccessManager.h>
 #include <SharedUtil.h>

libraries/baking/src/TextureBaker.h

@@ -18,7 +18,7 @@
 #include <QDir>
 #include <QImageReader>
 
-#include <image/Image.h>
+#include <image/TextureProcessing.h>
 
 #include "Baker.h"
 

libraries/baking/src/baking/TextureFileNamer.h

@@ -15,7 +15,7 @@
 #include <QtCore/QFileInfo>
 #include <QHash>
 
-#include <image/Image.h>
+#include <image/TextureProcessing.h>
 
 class TextureFileNamer {
 public:

libraries/graphics-scripting/src/graphics-scripting/ScriptableModel.cpp

@@ -15,7 +15,7 @@
 #include "GraphicsScriptingUtil.h"
 #include "ScriptableMesh.h"
 #include "graphics/Material.h"
-#include "image/Image.h"
+#include "image/TextureProcessing.h"
 
 // #define SCRIPTABLE_MESH_DEBUG 1
 

libraries/image/CMakeLists.txt

@@ -3,6 +3,7 @@ setup_hifi_library()
 link_hifi_libraries(shared gpu)
 target_nvtt()
 target_etc2comp()
+target_openexr()
 
 if (UNIX AND NOT APPLE)
   set(THREADS_PREFER_PTHREAD_FLAG ON)

libraries/image/src/image/Image.h

@@ -1,9 +1,10 @@
+#pragma once
 //
 //  Image.h
-//  image/src/image
+//  image/src/Image
 //
-//  Created by Clement Brisset on 4/5/2017.
-//  Copyright 2017 High Fidelity, Inc.
+//  Created by Olivier Prat on 29/3/2019.
+//  Copyright 2019 High Fidelity, Inc.
 //
 //  Distributed under the Apache License, Version 2.0.
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
@@ -12,80 +13,85 @@
 #ifndef hifi_image_Image_h
 #define hifi_image_Image_h
 
-#include <QVariant>
-
-#include <gpu/Texture.h>
+#include <QImage>
 
 #include "ColorChannel.h"
 
-class QByteArray;
-class QImage;
+#include <glm/fwd.hpp>
+#include <glm/vec2.hpp>
+#include <GLMHelpers.h>
 
 namespace image {
 
-namespace TextureUsage {
+    class Image {
+    public:
 
-enum Type {
-    DEFAULT_TEXTURE,
-    STRICT_TEXTURE,
-    ALBEDO_TEXTURE,
-    NORMAL_TEXTURE,
-    BUMP_TEXTURE,
-    SPECULAR_TEXTURE,
-    METALLIC_TEXTURE = SPECULAR_TEXTURE, // for now spec and metallic texture are the same, converted to grey
-    ROUGHNESS_TEXTURE,
-    GLOSS_TEXTURE,
-    EMISSIVE_TEXTURE,
-    CUBE_TEXTURE,
-    OCCLUSION_TEXTURE,
-    SCATTERING_TEXTURE = OCCLUSION_TEXTURE,
-    LIGHTMAP_TEXTURE,
-    UNUSED_TEXTURE
-};
+        enum Format {
+            Format_Invalid = QImage::Format_Invalid,
+            Format_Mono = QImage::Format_Mono,
+            Format_MonoLSB = QImage::Format_MonoLSB,
+            Format_Indexed8 = QImage::Format_Indexed8,
+            Format_RGB32 = QImage::Format_RGB32,
+            Format_ARGB32 = QImage::Format_ARGB32,
+            Format_ARGB32_Premultiplied = QImage::Format_ARGB32_Premultiplied,
+            Format_RGB16 = QImage::Format_RGB16,
+            Format_ARGB8565_Premultiplied = QImage::Format_ARGB8565_Premultiplied,
+            Format_RGB666 = QImage::Format_RGB666,
+            Format_ARGB6666_Premultiplied = QImage::Format_ARGB6666_Premultiplied,
+            Format_RGB555 = QImage::Format_RGB555,
+            Format_ARGB8555_Premultiplied = QImage::Format_ARGB8555_Premultiplied,
+            Format_RGB888 = QImage::Format_RGB888,
+            Format_RGB444 = QImage::Format_RGB444,
+            Format_ARGB4444_Premultiplied = QImage::Format_ARGB4444_Premultiplied,
+            Format_RGBX8888 = QImage::Format_RGBX8888,
+            Format_RGBA8888 = QImage::Format_RGBA8888,
+            Format_RGBA8888_Premultiplied = QImage::Format_RGBA8888_Premultiplied,
+            Format_Grayscale8 = QImage::Format_Grayscale8,
+            Format_R11G11B10F = QImage::Format_RGB30,
+            Format_PACKED_FLOAT = Format_R11G11B10F
+        };
 
-using TextureLoader = std::function<gpu::TexturePointer(QImage&&, const std::string&, bool, gpu::BackendTarget, const std::atomic<bool>&)>;
-TextureLoader getTextureLoaderForType(Type type, const QVariantMap& options = QVariantMap());
+        using AspectRatioMode = Qt::AspectRatioMode;
+        using TransformationMode = Qt::TransformationMode;
 
-gpu::TexturePointer create2DTextureFromImage(QImage&& image, const std::string& srcImageName,
-                                             bool compress, gpu::BackendTarget target, const std::atomic<bool>& abortProcessing);
-gpu::TexturePointer createStrict2DTextureFromImage(QImage&& image, const std::string& srcImageName,
-                                                   bool compress, gpu::BackendTarget target, const std::atomic<bool>& abortProcessing);
-gpu::TexturePointer createAlbedoTextureFromImage(QImage&& image, const std::string& srcImageName,
-                                                 bool compress, gpu::BackendTarget target, const std::atomic<bool>& abortProcessing);
-gpu::TexturePointer createEmissiveTextureFromImage(QImage&& image, const std::string& srcImageName,
-                                                   bool compress, gpu::BackendTarget target, const std::atomic<bool>& abortProcessing);
-gpu::TexturePointer createNormalTextureFromNormalImage(QImage&& image, const std::string& srcImageName,
-                                                       bool compress, gpu::BackendTarget target, const std::atomic<bool>& abortProcessing);
-gpu::TexturePointer createNormalTextureFromBumpImage(QImage&& image, const std::string& srcImageName,
-                                                     bool compress, gpu::BackendTarget target, const std::atomic<bool>& abortProcessing);
-gpu::TexturePointer createRoughnessTextureFromImage(QImage&& image, const std::string& srcImageName,
-                                                    bool compress, gpu::BackendTarget target, const std::atomic<bool>& abortProcessing);
-gpu::TexturePointer createRoughnessTextureFromGlossImage(QImage&& image, const std::string& srcImageName,
-                                                         bool compress, gpu::BackendTarget target, const std::atomic<bool>& abortProcessing);
-gpu::TexturePointer createMetallicTextureFromImage(QImage&& image, const std::string& srcImageName,
-                                                   bool compress, gpu::BackendTarget target, const std::atomic<bool>& abortProcessing);
-gpu::TexturePointer createCubeTextureFromImage(QImage&& image, const std::string& srcImageName,
-                                               bool compress, gpu::BackendTarget target, const std::atomic<bool>& abortProcessing);
-gpu::TexturePointer createCubeTextureFromImageWithoutIrradiance(QImage&& image, const std::string& srcImageName,
-                                                                bool compress, gpu::BackendTarget target, const std::atomic<bool>& abortProcessing);
-gpu::TexturePointer createLightmapTextureFromImage(QImage&& image, const std::string& srcImageName,
-                                                   bool compress, gpu::BackendTarget target, const std::atomic<bool>& abortProcessing); 
-gpu::TexturePointer process2DTextureColorFromImage(QImage&& srcImage, const std::string& srcImageName, bool compress,
-                                                   gpu::BackendTarget target, bool isStrict, const std::atomic<bool>& abortProcessing);
-gpu::TexturePointer process2DTextureNormalMapFromImage(QImage&& srcImage, const std::string& srcImageName, bool compress,
-                                                       gpu::BackendTarget target, bool isBumpMap, const std::atomic<bool>& abortProcessing);
-gpu::TexturePointer process2DTextureGrayscaleFromImage(QImage&& srcImage, const std::string& srcImageName, bool compress,
-                                                       gpu::BackendTarget target, bool isInvertedPixels, const std::atomic<bool>& abortProcessing);
-gpu::TexturePointer processCubeTextureColorFromImage(QImage&& srcImage, const std::string& srcImageName, bool compress,
-                                                     gpu::BackendTarget target, bool generateIrradiance, const std::atomic<bool>& abortProcessing);
+        Image() {}
+        Image(int width, int height, Format format) : _data(width, height, (QImage::Format)format) {}
+        Image(const QImage& data) : _data(data) {}
+        void operator=(const QImage& image) {
+            _data = image;
+        }
 
-} // namespace TextureUsage
+        bool isNull() const { return _data.isNull(); }
 
-const QStringList getSupportedFormats();
+        Format getFormat() const { return (Format)_data.format(); }
+        bool hasAlphaChannel() const { return _data.hasAlphaChannel(); }
 
-gpu::TexturePointer processImage(std::shared_ptr<QIODevice> content, const std::string& url, ColorChannel sourceChannel,
-                                 int maxNumPixels, TextureUsage::Type textureType,
-                                 bool compress, gpu::BackendTarget target, const std::atomic<bool>& abortProcessing = false);
+        glm::uint32 getWidth() const { return (glm::uint32)_data.width(); }
+        glm::uint32 getHeight() const { return (glm::uint32)_data.height(); }
+        glm::uvec2 getSize() const { return toGlm(_data.size()); }
+        size_t getByteCount() const { return _data.byteCount(); }
+
+        QRgb getPixel(int x, int y) const { return _data.pixel(x, y); }
+        void setPixel(int x, int y, QRgb value) {
+            _data.setPixel(x, y, value);
+        }
+
+        glm::uint8* editScanLine(int y) { return _data.scanLine(y); }
+        const glm::uint8* getScanLine(int y) const { return _data.scanLine(y); }
+        const glm::uint8* getBits() const { return _data.constBits(); }
+
+        Image getScaled(glm::uvec2 newSize, AspectRatioMode ratioMode, TransformationMode transformationMode = Qt::SmoothTransformation) const;
+        Image getConvertedToFormat(Format newFormat) const;
+        Image getSubImage(QRect rect) const;
+        Image getMirrored(bool horizontal, bool vertical) const;
+
+        // Inplace transformations
+        void invertPixels();
+
+    private:
+
+        QImage _data;
+    };
 
 } // namespace image
 

libraries/image/src/image/OpenEXRReader.cpp

@@ -0,0 +1,99 @@
+//
+//  OpenEXRReader.cpp
+//  image/src/image
+//
+//  Created by Olivier Prat
+//  Copyright 2019 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#include "OpenEXRReader.h"
+
+#include "TextureProcessing.h"
+#include "ImageLogging.h"
+
+#include <QIODevice>
+#include <QDebug>
+
+#if !defined(Q_OS_ANDROID)
+
+#include <OpenEXR/ImfIO.h>
+#include <OpenEXR/ImfRgbaFile.h>
+#include <OpenEXR/ImfArray.h>
+#include <OpenEXR/ImfTestFile.h>
+
+class QIODeviceImfStream : public Imf::IStream {
+public:
+
+    QIODeviceImfStream(QIODevice& device, const std::string& filename) :
+        Imf::IStream(filename.c_str()), _device(device) {
+    }
+
+    bool read(char c[/*n*/], int n) override {
+        if (_device.read(c, n) <= 0) {
+            qWarning(imagelogging) << "OpenEXR - in file " << fileName() << " : " << _device.errorString();
+            return false;
+        }
+        return true;
+    }
+
+    Imf::Int64 tellg() override {
+        return _device.pos();
+    }
+
+    void seekg(Imf::Int64 pos) override {
+        _device.seek(pos);
+    }
+
+    void clear() override {
+        // Not much to do
+    }
+
+private:
+
+    QIODevice&  _device;
+};
+
+#endif
+
+image::Image image::readOpenEXR(QIODevice& content, const std::string& filename) {
+#if !defined(Q_OS_ANDROID)
+    QIODeviceImfStream device(content, filename);
+
+    if (Imf::isOpenExrFile(device)) {
+        Imf::RgbaInputFile file(device);
+        Imath::Box2i viewport = file.dataWindow();
+        Imf::Array2D<Imf::Rgba> pixels;
+        int width = viewport.max.x - viewport.min.x + 1;
+        int height = viewport.max.y - viewport.min.y + 1;
+
+        pixels.resizeErase(height, width);
+
+        file.setFrameBuffer(&pixels[0][0] - viewport.min.x - viewport.min.y * width, 1, width);
+        file.readPixels(viewport.min.y, viewport.max.y);
+
+        Image image{ width, height, Image::Format_PACKED_FLOAT };
+        auto packHDRPixel = getHDRPackingFunction();
+        
+        for (int y = 0; y < height; y++) {
+            const auto srcScanline = pixels[y];
+            gpu::uint32* dstScanline = (gpu::uint32*) image.editScanLine(y);
+
+            for (int x = 0; x < width; x++) {
+                const auto& srcPixel = srcScanline[x];
+                auto& dstPixel = dstScanline[x];
+                glm::vec3 floatPixel{ srcPixel.r, srcPixel.g, srcPixel.b };
+
+                dstPixel = packHDRPixel(floatPixel);
+            }
+        }
+        return image;
+    } else {
+        qWarning(imagelogging) << "OpenEXR - File " << filename.c_str() << " doesn't have the proper format";
+    }
+#endif
+
+    return QImage();
+}

libraries/image/src/image/OpenEXRReader.h

@@ -0,0 +1,24 @@
+//
+//  OpenEXRReader.h
+//  image/src/image
+//
+//  Created by Olivier Prat
+//  Copyright 2019 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#ifndef hifi_image_OpenEXRReader_h
+#define hifi_image_OpenEXRReader_h
+
+#include "Image.h"
+
+namespace image {
+
+    // TODO Move this into a plugin that QImageReader can use
+    Image readOpenEXR(QIODevice& contents, const std::string& filename);
+
+}
+
+#endif // hifi_image_OpenEXRReader_h

libraries/image/src/image/TGAReader.cpp

@@ -16,7 +16,7 @@
 #include <QIODevice>
 #include <QDebug>
 
-QImage image::readTGA(QIODevice& content) {
+image::Image image::readTGA(QIODevice& content) {
     enum class TGAImageType : uint8_t {
         NoImageData = 0,
         UncompressedColorMapped = 1,

libraries/image/src/image/TGAReader.h

@@ -12,12 +12,11 @@
 #ifndef hifi_image_TGAReader_h
 #define hifi_image_TGAReader_h
 
-#include <QImage>
+#include "Image.h"
 
 namespace image {
 
-// TODO Move this into a plugin that QImageReader can use
-QImage readTGA(QIODevice& contents);
+    Image readTGA(QIODevice& contents);
 
 }
 

libraries/image/src/image/TextureProcessing.h

@@ -0,0 +1,92 @@
+//
+//  TextureProcessing.h
+//  image/src/TextureProcessing
+//
+//  Created by Clement Brisset on 4/5/2017.
+//  Copyright 2017 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#ifndef hifi_image_TextureProcessing_h
+#define hifi_image_TextureProcessing_h
+
+#include <QVariant>
+
+#include <gpu/Texture.h>
+
+#include "Image.h"
+
+namespace image {
+
+    std::function<gpu::uint32(const glm::vec3&)> getHDRPackingFunction();
+    std::function<glm::vec3(gpu::uint32)> getHDRUnpackingFunction();
+
+namespace TextureUsage {
+
+enum Type {
+    DEFAULT_TEXTURE,
+    STRICT_TEXTURE,
+    ALBEDO_TEXTURE,
+    NORMAL_TEXTURE,
+    BUMP_TEXTURE,
+    SPECULAR_TEXTURE,
+    METALLIC_TEXTURE = SPECULAR_TEXTURE, // for now spec and metallic texture are the same, converted to grey
+    ROUGHNESS_TEXTURE,
+    GLOSS_TEXTURE,
+    EMISSIVE_TEXTURE,
+    CUBE_TEXTURE,
+    OCCLUSION_TEXTURE,
+    SCATTERING_TEXTURE = OCCLUSION_TEXTURE,
+    LIGHTMAP_TEXTURE,
+    UNUSED_TEXTURE
+};
+
+using TextureLoader = std::function<gpu::TexturePointer(Image&&, const std::string&, bool, gpu::BackendTarget, const std::atomic<bool>&)>;
+TextureLoader getTextureLoaderForType(Type type, const QVariantMap& options = QVariantMap());
+
+gpu::TexturePointer create2DTextureFromImage(Image&& image, const std::string& srcImageName,
+                                             bool compress, gpu::BackendTarget target, const std::atomic<bool>& abortProcessing);
+gpu::TexturePointer createStrict2DTextureFromImage(Image&& image, const std::string& srcImageName,
+                                                   bool compress, gpu::BackendTarget target, const std::atomic<bool>& abortProcessing);
+gpu::TexturePointer createAlbedoTextureFromImage(Image&& image, const std::string& srcImageName,
+                                                 bool compress, gpu::BackendTarget target, const std::atomic<bool>& abortProcessing);
+gpu::TexturePointer createEmissiveTextureFromImage(Image&& image, const std::string& srcImageName,
+                                                   bool compress, gpu::BackendTarget target, const std::atomic<bool>& abortProcessing);
+gpu::TexturePointer createNormalTextureFromNormalImage(Image&& image, const std::string& srcImageName,
+                                                       bool compress, gpu::BackendTarget target, const std::atomic<bool>& abortProcessing);
+gpu::TexturePointer createNormalTextureFromBumpImage(Image&& image, const std::string& srcImageName,
+                                                     bool compress, gpu::BackendTarget target, const std::atomic<bool>& abortProcessing);
+gpu::TexturePointer createRoughnessTextureFromImage(Image&& image, const std::string& srcImageName,
+                                                    bool compress, gpu::BackendTarget target, const std::atomic<bool>& abortProcessing);
+gpu::TexturePointer createRoughnessTextureFromGlossImage(Image&& image, const std::string& srcImageName,
+                                                         bool compress, gpu::BackendTarget target, const std::atomic<bool>& abortProcessing);
+gpu::TexturePointer createMetallicTextureFromImage(Image&& image, const std::string& srcImageName,
+                                                   bool compress, gpu::BackendTarget target, const std::atomic<bool>& abortProcessing);
+gpu::TexturePointer createCubeTextureFromImage(Image&& image, const std::string& srcImageName,
+                                               bool compress, gpu::BackendTarget target, const std::atomic<bool>& abortProcessing);
+gpu::TexturePointer createCubeTextureFromImageWithoutIrradiance(Image&& image, const std::string& srcImageName,
+                                                                bool compress, gpu::BackendTarget target, const std::atomic<bool>& abortProcessing);
+gpu::TexturePointer createLightmapTextureFromImage(Image&& image, const std::string& srcImageName,
+                                                   bool compress, gpu::BackendTarget target, const std::atomic<bool>& abortProcessing); 
+gpu::TexturePointer process2DTextureColorFromImage(Image&& srcImage, const std::string& srcImageName, bool compress,
+                                                   gpu::BackendTarget target, bool isStrict, const std::atomic<bool>& abortProcessing);
+gpu::TexturePointer process2DTextureNormalMapFromImage(Image&& srcImage, const std::string& srcImageName, bool compress,
+                                                       gpu::BackendTarget target, bool isBumpMap, const std::atomic<bool>& abortProcessing);
+gpu::TexturePointer process2DTextureGrayscaleFromImage(Image&& srcImage, const std::string& srcImageName, bool compress,
+                                                       gpu::BackendTarget target, bool isInvertedPixels, const std::atomic<bool>& abortProcessing);
+gpu::TexturePointer processCubeTextureColorFromImage(Image&& srcImage, const std::string& srcImageName, bool compress,
+                                                     gpu::BackendTarget target, bool generateIrradiance, const std::atomic<bool>& abortProcessing);
+
+} // namespace TextureUsage
+
+const QStringList getSupportedFormats();
+
+gpu::TexturePointer processImage(std::shared_ptr<QIODevice> content, const std::string& url, ColorChannel sourceChannel,
+                                 int maxNumPixels, TextureUsage::Type textureType,
+                                 bool compress, gpu::BackendTarget target, const std::atomic<bool>& abortProcessing = false);
+
+} // namespace image
+
+#endif // hifi_image_TextureProcessing_h

libraries/material-networking/src/material-networking/TextureCache.cpp

@@ -34,7 +34,7 @@
 #include <gl/GLHelpers.h>
 #include <gpu/Batch.h>
 
-#include <image/Image.h>
+#include <image/TextureProcessing.h>
 
 #include <NumericalConstants.h>
 #include <shared/NsightHelpers.h>

libraries/material-networking/src/material-networking/TextureCache.h

@@ -23,7 +23,7 @@
 #include <ResourceCache.h>
 #include <graphics/TextureMap.h>
 #include <image/ColorChannel.h>
-#include <image/Image.h>
+#include <image/TextureProcessing.h>
 #include <ktx/KTX.h>
 #include <TextureMeta.h>
 

tools/oven/src/Oven.cpp

@@ -14,7 +14,7 @@
 #include <QtCore/QDebug>
 #include <QtCore/QThread>
 
-#include <image/Image.h>
+#include <image/TextureProcessing.h>
 
 #include <DependencyManager.h>
 #include <StatTracker.h>

tools/oven/src/OvenCLIApplication.cpp

@@ -14,7 +14,7 @@
 #include <QtCore/QCommandLineParser>
 #include <QtCore/QUrl>
 
-#include <image/Image.h>
+#include <image/TextureProcessing.h>
 #include <TextureBaker.h>
 
 #include "BakerCLI.h"