Differential D16893 Diff 59260 source/blender/render/intern/multires_bake.cc

Changeset View

Standalone View

source/blender/render/intern/multires_bake.cc

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Lines	struct MultiresBakeResult {
float height_min, height_max;		float height_min, height_max;
};		};

struct MResolvePixelData {		struct MResolvePixelData {
const float (*vert_positions)[3];		const float (*vert_positions)[3];
const float (*vert_normals)[3];		const float (*vert_normals)[3];
MPoly *mpoly;		MPoly *mpoly;
const int *material_indices;		const int *material_indices;
MLoop *mloop;		const int *corner_verts;
MLoopUV *mloopuv;		MLoopUV *mloopuv;
float uv_offset[2];		float uv_offset[2];
const MLoopTri *mlooptri;		const MLoopTri *mlooptri;
float *pvtangent;		float *pvtangent;
const float (*precomputed_normals)[3];		const float (*precomputed_normals)[3];
int w, h;		int w, h;
int tri_index;		int tri_index;
DerivedMesh lores_dm, hires_dm;		DerivedMesh lores_dm, hires_dm;
Show All 36 Lines	static void multiresbake_get_normal(const MResolvePixelData *data,
const int vert_index,		const int vert_index,
float r_normal[3])		float r_normal[3])
{		{
const int poly_index = data->mlooptri[tri_num].poly;		const int poly_index = data->mlooptri[tri_num].poly;
const MPoly *mp = &data->mpoly[poly_index];		const MPoly *mp = &data->mpoly[poly_index];
const bool smoothnormal = (mp->flag & ME_SMOOTH) != 0;		const bool smoothnormal = (mp->flag & ME_SMOOTH) != 0;

if (smoothnormal) {		if (smoothnormal) {
const int vi = data->mloop[data->mlooptri[tri_num].tri[vert_index]].v;		const int vi = data->corner_verts[data->mlooptri[tri_num].tri[vert_index]];
copy_v3_v3(r_normal, data->vert_normals[vi]);		copy_v3_v3(r_normal, data->vert_normals[vi]);
}		}
else {		else {
if (data->precomputed_normals) {		if (data->precomputed_normals) {
copy_v3_v3(r_normal, data->precomputed_normals[poly_index]);		copy_v3_v3(r_normal, data->precomputed_normals[poly_index]);
}		}
else {		else {
BKE_mesh_calc_poly_normal(mp, &data->mloop[mp->loopstart], data->vert_positions, r_normal);		BKE_mesh_calc_poly_normal(
		mp, &data->corner_verts[mp->loopstart], data->vert_positions, r_normal);
}		}
}		}
}		}

static void init_bake_rast(MBakeRast *bake_rast,		static void init_bake_rast(MBakeRast *bake_rast,
const ImBuf *ibuf,		const ImBuf *ibuf,
const MResolvePixelData *data,		const MResolvePixelData *data,
MFlushPixel flush_pixel,		MFlushPixel flush_pixel,
▲ Show 20 Lines • Show All 117 Lines • ▼ Show 20 Lines	static void rasterize_half(const MBakeRast *bake_rast,

for (y = y0; y < y1; y++) {		for (y = y0; y < y1; y++) {
/-b(x-x0) + a(y-y0) = 0 /		/-b(x-x0) + a(y-y0) = 0 /
int iXl, iXr, x;		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_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;		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) {		if (is_mid_right != 0) {
std::swap( x_l, x_r);		std::swap(x_l, x_r);
}		}

iXl = int(ceilf(x_l));		iXl = int(ceilf(x_l));
iXr = int(ceilf(x_r));		iXr = int(ceilf(x_r));

if (iXr > 0 && iXl < w) {		if (iXr > 0 && iXl < w) {
iXl = iXl < 0 ? 0 : iXl;		iXl = iXl < 0 ? 0 : iXl;
iXr = iXr >= w ? w : iXr;		iXr = iXr >= w ? w : iXr;
Show All 22 Lines	static void bake_rasterize(const MBakeRast *bake_rast,

/* skip degenerates */		/* skip degenerates */
if ((slo == smi && tlo == tmi) \|\| (slo == shi && tlo == thi) \|\| (smi == shi && tmi == thi)) {		if ((slo == smi && tlo == tmi) \|\| (slo == shi && tlo == thi) \|\| (smi == shi && tmi == thi)) {
return;		return;
}		}

/* sort by T */		/* sort by T */
if (tlo > tmi && tlo > thi) {		if (tlo > tmi && tlo > thi) {
std::swap( shi, slo);		std::swap(shi, slo);
std::swap( thi, tlo);		std::swap(thi, tlo);
}		}
else if (tmi > thi) {		else if (tmi > thi) {
std::swap( shi, smi);		std::swap(shi, smi);
std::swap( thi, tmi);		std::swap(thi, tmi);
}		}

if (tlo > tmi) {		if (tlo > tmi) {
std::swap( slo, smi);		std::swap(slo, smi);
std::swap( tlo, tmi);		std::swap(tlo, tmi);
}		}

/* check if mid point is to the left or to the right of the lo-hi edge */		/* 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;		is_mid_right = (-(shi - slo) * (tmi - thi) + (thi - tlo) * (smi - shi)) > 0 ? 1 : 0;
ylo = int(ceilf(tlo));		ylo = int(ceilf(tlo));
yhi_beg = int(ceilf(tmi));		yhi_beg = int(ceilf(tmi));
yhi = int(ceilf(thi));		yhi = int(ceilf(thi));

▲ Show 20 Lines • Show All 149 Lines • ▼ Show 20 Lines	if (tot_tri < 1) {
return;		return;
}		}

MultiresBakeThread *handles;		MultiresBakeThread *handles;
MultiresBakeQueue queue;		MultiresBakeQueue queue;

const float(positions)[3] = (float()[3])dm->getVertArray(dm);		const float(positions)[3] = (float()[3])dm->getVertArray(dm);
MPoly *mpoly = dm->getPolyArray(dm);		MPoly *mpoly = dm->getPolyArray(dm);
MLoop *mloop = dm->getLoopArray(dm);
MLoopUV mloopuv = static_cast<MLoopUV >(dm->getLoopDataArray(dm, CD_MLOOPUV));		MLoopUV mloopuv = static_cast<MLoopUV >(dm->getLoopDataArray(dm, CD_MLOOPUV));
float *pvtangent = nullptr;		float *pvtangent = NULL;

ListBase threads;		ListBase threads;
int i, tot_thread = bkr->threads > 0 ? bkr->threads : BLI_system_thread_count();		int i, tot_thread = bkr->threads > 0 ? bkr->threads : BLI_system_thread_count();

void *bake_data = nullptr;		void *bake_data = nullptr;

Mesh *temp_mesh = BKE_mesh_new_nomain(		Mesh *temp_mesh = BKE_mesh_new_nomain(
dm->getNumVerts(dm), dm->getNumEdges(dm), 0, dm->getNumLoops(dm), dm->getNumPolys(dm));		dm->getNumVerts(dm), dm->getNumEdges(dm), 0, dm->getNumLoops(dm), dm->getNumPolys(dm));
memcpy(temp_mesh->vert_positions_for_write().data(),		memcpy(temp_mesh->vert_positions_for_write().data(),
positions,		positions,
temp_mesh->totvert * sizeof(float[3]));		temp_mesh->totvert * sizeof(float[3]));
memcpy(BKE_mesh_edges_for_write(temp_mesh),		memcpy(BKE_mesh_edges_for_write(temp_mesh),
dm->getEdgeArray(dm),		dm->getEdgeArray(dm),
temp_mesh->totedge * sizeof(MEdge));		temp_mesh->totedge * sizeof(MEdge));
memcpy(BKE_mesh_polys_for_write(temp_mesh),		memcpy(BKE_mesh_polys_for_write(temp_mesh),
dm->getPolyArray(dm),		dm->getPolyArray(dm),
temp_mesh->totpoly * sizeof(MPoly));		temp_mesh->totpoly * sizeof(MPoly));
memcpy(BKE_mesh_loops_for_write(temp_mesh),		memcpy(BKE_mesh_corner_verts_for_write(temp_mesh),
dm->getLoopArray(dm),		dm->getCornerVertArray(dm),
temp_mesh->totloop * sizeof(MLoop));		temp_mesh->totloop * sizeof(int));
		memcpy(BKE_mesh_corner_edges_for_write(temp_mesh),
		dm->getCornerEdgeArray(dm),
		temp_mesh->totloop * sizeof(int));
const float(*vert_normals)[3] = BKE_mesh_vertex_normals_ensure(temp_mesh);		const float(*vert_normals)[3] = BKE_mesh_vertex_normals_ensure(temp_mesh);
const float(*poly_normals)[3] = BKE_mesh_poly_normals_ensure(temp_mesh);		const float(*poly_normals)[3] = BKE_mesh_poly_normals_ensure(temp_mesh);

if (require_tangent) {		if (require_tangent) {
if (CustomData_get_layer_index(&dm->loopData, CD_TANGENT) == -1) {		if (CustomData_get_layer_index(&dm->loopData, CD_TANGENT) == -1) {
BKE_mesh_calc_loop_tangent_ex(		BKE_mesh_calc_loop_tangent_ex(
positions,		positions,
dm->getPolyArray(dm),		dm->getPolyArray(dm),
dm->getNumPolys(dm),		dm->getNumPolys(dm),
dm->getLoopArray(dm),		dm->getCornerVertArray(dm),
dm->getLoopTriArray(dm),		dm->getLoopTriArray(dm),
dm->getNumLoopTri(dm),		dm->getNumLoopTri(dm),
&dm->loopData,		&dm->loopData,
true,		true,
nullptr,		nullptr,
0,		0,
vert_normals,		vert_normals,
poly_normals,		poly_normals,
Show All 37 Lines	for (i = 0; i < tot_thread; i++) {
handle->data.mpoly = mpoly;		handle->data.mpoly = mpoly;
handle->data.material_indices = static_cast<const int *>(		handle->data.material_indices = static_cast<const int *>(
CustomData_get_layer_named(&dm->polyData, CD_PROP_INT32, "material_index"));		CustomData_get_layer_named(&dm->polyData, CD_PROP_INT32, "material_index"));
handle->data.vert_positions = positions;		handle->data.vert_positions = positions;
handle->data.vert_normals = vert_normals;		handle->data.vert_normals = vert_normals;
handle->data.mloopuv = mloopuv;		handle->data.mloopuv = mloopuv;
BKE_image_get_tile_uv(ima, tile->tile_number, handle->data.uv_offset);		BKE_image_get_tile_uv(ima, tile->tile_number, handle->data.uv_offset);
handle->data.mlooptri = mlooptri;		handle->data.mlooptri = mlooptri;
handle->data.mloop = mloop;		handle->data.corner_verts = dm->getCornerVertArray(dm);
handle->data.pvtangent = pvtangent;		handle->data.pvtangent = pvtangent;
handle->data.precomputed_normals = poly_normals; /* don't strictly need this */		handle->data.precomputed_normals = poly_normals; /* don't strictly need this */
handle->data.w = ibuf->x;		handle->data.w = ibuf->x;
handle->data.h = ibuf->y;		handle->data.h = ibuf->y;
handle->data.lores_dm = dm;		handle->data.lores_dm = dm;
handle->data.hires_dm = bkr->hires_dm;		handle->data.hires_dm = bkr->hires_dm;
handle->data.lvl = lvl;		handle->data.lvl = lvl;
handle->data.pass_data = passKnownData;		handle->data.pass_data = passKnownData;
▲ Show 20 Lines • Show All 140 Lines • ▼ Show 20 Lines	if (co != nullptr) {
interp_bilinear_grid(&key, grid_data[g_index + S], crn_x, crn_y, 1, co);		interp_bilinear_grid(&key, grid_data[g_index + S], crn_x, crn_y, 1, co);
}		}
}		}

/* mode = 0: interpolate normals,		/* mode = 0: interpolate normals,
* mode = 1: interpolate coord */		* mode = 1: interpolate coord */

static void interp_bilinear_mpoly(DerivedMesh *dm,		static void interp_bilinear_mpoly(DerivedMesh *dm,
MLoop *mloop,		const int *corner_verts,
MPoly *mpoly,		MPoly *mpoly,
const float u,		const float u,
const float v,		const float v,
const int mode,		const int mode,
float res[3])		float res[3])
{		{
float data[4][3];		float data[4][3];

if (mode == 0) {		if (mode == 0) {
dm->getVertNo(dm, mloop[mpoly->loopstart].v, data[0]);		dm->getVertNo(dm, corner_verts[mpoly->loopstart], data[0]);
dm->getVertNo(dm, mloop[mpoly->loopstart + 1].v, data[1]);		dm->getVertNo(dm, corner_verts[mpoly->loopstart + 1], data[1]);
dm->getVertNo(dm, mloop[mpoly->loopstart + 2].v, data[2]);		dm->getVertNo(dm, corner_verts[mpoly->loopstart + 2], data[2]);
dm->getVertNo(dm, mloop[mpoly->loopstart + 3].v, data[3]);		dm->getVertNo(dm, corner_verts[mpoly->loopstart + 3], data[3]);
}		}
else {		else {
dm->getVertCo(dm, mloop[mpoly->loopstart].v, data[0]);		dm->getVertCo(dm, corner_verts[mpoly->loopstart], data[0]);
dm->getVertCo(dm, mloop[mpoly->loopstart + 1].v, data[1]);		dm->getVertCo(dm, corner_verts[mpoly->loopstart + 1], data[1]);
dm->getVertCo(dm, mloop[mpoly->loopstart + 2].v, data[2]);		dm->getVertCo(dm, corner_verts[mpoly->loopstart + 2], data[2]);
dm->getVertCo(dm, mloop[mpoly->loopstart + 3].v, data[3]);		dm->getVertCo(dm, corner_verts[mpoly->loopstart + 3], data[3]);
}		}

interp_bilinear_quad_v3(data, u, v, res);		interp_bilinear_quad_v3(data, u, v, res);
}		}

static void interp_barycentric_mlooptri(DerivedMesh *dm,		static void interp_barycentric_mlooptri(DerivedMesh *dm,
MLoop *mloop,		const int *corner_verts,
const MLoopTri *lt,		const MLoopTri *lt,
const float u,		const float u,
const float v,		const float v,
const int mode,		const int mode,
float res[3])		float res[3])
{		{
float data[3][3];		float data[3][3];

if (mode == 0) {		if (mode == 0) {
dm->getVertNo(dm, mloop[lt->tri[0]].v, data[0]);		dm->getVertNo(dm, corner_verts[lt->tri[0]], data[0]);
dm->getVertNo(dm, mloop[lt->tri[1]].v, data[1]);		dm->getVertNo(dm, corner_verts[lt->tri[1]], data[1]);
dm->getVertNo(dm, mloop[lt->tri[2]].v, data[2]);		dm->getVertNo(dm, corner_verts[lt->tri[2]], data[2]);
}		}
else {		else {
dm->getVertCo(dm, mloop[lt->tri[0]].v, data[0]);		dm->getVertCo(dm, corner_verts[lt->tri[0]], data[0]);
dm->getVertCo(dm, mloop[lt->tri[1]].v, data[1]);		dm->getVertCo(dm, corner_verts[lt->tri[1]], data[1]);
dm->getVertCo(dm, mloop[lt->tri[2]].v, data[2]);		dm->getVertCo(dm, corner_verts[lt->tri[2]], data[2]);
}		}

interp_barycentric_tri_v3(data, u, v, res);		interp_barycentric_tri_v3(data, u, v, res);
}		}

/* ************** Displacement Baker ************** */		/* ************** Displacement Baker ************** */

static void init_heights_data(MultiresBakeRender bkr, ImBuf *ibuf)		static void init_heights_data(MultiresBakeRender bkr, ImBuf *ibuf)
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Lines	static void apply_heights_callback(DerivedMesh *lores_dm,
const int tri_index,		const int tri_index,
const int lvl,		const int lvl,
const float st[2],		const float st[2],
float /tangmat/[3][3],		float /tangmat/[3][3],
const int x,		const int x,
const int y)		const int y)
{		{
const MLoopTri *lt = lores_dm->getLoopTriArray(lores_dm) + tri_index;		const MLoopTri *lt = lores_dm->getLoopTriArray(lores_dm) + tri_index;
MLoop *mloop = lores_dm->getLoopArray(lores_dm);		const int *corner_verts = lores_dm->getCornerVertArray(lores_dm);
MPoly *mpoly = lores_dm->getPolyArray(lores_dm) + lt->poly;		MPoly *mpoly = lores_dm->getPolyArray(lores_dm) + lt->poly;
MLoopUV mloopuv = static_cast<MLoopUV >(lores_dm->getLoopDataArray(lores_dm, CD_MLOOPUV));		MLoopUV mloopuv = static_cast<MLoopUV >(lores_dm->getLoopDataArray(lores_dm, CD_MLOOPUV));
MHeightBakeData height_data = (MHeightBakeData )bake_data;		MHeightBakeData height_data = (MHeightBakeData )bake_data;
MultiresBakeThread thread_data = (MultiresBakeThread )thread_data_v;		MultiresBakeThread thread_data = (MultiresBakeThread )thread_data_v;
float uv[2], st0, st1, st2, st3;		float uv[2], st0, st1, st2, st3;
int pixel = ibuf->x * y + x;		int pixel = ibuf->x * y + x;
float vec[3], p0[3], p1[3], n[3], len;		float vec[3], p0[3], p1[3], n[3], len;

Show All 26 Lines	get_ccgdm_data(lores_dm,
lt,		lt,
uv[0],		uv[0],
uv[1],		uv[1],
p0,		p0,
n);		n);
}		}
else {		else {
if (mpoly->totloop == 4) {		if (mpoly->totloop == 4) {
interp_bilinear_mpoly(lores_dm, mloop, mpoly, uv[0], uv[1], 1, p0);		interp_bilinear_mpoly(lores_dm, corner_verts, mpoly, uv[0], uv[1], 1, p0);
interp_bilinear_mpoly(lores_dm, mloop, mpoly, uv[0], uv[1], 0, n);		interp_bilinear_mpoly(lores_dm, corner_verts, mpoly, uv[0], uv[1], 0, n);
}		}
else {		else {
interp_barycentric_mlooptri(lores_dm, mloop, lt, uv[0], uv[1], 1, p0);		interp_barycentric_mlooptri(lores_dm, corner_verts, lt, uv[0], uv[1], 1, p0);
interp_barycentric_mlooptri(lores_dm, mloop, lt, uv[0], uv[1], 0, n);		interp_barycentric_mlooptri(lores_dm, corner_verts, lt, uv[0], uv[1], 0, n);
}		}
}		}

sub_v3_v3v3(vec, p1, p0);		sub_v3_v3v3(vec, p1, p0);
len = dot_v3v3(n, vec);		len = dot_v3v3(n, vec);

height_data->heights[pixel] = len;		height_data->heights[pixel] = len;

▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines