/** * @file llvlcomposition.cpp * @brief Viewer-side representation of a composition layer... * * $LicenseInfo:firstyear=2001&license=viewerlgpl$ * Second Life Viewer Source Code * Copyright (C) 2010, 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 "llvlcomposition.h" #include <functional> #include "llerror.h" #include "v3math.h" #include "llsurface.h" #include "lltextureview.h" #include "llviewertexture.h" #include "llviewertexturelist.h" #include "llfetchedgltfmaterial.h" #include "llgltfmateriallist.h" #include "llviewerregion.h" #include "noise.h" #include "llregionhandle.h" // for from_region_handle #include "llviewercontrol.h" extern LLColor4U MAX_WATER_COLOR; static const U32 BASE_SIZE = 128; static const F32 TERRAIN_DECODE_PRIORITY = 2048.f * 2048.f; namespace { F32 bilinear(const F32 v00, const F32 v01, const F32 v10, const F32 v11, const F32 x_frac, const F32 y_frac) { // Not sure if this is the right math... // Take weighted average of all four points (bilinear interpolation) F32 result; const F32 inv_x_frac = 1.f - x_frac; const F32 inv_y_frac = 1.f - y_frac; result = inv_x_frac*inv_y_frac*v00 + x_frac*inv_y_frac*v10 + inv_x_frac*y_frac*v01 + x_frac*y_frac*v11; return result; } void boost_minimap_texture(LLViewerFetchedTexture* tex, F32 virtual_size) { llassert(tex); if (!tex) { return; } tex->setBoostLevel(LLGLTexture::BOOST_TERRAIN); // in case the raw image is at low detail tex->addTextureStats(virtual_size); // priority } void boost_minimap_material(LLFetchedGLTFMaterial* mat, F32 virtual_size) { if (!mat) { return; } if (mat->mBaseColorTexture) { boost_minimap_texture(mat->mBaseColorTexture, virtual_size); } if (mat->mNormalTexture) { boost_minimap_texture(mat->mNormalTexture, virtual_size); } if (mat->mMetallicRoughnessTexture) { boost_minimap_texture(mat->mMetallicRoughnessTexture, virtual_size); } if (mat->mEmissiveTexture) { boost_minimap_texture(mat->mEmissiveTexture, virtual_size); } } void unboost_minimap_texture(LLViewerFetchedTexture* tex) { if (!tex) { return; } tex->setBoostLevel(LLGLTexture::BOOST_NONE); tex->setMinDiscardLevel(MAX_DISCARD_LEVEL + 1); } void unboost_minimap_material(LLFetchedGLTFMaterial* mat) { if (!mat) { return; } if (mat->mBaseColorTexture) { unboost_minimap_texture(mat->mBaseColorTexture); } if (mat->mNormalTexture) { unboost_minimap_texture(mat->mNormalTexture); } if (mat->mMetallicRoughnessTexture) { unboost_minimap_texture(mat->mMetallicRoughnessTexture); } if (mat->mEmissiveTexture) { unboost_minimap_texture(mat->mEmissiveTexture); } } }; LLTerrainMaterials::LLTerrainMaterials() { for (S32 i = 0; i < ASSET_COUNT; ++i) { mMaterialTexturesSet[i] = false; } } LLTerrainMaterials::~LLTerrainMaterials() { unboost(); } void LLTerrainMaterials::apply(const LLModifyRegion& other) { for (S32 i = 0; i < LLTerrainMaterials::ASSET_COUNT; ++i) { const LLGLTFMaterial* other_override = other.getMaterialOverride(i); LLGLTFMaterial* material_override = other_override ? new LLGLTFMaterial(*other_override) : nullptr; setMaterialOverride(i, material_override); } } bool LLTerrainMaterials::generateMaterials() { if (makeTexturesReady(true, true)) { return true; } if (makeMaterialsReady(true, true)) { return true; } return false; } void LLTerrainMaterials::boost() { for (S32 i = 0; i < ASSET_COUNT; ++i) { LLPointer<LLViewerFetchedTexture>& tex = mDetailTextures[i]; llassert(tex.notNull()); boost_minimap_texture(tex, TERRAIN_DECODE_PRIORITY); LLPointer<LLFetchedGLTFMaterial>& mat = mDetailMaterials[i]; boost_minimap_material(mat, TERRAIN_DECODE_PRIORITY); } } void LLTerrainMaterials::unboost() { for (S32 i = 0; i < ASSET_COUNT; ++i) { LLPointer<LLViewerFetchedTexture>& tex = mDetailTextures[i]; unboost_minimap_texture(tex); LLPointer<LLFetchedGLTFMaterial>& mat = mDetailMaterials[i]; unboost_minimap_material(mat); } } LLUUID LLTerrainMaterials::getDetailAssetID(S32 asset) { llassert(mDetailTextures[asset] && mDetailMaterials[asset]); // Assume both the the material and texture were fetched in the same way // using the same UUID. However, we may not know at this point which one // will load. return mDetailTextures[asset] ? mDetailTextures[asset]->getID() : LLUUID::null; } LLPointer<LLViewerFetchedTexture> fetch_terrain_texture(const LLUUID& id) { if (id.isNull()) { return nullptr; } LLPointer<LLViewerFetchedTexture> tex = LLViewerTextureManager::getFetchedTexture(id); return tex; } void LLTerrainMaterials::setDetailAssetID(S32 asset, const LLUUID& id) { // *NOTE: If there were multiple terrain swatches using the same asset // ID, the asset still in use will be temporarily unboosted. // It will be boosted again during terrain rendering. unboost_minimap_texture(mDetailTextures[asset]); unboost_minimap_material(mDetailMaterials[asset]); // This is terrain texture, but we are not setting it as BOOST_TERRAIN // since we will be manipulating it later as needed. mDetailTextures[asset] = fetch_terrain_texture(id); LLPointer<LLFetchedGLTFMaterial>& mat = mDetailMaterials[asset]; mat = id.isNull() ? nullptr : gGLTFMaterialList.getMaterial(id); mDetailRenderMaterials[asset] = nullptr; mMaterialTexturesSet[asset] = false; } const LLGLTFMaterial* LLTerrainMaterials::getMaterialOverride(S32 asset) const { return mDetailMaterialOverrides[asset]; } void LLTerrainMaterials::setMaterialOverride(S32 asset, LLGLTFMaterial* mat_override) { // Non-null overrides must be nontrivial. Otherwise, please set the override to null instead. llassert(!mat_override || *mat_override != LLGLTFMaterial::sDefault); mDetailMaterialOverrides[asset] = mat_override; mDetailRenderMaterials[asset] = nullptr; } LLTerrainMaterials::Type LLTerrainMaterials::getMaterialType() { LL_PROFILE_ZONE_SCOPED; const bool use_textures = makeTexturesReady(false, false) || !makeMaterialsReady(false, false); return use_textures ? Type::TEXTURE : Type::PBR; } bool LLTerrainMaterials::makeTexturesReady(bool boost, bool strict) { bool ready[ASSET_COUNT]; // *NOTE: Calls to makeTextureReady may boost textures. Do not early-return. for (S32 i = 0; i < ASSET_COUNT; i++) { ready[i] = mDetailTextures[i].notNull() && makeTextureReady(mDetailTextures[i], boost); } bool one_ready = false; for (S32 i = 0; i < ASSET_COUNT; i++) { const bool current_ready = ready[i]; one_ready = one_ready || current_ready; if (!current_ready && strict) { return false; } } return one_ready; } namespace { bool material_asset_ready(LLFetchedGLTFMaterial* mat) { return mat && mat->isLoaded(); } }; bool LLTerrainMaterials::makeMaterialsReady(bool boost, bool strict) { bool ready[ASSET_COUNT]; // *NOTE: This section may boost materials/textures. Do not early-return if ready[i] is false. for (S32 i = 0; i < ASSET_COUNT; i++) { ready[i] = false; LLPointer<LLFetchedGLTFMaterial>& mat = mDetailMaterials[i]; if (!material_asset_ready(mat)) { continue; } LLPointer<LLFetchedGLTFMaterial>& render_mat = mDetailRenderMaterials[i]; if (!render_mat) { render_mat = new LLFetchedGLTFMaterial(); *render_mat = *mat; // This render_mat is effectively already loaded, because it gets its data from mat. LLPointer<LLGLTFMaterial>& override_mat = mDetailMaterialOverrides[i]; if (override_mat) { render_mat->applyOverride(*override_mat); } } ready[i] = materialTexturesReady(render_mat, mMaterialTexturesSet[i], boost, strict); } #if 1 static LLCachedControl<bool> sRenderTerrainPBREnabled(gSavedSettings, "RenderTerrainPBREnabled", false); static LLCachedControl<bool> sRenderTerrainPBRForce(gSavedSettings, "RenderTerrainPBRForce", false); if (sRenderTerrainPBREnabled && sRenderTerrainPBRForce) { bool defined = true; for (S32 i = 0; i < ASSET_COUNT; i++) { if (!mDetailMaterials[i]) { defined = false; break; } } if (defined) { return true; } } #endif bool one_ready = false; for (S32 i = 0; i < ASSET_COUNT; i++) { const bool current_ready = ready[i]; one_ready = one_ready || current_ready; if (!current_ready && strict) { return false; } } return one_ready; } // Boost the texture loading priority // Return true when ready to use (i.e. texture is sufficiently loaded) // static bool LLTerrainMaterials::makeTextureReady(LLPointer<LLViewerFetchedTexture>& tex, bool boost) { //llassert(tex); ??? maybe ok ??? if (!tex) { return false; } if (tex->getDiscardLevel() < 0) { if (boost) { boost_minimap_texture(tex, BASE_SIZE*BASE_SIZE); } return false; } if ((tex->getDiscardLevel() != 0 && (tex->getWidth() < BASE_SIZE || tex->getHeight() < BASE_SIZE))) { if (boost) { boost_minimap_texture(tex, BASE_SIZE*BASE_SIZE); S32 width = tex->getFullWidth(); S32 height = tex->getFullHeight(); S32 min_dim = llmin(width, height); S32 ddiscard = 0; while (min_dim > BASE_SIZE && ddiscard < MAX_DISCARD_LEVEL) { ddiscard++; min_dim /= 2; } tex->setMinDiscardLevel(ddiscard); } return false; } if (tex->getComponents() == 0) { return false; } return true; } // Make sure to call material_asset_ready first // strict = true -> all materials must be sufficiently loaded // strict = false -> at least one material must be loaded // static bool LLTerrainMaterials::materialTexturesReady(LLPointer<LLFetchedGLTFMaterial>& mat, bool& textures_set, bool boost, bool strict) { llassert(mat); // Material is loaded, but textures may not be if (!textures_set) { textures_set = true; // *NOTE: These can sometimes be set to to nullptr due to // updateTEMaterialTextures. For the sake of robustness, we emulate // that fetching behavior by setting textures of null IDs to nullptr. mat->mBaseColorTexture = fetch_terrain_texture(mat->mTextureId[LLGLTFMaterial::GLTF_TEXTURE_INFO_BASE_COLOR]); mat->mNormalTexture = fetch_terrain_texture(mat->mTextureId[LLGLTFMaterial::GLTF_TEXTURE_INFO_NORMAL]); mat->mMetallicRoughnessTexture = fetch_terrain_texture(mat->mTextureId[LLGLTFMaterial::GLTF_TEXTURE_INFO_METALLIC_ROUGHNESS]); mat->mEmissiveTexture = fetch_terrain_texture(mat->mTextureId[LLGLTFMaterial::GLTF_TEXTURE_INFO_EMISSIVE]); } // *NOTE: Calls to makeTextureReady may boost textures. Do not early-return. bool ready[LLGLTFMaterial::GLTF_TEXTURE_INFO_COUNT]; ready[LLGLTFMaterial::GLTF_TEXTURE_INFO_BASE_COLOR] = mat->mTextureId[LLGLTFMaterial::GLTF_TEXTURE_INFO_BASE_COLOR].isNull() || makeTextureReady(mat->mBaseColorTexture, boost); ready[LLGLTFMaterial::GLTF_TEXTURE_INFO_NORMAL] = mat->mTextureId[LLGLTFMaterial::GLTF_TEXTURE_INFO_NORMAL].isNull() || makeTextureReady(mat->mNormalTexture, boost); ready[LLGLTFMaterial::GLTF_TEXTURE_INFO_METALLIC_ROUGHNESS] = mat->mTextureId[LLGLTFMaterial::GLTF_TEXTURE_INFO_METALLIC_ROUGHNESS].isNull() || makeTextureReady(mat->mMetallicRoughnessTexture, boost); ready[LLGLTFMaterial::GLTF_TEXTURE_INFO_EMISSIVE] = mat->mTextureId[LLGLTFMaterial::GLTF_TEXTURE_INFO_EMISSIVE].isNull() || makeTextureReady(mat->mEmissiveTexture, boost); if (strict) { for (U32 i = 0; i < LLGLTFMaterial::GLTF_TEXTURE_INFO_COUNT; ++i) { if (!ready[i]) { return false; } } } return true; } // Boost the loading priority of every known texture in the material // Return true when ready to use // static bool LLTerrainMaterials::makeMaterialReady(LLPointer<LLFetchedGLTFMaterial> &mat, bool &textures_set, bool boost, bool strict) { if (!material_asset_ready(mat)) { return false; } return materialTexturesReady(mat, textures_set, boost, strict); } // static const LLUUID (&LLVLComposition::getDefaultTextures())[ASSET_COUNT] { const static LLUUID default_textures[LLVLComposition::ASSET_COUNT] = { TERRAIN_DIRT_DETAIL, TERRAIN_GRASS_DETAIL, TERRAIN_MOUNTAIN_DETAIL, TERRAIN_ROCK_DETAIL }; return default_textures; } LLVLComposition::LLVLComposition(LLSurface *surfacep, const U32 width, const F32 scale) : LLTerrainMaterials(), LLViewerLayer(width, scale) { // Load Terrain Textures - Original ones const LLUUID (&default_textures)[LLVLComposition::ASSET_COUNT] = LLVLComposition::getDefaultTextures(); for (S32 i = 0; i < ASSET_COUNT; ++i) { setDetailAssetID(i, default_textures[i]); } mSurfacep = surfacep; // Initialize the texture matrix to defaults. for (S32 i = 0; i < CORNER_COUNT; ++i) { mStartHeight[i] = gSavedSettings.getF32("TerrainColorStartHeight"); mHeightRange[i] = gSavedSettings.getF32("TerrainColorHeightRange"); } } LLVLComposition::~LLVLComposition() { LLTerrainMaterials::~LLTerrainMaterials(); } void LLVLComposition::setSurface(LLSurface *surfacep) { mSurfacep = surfacep; } bool LLVLComposition::generateHeights(const F32 x, const F32 y, const F32 width, const F32 height) { if (!mParamsReady) { // All the parameters haven't been set yet (we haven't gotten the message from the sim) return false; } llassert(mSurfacep); if (!mSurfacep || !mSurfacep->getRegion()) { // We don't always have the region yet here.... return false; } S32 x_begin, y_begin, x_end, y_end; x_begin = ll_round( x * mScaleInv ); y_begin = ll_round( y * mScaleInv ); x_end = ll_round( (x + width) * mScaleInv ); y_end = ll_round( (y + width) * mScaleInv ); if (x_end > mWidth) { x_end = mWidth; } if (y_end > mWidth) { y_end = mWidth; } LLVector3d origin_global = from_region_handle(mSurfacep->getRegion()->getHandle()); // For perlin noise generation... const F32 slope_squared = 1.5f*1.5f; const F32 xyScale = 4.9215f; //0.93284f; const F32 zScale = 4; //0.92165f; const F32 z_offset = 0.f; const F32 noise_magnitude = 2.f; // Degree to which noise modulates composition layer (versus // simple height) const F32 xyScaleInv = (1.f / xyScale); const F32 zScaleInv = (1.f / zScale); const F32 inv_width = 1.f/mWidth; // OK, for now, just have the composition value equal the height at the point. for (S32 j = y_begin; j < y_end; j++) { for (S32 i = x_begin; i < x_end; i++) { F32 vec[3]; F32 vec1[3]; F32 twiddle; // Bilinearly interpolate the start height and height range of the textures F32 start_height = bilinear(mStartHeight[SOUTHWEST], mStartHeight[SOUTHEAST], mStartHeight[NORTHWEST], mStartHeight[NORTHEAST], i*inv_width, j*inv_width); // These will be bilinearly interpolated F32 height_range = bilinear(mHeightRange[SOUTHWEST], mHeightRange[SOUTHEAST], mHeightRange[NORTHWEST], mHeightRange[NORTHEAST], i*inv_width, j*inv_width); // These will be bilinearly interpolated LLVector3 location(i*mScale, j*mScale, 0.f); F32 height = mSurfacep->resolveHeightRegion(location) + z_offset; // Step 0: Measure the exact height at this texel vec[0] = (F32)(origin_global.mdV[VX]+location.mV[VX])*xyScaleInv; // Adjust to non-integer lattice vec[1] = (F32)(origin_global.mdV[VY]+location.mV[VY])*xyScaleInv; vec[2] = height*zScaleInv; // // Choose material value by adding to the exact height a random value // vec1[0] = vec[0]*(0.2222222222f); vec1[1] = vec[1]*(0.2222222222f); vec1[2] = vec[2]*(0.2222222222f); twiddle = noise2(vec1)*6.5f; // Low freq component for large divisions twiddle += turbulence2(vec, 2)*slope_squared; // High frequency component twiddle *= noise_magnitude; F32 scaled_noisy_height = (height + twiddle - start_height) * F32(ASSET_COUNT) / height_range; scaled_noisy_height = llmax(0.f, scaled_noisy_height); scaled_noisy_height = llmin(3.f, scaled_noisy_height); *(mDatap + i + j*mWidth) = scaled_noisy_height; } } return true; } LLTerrainMaterials gLocalTerrainMaterials; bool LLVLComposition::generateComposition() { if (!mParamsReady) { // All the parameters haven't been set yet (we haven't gotten the message from the sim) return false; } return LLTerrainMaterials::generateMaterials(); } F32 LLVLComposition::getStartHeight(S32 corner) { return mStartHeight[corner]; } void LLVLComposition::setDetailAssetID(S32 asset, const LLUUID& id) { if (id.isNull()) { return; } LLTerrainMaterials::setDetailAssetID(asset, id); mRawImages[asset] = NULL; mRawImagesBaseColor[asset] = NULL; mRawImagesEmissive[asset] = NULL; } void LLVLComposition::setStartHeight(S32 corner, const F32 start_height) { mStartHeight[corner] = start_height; } F32 LLVLComposition::getHeightRange(S32 corner) { return mHeightRange[corner]; } void LLVLComposition::setHeightRange(S32 corner, const F32 range) { mHeightRange[corner] = range; }