nel/src/3d/texture_bump.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2020  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
   6 //
   7 // This program is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU Affero General Public License as
   9 // published by the Free Software Foundation, either version 3 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU Affero General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU Affero General Public License
  18 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 #include "std3d.h"
  21
  22 #include "nel/3d/texture_bump.h"
  23
  24
  25
  26 #ifdef DEBUG_NEW
  27 #define new DEBUG_NEW
  28 #endif
  29
  30 namespace NL3D {
  31
  32 namespace /* anonymous */ {
  33
  34 // Map that give the normalization factor for each map from its sharename. This avoid to generate several time the maps to get the normalization factor if a bumpmap is shared by severals CTextureBump instances;
  35 struct CNormalizationInfo
  36 {
  37         uint  NumRefs;
  38         float NormalizationFactor;
  39 };
  40 typedef std::map<std::string, CNormalizationInfo> TNameToNI; // sharename to the normalization factor
  41 class CNameToNFStatic {
  42 public:
  43         TNameToNI Map;
  44         bool Initialized;
  45         CNameToNFStatic() : Initialized(true)
  46         {
  47
  48         }
  49         ~CNameToNFStatic()
  50         {
  51                 Initialized = false;
  52         }
  53 };
  54 CNameToNFStatic s_NameToNF;
  55
  56 } /* anonymous namespace */
  57
  58 #define GET_HGT(x, y) ((sint) ((src[(uint) (x) % width + ((uint) (y) % height) * width] & 0x00ff00) >> 8))
  59 /// create a DsDt texture from a height map (red component of a rgba bitmap)
  60 static void BuildDsDt(uint32 *src, sint width, sint height, uint16 *dest)
  61 {
  62         #define GET_HGT(x, y) ((sint) ((src[(uint) (x) % width + ((uint) (y) % height) * width] & 0x00ff00) >> 8))
  63         sint x, y;
  64         for (x = 0; x < width; ++x)
  65         {
  66                 for (y = 0; y < height; ++y)
  67                 {
  68                         sint off = x + y * width;
  69                         sint16 ds = (sint16) (GET_HGT(x + 1, y) - GET_HGT(x - 1, y));
  70                         sint16 dt = (sint16) (GET_HGT(x, y + 1) - GET_HGT(x, y - 1));
  71                         dest[off] = (uint16) ((ds & 0xff)  | ((dt & 0xff) << 8));
  72                 }
  73         }
  74 }
  75
  76
  77 /// create a rgba gradient texture from a height map (red component of a rgba bitmap)
  78 static void BuildDsDtAsRGBA(uint32 *src, sint width, sint height, uint32 *dest)
  79 {
  80         #define GET_HGT(x, y) ((sint) ((src[(uint) (x) % width + ((uint) (y) % height) * width] & 0x00ff00) >> 8))
  81         sint x, y;
  82         for (x = 0; x < width; ++x)
  83         {
  84                 for (y = 0; y < height; ++y)
  85                 {
  86                         sint off = x + y * width;
  87                         sint16 ds = (sint16) (GET_HGT(x + 1, y) - GET_HGT(x - 1, y));
  88                         sint16 dt = (sint16) (GET_HGT(x, y + 1) - GET_HGT(x, y - 1));
  89                         dest[off] = 0xff000000 | (uint32) ((ds + 0x80) & 0xff) | (uint32) ((dt + 0x80) << 8);
  90                 }
  91         }
  92 }
  93
  94 /// Normalize a DsDt texture after it has been built, and return the normalization factor
  95 static float NormalizeDsDt(uint16 *src, sint width, sint height)
  96 {
  97         const uint size = width * height;
  98         uint highestDelta = 0;
  99         uint k;
 100
 101         for (k = 0; k < size; ++k)
 102         {
 103                 highestDelta = std::max(highestDelta, (uint) ::abs((sint) (sint8) (src[k] & 255)));
 104                 highestDelta = std::max(highestDelta, (uint) ::abs((sint) (sint8) (src[k] >> 8)));
 105         }
 106
 107         if (highestDelta == 0)
 108         {
 109                 return 1.f;
 110         }
 111         float normalizationFactor = 127.f / highestDelta;
 112         for (k = 0; k < size; ++k)
 113         {
 114                 float fdu = (sint8) (src[k] & 255) * normalizationFactor;
 115                 float fdv = (sint8) (src[k] >> 8) * normalizationFactor;
 116                 NLMISC::clamp(fdu, -128, 127);
 117                 NLMISC::clamp(fdv, -128, 127);
 118                 uint8 du = (uint8) (sint8) fdu;
 119                 uint8 dv = (uint8) (sint8) fdv;
 120                 src[k] = (uint16) du | (((uint16) dv) << 8);
 121         }
 122         return 1.f / normalizationFactor;
 123 }
 124
 125 static float NormalizeDsDtAsRGBA(uint32 *src, sint width, sint height)
 126 {
 127         uint k;
 128         const uint size = width * height;
 129         uint highestDelta = 0;
 130
 131         /// first, get the highest delta
 132         for (k = 0; k < size; ++k)
 133         {
 134                 highestDelta = std::max(highestDelta, (uint) abs((sint8) ((src[k] & 0xff) - 0x80)));
 135                 highestDelta = std::max(highestDelta, (uint) abs((sint8) (((src[k] >> 8) & 0xff) - 0x80)));
 136         }
 137
 138         if (highestDelta == 0)
 139         {
 140                 return 1.f;
 141         }
 142         float normalizationFactor = 127.f / highestDelta;
 143         for (k = 0; k < size; ++k)
 144         {
 145                 float fdu = ((sint8) ((src[k] & 255) - 0x80)) * normalizationFactor;
 146                 float fdv = ((sint8) (((src[k] >> 8) & 0xff) - 0x80)) * normalizationFactor;
 147                 NLMISC::clamp(fdu, -128, 127);
 148                 NLMISC::clamp(fdv, -128, 127);
 149                 uint8 du = (uint8) ((sint8) fdu + 0x80);
 150                 uint8 dv = (uint8) ((sint8) fdv + 0x80);
 151                 src[k] = (src[k] & 0xffff0000) | (uint32) du | (uint32) (((uint16) dv) << 8);
 152         }
 153         return 1.f / normalizationFactor;
 154
 155 }
 156
 157
 158
 159
 160
 161 /*
 162  * Constructor
 163  */
 164 CTextureBump::CTextureBump() : _NormalizationFactor(NULL),
 165                                                            _DisableSharing(false),
 166                                                            _ForceNormalize(true)
 167 {
 168         // mipmapping not supported for now, disable it
 169         ITexture::setFilterMode(ITexture::Linear, ITexture::LinearMipMapOff);
 170 }
 171
 172
 173 ///==============================================================================================
 174 void CTextureBump::setFilterMode(TMagFilter magf, TMinFilter minf)
 175 {
 176         nlstop; // set filter mode not allowed with bump textures (not supported by some GPUs)
 177 }
 178
 179 void CTextureBump::setHeightMap(ITexture *heightMap)
 180 {
 181         if (heightMap != _HeightMap)
 182         {
 183                 _HeightMap = heightMap;
 184                 touch();
 185         }
 186 }
 187
 188
 189 ///==============================================================================================
 190 void CTextureBump::serial(NLMISC::IStream &f)
 191 {
 192         /// version 2 : normalization flag
 193         sint ver = f.serialVersion(3);
 194         ITexture::serial(f);
 195         ITexture *tex = NULL;
 196         if (f.isReading())
 197         {
 198                 f.serialPolyPtr(tex);
 199                 _HeightMap = tex;
 200                 touch();
 201         }
 202         else
 203         {
 204                 tex = _HeightMap;
 205                 f.serialPolyPtr(tex);
 206         }
 207         f.serial(_DisableSharing);
 208         if (ver >= 1)
 209         {
 210                 bool oldFlag = false;
 211                 f.serial(oldFlag); // backaward compatibility : serial the old "forceAbsoluteOffset" flag
 212         }
 213         if (ver >= 2)
 214         {
 215                 f.serial(_ForceNormalize);
 216         }
 217 }
 218
 219 ///==============================================================================================
 220 void CTextureBump::doGenerate(bool async)
 221 {
 222         if (!_HeightMap)
 223         {
 224                 makeDummy();
 225                 return;
 226         }
 227         // generate the height map
 228         _HeightMap->generate();
 229         if (!_HeightMap->convertToType(CBitmap::RGBA))
 230         {
 231                 makeDummy();
 232                 return;
 233         }
 234         releaseMipMaps();
 235         uint width = _HeightMap->getWidth();
 236         uint height = _HeightMap->getHeight();
 237         if (getUploadFormat() == RGBA8888)
 238         {
 239                 CBitmap::resize(_HeightMap->getWidth(), _HeightMap->getHeight(), CBitmap::RGBA);
 240         }
 241         else
 242         {
 243                 CBitmap::resize(_HeightMap->getWidth(), _HeightMap->getHeight(), CBitmap::DsDt);
 244         }
 245         // build the DsDt map
 246         if (getUploadFormat() == RGBA8888)
 247         {
 248                 BuildDsDtAsRGBA((uint32 *) &(_HeightMap->getPixels()[0]), width, height, (uint32 *) &(getPixels()[0]));
 249         }
 250         else
 251         {
 252                 BuildDsDt((uint32 *) &(_HeightMap->getPixels()[0]), width, height, (uint16 *) &(getPixels()[0]));
 253         }
 254
 255         float normalizationFactor = 1.0f;
 256         // Normalize the map if needed
 257         if (_ForceNormalize)
 258         {
 259                 if (getUploadFormat() == RGBA8888)
 260                 {
 261                         normalizationFactor = NormalizeDsDtAsRGBA((uint32 *) &(getPixels()[0]), width, height);
 262                 }
 263                 else
 264                 {
 265                         normalizationFactor = NormalizeDsDt((uint16 *) &(getPixels()[0]), width, height);
 266                 }
 267         }
 268         // create entry in the map for the normalization factor
 269         std::string shareName = getShareName();
 270         nlassertverbose(s_NameToNF.Initialized);
 271         TNameToNI::iterator it = s_NameToNF.Map.find(shareName);
 272         if (it == s_NameToNF.Map.end())
 273         {
 274                 // create a new entry
 275                 CNormalizationInfo ni;
 276                 ni.NumRefs = 1;
 277                 ni.NormalizationFactor = normalizationFactor;
 278                 std::pair<TNameToNI::iterator, bool> pb = s_NameToNF.Map.insert(TNameToNI::value_type(shareName, ni));
 279                 _NormalizationFactor = &(pb.first->second.NormalizationFactor);
 280         }
 281         else
 282         {
 283                 // another map has computed the factor
 284                 _NormalizationFactor = &(it->second.NormalizationFactor);
 285                 ++(it->second.NumRefs);
 286         }
 287
 288         if (_HeightMap->getReleasable())
 289         {
 290                 _HeightMap->release();
 291         }
 292 }
 293
 294 ///==============================================================================================
 295 void CTextureBump::release()
 296 {
 297         ITexture::release();
 298         if (_HeightMap != NULL)
 299         {
 300                 if (_HeightMap->getReleasable())
 301                 {
 302                         _HeightMap->release();
 303                 }
 304         }
 305 }
 306
 307
 308 ///==============================================================================================
 309 bool    CTextureBump::supportSharing() const
 310 {
 311         return !_DisableSharing && _HeightMap && _HeightMap->supportSharing();
 312 }
 313
 314
 315 ///==============================================================================================
 316 std::string     CTextureBump::getShareName() const
 317 {
 318         nlassert(supportSharing());
 319         return "BumpDsDt:" + _HeightMap->getShareName();
 320 }
 321
 322 ///==============================================================================================
 323 float CTextureBump::getNormalizationFactor()
 324 {
 325         if (!_Touched)
 326         {
 327                 if (_NormalizationFactor) return *_NormalizationFactor;
 328         }
 329         if (!_HeightMap) return 1.f;
 330         // not computed yet, see if another map has computed it
 331         std::string shareName = getShareName();
 332         nlassertverbose(s_NameToNF.Initialized);
 333         TNameToNI::iterator it = s_NameToNF.Map.find(shareName);
 334         if (it != s_NameToNF.Map.end())
 335         {
 336                 _NormalizationFactor = &(it->second.NormalizationFactor);
 337                 ++(it->second.NumRefs);
 338         }
 339         else
 340         {
 341                 doGenerate();
 342                 if (this->getReleasable()) this->release();
 343         }
 344         return _NormalizationFactor ? *_NormalizationFactor : 1.f;
 345 }
 346
 347 ///==============================================================================================
 348 CTextureBump::~CTextureBump()
 349 {
 350         if (s_NameToNF.Initialized && _NormalizationFactor && !s_NameToNF.Map.empty())
 351         {
 352                 // find normalization factor from its name
 353                 TNameToNI::iterator it = s_NameToNF.Map.find(getShareName());
 354
 355                 // if found
 356                 if (it != s_NameToNF.Map.end())
 357                 {
 358                         // we can delete it only if it's not used anymore
 359                         if (--(it->second.NumRefs) == 0) s_NameToNF.Map.erase(it);
 360                 }
 361         }
 362 }
 363
 364
 365
 366
 367 } // NL3D