nel/src/3d/cube_map_builder.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 #include "std3d.h"
  18
  19
  20
  21 #include "nel/3d/cube_map_builder.h"
  22 #include "nel/3d/texture_cube.h"
  23 #include "nel/3d/texture_mem.h"
  24 #include "nel/misc/vector.h"
  25 #include "nel/misc/rgba.h"
  26
  27
  28
  29 #ifdef DEBUG_NEW
  30 #define new DEBUG_NEW
  31 #endif
  32
  33 namespace NL3D
  34 {
  35
  36
  37 // utility function : build  a side of a cube map
  38 static uint8 *BuildCubeMapTex(const NLMISC::CVector &start,
  39                                                           const NLMISC::CVector &uDir,
  40                                                           const NLMISC::CVector &vDir,
  41                                                           uint size,
  42                                                           ICubeMapFunctor &f
  43                                                          )
  44 {
  45         NLMISC::CRGBA *map = new NLMISC::CRGBA[size * size];
  46         NLMISC::CRGBA *destTexel = map;
  47         NLMISC::CVector currN = start;
  48         NLMISC::CVector uStep = (2.f / size) * uDir;
  49         NLMISC::CVector vStep = (2.f / size) * vDir;
  50
  51         for (uint y = 0; y < size; ++y)
  52         {
  53                 NLMISC::CVector hCurrN = currN;
  54                 for (uint x = 0; x < size; ++x)
  55                 {
  56                         destTexel[x + y *size] = f(hCurrN.normed());
  57                         hCurrN += uStep;
  58                 }
  59                 currN += vStep;
  60         }
  61         return (uint8 *) map;
  62 }
  63
  64 // utility function : build  a side of a cube map, with luminance only
  65 static uint8 *BuildCubeMapTexLuminance(const NLMISC::CVector &start,
  66                                                           const NLMISC::CVector &uDir,
  67                                                           const NLMISC::CVector &vDir,
  68                                                           uint size,
  69                                                           ICubeMapFunctor &f
  70                                                          )
  71 {
  72         uint8 *map = new uint8[size * size];
  73         uint8 *destTexel = map;
  74         NLMISC::CVector currN = start;
  75         NLMISC::CVector uStep = (2.f / size) * uDir;
  76         NLMISC::CVector vStep = (2.f / size) * vDir;
  77
  78         for (uint y = 0; y < size; ++y)
  79         {
  80                 NLMISC::CVector hCurrN = currN;
  81                 for (uint x = 0; x < size; ++x)
  82                 {
  83                         destTexel[x + y *size] = f(hCurrN.normed()).A;
  84                         hCurrN += uStep;
  85                 }
  86                 currN += vStep;
  87         }
  88         return map;
  89 }
  90
  91
  92
  93 CTextureCube *BuildCubeMap(sint mapSize, ICubeMapFunctor &f, bool luminanceOnly /* = false*/, const std::string &shareName /* = "" */)
  94 {
  95         CUniquePtr<CTextureCube> cubeMap(new CTextureCube);
  96         CUniquePtr<CTextureMem> faces[6];
  97
  98         /// this gives the start (unormalized normal for each face for u,v = 0, 0)
  99         static const NLMISC::CVector start[] =
 100         {
 101                 NLMISC::CVector(1, 1, 1),               /// positive_x
 102                 NLMISC::CVector(-1, 1, -1),             /// negative_x
 103                 NLMISC::CVector(-1, 1, -1),             /// positive_y
 104                 NLMISC::CVector(-1, -1, 1),             /// negative_y
 105                 NLMISC::CVector(-1, 1, 1),              /// positive_z
 106                 NLMISC::CVector(1, 1, -1)               /// negative_z
 107         };
 108
 109
 110         static const NLMISC::CVector uDir[] =
 111         {
 112                 NLMISC::CVector::K,             /// positive_x
 113                 - NLMISC::CVector::K,                   /// negative_x
 114                 - NLMISC::CVector::I,                   /// positive_y
 115                 - NLMISC::CVector::I,                   /// negative_y
 116                 NLMISC::CVector::I,                     /// positive_z
 117                 -NLMISC::CVector::I,                    /// negative_z
 118         };
 119
 120         static const NLMISC::CVector vDir[] =
 121         {
 122                 - NLMISC::CVector::J,           /// positive_x
 123                 - NLMISC::CVector::J,           /// negative_x
 124                 NLMISC::CVector::K,                     /// positive_y
 125                 - NLMISC::CVector::K,           /// negative_y
 126                 NLMISC::CVector::J,             /// positive_z
 127                 NLMISC::CVector::J,             /// negative_z
 128         };
 129
 130
 131         uint k;
 132
 133         /// build all faces
 134         for (k = 0;  k < 6; ++k)
 135         {
 136                 faces[k].reset(new CTextureMem);
 137                 uint8 *map = luminanceOnly ?    BuildCubeMapTexLuminance(start[k], uDir[k], vDir[k], mapSize, f)
 138                                                            :    BuildCubeMapTex(start[k], uDir[k], vDir[k], mapSize, f);
 139                 faces[k]->setPointer(map,
 140                                                          mapSize * mapSize * sizeof(uint8) * (luminanceOnly ? 1 : 4),
 141                                                          true,
 142                                                          false,
 143                                                          mapSize,
 144                                                          mapSize,
 145                                                          luminanceOnly ? CBitmap::Luminance : CBitmap::RGBA
 146                                                         );
 147                 if (!shareName.empty())
 148                 {
 149                         faces[k]->setShareName(shareName + (char) ('0' + k));
 150                 }
 151         }
 152
 153         static const CTextureCube::TFace toTC[] = { CTextureCube::positive_x, CTextureCube::negative_x,
 154                                                                                                 CTextureCube::positive_z, CTextureCube::negative_z,
 155                                                                                                 CTextureCube::negative_y, CTextureCube::positive_y };
 156         /// assign faces
 157         for (k = 0;  k < 6; ++k)
 158         {
 159                 cubeMap->setTexture(toTC[k], faces[k].release());
 160         }
 161
 162         return cubeMap.release();
 163 }
 164
 165 } // NL3D