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