Translation to Portuguese of Brazil for Minetest
[oweals/minetest.git] / 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 }