eff021c9b14970482fed1417e226823a6ce547a7
[blender.git] / source / blender / render / intern / source / bake_api.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the 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 General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * Contributors:
19  *
20  * ***** END GPL LICENSE BLOCK *****
21  */
22
23 /** \file blender/render/intern/source/bake_api.c
24  *  \ingroup render
25  *
26  * \brief The API itself is simple. Blender sends a populated array of BakePixels to the renderer, and gets back an
27  * array of floats with the result.
28  *
29  * \section bake_api Development Notes for External Engines
30  *
31  * The Bake API is fully implemented with Python rna functions. The operator expects/call a function:
32  *
33  * ``def bake(scene, object, pass_type, object_id, pixel_array, num_pixels, depth, result)``
34  * - scene: current scene (Python object)
35  * - object: object to render (Python object)
36  * - pass_type: pass to render (string, e.g., "COMBINED", "AO", "NORMAL", ...)
37  * - object_id: index of object to bake (to use with the pixel_array)
38  * - pixel_array: list of primitive ids and barycentric coordinates to bake(Python object, see bake_pixel)
39  * - num_pixels: size of pixel_array, number of pixels to bake (int)
40  * - depth: depth of pixels to return (int, assuming always 4 now)
41  * - result: array to be populated by the engine (float array, PyLong_AsVoidPtr)
42  *
43  * \note Normals are expected to be in World Space and in the +X, +Y, +Z orientation.
44  *
45  * \subsection bake_pixel BakePixel data structure
46  *
47  * pixel_array is a Python object storing BakePixel elements:
48  *
49  * \code{.c}
50  * struct BakePixel {
51  *     int primitive_id, object_id;
52  *     float uv[2];
53  *     float du_dx, du_dy;
54  *     float dv_dx, dv_dy;
55  * };
56  * \endcode
57  *
58  * In python you have access to:
59  * - ``primitive_id``, ``object_id``,  ``uv``, ``du_dx``, ``du_dy``, ``next``
60  * - ``next()`` is a function that returns the next #BakePixel in the array.
61  *
62  * \note Pixels that should not be baked have ``primitive_id == -1``
63  *
64  * For a complete implementation example look at the Cycles Bake commit.
65  */
66
67 #include <limits.h>
68
69 #include "MEM_guardedalloc.h"
70
71 #include "BLI_math.h"
72
73 #include "DNA_mesh_types.h"
74
75 #include "BKE_cdderivedmesh.h"
76 #include "BKE_image.h"
77 #include "BKE_node.h"
78 #include "BKE_mesh.h"
79
80 #include "IMB_imbuf_types.h"
81 #include "IMB_imbuf.h"
82
83 #include "RE_bake.h"
84
85 /* local include */
86 #include "render_types.h"
87 #include "shading.h"
88 #include "zbuf.h"
89
90 /* Remove when Cycles moves from MFace to MLoopTri */
91 #define USE_MFACE_WORKAROUND
92
93 /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
94 /* defined in pipeline.c, is hardcopy of active dynamic allocated Render */
95 /* only to be used here in this file, it's for speed */
96 extern struct Render R;
97 /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
98
99
100 typedef struct BakeDataZSpan {
101         BakePixel *pixel_array;
102         int primitive_id;
103         BakeImage *bk_image;
104         ZSpan *zspan;
105         float du_dx, du_dy;
106         float dv_dx, dv_dy;
107 } BakeDataZSpan;
108
109 /**
110  * struct wrapping up tangent space data
111  */
112 typedef struct TSpace {
113         float tangent[3];
114         float sign;
115 } TSpace;
116
117 typedef struct TriTessFace {
118         const MVert *mverts[3];
119         const TSpace *tspace[3];
120         float normal[3]; /* for flat faces */
121         bool is_smooth;
122 } TriTessFace;
123
124 static void store_bake_pixel(void *handle, int x, int y, float u, float v)
125 {
126         BakeDataZSpan *bd = (BakeDataZSpan *)handle;
127         BakePixel *pixel;
128
129         const int width = bd->bk_image->width;
130         const size_t offset = bd->bk_image->offset;
131         const int i = offset + y * width + x;
132
133         pixel = &bd->pixel_array[i];
134         pixel->primitive_id = bd->primitive_id;
135
136         /* At this point object_id is always 0, since this function runs for the
137          * lowpoly mesh only. The object_id lookup indices are set afterwards. */
138
139         copy_v2_fl2(pixel->uv, u, v);
140
141         pixel->du_dx = bd->du_dx;
142         pixel->du_dy = bd->du_dy;
143         pixel->dv_dx = bd->dv_dx;
144         pixel->dv_dy = bd->dv_dy;
145         pixel->object_id = 0;
146 }
147
148 void RE_bake_mask_fill(const BakePixel pixel_array[], const size_t num_pixels, char *mask)
149 {
150         size_t i;
151         if (!mask)
152                 return;
153
154         /* only extend to pixels outside the mask area */
155         for (i = 0; i < num_pixels; i++) {
156                 if (pixel_array[i].primitive_id != -1) {
157                         mask[i] = FILTER_MASK_USED;
158                 }
159         }
160 }
161
162 void RE_bake_margin(ImBuf *ibuf, char *mask, const int margin)
163 {
164         /* margin */
165         IMB_filter_extend(ibuf, mask, margin);
166
167         if (ibuf->planes != R_IMF_PLANES_RGBA)
168                 /* clear alpha added by filtering */
169                 IMB_rectfill_alpha(ibuf, 1.0f);
170 }
171
172
173 /**
174  * This function returns the coordinate and normal of a barycentric u,v for a face defined by the primitive_id index.
175  * The returned normal is actually the direction from the same barycentric coordinate in the cage to the base mesh
176  * The returned coordinate is the point in the cage mesh
177  */
178 static void calc_point_from_barycentric_cage(
179         TriTessFace *triangles_low, TriTessFace *triangles_cage,
180         float mat_low[4][4], float mat_cage[4][4],
181         int primitive_id, float u, float v,
182         float r_co[3], float r_dir[3])
183 {
184         float data[2][3][3];
185         float coord[2][3];
186         float dir[3];
187         int i;
188
189         TriTessFace *triangle[2];
190
191         triangle[0] = &triangles_low[primitive_id];
192         triangle[1] = &triangles_cage[primitive_id];
193
194         for (i = 0; i < 2; i++) {
195                 copy_v3_v3(data[i][0], triangle[i]->mverts[0]->co);
196                 copy_v3_v3(data[i][1], triangle[i]->mverts[1]->co);
197                 copy_v3_v3(data[i][2], triangle[i]->mverts[2]->co);
198                 interp_barycentric_tri_v3(data[i], u, v, coord[i]);
199         }
200
201         /* convert from local to world space */
202         mul_m4_v3(mat_low, coord[0]);
203         mul_m4_v3(mat_cage, coord[1]);
204
205         sub_v3_v3v3(dir, coord[0], coord[1]);
206         normalize_v3(dir);
207
208         copy_v3_v3(r_co, coord[1]);
209         copy_v3_v3(r_dir, dir);
210 }
211
212 /**
213  * This function returns the coordinate and normal of a barycentric u,v for a face defined by the primitive_id index.
214  * The returned coordinate is extruded along the normal by cage_extrusion
215  */
216 static void calc_point_from_barycentric_extrusion(
217         TriTessFace *triangles,
218         float mat[4][4], float imat[4][4],
219         int primitive_id, float u, float v,
220         float cage_extrusion,
221         float r_co[3], float r_dir[3],
222         const bool is_cage)
223 {
224         float data[3][3];
225         float coord[3];
226         float dir[3];
227         float cage[3];
228         bool is_smooth;
229
230         TriTessFace *triangle = &triangles[primitive_id];
231         is_smooth = triangle->is_smooth || is_cage;
232
233         copy_v3_v3(data[0], triangle->mverts[0]->co);
234         copy_v3_v3(data[1], triangle->mverts[1]->co);
235         copy_v3_v3(data[2], triangle->mverts[2]->co);
236
237         interp_barycentric_tri_v3(data, u, v, coord);
238
239         if (is_smooth) {
240                 normal_short_to_float_v3(data[0], triangle->mverts[0]->no);
241                 normal_short_to_float_v3(data[1], triangle->mverts[1]->no);
242                 normal_short_to_float_v3(data[2], triangle->mverts[2]->no);
243
244                 interp_barycentric_tri_v3(data, u, v, dir);
245                 normalize_v3(dir);
246         }
247         else {
248                 copy_v3_v3(dir, triangle->normal);
249         }
250
251         mul_v3_v3fl(cage, dir, cage_extrusion);
252         add_v3_v3(coord, cage);
253
254         normalize_v3(dir);
255         negate_v3(dir);
256
257         /* convert from local to world space */
258         mul_m4_v3(mat, coord);
259         mul_transposed_mat3_m4_v3(imat, dir);
260         normalize_v3(dir);
261
262         copy_v3_v3(r_co, coord);
263         copy_v3_v3(r_dir, dir);
264 }
265
266 /**
267  * This function populates pixel_array and returns TRUE if things are correct
268  */
269 static bool cast_ray_highpoly(
270         BVHTreeFromMesh *treeData, TriTessFace *triangle_low, TriTessFace *triangles[],
271         BakePixel *pixel_array_low, BakePixel *pixel_array, float mat_low[4][4], BakeHighPolyData *highpoly,
272         const float co[3], const float dir[3], const int pixel_id, const int tot_highpoly)
273 {
274         int i;
275         int hit_mesh = -1;
276         float hit_distance = FLT_MAX;
277
278         BVHTreeRayHit *hits;
279         hits = MEM_mallocN(sizeof(BVHTreeRayHit) * tot_highpoly, "Bake Highpoly to Lowpoly: BVH Rays");
280
281         for (i = 0; i < tot_highpoly; i++) {
282                 float co_high[3], dir_high[3];
283
284                 hits[i].index = -1;
285                 /* TODO: we should use FLT_MAX here, but sweepsphere code isn't prepared for that */
286                 hits[i].dist = BVH_RAYCAST_DIST_MAX;
287
288                 /* transform the ray from the world space to the highpoly space */
289                 mul_v3_m4v3(co_high, highpoly[i].imat, co);
290
291                 /* rotates */
292                 mul_v3_mat3_m4v3(dir_high, highpoly[i].imat, dir);
293                 normalize_v3(dir_high);
294
295                 /* cast ray */
296                 if (treeData[i].tree) {
297                         BLI_bvhtree_ray_cast(treeData[i].tree, co_high, dir_high, 0.0f, &hits[i], treeData[i].raycast_callback, &treeData[i]);
298                 }
299
300                 if (hits[i].index != -1) {
301                         /* cull backface */
302                         const float dot = dot_v3v3(dir_high, hits[i].no);
303                         if (dot < 0.0f) {
304                                 float distance;
305                                 float hit_world[3];
306
307                                 /* distance comparison in world space */
308                                 mul_v3_m4v3(hit_world, highpoly[i].obmat, hits[i].co);
309                                 distance = len_squared_v3v3(hit_world, co);
310
311                                 if (distance < hit_distance) {
312                                         hit_mesh = i;
313                                         hit_distance = distance;
314                                 }
315                         }
316                 }
317         }
318
319         if (hit_mesh != -1) {
320                 int primitive_id_high = hits[hit_mesh].index;
321                 TriTessFace *triangle_high = &triangles[hit_mesh][primitive_id_high];
322                 BakePixel *pixel_low = &pixel_array_low[pixel_id];
323                 BakePixel *pixel_high = &pixel_array[pixel_id];
324
325                 pixel_high->primitive_id = primitive_id_high;
326                 pixel_high->object_id = hit_mesh;
327
328                 /* ray direction in high poly object space */
329                 float dir_high[3];
330                 mul_v3_mat3_m4v3(dir_high, highpoly[hit_mesh].imat, dir);
331                 normalize_v3(dir_high);
332
333                 /* compute position differentials on low poly object */
334                 float duco_low[3], dvco_low[3], dxco[3], dyco[3];
335                 sub_v3_v3v3(duco_low, triangle_low->mverts[0]->co, triangle_low->mverts[2]->co);
336                 sub_v3_v3v3(dvco_low, triangle_low->mverts[1]->co, triangle_low->mverts[2]->co);
337
338                 mul_v3_v3fl(dxco, duco_low, pixel_low->du_dx);
339                 madd_v3_v3fl(dxco, dvco_low, pixel_low->dv_dx);
340                 mul_v3_v3fl(dyco, duco_low, pixel_low->du_dy);
341                 madd_v3_v3fl(dyco, dvco_low, pixel_low->dv_dy);
342
343                 /* transform from low poly to to high poly object space */
344                 mul_mat3_m4_v3(mat_low, dxco);
345                 mul_mat3_m4_v3(mat_low, dyco);
346                 mul_mat3_m4_v3(highpoly[hit_mesh].imat, dxco);
347                 mul_mat3_m4_v3(highpoly[hit_mesh].imat, dyco);
348
349                 /* transfer position differentials */
350                 float tmp[3];
351                 mul_v3_v3fl(tmp, dir_high, 1.0f/dot_v3v3(dir_high, triangle_high->normal));
352                 madd_v3_v3fl(dxco, tmp, -dot_v3v3(dxco, triangle_high->normal));
353                 madd_v3_v3fl(dyco, tmp, -dot_v3v3(dyco, triangle_high->normal));
354
355                 /* compute barycentric differentials from position differentials */
356                 barycentric_differentials_from_position(
357                         hits[hit_mesh].co, triangle_high->mverts[0]->co,
358                         triangle_high->mverts[1]->co, triangle_high->mverts[2]->co,
359                         dxco, dyco, triangle_high->normal, true,
360                         &pixel_high->uv[0], &pixel_high->uv[1],
361                         &pixel_high->du_dx, &pixel_high->dv_dx,
362                         &pixel_high->du_dy, &pixel_high->dv_dy);
363
364                 /* verify we have valid uvs */
365                 BLI_assert(pixel_high->uv[0] >= -1e-3f &&
366                            pixel_high->uv[1] >= -1e-3f &&
367                            pixel_high->uv[0] + pixel_high->uv[1] <= 1.0f + 1e-3f);
368         }
369         else {
370                 pixel_array[pixel_id].primitive_id = -1;
371                 pixel_array[pixel_id].object_id = -1;
372         }
373
374         MEM_freeN(hits);
375         return hit_mesh != -1;
376 }
377
378 #ifdef USE_MFACE_WORKAROUND
379 /**
380  * Until cycles moves to #MLoopTri, we need to keep face-rotation in sync with #test_index_face
381  *
382  * We only need to consider quads since #BKE_mesh_recalc_tessellation doesn't execute this on triangles.
383  */
384 static void test_index_face_looptri(const MPoly *mp, MLoop *mloop, MLoopTri *lt)
385 {
386         if (mp->totloop == 4) {
387                 if (UNLIKELY((mloop[mp->loopstart + 2].v == 0) ||
388                              (mloop[mp->loopstart + 3].v == 0)))
389                 {
390                         /* remap: (2, 3, 0, 1) */
391                         unsigned int l = mp->loopstart;
392                         ARRAY_SET_ITEMS(lt[0].tri, l + 2, l + 3, l + 0);
393                         ARRAY_SET_ITEMS(lt[1].tri, l + 2, l + 0, l + 1);
394                 }
395         }
396 }
397 #endif
398
399 /**
400  * This function populates an array of verts for the triangles of a mesh
401  * Tangent and Normals are also stored
402  */
403 static TriTessFace *mesh_calc_tri_tessface(
404         Mesh *me, bool tangent, DerivedMesh *dm)
405 {
406         int i;
407         MVert *mvert;
408         TSpace *tspace;
409
410         const int tottri = poly_to_tri_count(me->totpoly, me->totloop);
411         MLoopTri *looptri;
412         TriTessFace *triangles;
413
414         /* calculate normal for each polygon only once */
415         unsigned int mpoly_prev = UINT_MAX;
416         float no[3];
417
418 #ifdef USE_MFACE_WORKAROUND
419         unsigned int mpoly_prev_testindex = UINT_MAX;
420 #endif
421
422         mvert = CustomData_get_layer(&me->vdata, CD_MVERT);
423         looptri = MEM_mallocN(sizeof(*looptri) * tottri, __func__);
424         triangles = MEM_mallocN(sizeof(TriTessFace) * tottri, __func__);
425
426         if (tangent) {
427                 DM_ensure_normals(dm);
428                 DM_calc_loop_tangents(dm);
429
430                 tspace = dm->getLoopDataArray(dm, CD_TANGENT);
431                 BLI_assert(tspace);
432         }
433
434         BKE_mesh_recalc_looptri(
435                     me->mloop, me->mpoly,
436                     me->mvert,
437                     me->totloop, me->totpoly,
438                     looptri);
439
440
441         const float *precomputed_normals = dm ? dm->getPolyDataArray(dm, CD_NORMAL) : NULL;
442         const bool calculate_normal = precomputed_normals ? false : true;
443
444         for (i = 0; i < tottri; i++) {
445                 const MLoopTri *lt = &looptri[i];
446                 const MPoly *mp = &me->mpoly[lt->poly];
447
448 #ifdef USE_MFACE_WORKAROUND
449                 if (lt->poly != mpoly_prev_testindex) {
450                         test_index_face_looptri(mp, me->mloop, &looptri[i]);
451                         mpoly_prev_testindex = lt->poly;
452                 }
453 #endif
454
455                 triangles[i].mverts[0] = &mvert[me->mloop[lt->tri[0]].v];
456                 triangles[i].mverts[1] = &mvert[me->mloop[lt->tri[1]].v];
457                 triangles[i].mverts[2] = &mvert[me->mloop[lt->tri[2]].v];
458                 triangles[i].is_smooth = (mp->flag & ME_SMOOTH) != 0;
459
460                 if (tangent) {
461                         triangles[i].tspace[0] = &tspace[lt->tri[0]];
462                         triangles[i].tspace[1] = &tspace[lt->tri[1]];
463                         triangles[i].tspace[2] = &tspace[lt->tri[2]];
464                 }
465
466                 if (calculate_normal) {
467                         if (lt->poly != mpoly_prev) {
468                                 BKE_mesh_calc_poly_normal(mp, &me->mloop[mp->loopstart], me->mvert, no);
469                                 mpoly_prev = lt->poly;
470                         }
471                         copy_v3_v3(triangles[i].normal, no);
472                 }
473                 else {
474                         copy_v3_v3(triangles[i].normal, &precomputed_normals[lt->poly]);
475                 }
476         }
477
478         MEM_freeN(looptri);
479
480         return triangles;
481 }
482
483 bool RE_bake_pixels_populate_from_objects(
484         struct Mesh *me_low, BakePixel pixel_array_from[],  BakePixel pixel_array_to[],
485         BakeHighPolyData highpoly[], const int tot_highpoly, const size_t num_pixels, const bool is_custom_cage,
486         const float cage_extrusion, float mat_low[4][4], float mat_cage[4][4], struct Mesh *me_cage)
487 {
488         size_t i;
489         int primitive_id;
490         float u, v;
491         float imat_low[4][4];
492         bool is_cage = me_cage != NULL;
493         bool result = true;
494
495         DerivedMesh *dm_low = NULL;
496         DerivedMesh **dm_highpoly;
497         BVHTreeFromMesh *treeData;
498
499         /* Note: all coordinates are in local space */
500         TriTessFace *tris_low = NULL;
501         TriTessFace *tris_cage = NULL;
502         TriTessFace **tris_high;
503
504         /* assume all lowpoly tessfaces can be quads */
505         tris_high = MEM_callocN(sizeof(TriTessFace *) * tot_highpoly, "MVerts Highpoly Mesh Array");
506
507         /* assume all highpoly tessfaces are triangles */
508         dm_highpoly = MEM_mallocN(sizeof(DerivedMesh *) * tot_highpoly, "Highpoly Derived Meshes");
509         treeData = MEM_callocN(sizeof(BVHTreeFromMesh) * tot_highpoly, "Highpoly BVH Trees");
510
511         if (!is_cage) {
512                 dm_low = CDDM_from_mesh(me_low);
513                 tris_low = mesh_calc_tri_tessface(me_low, true, dm_low);
514         }
515         else if (is_custom_cage) {
516                 tris_low = mesh_calc_tri_tessface(me_low, false, NULL);
517                 tris_cage = mesh_calc_tri_tessface(me_cage, false, NULL);
518         }
519         else {
520                 tris_cage = mesh_calc_tri_tessface(me_cage, false, NULL);
521         }
522
523         invert_m4_m4(imat_low, mat_low);
524
525         for (i = 0; i < tot_highpoly; i++) {
526                 tris_high[i] = mesh_calc_tri_tessface(highpoly[i].me, false, NULL);
527
528                 dm_highpoly[i] = CDDM_from_mesh(highpoly[i].me);
529                 DM_ensure_tessface(dm_highpoly[i]);
530
531                 if (dm_highpoly[i]->getNumTessFaces(dm_highpoly[i]) != 0) {
532                         /* Create a bvh-tree for each highpoly object */
533                         bvhtree_from_mesh_faces(&treeData[i], dm_highpoly[i], 0.0, 2, 6);
534
535                         if (treeData[i].tree == NULL) {
536                                 printf("Baking: out of memory while creating BHVTree for object \"%s\"\n", highpoly[i].ob->id.name + 2);
537                                 result = false;
538                                 goto cleanup;
539                         }
540                 }
541         }
542
543         for (i = 0; i < num_pixels; i++) {
544                 float co[3];
545                 float dir[3];
546                 TriTessFace *tri_low;
547
548                 primitive_id = pixel_array_from[i].primitive_id;
549
550                 if (primitive_id == -1) {
551                         pixel_array_to[i].primitive_id = -1;
552                         continue;
553                 }
554
555                 u = pixel_array_from[i].uv[0];
556                 v = pixel_array_from[i].uv[1];
557
558                 /* calculate from low poly mesh cage */
559                 if (is_custom_cage) {
560                         calc_point_from_barycentric_cage(tris_low, tris_cage, mat_low, mat_cage, primitive_id, u, v, co, dir);
561                         tri_low = &tris_cage[primitive_id];
562                 }
563                 else if (is_cage) {
564                         calc_point_from_barycentric_extrusion(tris_cage, mat_low, imat_low, primitive_id, u, v, cage_extrusion, co, dir, true);
565                         tri_low = &tris_cage[primitive_id];
566                 }
567                 else {
568                         calc_point_from_barycentric_extrusion(tris_low, mat_low, imat_low, primitive_id, u, v, cage_extrusion, co, dir, false);
569                         tri_low = &tris_low[primitive_id];
570                 }
571
572                 /* cast ray */
573                 if (!cast_ray_highpoly(treeData, tri_low, tris_high,
574                                        pixel_array_from, pixel_array_to, mat_low,
575                                        highpoly, co, dir, i, tot_highpoly)) {
576                         /* if it fails mask out the original pixel array */
577                         pixel_array_from[i].primitive_id = -1;
578                 }
579         }
580
581
582         /* garbage collection */
583 cleanup:
584         for (i = 0; i < tot_highpoly; i++) {
585                 free_bvhtree_from_mesh(&treeData[i]);
586
587                 if (dm_highpoly[i]) {
588                         dm_highpoly[i]->release(dm_highpoly[i]);
589                 }
590
591                 if (tris_high[i]) {
592                         MEM_freeN(tris_high[i]);
593                 }
594         }
595
596         MEM_freeN(tris_high);
597         MEM_freeN(treeData);
598         MEM_freeN(dm_highpoly);
599
600         if (dm_low) {
601                 dm_low->release(dm_low);
602         }
603         if (tris_low) {
604                 MEM_freeN(tris_low);
605         }
606         if (tris_cage) {
607                 MEM_freeN(tris_cage);
608         }
609
610         return result;
611 }
612
613 static void bake_differentials(BakeDataZSpan *bd, const float *uv1, const float *uv2, const float *uv3)
614 {
615         float A;
616
617         /* assumes dPdu = P1 - P3 and dPdv = P2 - P3 */
618         A = (uv2[0] - uv1[0]) * (uv3[1] - uv1[1]) - (uv3[0] - uv1[0]) * (uv2[1] - uv1[1]);
619
620         if (fabsf(A) > FLT_EPSILON) {
621                 A = 0.5f / A;
622
623                 bd->du_dx = (uv2[1] - uv3[1]) * A;
624                 bd->dv_dx = (uv3[1] - uv1[1]) * A;
625
626                 bd->du_dy = (uv3[0] - uv2[0]) * A;
627                 bd->dv_dy = (uv1[0] - uv3[0]) * A;
628         }
629         else {
630                 bd->du_dx = bd->du_dy = 0.0f;
631                 bd->dv_dx = bd->dv_dy = 0.0f;
632         }
633 }
634
635 void RE_bake_pixels_populate(
636         Mesh *me, BakePixel pixel_array[],
637         const size_t num_pixels, const BakeImages *bake_images, const char *uv_layer)
638 {
639         BakeDataZSpan bd;
640         size_t i;
641         int a, p_id;
642
643         const MLoopUV *mloopuv;
644         const int tottri = poly_to_tri_count(me->totpoly, me->totloop);
645         MLoopTri *looptri;
646 #ifdef USE_MFACE_WORKAROUND
647         unsigned int mpoly_prev_testindex = UINT_MAX;
648 #endif
649
650         if ((uv_layer == NULL) || (uv_layer[0] == '\0')) {
651                 mloopuv = CustomData_get_layer(&me->ldata, CD_MLOOPUV);
652         }
653         else {
654                 int uv_id = CustomData_get_named_layer(&me->ldata, CD_MLOOPUV, uv_layer);
655                 mloopuv = CustomData_get_layer_n(&me->ldata, CD_MTFACE, uv_id);
656         }
657
658         if (mloopuv == NULL)
659                 return;
660
661
662         bd.pixel_array = pixel_array;
663         bd.zspan = MEM_callocN(sizeof(ZSpan) * bake_images->size, "bake zspan");
664
665         /* initialize all pixel arrays so we know which ones are 'blank' */
666         for (i = 0; i < num_pixels; i++) {
667                 pixel_array[i].primitive_id = -1;
668                 pixel_array[i].object_id = 0;
669         }
670
671         for (i = 0; i < bake_images->size; i++) {
672                 zbuf_alloc_span(&bd.zspan[i], bake_images->data[i].width, bake_images->data[i].height, R.clipcrop);
673         }
674
675         looptri = MEM_mallocN(sizeof(*looptri) * tottri, __func__);
676
677         BKE_mesh_recalc_looptri(
678                 me->mloop, me->mpoly,
679                 me->mvert,
680                 me->totloop, me->totpoly,
681                 looptri);
682
683         p_id = -1;
684         for (i = 0; i < tottri; i++) {
685                 const MLoopTri *lt = &looptri[i];
686                 const MPoly *mp = &me->mpoly[lt->poly];
687                 float vec[3][2];
688                 int mat_nr = mp->mat_nr;
689                 int image_id = bake_images->lookup[mat_nr];
690
691                 bd.bk_image = &bake_images->data[image_id];
692                 bd.primitive_id = ++p_id;
693
694 #ifdef USE_MFACE_WORKAROUND
695                 if (lt->poly != mpoly_prev_testindex) {
696                         test_index_face_looptri(mp, me->mloop, &looptri[i]);
697                         mpoly_prev_testindex = lt->poly;
698                 }
699 #endif
700
701                 for (a = 0; a < 3; a++) {
702                         const float *uv = mloopuv[lt->tri[a]].uv;
703
704                         /* Note, workaround for pixel aligned UVs which are common and can screw up our intersection tests
705                          * where a pixel gets in between 2 faces or the middle of a quad,
706                          * camera aligned quads also have this problem but they are less common.
707                          * Add a small offset to the UVs, fixes bug #18685 - Campbell */
708                         vec[a][0] = uv[0] * (float)bd.bk_image->width - (0.5f + 0.001f);
709                         vec[a][1] = uv[1] * (float)bd.bk_image->height - (0.5f + 0.002f);
710                 }
711
712                 bake_differentials(&bd, vec[0], vec[1], vec[2]);
713                 zspan_scanconvert(&bd.zspan[image_id], (void *)&bd, vec[0], vec[1], vec[2], store_bake_pixel);
714         }
715
716         for (i = 0; i < bake_images->size; i++) {
717                 zbuf_free_span(&bd.zspan[i]);
718         }
719
720         MEM_freeN(looptri);
721         MEM_freeN(bd.zspan);
722 }
723
724 /* ******************** NORMALS ************************ */
725
726 /**
727  * convert a normalized normal to the -1.0 1.0 range
728  * the input is expected to be POS_X, POS_Y, POS_Z
729  */
730 static void normal_uncompress(float out[3], const float in[3])
731 {
732         int i;
733         for (i = 0; i < 3; i++)
734                 out[i] = 2.0f * in[i] - 1.0f;
735 }
736
737 static void normal_compress(float out[3], const float in[3], const BakeNormalSwizzle normal_swizzle[3])
738 {
739         const int swizzle_index[6] = {
740                 0,  /* R_BAKE_POSX */
741                 1,  /* R_BAKE_POSY */
742                 2,  /* R_BAKE_POSZ */
743                 0,  /* R_BAKE_NEGX */
744                 1,  /* R_BAKE_NEGY */
745                 2,  /* R_BAKE_NEGZ */
746         };
747         const float swizzle_sign[6] = {
748                 +1.0f,  /* R_BAKE_POSX */
749                 +1.0f,  /* R_BAKE_POSY */
750                 +1.0f,  /* R_BAKE_POSZ */
751                 -1.0f,  /* R_BAKE_NEGX */
752                 -1.0f,  /* R_BAKE_NEGY */
753                 -1.0f,  /* R_BAKE_NEGZ */
754         };
755
756         int i;
757
758         for (i = 0; i < 3; i++) {
759                 int index;
760                 float sign;
761
762                 sign  = swizzle_sign[normal_swizzle[i]];
763                 index = swizzle_index[normal_swizzle[i]];
764
765                 /*
766                  * There is a small 1e-5f bias for precision issues. otherwise
767                  * we randomly get 127 or 128 for neutral colors in tangent maps.
768                  * we choose 128 because it is the convention flat color. *
769                  */
770
771                 out[i] = sign * in[index] / 2.0f + 0.5f + 1e-5f;
772         }
773 }
774
775 /**
776  * This function converts an object space normal map to a tangent space normal map for a given low poly mesh
777  */
778 void RE_bake_normal_world_to_tangent(
779         const BakePixel pixel_array[], const size_t num_pixels, const int depth,
780         float result[], Mesh *me, const BakeNormalSwizzle normal_swizzle[3],
781         float mat[4][4])
782 {
783         size_t i;
784
785         TriTessFace *triangles;
786
787         DerivedMesh *dm = CDDM_from_mesh(me);
788
789         triangles = mesh_calc_tri_tessface(me, true, dm);
790
791         BLI_assert(num_pixels >= 3);
792
793         for (i = 0; i < num_pixels; i++) {
794                 TriTessFace *triangle;
795                 float tangents[3][3];
796                 float normals[3][3];
797                 float signs[3];
798                 int j;
799
800                 float tangent[3];
801                 float normal[3];
802                 float binormal[3];
803                 float sign;
804                 float u, v, w;
805
806                 float tsm[3][3]; /* tangent space matrix */
807                 float itsm[3][3];
808
809                 size_t offset;
810                 float nor[3]; /* texture normal */
811
812                 bool is_smooth;
813
814                 int primitive_id = pixel_array[i].primitive_id;
815
816                 offset = i * depth;
817
818                 if (primitive_id == -1) {
819                         if (depth == 4)
820                                 copy_v4_fl4(&result[offset], 0.5f, 0.5f, 1.0f, 1.0f);
821                         else
822                                 copy_v3_fl3(&result[offset], 0.5f, 0.5f, 1.0f);
823                         continue;
824                 }
825
826                 triangle = &triangles[primitive_id];
827                 is_smooth = triangle->is_smooth;
828
829                 for (j = 0; j < 3; j++) {
830                         const TSpace *ts;
831
832                         if (is_smooth)
833                                 normal_short_to_float_v3(normals[j], triangle->mverts[j]->no);
834                         else
835                                 normal[j] = triangle->normal[j];
836
837                         ts = triangle->tspace[j];
838                         copy_v3_v3(tangents[j], ts->tangent);
839                         signs[j] = ts->sign;
840                 }
841
842                 u = pixel_array[i].uv[0];
843                 v = pixel_array[i].uv[1];
844                 w = 1.0f - u - v;
845
846                 /* normal */
847                 if (is_smooth)
848                         interp_barycentric_tri_v3(normals, u, v, normal);
849
850                 /* tangent */
851                 interp_barycentric_tri_v3(tangents, u, v, tangent);
852
853                 /* sign */
854                 /* The sign is the same at all face vertices for any non degenerate face.
855                  * Just in case we clamp the interpolated value though. */
856                 sign = (signs[0]  * u + signs[1]  * v + signs[2] * w) < 0 ? (-1.0f) : 1.0f;
857
858                 /* binormal */
859                 /* B = sign * cross(N, T)  */
860                 cross_v3_v3v3(binormal, normal, tangent);
861                 mul_v3_fl(binormal, sign);
862
863                 /* populate tangent space matrix */
864                 copy_v3_v3(tsm[0], tangent);
865                 copy_v3_v3(tsm[1], binormal);
866                 copy_v3_v3(tsm[2], normal);
867
868                 /* texture values */
869                 normal_uncompress(nor, &result[offset]);
870
871                 /* converts from world space to local space */
872                 mul_transposed_mat3_m4_v3(mat, nor);
873
874                 invert_m3_m3(itsm, tsm);
875                 mul_m3_v3(itsm, nor);
876                 normalize_v3(nor);
877
878                 /* save back the values */
879                 normal_compress(&result[offset], nor, normal_swizzle);
880         }
881
882         /* garbage collection */
883         MEM_freeN(triangles);
884
885         if (dm)
886                 dm->release(dm);
887 }
888
889 void RE_bake_normal_world_to_object(
890         const BakePixel pixel_array[], const size_t num_pixels, const int depth,
891         float result[], struct Object *ob, const BakeNormalSwizzle normal_swizzle[3])
892 {
893         size_t i;
894         float iobmat[4][4];
895
896         invert_m4_m4(iobmat, ob->obmat);
897
898         for (i = 0; i < num_pixels; i++) {
899                 size_t offset;
900                 float nor[3];
901
902                 if (pixel_array[i].primitive_id == -1)
903                         continue;
904
905                 offset = i * depth;
906                 normal_uncompress(nor, &result[offset]);
907
908                 /* rotates only without translation */
909                 mul_mat3_m4_v3(iobmat, nor);
910                 normalize_v3(nor);
911
912                 /* save back the values */
913                 normal_compress(&result[offset], nor, normal_swizzle);
914         }
915 }
916
917 void RE_bake_normal_world_to_world(
918         const BakePixel pixel_array[], const size_t num_pixels, const int depth,
919         float result[], const BakeNormalSwizzle normal_swizzle[3])
920 {
921         size_t i;
922
923         for (i = 0; i < num_pixels; i++) {
924                 size_t offset;
925                 float nor[3];
926
927                 if (pixel_array[i].primitive_id == -1)
928                         continue;
929
930                 offset = i * depth;
931                 normal_uncompress(nor, &result[offset]);
932
933                 /* save back the values */
934                 normal_compress(&result[offset], nor, normal_swizzle);
935         }
936 }
937
938 void RE_bake_ibuf_clear(Image *image, const bool is_tangent)
939 {
940         ImBuf *ibuf;
941         void *lock;
942
943         const float vec_alpha[4] = {0.0f, 0.0f, 0.0f, 0.0f};
944         const float vec_solid[4] = {0.0f, 0.0f, 0.0f, 1.0f};
945         const float nor_alpha[4] = {0.5f, 0.5f, 1.0f, 0.0f};
946         const float nor_solid[4] = {0.5f, 0.5f, 1.0f, 1.0f};
947
948         ibuf = BKE_image_acquire_ibuf(image, NULL, &lock);
949         BLI_assert(ibuf);
950
951         if (is_tangent)
952                 IMB_rectfill(ibuf, (ibuf->planes == R_IMF_PLANES_RGBA) ? nor_alpha : nor_solid);
953         else
954                 IMB_rectfill(ibuf, (ibuf->planes == R_IMF_PLANES_RGBA) ? vec_alpha : vec_solid);
955
956         BKE_image_release_ibuf(image, ibuf, lock);
957 }
958
959 /* ************************************************************* */
960
961 /**
962  * not the real UV, but the internal per-face UV instead
963  * I'm using it to test if everything is correct */
964 static bool bake_uv(const BakePixel pixel_array[], const size_t num_pixels, const int depth, float result[])
965 {
966         size_t i;
967
968         for (i=0; i < num_pixels; i++) {
969                 size_t offset = i * depth;
970                 copy_v2_v2(&result[offset], pixel_array[i].uv);
971         }
972
973         return true;
974 }
975
976 bool RE_bake_internal(
977         Render *UNUSED(re), Object *UNUSED(object), const BakePixel pixel_array[],
978         const size_t num_pixels, const int depth, const ScenePassType pass_type, float result[])
979 {
980         switch (pass_type) {
981                 case SCE_PASS_UV:
982                 {
983                         return bake_uv(pixel_array, num_pixels, depth, result);
984                 }
985                 default:
986                         break;
987         }
988         return false;
989 }
990
991 int RE_pass_depth(const ScenePassType pass_type)
992 {
993         /* IMB_buffer_byte_from_float assumes 4 channels
994          * making it work for now - XXX */
995         return 4;
996
997         switch (pass_type) {
998                 case SCE_PASS_Z:
999                 case SCE_PASS_AO:
1000                 case SCE_PASS_MIST:
1001                 {
1002                         return 1;
1003                 }
1004                 case SCE_PASS_UV:
1005                 {
1006                         return 2;
1007                 }
1008                 case SCE_PASS_RGBA:
1009                 {
1010                         return 4;
1011                 }
1012                 case SCE_PASS_COMBINED:
1013                 case SCE_PASS_DIFFUSE:
1014                 case SCE_PASS_SPEC:
1015                 case SCE_PASS_SHADOW:
1016                 case SCE_PASS_REFLECT:
1017                 case SCE_PASS_NORMAL:
1018                 case SCE_PASS_VECTOR:
1019                 case SCE_PASS_REFRACT:
1020                 case SCE_PASS_INDEXOB:  /* XXX double check */
1021                 case SCE_PASS_INDIRECT:
1022                 case SCE_PASS_RAYHITS:  /* XXX double check */
1023                 case SCE_PASS_EMIT:
1024                 case SCE_PASS_ENVIRONMENT:
1025                 case SCE_PASS_INDEXMA:
1026                 case SCE_PASS_DIFFUSE_DIRECT:
1027                 case SCE_PASS_DIFFUSE_INDIRECT:
1028                 case SCE_PASS_DIFFUSE_COLOR:
1029                 case SCE_PASS_GLOSSY_DIRECT:
1030                 case SCE_PASS_GLOSSY_INDIRECT:
1031                 case SCE_PASS_GLOSSY_COLOR:
1032                 case SCE_PASS_TRANSM_DIRECT:
1033                 case SCE_PASS_TRANSM_INDIRECT:
1034                 case SCE_PASS_TRANSM_COLOR:
1035                 case SCE_PASS_SUBSURFACE_DIRECT:
1036                 case SCE_PASS_SUBSURFACE_INDIRECT:
1037                 case SCE_PASS_SUBSURFACE_COLOR:
1038                 default:
1039                 {
1040                         return 3;
1041                 }
1042         }
1043 }