nel/tools/3d/textures_tool/main.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
  18 #include "nel/misc/file.h"
  19 #include "nel/misc/common.h"
  20 #include "nel/misc/bitmap.h"
  21 #include "nel/misc/path.h"
  22 #include "nel/misc/cmd_args.h"
  23 #include "nel/misc/vector_2d.h"
  24 #include "nel/misc/uv.h"
  25 #include "nel/misc/algo.h"
  26
  27 struct CPoint
  28 {
  29         CPoint(sint _x, sint _y) :x(_x), y(_y)
  30         {
  31         }
  32
  33         CPoint operator + (const CPoint &p) const
  34         {
  35                 return CPoint(x + p.x, y + p.y);
  36         }
  37
  38         sint x;
  39         sint y;
  40 };
  41
  42 const CPoint Up(0, -1);
  43 const CPoint Down(0, 1);
  44 const CPoint Left(-1, 0);
  45 const CPoint Right(1, 0);
  46
  47 uint TextureSize = 4096;
  48
  49 const NLMISC::CRGBA DiscardColor = NLMISC::CRGBA::Red;
  50 const NLMISC::CRGBA KeepColor = NLMISC::CRGBA::Blue;
  51
  52 typedef std::vector<CPoint> CPoints;
  53
  54 struct CFace
  55 {
  56         std::vector<uint> indices;
  57 };
  58
  59 struct CObject
  60 {
  61         std::string name;
  62         std::vector<NLMISC::CUV> textureCoords;
  63         std::vector<CFace> faces;
  64
  65         void display()
  66         {
  67                 nlinfo("Object %s processed with %u vertices and %u faces", name.c_str(), (uint)textureCoords.size(), (uint)faces.size());
  68         }
  69 };
  70
  71 bool fillPoint(NLMISC::CBitmap &bitmap, sint width, CPoints &points)
  72 {
  73         if (points.empty()) return false;
  74
  75         // take last point in queue
  76         CPoint p(points.back());
  77         points.pop_back();
  78
  79         NLMISC::CRGBA c = bitmap.getPixelColor(p.x, p.y);
  80
  81         if (c == NLMISC::CRGBA::White)
  82         {
  83                 // white is used for background
  84
  85                 // replace with color we want to discard
  86                 bitmap.setPixelColor(p.x, p.y, DiscardColor);
  87
  88                 uint w = bitmap.getWidth();
  89                 uint h = bitmap.getHeight();
  90
  91                 // put adjacent pixels in queue to process later
  92                 if (p.y > 0) points.push_back(p + Up);
  93                 if (p.y < h-1) points.push_back(p + Down);
  94                 if (p.x > 0) points.push_back(p + Left);
  95                 if (p.x < w-1) points.push_back(p + Right);
  96         }
  97         else if (c == NLMISC::CRGBA::Black)
  98         {
  99                 // black is used for vertices
 100
 101                 // increase them by border width
 102                 for (sint y = -width; y <= width; ++y)
 103                 {
 104                         for (sint x = -width; x <= width; ++x)
 105                         {
 106                                 bitmap.setPixelColor(p.x + x, p.y + y, KeepColor);
 107                         }
 108                 }
 109         }
 110
 111         return true;
 112 }
 113
 114 void drawEdge(NLMISC::CBitmap &bitmap, const CObject &object, const CFace &face, uint index0, uint index1)
 115 {
 116         NLMISC::CUV uv0 = object.textureCoords[face.indices[index0]];
 117         NLMISC::CUV uv1 = object.textureCoords[face.indices[index1]];
 118
 119         std::vector<std::pair<sint, sint> > pixels;
 120
 121         // draw the triangle with vertices UV coordinates
 122         NLMISC::drawFullLine(uv0.U, uv0.V, uv1.U, uv1.V, pixels);
 123
 124         // for each pixels, set them to black
 125         for (uint j = 0, jlen = pixels.size(); j < jlen; ++j)
 126         {
 127                 bitmap.setPixelColor(pixels[j].first, pixels[j].second, NLMISC::CRGBA::Black);
 128         }
 129 }
 130
 131 int main(int argc, char **argv)
 132 {
 133         NLMISC::CApplicationContext applicationContext;
 134
 135         // Parse Command Line.
 136         //====================
 137         NLMISC::CCmdArgs args;
 138
 139         args.setDescription("Textures tool");
 140         args.addArg("c", "colorize", "color", "Colorize textures using a color (in HTML hexdecimal format like #rrggbb)");
 141         args.addArg("f", "fill", "color or image", "Fill background part with color or image");
 142         args.addArg("u", "uvmap", "", "Generate a UV Map texture from OBJ file");
 143         args.addArg("w", "width", "width of border", "Width of the border to fill (default 0)");
 144         args.addArg("s", "size", "size of output bitmap", "Width and height of generated bitmap (default 4096)");
 145         args.addArg("b", "background", "background color", "Color to use to fill background");
 146         args.addArg("o", "output", "filename", "Output filename");
 147         args.addAdditionalArg("filename", "File to process", true, true);
 148
 149         if (!args.parse(argc, argv)) return 1;
 150
 151         std::string filename = args.getAdditionalArg("filename").front();
 152
 153         std::string output = args.haveArg("o") ? args.getArg("o").front() : "";
 154
 155         if (args.haveArg("s"))
 156         {
 157                 // size of generated bitmap
 158                 NLMISC::fromString(args.getArg("s").front(), TextureSize);
 159         }
 160
 161         if (args.haveArg("c"))
 162         {
 163                 // colorize
 164                 NLMISC::CIFile file;
 165
 166                 NLMISC::CRGBA color;
 167                 color.fromString(args.getArg("c").front());
 168
 169                 if (file.open(filename))
 170                 {
 171                         NLMISC::CBitmap bitmap;
 172
 173                         if (bitmap.load(file))
 174                         {
 175                                 NLMISC::CObjectVector<uint8> &pixels = bitmap.getPixels();
 176
 177                                 NLMISC::CRGBA *pRGBA = (NLMISC::CRGBA*)&pixels[0];
 178
 179                                 uint32 size = bitmap.getSize();
 180
 181                                 for (uint j = 0; j < size; ++j)
 182                                 {
 183                                         pRGBA->modulateFromColorRGBOnly(*pRGBA, color);
 184                                         ++pRGBA;
 185                                 }
 186
 187                                 NLMISC::COFile out;
 188
 189                                 if (out.open(output))
 190                                 {
 191                                         bitmap.writePNG(out, 24);
 192                                 }
 193                         }
 194                 }
 195         }
 196
 197         if (args.haveArg("f"))
 198         {
 199                 // fill areas in a bitmap with another texture or color
 200
 201                 // for example :
 202                 // textures_tool -f normal.png -w 2 -b #000000 uvmap.png -o test_normal.png
 203                 // will use a copy 1024x1024 texture map on a 4096x4096 UV Map preserving the different areas
 204
 205                 std::string foregroundColorOrFilename = args.getArg("f").front();
 206
 207                 NLMISC::CRGBA foregroundColor = NLMISC::CRGBA::Black, backgroundColor = NLMISC::CRGBA::Black;
 208
 209                 NLMISC::CBitmap textureBitmap;
 210
 211                 bool useTexture = false;
 212
 213                 // f parameter is required
 214                 if (NLMISC::CFile::fileExists(foregroundColorOrFilename))
 215                 {
 216                         // load texture
 217                         NLMISC::CIFile textureFile;
 218
 219                         if (!textureFile.open(foregroundColorOrFilename))
 220                         {
 221                                 nlwarning("Unable to open %s", foregroundColorOrFilename.c_str());
 222                                 return 1;
 223                         }
 224
 225                         // decode texture
 226                         if (!textureBitmap.load(textureFile))
 227                         {
 228                                 nlwarning("Unable to decode %s", foregroundColorOrFilename.c_str());
 229                                 return 1;
 230                         }
 231
 232                         useTexture = true;
 233                 }
 234                 else
 235                 {
 236                         // parse color from argument
 237                         foregroundColor.fromString(foregroundColorOrFilename);
 238                 }
 239
 240                 if (args.haveArg("b"))
 241                 {
 242                         // parse HTML color from argument
 243                         backgroundColor.fromString(args.getArg("b").front());
 244                 }
 245
 246                 sint width = 0;
 247
 248                 if (args.haveArg("w"))
 249                 {
 250                         // parse width of borders
 251                         NLMISC::fromString(args.getArg("w").front(), width);
 252                 }
 253
 254                 // load bitmap
 255                 NLMISC::CIFile file;
 256
 257                 if (!file.open(filename))
 258                 {
 259                         nlwarning("Unable to open %s", filename.c_str());
 260                         return 1;
 261                 }
 262
 263                 // decode bitmap
 264                 NLMISC::CBitmap inBitmap;
 265
 266                 if (!inBitmap.load(file))
 267                 {
 268                         nlwarning("Unable to decode %s", filename.c_str());
 269                         return 1;
 270                 }
 271
 272                 CPoints Points;
 273
 274                 // we can't have more than width * height points, so allocate memory for all of them
 275                 Points.reserve(inBitmap.getWidth() * inBitmap.getHeight());
 276
 277                 // first point to process
 278                 Points.push_back(CPoint(0, 0));
 279
 280                 // process all points from 0, 0
 281                 while(fillPoint(inBitmap, width, Points)) { }
 282
 283                 // create a new bitmap for output
 284                 NLMISC::CBitmap outBitmap;
 285                 outBitmap.resize(inBitmap.getWidth(), inBitmap.getHeight());
 286
 287                 // copy points colors to new bitmap
 288                 for (sint y = 0, h = inBitmap.getHeight(); y < h; ++y)
 289                 {
 290                         for (sint x = 0, w = inBitmap.getWidth(); x < w; ++x)
 291                         {
 292                                 if (inBitmap.getPixelColor(x, y) != DiscardColor)
 293                                 {
 294                                         // we copy this point, repeat texture image if using it
 295                                         outBitmap.setPixelColor(x, y, useTexture ? textureBitmap.getPixelColor(x % textureBitmap.getWidth(), y % textureBitmap.getHeight()) : foregroundColor);
 296                                 }
 297                                 else
 298                                 {
 299                                         // put a background color
 300                                         outBitmap.setPixelColor(x, y, backgroundColor);
 301                                 }
 302                         }
 303                 }
 304
 305                 // save output bitmap
 306                 NLMISC::COFile outFile;
 307
 308                 if (outFile.open(output))
 309                 {
 310                         outBitmap.writePNG(outFile, 24);
 311                 }
 312         }
 313
 314         if (args.haveArg("u"))
 315         {
 316                 NLMISC::CIFile objFile;
 317
 318                 if (!objFile.open(filename))
 319                 {
 320                         nlwarning("Unable to open %s", filename.c_str());
 321                         return 1;
 322                 }
 323
 324                 CObject object;
 325
 326                 char buffer[1024];
 327
 328                 while (!objFile.eof())
 329                 {
 330                         objFile.getline(buffer, 1024);
 331                         buffer[1023] = '\0';
 332
 333                         std::string line(buffer);
 334
 335                         if (line.size() > 1022)
 336                         {
 337                                 nlwarning("More than 1022 bytes on a line!");
 338                                 return 1;
 339                         }
 340
 341                         if (line.size() < 3) continue;
 342
 343                         // texture coordinate
 344                         if (line.substr(0, 3) == "vt ")
 345                         {
 346                                 // vertex texture
 347                                 std::vector<std::string> tokens;
 348                                 NLMISC::explode(line, std::string(" "), tokens);
 349
 350                                 if (tokens.size() == 3)
 351                                 {
 352                                         float u, v;
 353                                         NLMISC::fromString(tokens[1], u);
 354                                         NLMISC::fromString(tokens[2], v);
 355
 356                                         // V coordinates are inverted
 357                                         object.textureCoords.push_back(NLMISC::CUV(u * (float)TextureSize, (1.f - v) * (float)TextureSize));
 358                                 }
 359                                 else
 360                                 {
 361                                         nlwarning("Not 3 arguments for VT");
 362                                 }
 363                         }
 364                         else if (line.substr(0, 2) == "f ")
 365                         {
 366                                 // face
 367                                 std::vector<std::string> tokens;
 368                                 NLMISC::explode(line, std::string(" "), tokens);
 369
 370                                 CFace face;
 371                                 face.indices.resize(tokens.size()-1);
 372
 373                                 bool faceValid = true;
 374
 375                                 for (uint i = 1, ilen = tokens.size(); i < ilen; ++i)
 376                                 {
 377                                         std::vector<std::string> tokens2;
 378                                         NLMISC::explode(tokens[i], std::string("/"), tokens2);
 379
 380                                         if (tokens2.size() == 3)
 381                                         {
 382                                                 if (NLMISC::fromString(tokens2[1], face.indices[i - 1]))
 383                                                 {
 384                                                         // we want indices start from 0 instead of 1
 385                                                         --face.indices[i - 1];
 386                                                 }
 387                                                 else
 388                                                 {
 389                                                         faceValid = false;
 390                                                 }
 391                                         }
 392                                         else
 393                                         {
 394                                                 nlwarning("Not 3 arguments for indices");
 395                                         }
 396                                 }
 397
 398                                 if (faceValid) object.faces.push_back(face);
 399                         }
 400                         else if (line.substr(0, 2) == "o ")
 401                         {
 402                                 // object
 403                                 object.name = line.substr(2);
 404                                 object.display();
 405                         }
 406                 }
 407
 408                 object.display();
 409
 410                 objFile.close();
 411
 412                 // draw UV Map
 413                 // create a new bitmap for output
 414                 NLMISC::CBitmap outBitmap;
 415                 outBitmap.resize(TextureSize, TextureSize);
 416
 417                 // white background
 418                 memset(&outBitmap.getPixels()[0], 255, TextureSize * TextureSize * 4);
 419
 420                 // process all faces
 421                 for (uint i = 0, ilen = object.faces.size(); i < ilen; ++i)
 422                 {
 423                         const CFace &face = object.faces[i];
 424
 425                         // pixels of a face
 426                         for (uint k = 1, klen = face.indices.size(); k < klen; ++k)
 427                         {
 428                                 drawEdge(outBitmap, object, face, k - 1, k);
 429                         }
 430
 431                         // link last and fist pixels
 432                         drawEdge(outBitmap, object, face, face.indices.size()-1, 0);
 433                 }
 434
 435                 // save output bitmap
 436                 NLMISC::COFile outFile;
 437
 438                 if (outFile.open(output))
 439                 {
 440                         outBitmap.writePNG(outFile, 24);
 441                 }
 442         }
 443
 444         return 0;
 445 }