Differential D16893 Diff 58979 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
	float height_min, height_max;			float height_min, height_max;
	};			};

	struct MResolvePixelData {			struct MResolvePixelData {
	const float (*positions)[3];			const float (*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
	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->positions, r_normal);			BKE_mesh_calc_poly_normal(mp, &data->corner_verts[mp->loopstart], data->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 184 Lines • ▼ Show 20 Lines
	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
	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.positions = positions;			handle->data.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
	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
	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
	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