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