SL-20606: Full GLTF material preview. Works for most materials.

1 files changed, 501 insertions, 0 deletions

diff --git a/indra/newview/llgltfmaterialpreviewmgr.cpp b/indra/newview/llgltfmaterialpreviewmgr.cpp
new file mode 100644
index 0000000000..9ef1bbf884
--- /dev/null
+++ b/indra/newview/llgltfmaterialpreviewmgr.cpp
@@ -0,0 +1,501 @@
+/**
+ * @file llgltfmaterialpreviewmgr.cpp
+ *
+ * $LicenseInfo:firstyear=2023&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2023, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#include "llviewerprecompiledheaders.h"
+
+#include "llgltfmaterialpreviewmgr.h"
+
+#include <vector>
+
+#include "llavatarappearancedefines.h"
+#include "llenvironment.h"
+#include "llselectmgr.h"
+#include "llviewercamera.h"
+#include "llviewerobject.h"
+#include "llviewershadermgr.h"
+#include "llviewertexturelist.h"
+#include "llviewerwindow.h"
+#include "llvolumemgr.h"
+#include "pipeline.h"
+
+LLGLTFMaterialPreviewMgr gGLTFMaterialPreviewMgr;
+
+namespace
+{
+    constexpr S32 FULLY_LOADED = 0;
+    constexpr S32 NOT_LOADED = 99;
+};
+
+LLGLTFPreviewTexture::MaterialLoadLevels::MaterialLoadLevels()
+{
+    for (U32 i = 0; i < LLGLTFMaterial::GLTF_TEXTURE_INFO_COUNT; ++i)
+    {
+        levels[i] = NOT_LOADED;
+    }
+}
+
+S32& LLGLTFPreviewTexture::MaterialLoadLevels::operator[](size_t i)
+{
+    llassert(i >= 0 && i < LLGLTFMaterial::GLTF_TEXTURE_INFO_COUNT);
+    return levels[i];
+}
+
+const S32& LLGLTFPreviewTexture::MaterialLoadLevels::operator[](size_t i) const
+{
+    llassert(i >= 0 && i < LLGLTFMaterial::GLTF_TEXTURE_INFO_COUNT);
+    return levels[i];
+}
+
+bool LLGLTFPreviewTexture::MaterialLoadLevels::operator<(const MaterialLoadLevels& other) const
+{
+    bool less = false;
+    for (U32 i = 0; i < LLGLTFMaterial::GLTF_TEXTURE_INFO_COUNT; ++i)
+    {
+        if (((*this)[i] > other[i])) { return false; }
+        less = less || ((*this)[i] < other[i]);
+    }
+    return less;
+}
+
+bool LLGLTFPreviewTexture::MaterialLoadLevels::operator>(const MaterialLoadLevels& other) const
+{
+    bool great = false;
+    for (U32 i = 0; i < LLGLTFMaterial::GLTF_TEXTURE_INFO_COUNT; ++i)
+    {
+        if (((*this)[i] < other[i])) { return false; }
+        great = great || ((*this)[i] > other[i]);
+    }
+    return great;
+}
+
+namespace
+{
+    void fetch_texture_for_ui(LLPointer<LLViewerFetchedTexture>& img, const LLUUID& id)
+    {
+        if (id.notNull())
+        {
+            if (LLAvatarAppearanceDefines::LLAvatarAppearanceDictionary::isBakedImageId(id))
+            {
+                LLViewerObject* obj = LLSelectMgr::getInstance()->getSelection()->getFirstObject();
+                if (obj)
+                {
+                    LLViewerTexture* viewerTexture = obj->getBakedTextureForMagicId(id);
+                    img = viewerTexture ? dynamic_cast<LLViewerFetchedTexture*>(viewerTexture) : NULL;
+                }
+            }
+            else
+            {
+                img = LLViewerTextureManager::getFetchedTexture(id, FTT_DEFAULT, TRUE, LLGLTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE);
+            }
+        }
+        if (img)
+        {
+            img->setBoostLevel(LLGLTexture::BOOST_PREVIEW);
+            img->forceToSaveRawImage(0);
+        }
+    };
+
+    // *NOTE: Does not use the same conventions as texture discard level. Lower is better.
+    S32 get_texture_load_level(const LLPointer<LLViewerFetchedTexture>& texture)
+    {
+        if (!texture) { return FULLY_LOADED; }
+        const S32 raw_level = texture->getDiscardLevel();
+        if (raw_level < 0) { return NOT_LOADED; }
+        return raw_level;
+    }
+
+    LLGLTFPreviewTexture::MaterialLoadLevels get_material_load_levels(LLFetchedGLTFMaterial& material)
+    {
+        using MaterialTextures = LLPointer<LLViewerFetchedTexture>*[LLGLTFMaterial::GLTF_TEXTURE_INFO_COUNT];
+
+        MaterialTextures textures;
+
+        textures[LLGLTFMaterial::GLTF_TEXTURE_INFO_BASE_COLOR] = &material.mBaseColorTexture;
+        textures[LLGLTFMaterial::GLTF_TEXTURE_INFO_NORMAL] = &material.mNormalTexture;
+        textures[LLGLTFMaterial::GLTF_TEXTURE_INFO_METALLIC_ROUGHNESS] = &material.mMetallicRoughnessTexture;
+        textures[LLGLTFMaterial::GLTF_TEXTURE_INFO_EMISSIVE] = &material.mEmissiveTexture;
+
+        LLGLTFPreviewTexture::MaterialLoadLevels levels;
+
+        for (U32 i = 0; i < LLGLTFMaterial::GLTF_TEXTURE_INFO_COUNT; ++i)
+        {
+            fetch_texture_for_ui(*textures[i], material.mTextureId[i]);
+            levels[i] = get_texture_load_level(*textures[i]);
+        }
+
+        return levels;
+    }
+
+    // Is the material loaded enough to start rendering a preview?
+    bool is_material_loaded_enough_for_ui(LLFetchedGLTFMaterial& material)
+    {
+        if (material.isFetching())
+        {
+            return false;
+        }
+
+        LLGLTFPreviewTexture::MaterialLoadLevels levels = get_material_load_levels(material);
+
+        for (U32 i = 0; i < LLGLTFMaterial::GLTF_TEXTURE_INFO_COUNT; ++i)
+        {
+            if (levels[i] == NOT_LOADED)
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+};  // namespace
+
+LLGLTFPreviewTexture::LLGLTFPreviewTexture(LLPointer<LLFetchedGLTFMaterial> material, S32 width)
+    : LLViewerDynamicTexture(width, width, 4, EOrder::ORDER_MIDDLE, FALSE)
+    , mGLTFMaterial(material)
+{
+}
+
+// static
+LLPointer<LLGLTFPreviewTexture> LLGLTFPreviewTexture::create(LLPointer<LLFetchedGLTFMaterial> material)
+{
+    return new LLGLTFPreviewTexture(material, LLPipeline::MAX_BAKE_WIDTH);
+}
+
+void LLGLTFPreviewTexture::preRender(BOOL clear_depth)
+{
+    LL_PROFILE_ZONE_SCOPED_CATEGORY_UI;
+
+    MaterialLoadLevels current_load = get_material_load_levels(*mGLTFMaterial.get());
+    if (current_load < mBestLoad)
+    {
+        mShouldRender = true;
+        mBestLoad = current_load;
+    }
+
+    if (!mShouldRender) { return; }
+
+    LLViewerDynamicTexture::preRender(clear_depth);
+}
+
+
+namespace {
+
+struct GLTFPreviewModel
+{
+    GLTFPreviewModel(LLPointer<LLDrawInfo>& info, const LLMatrix4& mat)
+    : mDrawInfo(info)
+    , mModelMatrix(mat)
+    {
+        mDrawInfo->mModelMatrix = &mModelMatrix;
+    }
+    LLPointer<LLDrawInfo> mDrawInfo;
+    LLMatrix4 mModelMatrix; // Referenced by mDrawInfo
+};
+
+// Like LLVolumeGeometryManager::registerFace but without batching or too-many-indices/vertices checking.
+std::vector<GLTFPreviewModel> create_preview_sphere(LLPointer<LLFetchedGLTFMaterial>& material, const LLMatrix4& model_matrix)
+{
+    LL_PROFILE_ZONE_SCOPED_CATEGORY_UI;
+
+    const LLColor4U vertex_color(material->mBaseColor);
+
+    LLPrimitive prim;
+    prim.init_primitive(LL_PCODE_VOLUME);
+    LLVolumeParams params;
+    params.setType(LL_PCODE_PROFILE_CIRCLE_HALF, LL_PCODE_PATH_CIRCLE);
+    params.setBeginAndEndS(0.f, 1.f);
+    params.setBeginAndEndT(0.f, 1.f);
+    params.setRatio(1, 1);
+    params.setShear(0, 0);
+    constexpr auto MAX_LOD = LLVolumeLODGroup::NUM_LODS - 1;
+    prim.setVolume(params, MAX_LOD);
+
+    LLVolume* volume = prim.getVolume();
+    llassert(volume);
+    for (LLVolumeFace& face : volume->getVolumeFaces())
+    {
+        face.createTangents();
+    }
+
+    std::vector<GLTFPreviewModel> preview_sphere;
+    preview_sphere.reserve(volume->getNumFaces());
+
+    LLPointer<LLVertexBuffer> buf = new LLVertexBuffer(
+        LLVertexBuffer::MAP_VERTEX |
+        LLVertexBuffer::MAP_NORMAL |
+        LLVertexBuffer::MAP_TEXCOORD0 |
+        LLVertexBuffer::MAP_COLOR |
+        LLVertexBuffer::MAP_TANGENT
+    );
+    U32 nv = 0;
+    U32 ni = 0;
+    for (LLVolumeFace& face : volume->getVolumeFaces())
+    {
+        nv += face.mNumVertices;
+        ni += face.mNumIndices;
+    }
+    buf->allocateBuffer(nv, ni);
+
+    // UV hacks
+    // Higher factor helps to see more details on the preview sphere
+    const LLVector2 uv_factor(2.0f, 2.0f);
+    // Offset places center of material in center of view
+    const LLVector2 uv_offset(-0.5f, -0.5f);
+
+    LLStrider<U16> indices;
+    LLStrider<LLVector4a> positions;
+    LLStrider<LLVector4a> normals;
+    LLStrider<LLVector2> texcoords;
+    LLStrider<LLColor4U> colors;
+    LLStrider<LLVector4a> tangents;
+	buf->getIndexStrider(indices);
+	buf->getVertexStrider(positions);
+	buf->getNormalStrider(normals);
+	buf->getTexCoord0Strider(texcoords);
+	buf->getColorStrider(colors);
+	buf->getTangentStrider(tangents);
+    U32 index_offset = 0;
+    U32 vertex_offset = 0;
+    for (const LLVolumeFace& face : volume->getVolumeFaces())
+    {
+        for (S32 i = 0; i < face.mNumIndices; ++i)
+        {
+            *indices++ = face.mIndices[i] + vertex_offset;
+        }
+        for (S32 v = 0; v < face.mNumVertices; ++v)
+        {
+            *positions++ = face.mPositions[v];
+            *normals++ = face.mNormals[v];
+            LLVector2 uv(face.mTexCoords[v]);
+            uv.scaleVec(uv_factor);
+            uv += uv_offset;
+            *texcoords++ = uv;
+            *colors++ = vertex_color;
+            *tangents++ = face.mTangents[v];
+        }
+
+        constexpr LLViewerTexture* no_media = nullptr;
+        LLPointer<LLDrawInfo> info = new LLDrawInfo(U16(vertex_offset), U16(vertex_offset + face.mNumVertices - 1), face.mNumIndices, index_offset, no_media, buf.get());
+        info->mGLTFMaterial = material;
+        preview_sphere.emplace_back(info, model_matrix);
+        index_offset += face.mNumIndices;
+        vertex_offset += face.mNumVertices;
+    }
+
+    buf->unmapBuffer();
+
+    return preview_sphere;
+}
+
+// Final, direct modifications to shader constants, just before render
+void fixup_shader_constants(LLGLSLShader& shader)
+{
+    // Sunlight intensity of 0 no matter what
+    shader.uniform1i(LLShaderMgr::SUN_UP_FACTOR, 1);
+    shader.uniform3fv(LLShaderMgr::SUNLIGHT_COLOR, 1, LLColor3::white.mV);
+    shader.uniform1f(LLShaderMgr::DENSITY_MULTIPLIER, 0.0f);
+
+    // Ignore sun shadow (if enabled)
+    for (U32 i = 0; i < 6; i++)
+    {
+        const S32 channel = shader.getTextureChannel(LLShaderMgr::DEFERRED_SHADOW0+i);
+        if (channel != -1)
+        {
+            gGL.getTexUnit(channel)->bind(LLViewerFetchedTexture::sWhiteImagep, TRUE);
+        }
+    }
+}
+
+// Set a variable to a value temporarily, and restor the variable's old value
+// when this object leaves scope.
+template<typename T>
+struct SetTemporarily
+{
+    T* mRef;
+    T mOldVal;
+    SetTemporarily(T* var, T temp_val)
+    {
+        mRef = var;
+        mOldVal = *mRef;
+        *mRef = temp_val;
+    }
+    ~SetTemporarily()
+    {
+        *mRef = mOldVal;
+    }
+};
+
+}; // namespace
+
+BOOL LLGLTFPreviewTexture::render()
+{
+    LL_PROFILE_ZONE_SCOPED_CATEGORY_UI;
+
+    if (!mShouldRender) { return FALSE; }
+    
+    LLGLDepthTest(GL_FALSE);
+    LLGLDisable stencil(GL_STENCIL_TEST);
+    LLGLDisable scissor(GL_SCISSOR_TEST);
+    SetTemporarily<bool> no_glow(&LLPipeline::sRenderGlow, false);
+    SetTemporarily<bool> no_ssr(&LLPipeline::RenderScreenSpaceReflections, false);
+    SetTemporarily<U32> no_fxaa(&LLPipeline::RenderFSAASamples, U32(0));
+    SetTemporarily<LLPipeline::RenderTargetPack*> use_auxiliary_render_target(&gPipeline.mRT, &gPipeline.mAuxillaryRT);
+
+    LLVector3 light_dir3(1.0f, 1.0f, 1.0f);
+    light_dir3.normalize();
+    const LLVector4 light_dir = LLVector4(light_dir3, 0);
+    SetTemporarily<S32> sun_light_only(&LLPipeline::RenderLocalLightCount, 0);
+
+    gPipeline.mReflectionMapManager.forceDefaultProbeAndUpdateUniforms();
+
+    LLViewerCamera camera;
+
+    // Calculate the object distance at which the object of a given radius will
+    // span the partial width of the screen given by fill_ratio.
+    // Assume the primitive has a scale of 1 (this is the default).
+    constexpr F32 fill_ratio = 0.8f;
+    constexpr F32 object_radius = 0.5f;
+    const F32 object_distance = (object_radius / fill_ratio) * tan(camera.getDefaultFOV());
+    // Negative coordinate shows the textures on the sphere right-side up, when
+    // combined with the UV hacks in create_preview_sphere
+    const LLVector3 object_position(0.0, -object_distance, 0.0);
+    LLMatrix4 object_transform;
+    object_transform.translate(object_position);
+
+    // Set up camera and viewport
+    const LLVector3 origin(0.0, 0.0, 0.0);
+    camera.lookAt(origin, object_position);
+    camera.setAspect(mFullHeight / mFullWidth);
+    const LLRect texture_rect(0, mFullHeight, mFullWidth, 0);
+    camera.setPerspective(NOT_FOR_SELECTION, texture_rect.mLeft, texture_rect.mBottom, texture_rect.getWidth(), texture_rect.getHeight(), FALSE, camera.getNear(), MAX_FAR_CLIP*2.f);
+
+    // Generate sphere object on-the-fly. Discard afterwards. (Vertex buffer is
+    // discarded, but the sphere should be cached in LLVolumeMgr.)
+    std::vector<GLTFPreviewModel> preview_sphere = create_preview_sphere(mGLTFMaterial, object_transform);
+
+    glClearColor(0, 0, 0, 0);
+
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+    gPipeline.setupHWLights();
+    glh::matrix4f mat = copy_matrix(gGLModelView);
+    glh::vec4f transformed_light_dir(light_dir.mV);
+    mat.mult_matrix_vec(transformed_light_dir);
+    SetTemporarily<LLVector4> force_sun_direction_high_graphics(&gPipeline.mTransformedSunDir, LLVector4(transformed_light_dir.v));
+    // Override lights to ensure the sun is always shining from a certain direction (low graphics)
+    // See also force_sun_direction_high_graphics and fixup_shader_constants
+    {
+        LLLightState* light = gGL.getLight(0);
+        light->setPosition(light_dir);
+        constexpr bool sun_up = true;
+        light->setSunPrimary(sun_up);
+    }
+
+    LLRenderTarget& screen = gPipeline.mAuxillaryRT.screen;
+
+#if 0
+    if (mGLTFMaterial->mAlphaMode == LLGLTFMaterial::ALPHA_MODE_OPAQUE || mGLTFMaterial->mAlphaMode == LLGLTFMaterial::ALPHA_MODE_MASK)
+    {
+        // *TODO: Opaque/alpha mask rendering (gDeferredPBROpaqueProgram)
+    }
+    else
+#endif
+    {
+        // Alpha blend rendering
+
+        screen.bindTarget();
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+        LLGLSLShader& shader = gDeferredPBRAlphaProgram;
+
+        gPipeline.bindDeferredShader(shader);
+        fixup_shader_constants(shader);
+
+        for (GLTFPreviewModel& part : preview_sphere)
+        {
+            LLRenderPass::pushGLTFBatch(*part.mDrawInfo);
+        }
+
+        gPipeline.unbindDeferredShader(shader);
+
+        screen.flush();
+    }
+
+    gPipeline.copyScreenSpaceReflections(&screen, &gPipeline.mSceneMap);
+    gPipeline.generateLuminance(&screen, &gPipeline.mLuminanceMap);
+    gPipeline.generateExposure(&gPipeline.mLuminanceMap, &gPipeline.mExposureMap);
+    gPipeline.gammaCorrect(&screen, &gPipeline.mPostMap);
+    LLVertexBuffer::unbind();
+    gPipeline.generateGlow(&gPipeline.mPostMap);
+    gPipeline.combineGlow(&gPipeline.mPostMap, &screen);
+	gPipeline.renderDoF(&screen, &gPipeline.mPostMap);
+	gPipeline.applyFXAA(&gPipeline.mPostMap, &screen);
+
+	gDeferredPostNoDoFProgram.bind();
+
+	// From LLPipeline::renderFinalize: "Whatever is last in the above post processing chain should _always_ be rendered directly here.  If not, expect problems."
+	gDeferredPostNoDoFProgram.bindTexture(LLShaderMgr::DEFERRED_DIFFUSE, &screen);
+	gDeferredPostNoDoFProgram.bindTexture(LLShaderMgr::DEFERRED_DEPTH, mBoundTarget, true);
+
+	{
+		LLGLDepthTest depth_test(GL_TRUE, GL_TRUE, GL_ALWAYS);
+		gPipeline.mScreenTriangleVB->setBuffer();
+		gPipeline.mScreenTriangleVB->drawArrays(LLRender::TRIANGLES, 0, 3);
+	}
+
+	gDeferredPostNoDoFProgram.unbind();
+
+    // Clean up
+    gPipeline.setupHWLights();
+    gPipeline.mReflectionMapManager.forceDefaultProbeAndUpdateUniforms(false);
+
+    return TRUE;
+}
+
+void LLGLTFPreviewTexture::postRender(BOOL success)
+{
+    LL_PROFILE_ZONE_SCOPED_CATEGORY_UI;
+
+    if (!mShouldRender) { return; }
+    mShouldRender = false;
+
+    LLViewerDynamicTexture::postRender(success);
+}
+
+// static
+LLPointer<LLViewerTexture> LLGLTFMaterialPreviewMgr::getPreview(LLPointer<LLFetchedGLTFMaterial> &material)
+{
+    if (!material)
+    {
+        return nullptr;
+    }
+
+    if (!is_material_loaded_enough_for_ui(*material))
+    {
+        return nullptr;
+    }
+
+    return LLGLTFPreviewTexture::create(material);
+}