src/mesh.cpp

   1 /*
   2 Minetest
   3 Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU Lesser General Public License as published by
   7 the Free Software Foundation; either version 2.1 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License along
  16 with this program; if not, write to the Free Software Foundation, Inc.,
  17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #include "mesh.h"
  21 #include "log.h"
  22 #include <cassert>
  23 #include <iostream>
  24 #include <IAnimatedMesh.h>
  25 #include <SAnimatedMesh.h>
  26 #include <ICameraSceneNode.h>
  27
  28 // In Irrlicht 1.8 the signature of ITexture::lock was changed from
  29 // (bool, u32) to (E_TEXTURE_LOCK_MODE, u32).
  30 #if IRRLICHT_VERSION_MAJOR == 1 && IRRLICHT_VERSION_MINOR <= 7
  31 #define MY_ETLM_READ_ONLY true
  32 #else
  33 #define MY_ETLM_READ_ONLY video::ETLM_READ_ONLY
  34 #endif
  35
  36 scene::IAnimatedMesh* createCubeMesh(v3f scale)
  37 {
  38         video::SColor c(255,255,255,255);
  39         video::S3DVertex vertices[24] =
  40         {
  41                 // Up
  42                 video::S3DVertex(-0.5,+0.5,-0.5, 0,1,0, c, 0,1),
  43                 video::S3DVertex(-0.5,+0.5,+0.5, 0,1,0, c, 0,0),
  44                 video::S3DVertex(+0.5,+0.5,+0.5, 0,1,0, c, 1,0),
  45                 video::S3DVertex(+0.5,+0.5,-0.5, 0,1,0, c, 1,1),
  46                 // Down
  47                 video::S3DVertex(-0.5,-0.5,-0.5, 0,-1,0, c, 0,0),
  48                 video::S3DVertex(+0.5,-0.5,-0.5, 0,-1,0, c, 1,0),
  49                 video::S3DVertex(+0.5,-0.5,+0.5, 0,-1,0, c, 1,1),
  50                 video::S3DVertex(-0.5,-0.5,+0.5, 0,-1,0, c, 0,1),
  51                 // Right
  52                 video::S3DVertex(+0.5,-0.5,-0.5, 1,0,0, c, 0,1),
  53                 video::S3DVertex(+0.5,+0.5,-0.5, 1,0,0, c, 0,0),
  54                 video::S3DVertex(+0.5,+0.5,+0.5, 1,0,0, c, 1,0),
  55                 video::S3DVertex(+0.5,-0.5,+0.5, 1,0,0, c, 1,1),
  56                 // Left
  57                 video::S3DVertex(-0.5,-0.5,-0.5, -1,0,0, c, 1,1),
  58                 video::S3DVertex(-0.5,-0.5,+0.5, -1,0,0, c, 0,1),
  59                 video::S3DVertex(-0.5,+0.5,+0.5, -1,0,0, c, 0,0),
  60                 video::S3DVertex(-0.5,+0.5,-0.5, -1,0,0, c, 1,0),
  61                 // Back
  62                 video::S3DVertex(-0.5,-0.5,+0.5, 0,0,1, c, 1,1),
  63                 video::S3DVertex(+0.5,-0.5,+0.5, 0,0,1, c, 0,1),
  64                 video::S3DVertex(+0.5,+0.5,+0.5, 0,0,1, c, 0,0),
  65                 video::S3DVertex(-0.5,+0.5,+0.5, 0,0,1, c, 1,0),
  66                 // Front
  67                 video::S3DVertex(-0.5,-0.5,-0.5, 0,0,-1, c, 0,1),
  68                 video::S3DVertex(-0.5,+0.5,-0.5, 0,0,-1, c, 0,0),
  69                 video::S3DVertex(+0.5,+0.5,-0.5, 0,0,-1, c, 1,0),
  70                 video::S3DVertex(+0.5,-0.5,-0.5, 0,0,-1, c, 1,1),
  71         };
  72
  73         u16 indices[6] = {0,1,2,2,3,0};
  74
  75         scene::SMesh *mesh = new scene::SMesh();
  76         for (u32 i=0; i<6; ++i)
  77         {
  78                 scene::IMeshBuffer *buf = new scene::SMeshBuffer();
  79                 buf->append(vertices + 4 * i, 4, indices, 6);
  80                 // Set default material
  81                 buf->getMaterial().setFlag(video::EMF_LIGHTING, false);
  82                 buf->getMaterial().setFlag(video::EMF_BILINEAR_FILTER, false);
  83                 buf->getMaterial().MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
  84                 // Add mesh buffer to mesh
  85                 mesh->addMeshBuffer(buf);
  86                 buf->drop();
  87         }
  88
  89         scene::SAnimatedMesh *anim_mesh = new scene::SAnimatedMesh(mesh);
  90         mesh->drop();
  91         scaleMesh(anim_mesh, scale);  // also recalculates bounding box
  92         return anim_mesh;
  93 }
  94
  95 static scene::IAnimatedMesh* extrudeARGB(u32 twidth, u32 theight, u8 *data)
  96 {
  97         const s32 argb_wstep = 4 * twidth;
  98         const s32 alpha_threshold = 1;
  99
 100         scene::IMeshBuffer *buf = new scene::SMeshBuffer();
 101         video::SColor c(255,255,255,255);
 102
 103         // Front and back
 104         {
 105                 video::S3DVertex vertices[8] =
 106                 {
 107                         video::S3DVertex(-0.5,-0.5,-0.5, 0,0,-1, c, 0,1),
 108                         video::S3DVertex(-0.5,+0.5,-0.5, 0,0,-1, c, 0,0),
 109                         video::S3DVertex(+0.5,+0.5,-0.5, 0,0,-1, c, 1,0),
 110                         video::S3DVertex(+0.5,-0.5,-0.5, 0,0,-1, c, 1,1),
 111                         video::S3DVertex(+0.5,-0.5,+0.5, 0,0,+1, c, 1,1),
 112                         video::S3DVertex(+0.5,+0.5,+0.5, 0,0,+1, c, 1,0),
 113                         video::S3DVertex(-0.5,+0.5,+0.5, 0,0,+1, c, 0,0),
 114                         video::S3DVertex(-0.5,-0.5,+0.5, 0,0,+1, c, 0,1),
 115                 };
 116                 u16 indices[12] = {0,1,2,2,3,0,4,5,6,6,7,4};
 117                 buf->append(vertices, 8, indices, 12);
 118         }
 119
 120         // "Interior"
 121         // (add faces where a solid pixel is next to a transparent one)
 122         u8 *solidity = new u8[(twidth+2) * (theight+2)];
 123         u32 wstep = twidth + 2;
 124         for (u32 y = 0; y < theight + 2; ++y)
 125         {
 126                 u8 *scanline = solidity + y * wstep;
 127                 if (y == 0 || y == theight + 1)
 128                 {
 129                         for (u32 x = 0; x < twidth + 2; ++x)
 130                                 scanline[x] = 0;
 131                 }
 132                 else
 133                 {
 134                         scanline[0] = 0;
 135                         u8 *argb_scanline = data + (y - 1) * argb_wstep;
 136                         for (u32 x = 0; x < twidth; ++x)
 137                                 scanline[x+1] = (argb_scanline[x*4+3] >= alpha_threshold);
 138                         scanline[twidth + 1] = 0;
 139                 }
 140         }
 141
 142         // without this, there would be occasional "holes" in the mesh
 143         f32 eps = 0.01;
 144
 145         for (u32 y = 0; y <= theight; ++y)
 146         {
 147                 u8 *scanline = solidity + y * wstep + 1;
 148                 for (u32 x = 0; x <= twidth; ++x)
 149                 {
 150                         if (scanline[x] && !scanline[x + wstep])
 151                         {
 152                                 u32 xx = x + 1;
 153                                 while (scanline[xx] && !scanline[xx + wstep])
 154                                         ++xx;
 155                                 f32 vx1 = (x - eps) / (f32) twidth - 0.5;
 156                                 f32 vx2 = (xx + eps) / (f32) twidth - 0.5;
 157                                 f32 vy = 0.5 - (y - eps) / (f32) theight;
 158                                 f32 tx1 = x / (f32) twidth;
 159                                 f32 tx2 = xx / (f32) twidth;
 160                                 f32 ty = (y - 0.5) / (f32) theight;
 161                                 video::S3DVertex vertices[8] =
 162                                 {
 163                                         video::S3DVertex(vx1,vy,-0.5, 0,-1,0, c, tx1,ty),
 164                                         video::S3DVertex(vx2,vy,-0.5, 0,-1,0, c, tx2,ty),
 165                                         video::S3DVertex(vx2,vy,+0.5, 0,-1,0, c, tx2,ty),
 166                                         video::S3DVertex(vx1,vy,+0.5, 0,-1,0, c, tx1,ty),
 167                                 };
 168                                 u16 indices[6] = {0,1,2,2,3,0};
 169                                 buf->append(vertices, 4, indices, 6);
 170                                 x = xx - 1;
 171                         }
 172                         if (!scanline[x] && scanline[x + wstep])
 173                         {
 174                                 u32 xx = x + 1;
 175                                 while (!scanline[xx] && scanline[xx + wstep])
 176                                         ++xx;
 177                                 f32 vx1 = (x - eps) / (f32) twidth - 0.5;
 178                                 f32 vx2 = (xx + eps) / (f32) twidth - 0.5;
 179                                 f32 vy = 0.5 - (y + eps) / (f32) theight;
 180                                 f32 tx1 = x / (f32) twidth;
 181                                 f32 tx2 = xx / (f32) twidth;
 182                                 f32 ty = (y + 0.5) / (f32) theight;
 183                                 video::S3DVertex vertices[8] =
 184                                 {
 185                                         video::S3DVertex(vx1,vy,-0.5, 0,1,0, c, tx1,ty),
 186                                         video::S3DVertex(vx1,vy,+0.5, 0,1,0, c, tx1,ty),
 187                                         video::S3DVertex(vx2,vy,+0.5, 0,1,0, c, tx2,ty),
 188                                         video::S3DVertex(vx2,vy,-0.5, 0,1,0, c, tx2,ty),
 189                                 };
 190                                 u16 indices[6] = {0,1,2,2,3,0};
 191                                 buf->append(vertices, 4, indices, 6);
 192                                 x = xx - 1;
 193                         }
 194                 }
 195         }
 196
 197         for (u32 x = 0; x <= twidth; ++x)
 198         {
 199                 u8 *scancol = solidity + x + wstep;
 200                 for (u32 y = 0; y <= theight; ++y)
 201                 {
 202                         if (scancol[y * wstep] && !scancol[y * wstep + 1])
 203                         {
 204                                 u32 yy = y + 1;
 205                                 while (scancol[yy * wstep] && !scancol[yy * wstep + 1])
 206                                         ++yy;
 207                                 f32 vx = (x - eps) / (f32) twidth - 0.5;
 208                                 f32 vy1 = 0.5 - (y - eps) / (f32) theight;
 209                                 f32 vy2 = 0.5 - (yy + eps) / (f32) theight;
 210                                 f32 tx = (x - 0.5) / (f32) twidth;
 211                                 f32 ty1 = y / (f32) theight;
 212                                 f32 ty2 = yy / (f32) theight;
 213                                 video::S3DVertex vertices[8] =
 214                                 {
 215                                         video::S3DVertex(vx,vy1,-0.5, 1,0,0, c, tx,ty1),
 216                                         video::S3DVertex(vx,vy1,+0.5, 1,0,0, c, tx,ty1),
 217                                         video::S3DVertex(vx,vy2,+0.5, 1,0,0, c, tx,ty2),
 218                                         video::S3DVertex(vx,vy2,-0.5, 1,0,0, c, tx,ty2),
 219                                 };
 220                                 u16 indices[6] = {0,1,2,2,3,0};
 221                                 buf->append(vertices, 4, indices, 6);
 222                                 y = yy - 1;
 223                         }
 224                         if (!scancol[y * wstep] && scancol[y * wstep + 1])
 225                         {
 226                                 u32 yy = y + 1;
 227                                 while (!scancol[yy * wstep] && scancol[yy * wstep + 1])
 228                                         ++yy;
 229                                 f32 vx = (x + eps) / (f32) twidth - 0.5;
 230                                 f32 vy1 = 0.5 - (y - eps) / (f32) theight;
 231                                 f32 vy2 = 0.5 - (yy + eps) / (f32) theight;
 232                                 f32 tx = (x + 0.5) / (f32) twidth;
 233                                 f32 ty1 = y / (f32) theight;
 234                                 f32 ty2 = yy / (f32) theight;
 235                                 video::S3DVertex vertices[8] =
 236                                 {
 237                                         video::S3DVertex(vx,vy1,-0.5, -1,0,0, c, tx,ty1),
 238                                         video::S3DVertex(vx,vy2,-0.5, -1,0,0, c, tx,ty2),
 239                                         video::S3DVertex(vx,vy2,+0.5, -1,0,0, c, tx,ty2),
 240                                         video::S3DVertex(vx,vy1,+0.5, -1,0,0, c, tx,ty1),
 241                                 };
 242                                 u16 indices[6] = {0,1,2,2,3,0};
 243                                 buf->append(vertices, 4, indices, 6);
 244                                 y = yy - 1;
 245                         }
 246                 }
 247         }
 248
 249         delete[] solidity;
 250
 251         // Add to mesh
 252         scene::SMesh *mesh = new scene::SMesh();
 253         mesh->addMeshBuffer(buf);
 254         buf->drop();
 255         scene::SAnimatedMesh *anim_mesh = new scene::SAnimatedMesh(mesh);
 256         mesh->drop();
 257         return anim_mesh;
 258 }
 259
 260 scene::IAnimatedMesh* createExtrudedMesh(video::ITexture *texture,
 261                 video::IVideoDriver *driver, v3f scale)
 262 {
 263         scene::IAnimatedMesh *mesh = NULL;
 264         core::dimension2d<u32> size = texture->getSize();
 265         video::ECOLOR_FORMAT format = texture->getColorFormat();
 266         if (format == video::ECF_A8R8G8B8)
 267         {
 268                 // Texture is in the correct color format, we can pass it
 269                 // to extrudeARGB right away.
 270                 void *data = texture->lock(MY_ETLM_READ_ONLY);
 271                 if (data == NULL)
 272                         return NULL;
 273                 mesh = extrudeARGB(size.Width, size.Height, (u8*) data);
 274                 texture->unlock();
 275         }
 276         else
 277         {
 278                 video::IImage *img1 = driver->createImageFromData(format, size, texture->lock(MY_ETLM_READ_ONLY));
 279                 if (img1 == NULL)
 280                         return NULL;
 281
 282                 // img1 is in the texture's color format, convert to 8-bit ARGB
 283                 video::IImage *img2 = driver->createImage(video::ECF_A8R8G8B8, size);
 284                 if (img2 != NULL)
 285                 {
 286                         img1->copyTo(img2);
 287                         img1->drop();
 288
 289                         mesh = extrudeARGB(size.Width, size.Height, (u8*) img2->lock());
 290                         img2->unlock();
 291                         img2->drop();
 292                 }
 293                 img1->drop();
 294         }
 295
 296         // Set default material
 297         mesh->getMeshBuffer(0)->getMaterial().setTexture(0, texture);
 298         mesh->getMeshBuffer(0)->getMaterial().setFlag(video::EMF_LIGHTING, false);
 299         mesh->getMeshBuffer(0)->getMaterial().setFlag(video::EMF_BILINEAR_FILTER, false);
 300         mesh->getMeshBuffer(0)->getMaterial().MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
 301
 302         scaleMesh(mesh, scale);  // also recalculates bounding box
 303         return mesh;
 304 }
 305
 306 void scaleMesh(scene::IMesh *mesh, v3f scale)
 307 {
 308         if(mesh == NULL)
 309                 return;
 310
 311         core::aabbox3d<f32> bbox;
 312         bbox.reset(0,0,0);
 313
 314         u16 mc = mesh->getMeshBufferCount();
 315         for(u16 j=0; j<mc; j++)
 316         {
 317                 scene::IMeshBuffer *buf = mesh->getMeshBuffer(j);
 318                 video::S3DVertex *vertices = (video::S3DVertex*)buf->getVertices();
 319                 u16 vc = buf->getVertexCount();
 320                 for(u16 i=0; i<vc; i++)
 321                 {
 322                         vertices[i].Pos *= scale;
 323                 }
 324                 buf->recalculateBoundingBox();
 325
 326                 // calculate total bounding box
 327                 if(j == 0)
 328                         bbox = buf->getBoundingBox();
 329                 else
 330                         bbox.addInternalBox(buf->getBoundingBox());
 331         }
 332         mesh->setBoundingBox(bbox);
 333 }
 334
 335 void translateMesh(scene::IMesh *mesh, v3f vec)
 336 {
 337         if(mesh == NULL)
 338                 return;
 339
 340         core::aabbox3d<f32> bbox;
 341         bbox.reset(0,0,0);
 342
 343         u16 mc = mesh->getMeshBufferCount();
 344         for(u16 j=0; j<mc; j++)
 345         {
 346                 scene::IMeshBuffer *buf = mesh->getMeshBuffer(j);
 347                 video::S3DVertex *vertices = (video::S3DVertex*)buf->getVertices();
 348                 u16 vc = buf->getVertexCount();
 349                 for(u16 i=0; i<vc; i++)
 350                 {
 351                         vertices[i].Pos += vec;
 352                 }
 353                 buf->recalculateBoundingBox();
 354
 355                 // calculate total bounding box
 356                 if(j == 0)
 357                         bbox = buf->getBoundingBox();
 358                 else
 359                         bbox.addInternalBox(buf->getBoundingBox());
 360         }
 361         mesh->setBoundingBox(bbox);
 362 }
 363
 364 void setMeshColor(scene::IMesh *mesh, const video::SColor &color)
 365 {
 366         if(mesh == NULL)
 367                 return;
 368
 369         u16 mc = mesh->getMeshBufferCount();
 370         for(u16 j=0; j<mc; j++)
 371         {
 372                 scene::IMeshBuffer *buf = mesh->getMeshBuffer(j);
 373                 video::S3DVertex *vertices = (video::S3DVertex*)buf->getVertices();
 374                 u16 vc = buf->getVertexCount();
 375                 for(u16 i=0; i<vc; i++)
 376                 {
 377                         vertices[i].Color = color;
 378                 }
 379         }
 380 }
 381
 382 void setMeshColorByNormalXYZ(scene::IMesh *mesh,
 383                 const video::SColor &colorX,
 384                 const video::SColor &colorY,
 385                 const video::SColor &colorZ)
 386 {
 387         if(mesh == NULL)
 388                 return;
 389
 390         u16 mc = mesh->getMeshBufferCount();
 391         for(u16 j=0; j<mc; j++)
 392         {
 393                 scene::IMeshBuffer *buf = mesh->getMeshBuffer(j);
 394                 video::S3DVertex *vertices = (video::S3DVertex*)buf->getVertices();
 395                 u16 vc = buf->getVertexCount();
 396                 for(u16 i=0; i<vc; i++)
 397                 {
 398                         f32 x = fabs(vertices[i].Normal.X);
 399                         f32 y = fabs(vertices[i].Normal.Y);
 400                         f32 z = fabs(vertices[i].Normal.Z);
 401                         if(x >= y && x >= z)
 402                                 vertices[i].Color = colorX;
 403                         else if(y >= z)
 404                                 vertices[i].Color = colorY;
 405                         else
 406                                 vertices[i].Color = colorZ;
 407
 408                 }
 409         }
 410 }
 411
 412 video::ITexture *generateTextureFromMesh(scene::IMesh *mesh,
 413                 IrrlichtDevice *device,
 414                 core::dimension2d<u32> dim,
 415                 std::string texture_name,
 416                 v3f camera_position,
 417                 v3f camera_lookat,
 418                 core::CMatrix4<f32> camera_projection_matrix,
 419                 video::SColorf ambient_light,
 420                 v3f light_position,
 421                 video::SColorf light_color,
 422                 f32 light_radius)
 423 {
 424         video::IVideoDriver *driver = device->getVideoDriver();
 425         if(driver->queryFeature(video::EVDF_RENDER_TO_TARGET) == false)
 426         {
 427                 static bool warned = false;
 428                 if(!warned)
 429                 {
 430                         errorstream<<"generateTextureFromMesh(): EVDF_RENDER_TO_TARGET"
 431                                         " not supported."<<std::endl;
 432                         warned = true;
 433                 }
 434                 return NULL;
 435         }
 436
 437         // Create render target texture
 438         video::ITexture *rtt = driver->addRenderTargetTexture(
 439                         dim, texture_name.c_str(), video::ECF_A8R8G8B8);
 440         if(rtt == NULL)
 441         {
 442                 errorstream<<"generateTextureFromMesh(): addRenderTargetTexture"
 443                                 " returned NULL."<<std::endl;
 444                 return NULL;
 445         }
 446
 447         // Set render target
 448         driver->setRenderTarget(rtt, false, true, video::SColor(0,0,0,0));
 449
 450         // Get a scene manager
 451         scene::ISceneManager *smgr_main = device->getSceneManager();
 452         assert(smgr_main);
 453         scene::ISceneManager *smgr = smgr_main->createNewSceneManager();
 454         assert(smgr);
 455
 456         scene::IMeshSceneNode* meshnode = smgr->addMeshSceneNode(mesh, NULL, -1, v3f(0,0,0), v3f(0,0,0), v3f(1,1,1), true);
 457         meshnode->setMaterialFlag(video::EMF_LIGHTING, true);
 458         meshnode->setMaterialFlag(video::EMF_ANTI_ALIASING, true);
 459         meshnode->setMaterialFlag(video::EMF_BILINEAR_FILTER, true);
 460
 461         scene::ICameraSceneNode* camera = smgr->addCameraSceneNode(0,
 462                         camera_position, camera_lookat);
 463         // second parameter of setProjectionMatrix (isOrthogonal) is ignored
 464         camera->setProjectionMatrix(camera_projection_matrix, false);
 465
 466         smgr->setAmbientLight(ambient_light);
 467         smgr->addLightSceneNode(0, light_position, light_color, light_radius);
 468
 469         // Render scene
 470         driver->beginScene(true, true, video::SColor(0,0,0,0));
 471         smgr->drawAll();
 472         driver->endScene();
 473
 474         // NOTE: The scene nodes should not be dropped, otherwise
 475         //       smgr->drop() segfaults
 476         /*cube->drop();
 477         camera->drop();
 478         light->drop();*/
 479         // Drop scene manager
 480         smgr->drop();
 481
 482         // Unset render target
 483         driver->setRenderTarget(0, false, true, 0);
 484
 485         return rtt;
 486 }