griefith/test
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
8fb2ff458ba579dba08bfdf57d043ad158b5db07
test/source/blender/render/intern/multires_bake.c
Hans Goudey cfa53e0fbe Refactor: Move normals out of MVert, lazy calculation 
As described in T91186, this commit moves mesh vertex normals into a
contiguous array of float vectors in a custom data layer, how face
normals are currently stored.

The main interface is documented in `BKE_mesh.h`. Vertex and face
normals are now calculated on-demand and cached, retrieved with an
"ensure" function. Since the logical state of a mesh is now "has
normals when necessary", they can be retrieved from a `const` mesh.

The goal is to use on-demand calculation for all derived data, but
leave room for eager calculation for performance purposes (modifier
evaluation is threaded, but viewport data generation is not).

**Benefits**
This moves us closer to a SoA approach rather than the current AoS
paradigm. Accessing a contiguous `float3` is much more efficient than
retrieving data from a larger struct. The memory requirements for
accessing only normals or vertex locations are smaller, and at the
cost of more memory usage for just normals, they now don't have to
be converted between float and short, which also simplifies code

In the future, the remaining items can be removed from `MVert`,
leaving only `float3`, which has similar benefits (see T93602).

Removing the combination of derived and original data makes it
conceptually simpler to only calculate normals when necessary.
This is especially important now that we have more opportunities
for temporary meshes in geometry nodes.

**Performance**
In addition to the theoretical future performance improvements by
making `MVert == float3`, I've done some basic performance testing
on this patch directly. The data is fairly rough, but it gives an idea
about where things stand generally.
 - Mesh line primitive 4m Verts: 1.16x faster (36 -> 31 ms),
   showing that accessing just `MVert` is now more efficient.
 - Spring Splash Screen: 1.03-1.06 -> 1.06-1.11 FPS, a very slight
   change that at least shows there is no regression.
 - Sprite Fright Snail Smoosh: 3.30-3.40 -> 3.42-3.50 FPS, a small
   but observable speedup.
 - Set Position Node with Scaled Normal: 1.36x faster (53 -> 39 ms),
   shows that using normals in geometry nodes is faster.
 - Normal Calculation 1.6m Vert Cube: 1.19x faster (25 -> 21 ms),
   shows that calculating normals is slightly faster now.
 - File Size of 1.6m Vert Cube: 1.03x smaller (214.7 -> 208.4 MB),
   Normals are not saved in files, which can help with large meshes.

As for memory usage, it may be slightly more in some cases, but
I didn't observe any difference in the production files I tested.

**Tests**
Some modifiers and cycles test results need to be updated with this
commit, for two reasons:
 - The subdivision surface modifier is not responsible for calculating
   normals anymore. In master, the modifier creates different normals
   than the result of the `Mesh` normal calculation, so this is a bug
   fix.
 - There are small differences in the results of some modifiers that
   use normals because they are not converted to and from `short`
   anymore.

**Future improvements**
 - Remove `ModifierTypeInfo::dependsOnNormals`. Code in each modifier
   already retrieves normals if they are needed anyway.
 - Copy normals as part of a better CoW system for attributes.
 - Make more areas use lazy instead of eager normal calculation.
 - Remove `BKE_mesh_normals_tag_dirty` in more places since that is
   now the default state of a new mesh.
 - Possibly apply a similar change to derived face corner normals.

Differential Revision: https://developer.blender.org/D12770
2022-01-13 14:38:25 -06:00

1500 lines
45 KiB
C
Raw Blame History

/*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* The Original Code is Copyright (C) 2012 by Blender Foundation
* All rights reserved.
*/
/** \file
* \ingroup render
*/
#include <string.h>
#include "MEM_guardedalloc.h"
#include "DNA_mesh_types.h"
#include "DNA_object_types.h"
#include "DNA_scene_types.h"
#include "BLI_listbase.h"
#include "BLI_math.h"
#include "BLI_threads.h"
#include "BKE_ccg.h"
#include "BKE_global.h"
#include "BKE_image.h"
#include "BKE_material.h"
#include "BKE_mesh.h"
#include "BKE_modifier.h"
#include "BKE_multires.h"
#include "BKE_subsurf.h"
#include "DEG_depsgraph.h"
#include "RE_multires_bake.h"
#include "RE_pipeline.h"
#include "RE_texture.h"
#include "IMB_imbuf.h"
#include "IMB_imbuf_types.h"
typedef void (*MPassKnownData)(DerivedMesh *lores_dm,
DerivedMesh *hires_dm,
void *thread_data,
void *bake_data,
ImBuf *ibuf,
const int face_index,
const int lvl,
const float st[2],
float tangmat[3][3],
const int x,
const int y);
typedef void *(*MInitBakeData)(MultiresBakeRender *bkr, Image *ima);
typedef void (*MFreeBakeData)(void *bake_data);
typedef struct MultiresBakeResult {
float height_min, height_max;
} MultiresBakeResult;
typedef struct {
MVert *mvert;
const float (*vert_normals)[3];
MPoly *mpoly;
MLoop *mloop;
MLoopUV *mloopuv;
const MLoopTri *mlooptri;
float *pvtangent;
const float *precomputed_normals;
int w, h;
int tri_index;
DerivedMesh *lores_dm, *hires_dm;
int lvl;
void *thread_data;
void *bake_data;
ImBuf *ibuf;
MPassKnownData pass_data;
/* material aligned UV array */
Image **image_array;
} MResolvePixelData;
typedef void (*MFlushPixel)(const MResolvePixelData *data, const int x, const int y);
typedef struct {
int w, h;
char *texels;
const MResolvePixelData *data;
MFlushPixel flush_pixel;
short *do_update;
} MBakeRast;
typedef struct {
float *heights;
Image *ima;
DerivedMesh *ssdm;
const int *orig_index_mp_to_orig;
} MHeightBakeData;
typedef struct {
const int *orig_index_mp_to_orig;
} MNormalBakeData;
typedef struct BakeImBufuserData {
float *displacement_buffer;
char *mask_buffer;
} BakeImBufuserData;
static void multiresbake_get_normal(const MResolvePixelData *data,
float norm[],
const int tri_num,
const int vert_index)
{
const int poly_index = data->mlooptri[tri_num].poly;
const MPoly *mp = &data->mpoly[poly_index];
const bool smoothnormal = (mp->flag & ME_SMOOTH) != 0;
if (!smoothnormal) { /* flat */
if (data->precomputed_normals) {
copy_v3_v3(norm, &data->precomputed_normals[poly_index]);
}
else {
BKE_mesh_calc_poly_normal(mp, &data->mloop[mp->loopstart], data->mvert, norm);
}
}
else {
const int vi = data->mloop[data->mlooptri[tri_num].tri[vert_index]].v;
copy_v3_v3(norm, data->vert_normals[vi]);
}
}
static void init_bake_rast(MBakeRast *bake_rast,
const ImBuf *ibuf,
const MResolvePixelData *data,
MFlushPixel flush_pixel,
short *do_update)
{
BakeImBufuserData *userdata = (BakeImBufuserData *)ibuf->userdata;
memset(bake_rast, 0, sizeof(MBakeRast));
bake_rast->texels = userdata->mask_buffer;
bake_rast->w = ibuf->x;
bake_rast->h = ibuf->y;
bake_rast->data = data;
bake_rast->flush_pixel = flush_pixel;
bake_rast->do_update = do_update;
}
static void flush_pixel(const MResolvePixelData *data, const int x, const int y)
{
const float st[2] = {(x + 0.5f) / data->w, (y + 0.5f) / data->h};
const float *st0, *st1, *st2;
const float *tang0, *tang1, *tang2;
float no0[3], no1[3], no2[3];
float fUV[2], from_tang[3][3], to_tang[3][3];
float u, v, w, sign;
int r;
st0 = data->mloopuv[data->mlooptri[data->tri_index].tri[0]].uv;
st1 = data->mloopuv[data->mlooptri[data->tri_index].tri[1]].uv;
st2 = data->mloopuv[data->mlooptri[data->tri_index].tri[2]].uv;
multiresbake_get_normal(data, no0, data->tri_index, 0); /* can optimize these 3 into one call */
multiresbake_get_normal(data, no1, data->tri_index, 1);
multiresbake_get_normal(data, no2, data->tri_index, 2);
resolve_tri_uv_v2(fUV, st, st0, st1, st2);
u = fUV[0];
v = fUV[1];
w = 1 - u - v;
if (data->pvtangent) {
tang0 = data->pvtangent + data->mlooptri[data->tri_index].tri[0] * 4;
tang1 = data->pvtangent + data->mlooptri[data->tri_index].tri[1] * 4;
tang2 = data->pvtangent + data->mlooptri[data->tri_index].tri[2] * 4;
/* the sign is the same at all face vertices for any non degenerate face.
* Just in case we clamp the interpolated value though. */
sign = (tang0[3] * u + tang1[3] * v + tang2[3] * w) < 0 ? (-1.0f) : 1.0f;
/* this sequence of math is designed specifically as is with great care
* to be compatible with our shader. Please don't change without good reason. */
for (r = 0; r < 3; r++) {
from_tang[0][r] = tang0[r] * u + tang1[r] * v + tang2[r] * w;
from_tang[2][r] = no0[r] * u + no1[r] * v + no2[r] * w;
}
cross_v3_v3v3(from_tang[1], from_tang[2], from_tang[0]); /* `B = sign * cross(N, T)` */
mul_v3_fl(from_tang[1], sign);
invert_m3_m3(to_tang, from_tang);
}
else {
zero_m3(to_tang);
}
data->pass_data(data->lores_dm,
data->hires_dm,
data->thread_data,
data->bake_data,
data->ibuf,
data->tri_index,
data->lvl,
st,
to_tang,
x,
y);
}
static void set_rast_triangle(const MBakeRast *bake_rast, const int x, const int y)
{
const int w = bake_rast->w;
const int h = bake_rast->h;
if (x >= 0 && x < w && y >= 0 && y < h) {
if ((bake_rast->texels[y * w + x]) == 0) {
bake_rast->texels[y * w + x] = FILTER_MASK_USED;
flush_pixel(bake_rast->data, x, y);
if (bake_rast->do_update) {
*bake_rast->do_update = true;
}
}
}
}
static void rasterize_half(const MBakeRast *bake_rast,
const float s0_s,
const float t0_s,
const float s1_s,
const float t1_s,
const float s0_l,
const float t0_l,
const float s1_l,
const float t1_l,
const int y0_in,
const int y1_in,
const int is_mid_right)
{
const int s_stable = fabsf(t1_s - t0_s) > FLT_EPSILON ? 1 : 0;
const int l_stable = fabsf(t1_l - t0_l) > FLT_EPSILON ? 1 : 0;
const int w = bake_rast->w;
const int h = bake_rast->h;
int y, y0, y1;
if (y1_in <= 0 || y0_in >= h) {
return;
}
y0 = y0_in < 0 ? 0 : y0_in;
y1 = y1_in >= h ? h : y1_in;
for (y = y0; y < y1; y++) {
/*-b(x-x0) + a(y-y0) = 0 */
int iXl, iXr, x;
float x_l = s_stable != 0 ? (s0_s + (((s1_s - s0_s) * (y - t0_s)) / (t1_s - t0_s))) : s0_s;
float x_r = l_stable != 0 ? (s0_l + (((s1_l - s0_l) * (y - t0_l)) / (t1_l - t0_l))) : s0_l;
if (is_mid_right != 0) {
SWAP(float, x_l, x_r);
}
iXl = (int)ceilf(x_l);
iXr = (int)ceilf(x_r);
if (iXr > 0 && iXl < w) {
iXl = iXl < 0 ? 0 : iXl;
iXr = iXr >= w ? w : iXr;
for (x = iXl; x < iXr; x++) {
set_rast_triangle(bake_rast, x, y);
}
}
}
}
static void bake_rasterize(const MBakeRast *bake_rast,
const float st0_in[2],
const float st1_in[2],
const float st2_in[2])
{
const int w = bake_rast->w;
const int h = bake_rast->h;
float slo = st0_in[0] * w - 0.5f;
float tlo = st0_in[1] * h - 0.5f;
float smi = st1_in[0] * w - 0.5f;
float tmi = st1_in[1] * h - 0.5f;
float shi = st2_in[0] * w - 0.5f;
float thi = st2_in[1] * h - 0.5f;
int is_mid_right = 0, ylo, yhi, yhi_beg;
/* skip degenerates */
if ((slo == smi && tlo == tmi) || (slo == shi && tlo == thi) || (smi == shi && tmi == thi)) {
return;
}
/* sort by T */
if (tlo > tmi && tlo > thi) {
SWAP(float, shi, slo);
SWAP(float, thi, tlo);
}
else if (tmi > thi) {
SWAP(float, shi, smi);
SWAP(float, thi, tmi);
}
if (tlo > tmi) {
SWAP(float, slo, smi);
SWAP(float, tlo, tmi);
}
/* check if mid point is to the left or to the right of the lo-hi edge */
is_mid_right = (-(shi - slo) * (tmi - thi) + (thi - tlo) * (smi - shi)) > 0 ? 1 : 0;
ylo = (int)ceilf(tlo);
yhi_beg = (int)ceilf(tmi);
yhi = (int)ceilf(thi);
// if (fTmi>ceilf(fTlo))
rasterize_half(bake_rast, slo, tlo, smi, tmi, slo, tlo, shi, thi, ylo, yhi_beg, is_mid_right);
rasterize_half(bake_rast, smi, tmi, shi, thi, slo, tlo, shi, thi, yhi_beg, yhi, is_mid_right);
}
static int multiresbake_test_break(MultiresBakeRender *bkr)
{
if (!bkr->stop) {
/* this means baker is executed outside from job system */
return 0;
}
return *bkr->stop || G.is_break;
}
/* **** Threading routines **** */
typedef struct MultiresBakeQueue {
int cur_tri;
int tot_tri;
SpinLock spin;
} MultiresBakeQueue;
typedef struct MultiresBakeThread {
/* this data is actually shared between all the threads */
MultiresBakeQueue *queue;
MultiresBakeRender *bkr;
Image *image;
void *bake_data;
/* thread-specific data */
MBakeRast bake_rast;
MResolvePixelData data;
/* displacement-specific data */
float height_min, height_max;
} MultiresBakeThread;
static int multires_bake_queue_next_tri(MultiresBakeQueue *queue)
{
int face = -1;
/* TODO: it could worth making it so thread will handle neighbor faces
* for better memory cache utilization
*/
BLI_spin_lock(&queue->spin);
if (queue->cur_tri < queue->tot_tri) {
face = queue->cur_tri;
queue->cur_tri++;
}
BLI_spin_unlock(&queue->spin);
return face;
}
static void *do_multires_bake_thread(void *data_v)
{
MultiresBakeThread *handle = (MultiresBakeThread *)data_v;
MResolvePixelData *data = &handle->data;
MBakeRast *bake_rast = &handle->bake_rast;
MultiresBakeRender *bkr = handle->bkr;
int tri_index;
while ((tri_index = multires_bake_queue_next_tri(handle->queue)) >= 0) {
const MLoopTri *lt = &data->mlooptri[tri_index];
const MPoly *mp = &data->mpoly[lt->poly];
const short mat_nr = mp->mat_nr;
const MLoopUV *mloopuv = data->mloopuv;
if (multiresbake_test_break(bkr)) {
break;
}
Image *tri_image = mat_nr < bkr->ob_image.len ? bkr->ob_image.array[mat_nr] : NULL;
if (tri_image != handle->image) {
continue;
}
data->tri_index = tri_index;
bake_rasterize(
bake_rast, mloopuv[lt->tri[0]].uv, mloopuv[lt->tri[1]].uv, mloopuv[lt->tri[2]].uv);
/* tag image buffer for refresh */
if (data->ibuf->rect_float) {
data->ibuf->userflags |= IB_RECT_INVALID;
}
data->ibuf->userflags |= IB_DISPLAY_BUFFER_INVALID;
/* update progress */
BLI_spin_lock(&handle->queue->spin);
bkr->baked_faces++;
if (bkr->do_update) {
*bkr->do_update = true;
}
if (bkr->progress) {
*bkr->progress = ((float)bkr->baked_objects +
(float)bkr->baked_faces / handle->queue->tot_tri) /
bkr->tot_obj;
}
BLI_spin_unlock(&handle->queue->spin);
}
return NULL;
}
/* some of arrays inside ccgdm are lazy-initialized, which will generally
* require lock around accessing such data
* this function will ensure all arrays are allocated before threading started
*/
static void init_ccgdm_arrays(DerivedMesh *dm)
{
CCGElem **grid_data;
CCGKey key;
int grid_size;
const int *grid_offset;
grid_size = dm->getGridSize(dm);
grid_data = dm->getGridData(dm);
grid_offset = dm->getGridOffset(dm);
dm->getGridKey(dm, &key);
(void)grid_size;
(void)grid_data;
(void)grid_offset;
}
static void do_multires_bake(MultiresBakeRender *bkr,
Image *ima,
bool require_tangent,
MPassKnownData passKnownData,
MInitBakeData initBakeData,
MFreeBakeData freeBakeData,
MultiresBakeResult *result)
{
DerivedMesh *dm = bkr->lores_dm;
const MLoopTri *mlooptri = dm->getLoopTriArray(dm);
const int lvl = bkr->lvl;
int tot_tri = dm->getNumLoopTri(dm);
if (tot_tri > 0) {
MultiresBakeThread *handles;
MultiresBakeQueue queue;
ImBuf *ibuf = BKE_image_acquire_ibuf(ima, NULL, NULL);
MVert *mvert = dm->getVertArray(dm);
MPoly *mpoly = dm->getPolyArray(dm);
MLoop *mloop = dm->getLoopArray(dm);
MLoopUV *mloopuv = dm->getLoopDataArray(dm, CD_MLOOPUV);
const float *precomputed_normals = dm->getPolyDataArray(dm, CD_NORMAL);
float *pvtangent = NULL;
ListBase threads;
int i, tot_thread = bkr->threads > 0 ? bkr->threads : BLI_system_thread_count();
void *bake_data = NULL;
if (require_tangent) {
if (CustomData_get_layer_index(&dm->loopData, CD_TANGENT) == -1) {
DM_calc_loop_tangents(dm, true, NULL, 0);
}
pvtangent = DM_get_loop_data_layer(dm, CD_TANGENT);
}
/* all threads shares the same custom bake data */
if (initBakeData) {
bake_data = initBakeData(bkr, ima);
}
if (tot_thread > 1) {
BLI_threadpool_init(&threads, do_multires_bake_thread, tot_thread);
}
handles = MEM_callocN(tot_thread * sizeof(MultiresBakeThread), "do_multires_bake handles");
init_ccgdm_arrays(bkr->hires_dm);
/* faces queue */
queue.cur_tri = 0;
queue.tot_tri = tot_tri;
BLI_spin_init(&queue.spin);
/* fill in threads handles */
for (i = 0; i < tot_thread; i++) {
MultiresBakeThread *handle = &handles[i];
handle->bkr = bkr;
handle->image = ima;
handle->queue = &queue;
handle->data.mpoly = mpoly;
handle->data.mvert = mvert;
handle->data.mloopuv = mloopuv;
handle->data.mlooptri = mlooptri;
handle->data.mloop = mloop;
handle->data.pvtangent = pvtangent;
handle->data.precomputed_normals = precomputed_normals; /* don't strictly need this */
handle->data.w = ibuf->x;
handle->data.h = ibuf->y;
handle->data.lores_dm = dm;
handle->data.hires_dm = bkr->hires_dm;
handle->data.lvl = lvl;
handle->data.pass_data = passKnownData;
handle->data.thread_data = handle;
handle->data.bake_data = bake_data;
handle->data.ibuf = ibuf;
handle->height_min = FLT_MAX;
handle->height_max = -FLT_MAX;
init_bake_rast(&handle->bake_rast, ibuf, &handle->data, flush_pixel, bkr->do_update);
if (tot_thread > 1) {
BLI_threadpool_insert(&threads, handle);
}
}
/* run threads */
if (tot_thread > 1) {
BLI_threadpool_end(&threads);
}
else {
do_multires_bake_thread(&handles[0]);
}
/* construct bake result */
result->height_min = handles[0].height_min;
result->height_max = handles[0].height_max;
for (i = 1; i < tot_thread; i++) {
result->height_min = min_ff(result->height_min, handles[i].height_min);
result->height_max = max_ff(result->height_max, handles[i].height_max);
}
BLI_spin_end(&queue.spin);
/* finalize baking */
if (freeBakeData) {
freeBakeData(bake_data);
}
MEM_freeN(handles);
BKE_image_release_ibuf(ima, ibuf, NULL);
}
}
/* mode = 0: interpolate normals,
* mode = 1: interpolate coord */
static void interp_bilinear_grid(
CCGKey *key, CCGElem *grid, float crn_x, float crn_y, int mode, float res[3])
{
int x0, x1, y0, y1;
float u, v;
float data[4][3];
x0 = (int)crn_x;
x1 = x0 >= (key->grid_size - 1) ? (key->grid_size - 1) : (x0 + 1);
y0 = (int)crn_y;
y1 = y0 >= (key->grid_size - 1) ? (key->grid_size - 1) : (y0 + 1);
u = crn_x - x0;
v = crn_y - y0;
if (mode == 0) {
copy_v3_v3(data[0], CCG_grid_elem_no(key, grid, x0, y0));
copy_v3_v3(data[1], CCG_grid_elem_no(key, grid, x1, y0));
copy_v3_v3(data[2], CCG_grid_elem_no(key, grid, x1, y1));
copy_v3_v3(data[3], CCG_grid_elem_no(key, grid, x0, y1));
}
else {
copy_v3_v3(data[0], CCG_grid_elem_co(key, grid, x0, y0));
copy_v3_v3(data[1], CCG_grid_elem_co(key, grid, x1, y0));
copy_v3_v3(data[2], CCG_grid_elem_co(key, grid, x1, y1));
copy_v3_v3(data[3], CCG_grid_elem_co(key, grid, x0, y1));
}
interp_bilinear_quad_v3(data, u, v, res);
}
static void get_ccgdm_data(DerivedMesh *lodm,
DerivedMesh *hidm,
const int *index_mp_to_orig,
const int lvl,
const MLoopTri *lt,
const float u,
const float v,
float co[3],
float n[3])
{
CCGElem **grid_data;
CCGKey key;
float crn_x, crn_y;
int grid_size, S, face_side;
int *grid_offset, g_index;
int poly_index = lt->poly;
grid_size = hidm->getGridSize(hidm);
grid_data = hidm->getGridData(hidm);
grid_offset = hidm->getGridOffset(hidm);
hidm->getGridKey(hidm, &key);
if (lvl == 0) {
MPoly *mpoly;
face_side = (grid_size << 1) - 1;
mpoly = lodm->getPolyArray(lodm) + poly_index;
g_index = grid_offset[poly_index];
S = mdisp_rot_face_to_crn(lodm->getVertArray(lodm),
mpoly,
lodm->getLoopArray(lodm),
lt,
face_side,
u * (face_side - 1),
v * (face_side - 1),
&crn_x,
&crn_y);
}
else {
/* number of faces per grid side */
int polys_per_grid_side = (1 << (lvl - 1));
/* get the original cage face index */
int cage_face_index = index_mp_to_orig ? index_mp_to_orig[poly_index] : poly_index;
/* local offset in total cage face grids
* `(1 << (2 * lvl))` is number of all polys for one cage face */
int loc_cage_poly_ofs = poly_index % (1 << (2 * lvl));
/* local offset in the vertex grid itself */
int cell_index = loc_cage_poly_ofs % (polys_per_grid_side * polys_per_grid_side);
int cell_side = (grid_size - 1) / polys_per_grid_side;
/* row and column based on grid side */
int row = cell_index / polys_per_grid_side;
int col = cell_index % polys_per_grid_side;
/* S is the vertex whose grid we are examining */
S = poly_index / (1 << (2 * (lvl - 1))) - grid_offset[cage_face_index];
/* get offset of grid data for original cage face */
g_index = grid_offset[cage_face_index];
crn_y = (row * cell_side) + u * cell_side;
crn_x = (col * cell_side) + v * cell_side;
}
CLAMP(crn_x, 0.0f, grid_size);
CLAMP(crn_y, 0.0f, grid_size);
if (n != NULL) {
interp_bilinear_grid(&key, grid_data[g_index + S], crn_x, crn_y, 0, n);
}
if (co != NULL) {
interp_bilinear_grid(&key, grid_data[g_index + S], crn_x, crn_y, 1, co);
}
}
/* mode = 0: interpolate normals,
* mode = 1: interpolate coord */
static void interp_bilinear_mpoly(DerivedMesh *dm,
MLoop *mloop,
MPoly *mpoly,
const float u,
const float v,
const int mode,
float res[3])
{
float data[4][3];
if (mode == 0) {
dm->getVertNo(dm, mloop[mpoly->loopstart].v, data[0]);
dm->getVertNo(dm, mloop[mpoly->loopstart + 1].v, data[1]);
dm->getVertNo(dm, mloop[mpoly->loopstart + 2].v, data[2]);
dm->getVertNo(dm, mloop[mpoly->loopstart + 3].v, data[3]);
}
else {
dm->getVertCo(dm, mloop[mpoly->loopstart].v, data[0]);
dm->getVertCo(dm, mloop[mpoly->loopstart + 1].v, data[1]);
dm->getVertCo(dm, mloop[mpoly->loopstart + 2].v, data[2]);
dm->getVertCo(dm, mloop[mpoly->loopstart + 3].v, data[3]);
}
interp_bilinear_quad_v3(data, u, v, res);
}
static void interp_barycentric_mlooptri(DerivedMesh *dm,
MLoop *mloop,
const MLoopTri *lt,
const float u,
const float v,
const int mode,
float res[3])
{
float data[3][3];
if (mode == 0) {
dm->getVertNo(dm, mloop[lt->tri[0]].v, data[0]);
dm->getVertNo(dm, mloop[lt->tri[1]].v, data[1]);
dm->getVertNo(dm, mloop[lt->tri[2]].v, data[2]);
}
else {
dm->getVertCo(dm, mloop[lt->tri[0]].v, data[0]);
dm->getVertCo(dm, mloop[lt->tri[1]].v, data[1]);
dm->getVertCo(dm, mloop[lt->tri[2]].v, data[2]);
}
interp_barycentric_tri_v3(data, u, v, res);
}
/* **************** Displacement Baker **************** */
static void *init_heights_data(MultiresBakeRender *bkr, Image *ima)
{
MHeightBakeData *height_data;
ImBuf *ibuf = BKE_image_acquire_ibuf(ima, NULL, NULL);
DerivedMesh *lodm = bkr->lores_dm;
BakeImBufuserData *userdata = ibuf->userdata;
if (userdata->displacement_buffer == NULL) {
userdata->displacement_buffer = MEM_callocN(sizeof(float) * ibuf->x * ibuf->y,
"MultiresBake heights");
}
height_data = MEM_callocN(sizeof(MHeightBakeData), "MultiresBake heightData");
height_data->ima = ima;
height_data->heights = userdata->displacement_buffer;
if (!bkr->use_lores_mesh) {
SubsurfModifierData smd = {{NULL}};
int ss_lvl = bkr->tot_lvl - bkr->lvl;
CLAMP(ss_lvl, 0, 6);
if (ss_lvl > 0) {
smd.levels = smd.renderLevels = ss_lvl;
smd.uv_smooth = SUBSURF_UV_SMOOTH_PRESERVE_BOUNDARIES;
smd.quality = 3;
height_data->ssdm = subsurf_make_derived_from_derived(
bkr->lores_dm, &smd, bkr->scene, NULL, 0);
init_ccgdm_arrays(height_data->ssdm);
}
}
height_data->orig_index_mp_to_orig = lodm->getPolyDataArray(lodm, CD_ORIGINDEX);
BKE_image_release_ibuf(ima, ibuf, NULL);
return (void *)height_data;
}
static void free_heights_data(void *bake_data)
{
MHeightBakeData *height_data = (MHeightBakeData *)bake_data;
if (height_data->ssdm) {
height_data->ssdm->release(height_data->ssdm);
}
MEM_freeN(height_data);
}
/* MultiresBake callback for heights baking
* general idea:
* - find coord of point with specified UV in hi-res mesh (let's call it p1)
* - find coord of point and normal with specified UV in lo-res mesh (or subdivided lo-res
* mesh to make texture smoother) let's call this point p0 and n.
* - height wound be dot(n, p1-p0) */
static void apply_heights_callback(DerivedMesh *lores_dm,
DerivedMesh *hires_dm,
void *thread_data_v,
void *bake_data,
ImBuf *ibuf,
const int tri_index,
const int lvl,
const float st[2],
float UNUSED(tangmat[3][3]),
const int x,
const int y)
{
const MLoopTri *lt = lores_dm->getLoopTriArray(lores_dm) + tri_index;
MLoop *mloop = lores_dm->getLoopArray(lores_dm);
MPoly *mpoly = lores_dm->getPolyArray(lores_dm) + lt->poly;
MLoopUV *mloopuv = lores_dm->getLoopDataArray(lores_dm, CD_MLOOPUV);
MHeightBakeData *height_data = (MHeightBakeData *)bake_data;
MultiresBakeThread *thread_data = (MultiresBakeThread *)thread_data_v;
float uv[2], *st0, *st1, *st2, *st3;
int pixel = ibuf->x * y + x;
float vec[3], p0[3], p1[3], n[3], len;
/* ideally we would work on triangles only, however, we rely on quads to get orthogonal
* coordinates for use in grid space (triangle barycentric is not orthogonal) */
if (mpoly->totloop == 4) {
st0 = mloopuv[mpoly->loopstart].uv;
st1 = mloopuv[mpoly->loopstart + 1].uv;
st2 = mloopuv[mpoly->loopstart + 2].uv;
st3 = mloopuv[mpoly->loopstart + 3].uv;
resolve_quad_uv_v2(uv, st, st0, st1, st2, st3);
}
else {
st0 = mloopuv[lt->tri[0]].uv;
st1 = mloopuv[lt->tri[1]].uv;
st2 = mloopuv[lt->tri[2]].uv;
resolve_tri_uv_v2(uv, st, st0, st1, st2);
}
clamp_v2(uv, 0.0f, 1.0f);
get_ccgdm_data(
lores_dm, hires_dm, height_data->orig_index_mp_to_orig, lvl, lt, uv[0], uv[1], p1, NULL);
if (height_data->ssdm) {
get_ccgdm_data(lores_dm,
height_data->ssdm,
height_data->orig_index_mp_to_orig,
0,
lt,
uv[0],
uv[1],
p0,
n);
}
else {
if (mpoly->totloop == 4) {
interp_bilinear_mpoly(lores_dm, mloop, mpoly, uv[0], uv[1], 1, p0);
interp_bilinear_mpoly(lores_dm, mloop, mpoly, uv[0], uv[1], 0, n);
}
else {
interp_barycentric_mlooptri(lores_dm, mloop, lt, uv[0], uv[1], 1, p0);
interp_barycentric_mlooptri(lores_dm, mloop, lt, uv[0], uv[1], 0, n);
}
}
sub_v3_v3v3(vec, p1, p0);
len = dot_v3v3(n, vec);
height_data->heights[pixel] = len;
thread_data->height_min = min_ff(thread_data->height_min, len);
thread_data->height_max = max_ff(thread_data->height_max, len);
if (ibuf->rect_float) {
float *rrgbf = ibuf->rect_float + pixel * 4;
rrgbf[0] = rrgbf[1] = rrgbf[2] = len;
rrgbf[3] = 1.0f;
}
else {
char *rrgb = (char *)ibuf->rect + pixel * 4;
rrgb[0] = rrgb[1] = rrgb[2] = unit_float_to_uchar_clamp(len);
rrgb[3] = 255;
}
}
/* **************** Normal Maps Baker **************** */
static void *init_normal_data(MultiresBakeRender *bkr, Image *UNUSED(ima))
{
MNormalBakeData *normal_data;
DerivedMesh *lodm = bkr->lores_dm;
normal_data = MEM_callocN(sizeof(MNormalBakeData), "MultiresBake normalData");
normal_data->orig_index_mp_to_orig = lodm->getPolyDataArray(lodm, CD_ORIGINDEX);
return (void *)normal_data;
}
static void free_normal_data(void *bake_data)
{
MNormalBakeData *normal_data = (MNormalBakeData *)bake_data;
MEM_freeN(normal_data);
}
/**
* MultiresBake callback for normals' baking.
*
* General idea:
* - Find coord and normal of point with specified UV in hi-res mesh.
* - Multiply it by tangmat.
* - Vector in color space would be `norm(vec) / 2 + (0.5, 0.5, 0.5)`.
*/
static void apply_tangmat_callback(DerivedMesh *lores_dm,
DerivedMesh *hires_dm,
void *UNUSED(thread_data),
void *bake_data,
ImBuf *ibuf,
const int tri_index,
const int lvl,
const float st[2],
float tangmat[3][3],
const int x,
const int y)
{
const MLoopTri *lt = lores_dm->getLoopTriArray(lores_dm) + tri_index;
MPoly *mpoly = lores_dm->getPolyArray(lores_dm) + lt->poly;
MLoopUV *mloopuv = lores_dm->getLoopDataArray(lores_dm, CD_MLOOPUV);
MNormalBakeData *normal_data = (MNormalBakeData *)bake_data;
float uv[2], *st0, *st1, *st2, *st3;
int pixel = ibuf->x * y + x;
float n[3], vec[3], tmp[3] = {0.5, 0.5, 0.5};
/* ideally we would work on triangles only, however, we rely on quads to get orthogonal
* coordinates for use in grid space (triangle barycentric is not orthogonal) */
if (mpoly->totloop == 4) {
st0 = mloopuv[mpoly->loopstart].uv;
st1 = mloopuv[mpoly->loopstart + 1].uv;
st2 = mloopuv[mpoly->loopstart + 2].uv;
st3 = mloopuv[mpoly->loopstart + 3].uv;
resolve_quad_uv_v2(uv, st, st0, st1, st2, st3);
}
else {
st0 = mloopuv[lt->tri[0]].uv;
st1 = mloopuv[lt->tri[1]].uv;
st2 = mloopuv[lt->tri[2]].uv;
resolve_tri_uv_v2(uv, st, st0, st1, st2);
}
clamp_v2(uv, 0.0f, 1.0f);
get_ccgdm_data(
lores_dm, hires_dm, normal_data->orig_index_mp_to_orig, lvl, lt, uv[0], uv[1], NULL, n);
mul_v3_m3v3(vec, tangmat, n);
normalize_v3_length(vec, 0.5);
add_v3_v3(vec, tmp);
if (ibuf->rect_float) {
float *rrgbf = ibuf->rect_float + pixel * 4;
rrgbf[0] = vec[0];
rrgbf[1] = vec[1];
rrgbf[2] = vec[2];
rrgbf[3] = 1.0f;
}
else {
unsigned char *rrgb = (unsigned char *)ibuf->rect + pixel * 4;
rgb_float_to_uchar(rrgb, vec);
rrgb[3] = 255;
}
}
/* TODO: restore ambient occlusion baking support, using BLI BVH? */
#if 0
/* **************** Ambient Occlusion Baker **************** */
/* Must be a power of two. */
# define MAX_NUMBER_OF_AO_RAYS 1024
static unsigned short ao_random_table_1[MAX_NUMBER_OF_AO_RAYS];
static unsigned short ao_random_table_2[MAX_NUMBER_OF_AO_RAYS];
static void init_ao_random(void)
{
int i;
for (i = 0; i < MAX_NUMBER_OF_AO_RAYS; i++) {
ao_random_table_1[i] = rand() & 0xffff;
ao_random_table_2[i] = rand() & 0xffff;
}
}
static unsigned short get_ao_random1(const int i)
{
return ao_random_table_1[i & (MAX_NUMBER_OF_AO_RAYS - 1)];
}
static unsigned short get_ao_random2(const int i)
{
return ao_random_table_2[i & (MAX_NUMBER_OF_AO_RAYS - 1)];
}
static void build_permutation_table(unsigned short permutation[],
unsigned short temp_permutation[],
const int number_of_rays,
const int is_first_perm_table)
{
int i, k;
for (i = 0; i < number_of_rays; i++) {
temp_permutation[i] = i;
}
for (i = 0; i < number_of_rays; i++) {
const unsigned int nr_entries_left = number_of_rays - i;
unsigned short rnd = is_first_perm_table != false ? get_ao_random1(i) : get_ao_random2(i);
const unsigned short entry = rnd % nr_entries_left;
/* pull entry */
permutation[i] = temp_permutation[entry];
/* delete entry */
for (k = entry; k < nr_entries_left - 1; k++) {
temp_permutation[k] = temp_permutation[k + 1];
}
}
/* verify permutation table
* every entry must appear exactly once
*/
# if 0
for (i = 0; i < number_of_rays; i++) temp_permutation[i] = 0;
for (i = 0; i < number_of_rays; i++) ++temp_permutation[permutation[i]];
for (i = 0; i < number_of_rays; i++) BLI_assert(temp_permutation[i] == 1);
# endif
}
static void create_ao_raytree(MultiresBakeRender *bkr, MAOBakeData *ao_data)
{
DerivedMesh *hidm = bkr->hires_dm;
RayObject *raytree;
RayFace *face;
CCGElem **grid_data;
CCGKey key;
int num_grids, grid_size /*, face_side */, num_faces;
int i;
num_grids = hidm->getNumGrids(hidm);
grid_size = hidm->getGridSize(hidm);
grid_data = hidm->getGridData(hidm);
hidm->getGridKey(hidm, &key);
/* face_side = (grid_size << 1) - 1; */ /* UNUSED */
num_faces = num_grids * (grid_size - 1) * (grid_size - 1);
raytree = ao_data->raytree = RE_rayobject_create(
bkr->raytrace_structure, num_faces, bkr->octree_resolution);
face = ao_data->rayfaces = (RayFace *)MEM_callocN(num_faces * sizeof(RayFace),
"ObjectRen faces");
for (i = 0; i < num_grids; i++) {
int x, y;
for (x = 0; x < grid_size - 1; x++) {
for (y = 0; y < grid_size - 1; y++) {
float co[4][3];
copy_v3_v3(co[0], CCG_grid_elem_co(&key, grid_data[i], x, y));
copy_v3_v3(co[1], CCG_grid_elem_co(&key, grid_data[i], x, y + 1));
copy_v3_v3(co[2], CCG_grid_elem_co(&key, grid_data[i], x + 1, y + 1));
copy_v3_v3(co[3], CCG_grid_elem_co(&key, grid_data[i], x + 1, y));
RE_rayface_from_coords(face, ao_data, face, co[0], co[1], co[2], co[3]);
RE_rayobject_add(raytree, RE_rayobject_unalignRayFace(face));
face++;
}
}
}
RE_rayobject_done(raytree);
}
static void *init_ao_data(MultiresBakeRender *bkr, Image *UNUSED(ima))
{
MAOBakeData *ao_data;
DerivedMesh *lodm = bkr->lores_dm;
unsigned short *temp_permutation_table;
size_t permutation_size;
init_ao_random();
ao_data = MEM_callocN(sizeof(MAOBakeData), "MultiresBake aoData");
ao_data->number_of_rays = bkr->number_of_rays;
ao_data->bias = bkr->bias;
ao_data->orig_index_mp_to_orig = lodm->getPolyDataArray(lodm, CD_ORIGINDEX);
create_ao_raytree(bkr, ao_data);
/* initialize permutation tables */
permutation_size = sizeof(unsigned short) * bkr->number_of_rays;
ao_data->permutation_table_1 = MEM_callocN(permutation_size, "multires AO baker perm1");
ao_data->permutation_table_2 = MEM_callocN(permutation_size, "multires AO baker perm2");
temp_permutation_table = MEM_callocN(permutation_size, "multires AO baker temp perm");
build_permutation_table(
ao_data->permutation_table_1, temp_permutation_table, bkr->number_of_rays, 1);
build_permutation_table(
ao_data->permutation_table_2, temp_permutation_table, bkr->number_of_rays, 0);
MEM_freeN(temp_permutation_table);
return (void *)ao_data;
}
static void free_ao_data(void *bake_data)
{
MAOBakeData *ao_data = (MAOBakeData *)bake_data;
RE_rayobject_free(ao_data->raytree);
MEM_freeN(ao_data->rayfaces);
MEM_freeN(ao_data->permutation_table_1);
MEM_freeN(ao_data->permutation_table_2);
MEM_freeN(ao_data);
}
/* builds an X and a Y axis from the given Z axis */
static void build_coordinate_frame(float axisX[3], float axisY[3], const float axisZ[3])
{
const float faX = fabsf(axisZ[0]);
const float faY = fabsf(axisZ[1]);
const float faZ = fabsf(axisZ[2]);
if (faX <= faY && faX <= faZ) {
const float len = sqrtf(axisZ[1] * axisZ[1] + axisZ[2] * axisZ[2]);
axisY[0] = 0;
axisY[1] = axisZ[2] / len;
axisY[2] = -axisZ[1] / len;
cross_v3_v3v3(axisX, axisY, axisZ);
}
else if (faY <= faZ) {
const float len = sqrtf(axisZ[0] * axisZ[0] + axisZ[2] * axisZ[2]);
axisX[0] = axisZ[2] / len;
axisX[1] = 0;
axisX[2] = -axisZ[0] / len;
cross_v3_v3v3(axisY, axisZ, axisX);
}
else {
const float len = sqrtf(axisZ[0] * axisZ[0] + axisZ[1] * axisZ[1]);
axisX[0] = axisZ[1] / len;
axisX[1] = -axisZ[0] / len;
axisX[2] = 0;
cross_v3_v3v3(axisY, axisZ, axisX);
}
}
/* return false if nothing was hit and true otherwise */
static int trace_ao_ray(MAOBakeData *ao_data, float ray_start[3], float ray_direction[3])
{
Isect isect = {{0}};
isect.dist = RE_RAYTRACE_MAXDIST;
copy_v3_v3(isect.start, ray_start);
copy_v3_v3(isect.dir, ray_direction);
isect.lay = -1;
normalize_v3(isect.dir);
return RE_rayobject_raycast(ao_data->raytree, &isect);
}
static void apply_ao_callback(DerivedMesh *lores_dm,
DerivedMesh *hires_dm,
void *UNUSED(thread_data),
void *bake_data,
ImBuf *ibuf,
const int tri_index,
const int lvl,
const float st[2],
float UNUSED(tangmat[3][3]),
const int x,
const int y)
{
const MLoopTri *lt = lores_dm->getLoopTriArray(lores_dm) + tri_index;
MPoly *mpoly = lores_dm->getPolyArray(lores_dm) + lt->poly;
MLoopUV *mloopuv = lores_dm->getLoopDataArray(lores_dm, CD_MLOOPUV);
MAOBakeData *ao_data = (MAOBakeData *)bake_data;
int i, k, perm_ofs;
float pos[3], nrm[3];
float cen[3];
float axisX[3], axisY[3], axisZ[3];
float shadow = 0;
float value;
int pixel = ibuf->x * y + x;
float uv[2], *st0, *st1, *st2, *st3;
/* ideally we would work on triangles only, however, we rely on quads to get orthogonal
* coordinates for use in grid space (triangle barycentric is not orthogonal) */
if (mpoly->totloop == 4) {
st0 = mloopuv[mpoly->loopstart].uv;
st1 = mloopuv[mpoly->loopstart + 1].uv;
st2 = mloopuv[mpoly->loopstart + 2].uv;
st3 = mloopuv[mpoly->loopstart + 3].uv;
resolve_quad_uv_v2(uv, st, st0, st1, st2, st3);
}
else {
st0 = mloopuv[lt->tri[0]].uv;
st1 = mloopuv[lt->tri[1]].uv;
st2 = mloopuv[lt->tri[2]].uv;
resolve_tri_uv_v2(uv, st, st0, st1, st2);
}
clamp_v2(uv, 0.0f, 1.0f);
get_ccgdm_data(
lores_dm, hires_dm, ao_data->orig_index_mp_to_orig, lvl, lt, uv[0], uv[1], pos, nrm);
/* offset ray origin by user bias along normal */
for (i = 0; i < 3; i++) {
cen[i] = pos[i] + ao_data->bias * nrm[i];
}
/* build tangent frame */
for (i = 0; i < 3; i++) {
axisZ[i] = nrm[i];
}
build_coordinate_frame(axisX, axisY, axisZ);
/* static noise */
perm_ofs = (get_ao_random2(get_ao_random1(x) + y)) & (MAX_NUMBER_OF_AO_RAYS - 1);
/* importance sample shadow rays (cosine weighted) */
for (i = 0; i < ao_data->number_of_rays; i++) {
int hit_something;
/* use N-Rooks to distribute our N ray samples across
* a multi-dimensional domain (2D)
*/
const unsigned short I =
ao_data->permutation_table_1[(i + perm_ofs) % ao_data->number_of_rays];
const unsigned short J = ao_data->permutation_table_2[i];
const float JitPh = (get_ao_random2(I + perm_ofs) & (MAX_NUMBER_OF_AO_RAYS - 1)) /
((float)MAX_NUMBER_OF_AO_RAYS);
const float JitTh = (get_ao_random1(J + perm_ofs) & (MAX_NUMBER_OF_AO_RAYS - 1)) /
((float)MAX_NUMBER_OF_AO_RAYS);
const float SiSqPhi = (I + JitPh) / ao_data->number_of_rays;
const float Theta = (float)(2 * M_PI) * ((J + JitTh) / ao_data->number_of_rays);
/* this gives results identical to the so-called cosine
* weighted distribution relative to the north pole.
*/
float SiPhi = sqrtf(SiSqPhi);
float CoPhi = SiSqPhi < 1.0f ? sqrtf(1.0f - SiSqPhi) : 0;
float CoThe = cosf(Theta);
float SiThe = sinf(Theta);
const float dx = CoThe * CoPhi;
const float dy = SiThe * CoPhi;
const float dz = SiPhi;
/* transform ray direction out of tangent frame */
float dv[3];
for (k = 0; k < 3; k++) {
dv[k] = axisX[k] * dx + axisY[k] * dy + axisZ[k] * dz;
}
hit_something = trace_ao_ray(ao_data, cen, dv);
if (hit_something != 0) {
shadow += 1;
}
}
value = 1.0f - (shadow / ao_data->number_of_rays);
if (ibuf->rect_float) {
float *rrgbf = ibuf->rect_float + pixel * 4;
rrgbf[0] = rrgbf[1] = rrgbf[2] = value;
rrgbf[3] = 1.0f;
}
else {
unsigned char *rrgb = (unsigned char *)ibuf->rect + pixel * 4;
rrgb[0] = rrgb[1] = rrgb[2] = unit_float_to_uchar_clamp(value);
rrgb[3] = 255;
}
}
#endif
/* ******$***************** Post processing ************************* */
static void bake_ibuf_filter(ImBuf *ibuf, char *mask, const int filter)
{
/* must check before filtering */
const bool is_new_alpha = (ibuf->planes != R_IMF_PLANES_RGBA) && BKE_imbuf_alpha_test(ibuf);
/* Margin */
if (filter) {
IMB_filter_extend(ibuf, mask, filter);
}
/* if the bake results in new alpha then change the image setting */
if (is_new_alpha) {
ibuf->planes = R_IMF_PLANES_RGBA;
}
else {
if (filter && ibuf->planes != R_IMF_PLANES_RGBA) {
/* clear alpha added by filtering */
IMB_rectfill_alpha(ibuf, 1.0f);
}
}
}
static void bake_ibuf_normalize_displacement(ImBuf *ibuf,
const float *displacement,
const char *mask,
float displacement_min,
float displacement_max)
{
int i;
const float *current_displacement = displacement;
const char *current_mask = mask;
float max_distance;
max_distance = max_ff(fabsf(displacement_min), fabsf(displacement_max));
for (i = 0; i < ibuf->x * ibuf->y; i++) {
if (*current_mask == FILTER_MASK_USED) {
float normalized_displacement;
if (max_distance > 1e-5f) {
normalized_displacement = (*current_displacement + max_distance) / (max_distance * 2);
}
else {
normalized_displacement = 0.5f;
}
if (ibuf->rect_float) {
/* currently baking happens to RGBA only */
float *fp = ibuf->rect_float + i * 4;
fp[0] = fp[1] = fp[2] = normalized_displacement;
fp[3] = 1.0f;
}
if (ibuf->rect) {
unsigned char *cp = (unsigned char *)(ibuf->rect + i);
cp[0] = cp[1] = cp[2] = unit_float_to_uchar_clamp(normalized_displacement);
cp[3] = 255;
}
}
current_displacement++;
current_mask++;
}
}
/* **************** Common functions public API relates on **************** */
static void count_images(MultiresBakeRender *bkr)
{
BLI_listbase_clear(&bkr->image);
bkr->tot_image = 0;
for (int i = 0; i < bkr->ob_image.len; i++) {
Image *ima = bkr->ob_image.array[i];
if (ima) {
ima->id.tag &= ~LIB_TAG_DOIT;
}
}
for (int i = 0; i < bkr->ob_image.len; i++) {
Image *ima = bkr->ob_image.array[i];
if (ima) {
if ((ima->id.tag & LIB_TAG_DOIT) == 0) {
LinkData *data = BLI_genericNodeN(ima);
BLI_addtail(&bkr->image, data);
bkr->tot_image++;
ima->id.tag |= LIB_TAG_DOIT;
}
}
}
for (int i = 0; i < bkr->ob_image.len; i++) {
Image *ima = bkr->ob_image.array[i];
if (ima) {
ima->id.tag &= ~LIB_TAG_DOIT;
}
}
}
static void bake_images(MultiresBakeRender *bkr, MultiresBakeResult *result)
{
LinkData *link;
for (link = bkr->image.first; link; link = link->next) {
Image *ima = (Image *)link->data;
ImBuf *ibuf = BKE_image_acquire_ibuf(ima, NULL, NULL);
if (ibuf->x > 0 && ibuf->y > 0) {
BakeImBufuserData *userdata = MEM_callocN(sizeof(BakeImBufuserData),
"MultiresBake userdata");
userdata->mask_buffer = MEM_callocN(ibuf->y * ibuf->x, "MultiresBake imbuf mask");
ibuf->userdata = userdata;
switch (bkr->mode) {
case RE_BAKE_NORMALS:
do_multires_bake(
bkr, ima, true, apply_tangmat_callback, init_normal_data, free_normal_data, result);
break;
case RE_BAKE_DISPLACEMENT:
do_multires_bake(bkr,
ima,
false,
apply_heights_callback,
init_heights_data,
free_heights_data,
result);
break;
/* TODO: restore ambient occlusion baking support. */
#if 0
case RE_BAKE_AO:
do_multires_bake(bkr, ima, false, apply_ao_callback, init_ao_data, free_ao_data, result);
break;
#endif
}
}
BKE_image_release_ibuf(ima, ibuf, NULL);
ima->id.tag |= LIB_TAG_DOIT;
}
}
static void finish_images(MultiresBakeRender *bkr, MultiresBakeResult *result)
{
LinkData *link;
bool use_displacement_buffer = bkr->mode == RE_BAKE_DISPLACEMENT;
for (link = bkr->image.first; link; link = link->next) {
Image *ima = (Image *)link->data;
ImBuf *ibuf = BKE_image_acquire_ibuf(ima, NULL, NULL);
BakeImBufuserData *userdata = (BakeImBufuserData *)ibuf->userdata;
if (ibuf->x <= 0 || ibuf->y <= 0) {
continue;
}
if (use_displacement_buffer) {
bake_ibuf_normalize_displacement(ibuf,
userdata->displacement_buffer,
userdata->mask_buffer,
result->height_min,
result->height_max);
}
bake_ibuf_filter(ibuf, userdata->mask_buffer, bkr->bake_filter);
ibuf->userflags |= IB_DISPLAY_BUFFER_INVALID;
BKE_image_mark_dirty(ima, ibuf);
if (ibuf->rect_float) {
ibuf->userflags |= IB_RECT_INVALID;
}
if (ibuf->mipmap[0]) {
ibuf->userflags |= IB_MIPMAP_INVALID;
imb_freemipmapImBuf(ibuf);
}
if (ibuf->userdata) {
if (userdata->displacement_buffer) {
MEM_freeN(userdata->displacement_buffer);
}
MEM_freeN(userdata->mask_buffer);
MEM_freeN(userdata);
ibuf->userdata = NULL;
}
BKE_image_release_ibuf(ima, ibuf, NULL);
DEG_id_tag_update(&ima->id, 0);
}
}
void RE_multires_bake_images(MultiresBakeRender *bkr)
{
MultiresBakeResult result;
count_images(bkr);
bake_images(bkr, &result);
finish_images(bkr, &result);
}
Reference in New Issue View Git Blame Copy Permalink