1 files changed, 54 insertions, 162 deletions

diff --git a/indra/newview/llmaterialeditor.cpp b/indra/newview/llmaterialeditor.cpp
index 7b17fb5fdf..2052f252b3 100644
--- a/indra/newview/llmaterialeditor.cpp
+++ b/indra/newview/llmaterialeditor.cpp
@@ -55,6 +55,7 @@
 #include "llfloaterperms.h"
 
 #include "tinygltf/tiny_gltf.h"
+#include "lltinygltfhelper.h"
 #include <strstream>
 
 
@@ -1018,18 +1019,15 @@ void LLMaterialEditor::onCancelMsgCallback(const LLSD& notification, const LLSD&
 class LLMaterialFilePicker : public LLFilePickerThread
 {
 public:
-    LLMaterialFilePicker(LLMaterialEditor* me);
+    LLMaterialFilePicker();
     virtual void notify(const std::vector<std::string>& filenames);
-    void loadMaterial(const std::string& filename);
     static void	textureLoadedCallback(BOOL success, LLViewerFetchedTexture* src_vi, LLImageRaw* src, LLImageRaw* src_aux, S32 discard_level, BOOL final, void* userdata);
-private:
-    LLMaterialEditor* mME;
+
 };
 
-LLMaterialFilePicker::LLMaterialFilePicker(LLMaterialEditor* me)
+LLMaterialFilePicker::LLMaterialFilePicker()
     : LLFilePickerThread(LLFilePicker::FFLOAD_MATERIAL)
 {
-    mME = me;
 }
 
 void LLMaterialFilePicker::notify(const std::vector<std::string>& filenames)
@@ -1042,82 +1040,20 @@ void LLMaterialFilePicker::notify(const std::vector<std::string>& filenames)
     
     if (filenames.size() > 0)
     {
-        loadMaterial(filenames[0]);
-    }
-}
-
-const tinygltf::Image* get_image_from_texture_index(const tinygltf::Model& model, S32 texture_index)
-{
-    if (texture_index >= 0)
-    {
-        S32 source_idx = model.textures[texture_index].source;
-        if (source_idx >= 0)
+        LLMaterialEditor* me = (LLMaterialEditor*)LLFloaterReg::getInstance("material_editor");
+        if (me)
         {
-            return &(model.images[source_idx]);
+            me->loadMaterialFromFile(filenames[0]);
         }
     }
-
-    return nullptr;
-}
-
-static LLImageRaw* get_texture(const std::string& folder, const tinygltf::Model& model, S32 texture_index, std::string& name)
-{
-    const tinygltf::Image* image = get_image_from_texture_index(model, texture_index);
-    LLImageRaw* rawImage = nullptr;
-
-    if (image != nullptr && 
-        image->bits == 8 &&
-        !image->image.empty() &&
-        image->component <= 4)
-    {
-        name = image->name;
-        rawImage = new LLImageRaw(&image->image[0], image->width, image->height, image->component);
-        rawImage->verticalFlip();
-    }
-
-    return rawImage;
-}
-
-static void strip_alpha_channel(LLPointer<LLImageRaw>& img)
-{
-    if (img->getComponents() == 4)
-    {
-        LLImageRaw* tmp = new LLImageRaw(img->getWidth(), img->getHeight(), 3);
-        tmp->copyUnscaled4onto3(img);
-        img = tmp;
-    }
-}
-
-// copy red channel from src_img to dst_img
-// PRECONDITIONS:
-// dst_img must be 3 component
-// src_img and dst_image must have the same dimensions
-static void copy_red_channel(LLPointer<LLImageRaw>& src_img, LLPointer<LLImageRaw>& dst_img)
-{
-    llassert(src_img->getWidth() == dst_img->getWidth() && src_img->getHeight() == dst_img->getHeight());
-    llassert(dst_img->getComponents() == 3);
-
-    U32 pixel_count = dst_img->getWidth() * dst_img->getHeight();
-    U8* src = src_img->getData();
-    U8* dst = dst_img->getData();
-    S8 src_components = src_img->getComponents();
-
-    for (U32 i = 0; i < pixel_count; ++i)
-    {
-        dst[i * 3] = src[i * src_components];
-    }
 }
 
-static void pack_textures(tinygltf::Model& model, tinygltf::Material& material, 
+static void pack_textures(
     LLPointer<LLImageRaw>& albedo_img,
     LLPointer<LLImageRaw>& normal_img,
     LLPointer<LLImageRaw>& mr_img,
     LLPointer<LLImageRaw>& emissive_img,
     LLPointer<LLImageRaw>& occlusion_img,
-    LLPointer<LLViewerFetchedTexture>& albedo_tex,
-    LLPointer<LLViewerFetchedTexture>& normal_tex,
-    LLPointer<LLViewerFetchedTexture>& mr_tex,
-    LLPointer<LLViewerFetchedTexture>& emissive_tex,
     LLPointer<LLImageJ2C>& albedo_j2c,
     LLPointer<LLImageJ2C>& normal_j2c,
     LLPointer<LLImageJ2C>& mr_j2c,
@@ -1125,76 +1061,31 @@ static void pack_textures(tinygltf::Model& model, tinygltf::Material& material,
 {
     if (albedo_img)
     {
-        albedo_tex = LLViewerTextureManager::getFetchedTexture(albedo_img, FTType::FTT_LOCAL_FILE, true);
         albedo_j2c = LLViewerTextureList::convertToUploadFile(albedo_img);
     }
 
     if (normal_img)
     {
-        strip_alpha_channel(normal_img);
-        normal_tex = LLViewerTextureManager::getFetchedTexture(normal_img, FTType::FTT_LOCAL_FILE, true);
         normal_j2c = LLViewerTextureList::convertToUploadFile(normal_img);
     }
 
     if (mr_img)
     {
-        strip_alpha_channel(mr_img);
-
-        if (occlusion_img && material.pbrMetallicRoughness.metallicRoughnessTexture.index != material.occlusionTexture.index)
-        {
-            // occlusion is a distinct texture from pbrMetallicRoughness
-            // pack into mr red channel
-            int occlusion_idx = material.occlusionTexture.index;
-            int mr_idx = material.pbrMetallicRoughness.metallicRoughnessTexture.index;
-            if (occlusion_idx != mr_idx)
-            {
-                //scale occlusion image to match resolution of mr image
-                occlusion_img->scale(mr_img->getWidth(), mr_img->getHeight());
-             
-                copy_red_channel(occlusion_img, mr_img);
-            }
-        }
-    }
-    else if (occlusion_img)
-    {
-        //no mr but occlusion exists, make a white mr_img and copy occlusion red channel over
-        mr_img = new LLImageRaw(occlusion_img->getWidth(), occlusion_img->getHeight(), 3);
-        mr_img->clear(255, 255, 255);
-        copy_red_channel(occlusion_img, mr_img);
-
-    }
-
-    if (mr_img)
-    {
-        mr_tex = LLViewerTextureManager::getFetchedTexture(mr_img, FTType::FTT_LOCAL_FILE, true);
         mr_j2c = LLViewerTextureList::convertToUploadFile(mr_img);
     }
 
     if (emissive_img)
     {
-        strip_alpha_channel(emissive_img);
-        emissive_tex = LLViewerTextureManager::getFetchedTexture(emissive_img, FTType::FTT_LOCAL_FILE, true);
         emissive_j2c = LLViewerTextureList::convertToUploadFile(emissive_img);
     }
 }
 
-static LLColor4 get_color(const std::vector<double>& in)
-{
-    LLColor4 out;
-    for (S32 i = 0; i < llmin((S32) in.size(), 4); ++i)
-    {
-        out.mV[i] = in[i];
-    }
-
-    return out;
-}
-
 void LLMaterialFilePicker::textureLoadedCallback(BOOL success, LLViewerFetchedTexture* src_vi, LLImageRaw* src, LLImageRaw* src_aux, S32 discard_level, BOOL final, void* userdata)
 {
 }
 
 
-void LLMaterialFilePicker::loadMaterial(const std::string& filename)
+void LLMaterialEditor::loadMaterialFromFile(const std::string& filename)
 {
     tinygltf::TinyGLTF loader;
     std::string        error_msg;
@@ -1240,90 +1131,91 @@ void LLMaterialFilePicker::loadMaterial(const std::string& filename)
     model_out.materials.resize(1);
 
     // get albedo texture
-    LLPointer<LLImageRaw> albedo_img = get_texture(folder, model_in, material_in.pbrMetallicRoughness.baseColorTexture.index, mME->mAlbedoName);
+    LLPointer<LLImageRaw> albedo_img = LLTinyGLTFHelper::getTexture(folder, model_in, material_in.pbrMetallicRoughness.baseColorTexture.index, mAlbedoName);
     // get normal map
-    LLPointer<LLImageRaw> normal_img = get_texture(folder, model_in, material_in.normalTexture.index, mME->mNormalName);
+    LLPointer<LLImageRaw> normal_img = LLTinyGLTFHelper::getTexture(folder, model_in, material_in.normalTexture.index, mNormalName);
     // get metallic-roughness texture
-    LLPointer<LLImageRaw> mr_img = get_texture(folder, model_in, material_in.pbrMetallicRoughness.metallicRoughnessTexture.index, mME->mMetallicRoughnessName);
+    LLPointer<LLImageRaw> mr_img = LLTinyGLTFHelper::getTexture(folder, model_in, material_in.pbrMetallicRoughness.metallicRoughnessTexture.index, mMetallicRoughnessName);
     // get emissive texture
-    LLPointer<LLImageRaw> emissive_img = get_texture(folder, model_in, material_in.emissiveTexture.index, mME->mEmissiveName);
+    LLPointer<LLImageRaw> emissive_img = LLTinyGLTFHelper::getTexture(folder, model_in, material_in.emissiveTexture.index, mEmissiveName);
     // get occlusion map if needed
     LLPointer<LLImageRaw> occlusion_img;
     if (material_in.occlusionTexture.index != material_in.pbrMetallicRoughness.metallicRoughnessTexture.index)
     {
         std::string tmp;
-        occlusion_img = get_texture(folder, model_in, material_in.occlusionTexture.index, tmp);
+        occlusion_img = LLTinyGLTFHelper::getTexture(folder, model_in, material_in.occlusionTexture.index, tmp);
     }
 
-    pack_textures(model_in, material_in, albedo_img, normal_img, mr_img, emissive_img, occlusion_img,
-        mME->mAlbedoFetched, mME->mNormalFetched, mME->mMetallicRoughnessFetched, mME->mEmissiveFetched,
-        mME->mAlbedoJ2C, mME->mNormalJ2C, mME->mMetallicRoughnessJ2C, mME->mEmissiveJ2C);
+    LLTinyGLTFHelper::initFetchedTextures(material_in, albedo_img, normal_img, mr_img, emissive_img, occlusion_img,
+        mAlbedoFetched, mNormalFetched, mMetallicRoughnessFetched, mEmissiveFetched);
+    pack_textures(albedo_img, normal_img, mr_img, emissive_img, occlusion_img,
+        mAlbedoJ2C, mNormalJ2C, mMetallicRoughnessJ2C, mEmissiveJ2C);
     
     LLUUID albedo_id;
-    if (mME->mAlbedoFetched.notNull())
+    if (mAlbedoFetched.notNull())
     {
-        mME->mAlbedoFetched->forceToSaveRawImage(0, F32_MAX);
-        albedo_id = mME->mAlbedoFetched->getID();
+        mAlbedoFetched->forceToSaveRawImage(0, F32_MAX);
+        albedo_id = mAlbedoFetched->getID();
         
-        if (mME->mAlbedoName.empty())
+        if (mAlbedoName.empty())
         {
-            mME->mAlbedoName = MATERIAL_ALBEDO_DEFAULT_NAME;
+            mAlbedoName = MATERIAL_ALBEDO_DEFAULT_NAME;
         }
     }
 
     LLUUID normal_id;
-    if (mME->mNormalFetched.notNull())
+    if (mNormalFetched.notNull())
     {
-        mME->mNormalFetched->forceToSaveRawImage(0, F32_MAX);
-        normal_id = mME->mNormalFetched->getID();
+        mNormalFetched->forceToSaveRawImage(0, F32_MAX);
+        normal_id = mNormalFetched->getID();
 
-        if (mME->mNormalName.empty())
+        if (mNormalName.empty())
         {
-            mME->mNormalName = MATERIAL_NORMAL_DEFAULT_NAME;
+            mNormalName = MATERIAL_NORMAL_DEFAULT_NAME;
         }
     }
 
     LLUUID mr_id;
-    if (mME->mMetallicRoughnessFetched.notNull())
+    if (mMetallicRoughnessFetched.notNull())
     {
-        mME->mMetallicRoughnessFetched->forceToSaveRawImage(0, F32_MAX);
-        mr_id = mME->mMetallicRoughnessFetched->getID();
+        mMetallicRoughnessFetched->forceToSaveRawImage(0, F32_MAX);
+        mr_id = mMetallicRoughnessFetched->getID();
 
-        if (mME->mMetallicRoughnessName.empty())
+        if (mMetallicRoughnessName.empty())
         {
-            mME->mMetallicRoughnessName = MATERIAL_METALLIC_DEFAULT_NAME;
+            mMetallicRoughnessName = MATERIAL_METALLIC_DEFAULT_NAME;
         }
     }
 
     LLUUID emissive_id;
-    if (mME->mEmissiveFetched.notNull())
+    if (mEmissiveFetched.notNull())
     {
-        mME->mEmissiveFetched->forceToSaveRawImage(0, F32_MAX);
-        emissive_id = mME->mEmissiveFetched->getID();
+        mEmissiveFetched->forceToSaveRawImage(0, F32_MAX);
+        emissive_id = mEmissiveFetched->getID();
 
-        if (mME->mEmissiveName.empty())
+        if (mEmissiveName.empty())
         {
-            mME->mEmissiveName = MATERIAL_EMISSIVE_DEFAULT_NAME;
+            mEmissiveName = MATERIAL_EMISSIVE_DEFAULT_NAME;
         }
     }
 
-    mME->setAlbedoId(albedo_id);
-    mME->setAlbedoUploadId(albedo_id);
-    mME->setMetallicRoughnessId(mr_id);
-    mME->setMetallicRoughnessUploadId(mr_id);
-    mME->setEmissiveId(emissive_id);
-    mME->setEmissiveUploadId(emissive_id);
-    mME->setNormalId(normal_id);
-    mME->setNormalUploadId(normal_id);
+    setAlbedoId(albedo_id);
+    setAlbedoUploadId(albedo_id);
+    setMetallicRoughnessId(mr_id);
+    setMetallicRoughnessUploadId(mr_id);
+    setEmissiveId(emissive_id);
+    setEmissiveUploadId(emissive_id);
+    setNormalId(normal_id);
+    setNormalUploadId(normal_id);
 
-    mME->setFromGltfModel(model_in);
+    setFromGltfModel(model_in);
 
-    mME->setFromGltfMetaData(filename_lc, model_in);
+    setFromGltfMetaData(filename_lc, model_in);
 
-    mME->setHasUnsavedChanges(true);
-    mME->openFloater();
+    setHasUnsavedChanges(true);
+    openFloater();
 
-    mME->applyToSelection();
+    applyToSelection();
 }
 
 bool LLMaterialEditor::setFromGltfModel(tinygltf::Model& model, bool set_textures)
@@ -1389,8 +1281,8 @@ bool LLMaterialEditor::setFromGltfModel(tinygltf::Model& model, bool set_texture
         setAlphaMode(material_in.alphaMode);
         setAlphaCutoff(material_in.alphaCutoff);
 
-        setAlbedoColor(get_color(material_in.pbrMetallicRoughness.baseColorFactor));
-        setEmissiveColor(get_color(material_in.emissiveFactor));
+        setAlbedoColor(LLTinyGLTFHelper::getColor(material_in.pbrMetallicRoughness.baseColorFactor));
+        setEmissiveColor(LLTinyGLTFHelper::getColor(material_in.emissiveFactor));
 
         setMetalnessFactor(material_in.pbrMetallicRoughness.metallicFactor);
         setRoughnessFactor(material_in.pbrMetallicRoughness.roughnessFactor);
@@ -1612,7 +1504,7 @@ void LLMaterialEditor::setFromGltfMetaData(const std::string& filename, tinygltf
 
 void LLMaterialEditor::importMaterial()
 {
-    (new LLMaterialFilePicker(this))->getFile();
+    (new LLMaterialFilePicker())->getFile();
 }
 
 class LLRemderMaterialFunctor : public LLSelectedTEFunctor