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
 288                         mesh = extrudeARGB(size.Width, size.Height, (u8*) img2->lock());
 289                         img2->unlock();
 290                         img2->drop();
 291                 }
 292                 img1->drop();
 293         }
 294
 295         // Set default material
 296         mesh->getMeshBuffer(0)->getMaterial().setTexture(0, texture);
 297         mesh->getMeshBuffer(0)->getMaterial().setFlag(video::EMF_LIGHTING, false);
 298         mesh->getMeshBuffer(0)->getMaterial().setFlag(video::EMF_BILINEAR_FILTER, false);
 299         mesh->getMeshBuffer(0)->getMaterial().MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
 300
 301         scaleMesh(mesh, scale);  // also recalculates bounding box
 302         return mesh;
 303 }
 304
 305 void scaleMesh(scene::IMesh *mesh, v3f scale)
 306 {
 307         if(mesh == NULL)
 308                 return;
 309
 310         core::aabbox3d<f32> bbox;
 311         bbox.reset(0,0,0);
 312
 313         u16 mc = mesh->getMeshBufferCount();
 314         for(u16 j=0; j<mc; j++)
 315         {
 316                 scene::IMeshBuffer *buf = mesh->getMeshBuffer(j);
 317                 video::S3DVertex *vertices = (video::S3DVertex*)buf->getVertices();
 318                 u16 vc = buf->getVertexCount();
 319                 for(u16 i=0; i<vc; i++)
 320                 {
 321                         vertices[i].Pos *= scale;
 322                 }
 323                 buf->recalculateBoundingBox();
 324
 325                 // calculate total bounding box
 326                 if(j == 0)
 327                         bbox = buf->getBoundingBox();
 328                 else
 329                         bbox.addInternalBox(buf->getBoundingBox());
 330         }
 331         mesh->setBoundingBox(bbox);
 332 }
 333
 334 void translateMesh(scene::IMesh *mesh, v3f vec)
 335 {
 336         if(mesh == NULL)
 337                 return;
 338
 339         core::aabbox3d<f32> bbox;
 340         bbox.reset(0,0,0);
 341
 342         u16 mc = mesh->getMeshBufferCount();
 343         for(u16 j=0; j<mc; j++)
 344         {
 345                 scene::IMeshBuffer *buf = mesh->getMeshBuffer(j);
 346                 video::S3DVertex *vertices = (video::S3DVertex*)buf->getVertices();
 347                 u16 vc = buf->getVertexCount();
 348                 for(u16 i=0; i<vc; i++)
 349                 {
 350                         vertices[i].Pos += vec;
 351                 }
 352                 buf->recalculateBoundingBox();
 353
 354                 // calculate total bounding box
 355                 if(j == 0)
 356                         bbox = buf->getBoundingBox();
 357                 else
 358                         bbox.addInternalBox(buf->getBoundingBox());
 359         }
 360         mesh->setBoundingBox(bbox);
 361 }
 362
 363 void setMeshColor(scene::IMesh *mesh, const video::SColor &color)
 364 {
 365         if(mesh == NULL)
 366                 return;
 367
 368         u16 mc = mesh->getMeshBufferCount();
 369         for(u16 j=0; j<mc; j++)
 370         {
 371                 scene::IMeshBuffer *buf = mesh->getMeshBuffer(j);
 372                 video::S3DVertex *vertices = (video::S3DVertex*)buf->getVertices();
 373                 u16 vc = buf->getVertexCount();
 374                 for(u16 i=0; i<vc; i++)
 375                 {
 376                         vertices[i].Color = color;
 377                 }
 378         }
 379 }
 380
 381 void setMeshColorByNormalXYZ(scene::IMesh *mesh,
 382                 const video::SColor &colorX,
 383                 const video::SColor &colorY,
 384                 const video::SColor &colorZ)
 385 {
 386         if(mesh == NULL)
 387                 return;
 388
 389         u16 mc = mesh->getMeshBufferCount();
 390         for(u16 j=0; j<mc; j++)
 391         {
 392                 scene::IMeshBuffer *buf = mesh->getMeshBuffer(j);
 393                 video::S3DVertex *vertices = (video::S3DVertex*)buf->getVertices();
 394                 u16 vc = buf->getVertexCount();
 395                 for(u16 i=0; i<vc; i++)
 396                 {
 397                         f32 x = fabs(vertices[i].Normal.X);
 398                         f32 y = fabs(vertices[i].Normal.Y);
 399                         f32 z = fabs(vertices[i].Normal.Z);
 400                         if(x >= y && x >= z)
 401                                 vertices[i].Color = colorX;
 402                         else if(y >= z)
 403                                 vertices[i].Color = colorY;
 404                         else
 405                                 vertices[i].Color = colorZ;
 406
 407                 }
 408         }
 409 }
 410
 411 video::ITexture *generateTextureFromMesh(scene::IMesh *mesh,
 412                 IrrlichtDevice *device,
 413                 core::dimension2d<u32> dim,
 414                 std::string texture_name,
 415                 v3f camera_position,
 416                 v3f camera_lookat,
 417                 core::CMatrix4<f32> camera_projection_matrix,
 418                 video::SColorf ambient_light,
 419                 v3f light_position,
 420                 video::SColorf light_color,
 421                 f32 light_radius)
 422 {
 423         video::IVideoDriver *driver = device->getVideoDriver();
 424         if(driver->queryFeature(video::EVDF_RENDER_TO_TARGET) == false)
 425         {
 426                 static bool warned = false;
 427                 if(!warned)
 428                 {
 429                         errorstream<<"generateTextureFromMesh(): EVDF_RENDER_TO_TARGET"
 430                                         " not supported."<<std::endl;
 431                         warned = true;
 432                 }
 433                 return NULL;
 434         }
 435
 436         // Create render target texture
 437         video::ITexture *rtt = driver->addRenderTargetTexture(
 438                         dim, texture_name.c_str(), video::ECF_A8R8G8B8);
 439         if(rtt == NULL)
 440         {
 441                 errorstream<<"generateTextureFromMesh(): addRenderTargetTexture"
 442                                 " returned NULL."<<std::endl;
 443                 return NULL;
 444         }
 445
 446         // Set render target
 447         driver->setRenderTarget(rtt, false, true, video::SColor(0,0,0,0));
 448
 449         // Get a scene manager
 450         scene::ISceneManager *smgr_main = device->getSceneManager();
 451         assert(smgr_main);
 452         scene::ISceneManager *smgr = smgr_main->createNewSceneManager();
 453         assert(smgr);
 454
 455         scene::IMeshSceneNode* meshnode = smgr->addMeshSceneNode(mesh, NULL, -1, v3f(0,0,0), v3f(0,0,0), v3f(1,1,1), true);
 456         meshnode->setMaterialFlag(video::EMF_LIGHTING, true);
 457         meshnode->setMaterialFlag(video::EMF_ANTI_ALIASING, true);
 458         meshnode->setMaterialFlag(video::EMF_BILINEAR_FILTER, true);
 459
 460         scene::ICameraSceneNode* camera = smgr->addCameraSceneNode(0,
 461                         camera_position, camera_lookat);
 462         // second parameter of setProjectionMatrix (isOrthogonal) is ignored
 463         camera->setProjectionMatrix(camera_projection_matrix, false);
 464
 465         smgr->setAmbientLight(ambient_light);
 466         smgr->addLightSceneNode(0, light_position, light_color, light_radius);
 467
 468         // Render scene
 469         driver->beginScene(true, true, video::SColor(0,0,0,0));
 470         smgr->drawAll();
 471         driver->endScene();
 472
 473         // NOTE: The scene nodes should not be dropped, otherwise
 474         //       smgr->drop() segfaults
 475         /*cube->drop();
 476         camera->drop();
 477         light->drop();*/
 478         // Drop scene manager
 479         smgr->drop();
 480
 481         // Unset render target
 482         driver->setRenderTarget(0, false, true, 0);
 483
 484         return rtt;
 485 }