112namespace subdiv = bke::subdiv;
119template<
class T>
T interp_barycentric_triangle(
const T data[3],
const float2 &uv)
126 const float u,
const float v,
const T &p0,
const T &p1,
const T &p2,
const T &p3)
128 const float w0 = (1 - u) * (1 -
v);
129 const float w1 = u * (1 -
v);
130 const float w2 = u *
v;
131 const float w3 = (1 - u) *
v;
133 return p0 * w0 + p1 * w1 + p2 * w2 + p3 * w3;
149template<
class T>
class Grid {
153 T get_element(
const int x,
const int y)
const
160 Grid(
const Span<T>
data,
const int side_size) : data_(
data), side_size_(side_size)
167 const float2 xy = uv * (side_size_ - 1);
169 const int x0 = int(xy.
x);
170 const int x1 = x0 >= (side_size_ - 1) ? (side_size_ - 1) : (x0 + 1);
172 const int y0 = int(xy.
y);
173 const int y1 = y0 >= (side_size_ - 1) ? (side_size_ - 1) : (y0 + 1);
175 const float u = xy.
x - x0;
176 const float v = xy.
y - y0;
179 u,
v, get_element(x0, y0), get_element(x1, y0), get_element(x1, y1), get_element(x0, y1));
184Grid<T> get_subdiv_ccg_grid(
const SubdivCCG &subdiv_ccg,
const int grid_index,
const Span<T>
data)
186 const int64_t offset =
int64_t(grid_index) * subdiv_ccg.grid_area;
187 return Grid(
Span(
data.data() + offset, subdiv_ccg.grid_area), subdiv_ccg.grid_size);
190float3 sample_position_on_subdiv_ccg(
const SubdivCCG &subdiv_ccg,
191 const int grid_index,
194 const Grid<float3> grid = get_subdiv_ccg_grid(
195 subdiv_ccg, grid_index, subdiv_ccg.positions.as_span());
196 return grid.sample(grid_uv);
199float3 sample_normal_on_subdiv_ccg(
const SubdivCCG &subdiv_ccg,
200 const int grid_index,
205 const Grid<float3> grid = get_subdiv_ccg_grid(
206 subdiv_ccg, grid_index, subdiv_ccg.normals.as_span());
207 return grid.sample(grid_uv);
217 Span<float3> vert_positions;
218 Span<float3> vert_normals;
220 Span<int> corner_verts;
221 Span<int3> corner_tris;
222 Span<float3> corner_normals;
226 OffsetIndices<int> faces;
227 Span<float3> face_normals;
228 VArraySpan<bool> sharp_faces;
230 VArraySpan<float2> uv_map;
232 VArraySpan<int> material_indices;
234 MeshArrays() =
default;
236 explicit MeshArrays(
const Mesh &mesh)
238 bke::AttributeAccessor attributes = mesh.
attributes();
240 const StringRef active_uv_map = mesh.active_uv_map_name();
241 vert_positions = mesh.vert_positions();
242 vert_normals = mesh.vert_normals();
244 corner_verts = mesh.corner_verts();
245 corner_tris = mesh.corner_tris();
246 corner_normals = mesh.corner_normals();
248 tri_faces = mesh.corner_tri_faces();
250 faces = mesh.faces();
251 face_normals = mesh.face_normals();
256 material_indices = *attributes.lookup_or_default<
int>(
262static float2 face_center_tex_uv_calc(
const MeshArrays &mesh_arrays,
const int face_index)
264 const IndexRange &face = mesh_arrays.faces[face_index];
265 float2 tex_uv_acc(0.0f, 0.0f);
266 for (
const int corner : face) {
267 tex_uv_acc += mesh_arrays.uv_map[corner];
269 return tex_uv_acc / face.size();
275static float3 face_center_smooth_normal_calc(
const MeshArrays &mesh_arrays,
const int face_index)
277 const IndexRange &face = mesh_arrays.faces[face_index];
278 float3 normal_acc(0.0f, 0.0f, 0.0f);
279 for (
const int corner : face) {
280 normal_acc += mesh_arrays.vert_normals[mesh_arrays.corner_verts[corner]];
286 return normal_acc / face.size();
294 mesh_arrays.corner_verts,
295 mesh_arrays.corner_tris,
296 mesh_arrays.tri_faces,
297 mesh_arrays.sharp_faces,
298 mesh_arrays.vert_normals,
299 mesh_arrays.face_normals,
300 mesh_arrays.corner_normals,
301 {mesh_arrays.uv_map});
303 return tangent_data[0];
307static float4 face_center_uv_tangent_calc(
const MeshArrays &mesh_arrays,
308 const Span<float4> uv_tangents,
309 const int face_index)
311 const IndexRange &face = mesh_arrays.faces[face_index];
312 float4 tex_uv_acc(0.0f, 0.0f, 0.0f, 0.0f);
313 for (
const int corner : face) {
314 tex_uv_acc += uv_tangents[corner];
316 return tex_uv_acc / face.size();
326 Array<float> displacement_buffer;
327 Array<char> mask_buffer;
330struct RasterizeTile {
331 ImBuf *ibuf =
nullptr;
332 ExtraBuffers *extra_buffers =
nullptr;
336struct RasterizeTriangle {
354 bool has_uv_tangents;
359 return interp_barycentric_triangle(positions, uv);
371struct RasterizeQuad {
389 bool has_uv_tangents;
393struct RasterizeResult {
401 ExtraBuffers extra_buffers;
405struct MultiresBakeResult {
406 Vector<BakedImBuf> baked_ibufs;
412 const Mesh *highres_bake_mesh =
nullptr;
421 virtual ~MultiresBaker() =
default;
423 virtual float3 bake_pixel(
const RasterizeTriangle &triangle,
426 RasterizeResult &
result)
const = 0;
428 virtual void write_pixel(
const RasterizeTile &
tile,
430 const float3 &value)
const = 0;
433 void write_pixel_to_image_buffer(ImBuf &ibuf,
const int2 &coord,
const float3 &value)
const
437 if (ibuf.float_data()) {
440 float *rrgbf = ibuf.float_data_for_write() + pixel * 4;
447 if (ibuf.byte_data()) {
448 uchar *rrgb = ibuf.byte_data_for_write() + pixel * 4;
455static bool multiresbake_test_break(
const MultiresBakeRender &bake)
466static float2 get_tile_uv(Image &image, ImageTile &
tile)
473static bool need_tangent(
const MultiresBakeRender &bake)
481static float3x3 get_from_tangent_matrix_tbn(
const RasterizeTriangle &triangle,
484 if (!triangle.has_uv_tangents) {
488 const float u = bary_uv.
x;
489 const float v = bary_uv.
y;
490 const float w = 1 - u -
v;
492 const float3 &no0 = triangle.normals[0];
493 const float3 &no1 = triangle.normals[1];
494 const float3 &no2 = triangle.normals[2];
496 const float4 &tang0 = triangle.uv_tangents[0];
497 const float4 &tang1 = triangle.uv_tangents[1];
498 const float4 &tang2 = triangle.uv_tangents[2];
502 const float sign = (tang0.
w * u + tang1.
w *
v + tang2.
w *
w) < 0 ? (-1.0f) : 1.0f;
508 from_tangent.
x = tang0.xyz() * u + tang1.xyz() *
v + tang2.xyz() *
w;
509 from_tangent.
z = no0.xyz() * u + no1.xyz() *
v + no2.xyz() *
w;
517static float3x3 get_to_tangent_matrix_tbn(
const RasterizeTriangle &triangle,
const float2 &bary_uv)
519 const float3x3 from_tangent = get_from_tangent_matrix_tbn(triangle, bary_uv);
525static float3x3 get_to_tangent_matrix_tnb(
const RasterizeTriangle &triangle,
const float2 &bary_uv)
527 float3x3 from_tangent = get_from_tangent_matrix_tbn(triangle, bary_uv);
528 std::swap(from_tangent.
y, from_tangent.
z);
538static void flush_pixel(
const MultiresBaker &baker,
539 const RasterizeTile &
tile,
540 const RasterizeTriangle &triangle,
547 const float2 bary_uv = resolve_tri_uv(
548 st, triangle.tex_uvs[0], triangle.tex_uvs[1], triangle.tex_uvs[2]);
549 const float2 grid_uv = interp_barycentric_triangle(triangle.grid_uvs, bary_uv);
551 const float3 baked_pixel = baker.bake_pixel(triangle, bary_uv, grid_uv,
result);
552 baker.write_pixel(
tile,
int2(
x,
y), baked_pixel);
555static void set_rast_triangle(
const MultiresBaker &baker,
556 const RasterizeTile &
tile,
557 const RasterizeTriangle &triangle,
562 const int w =
tile.ibuf->
x;
563 const int h =
tile.ibuf->
y;
574static void rasterize_half(
const MultiresBaker &baker,
575 const RasterizeTile &
tile,
576 const RasterizeTriangle &triangle,
583 const bool is_mid_right,
588 const int w =
tile.ibuf->
x;
589 const int h =
tile.ibuf->
y;
591 if (y1_in <= 0 || y0_in >= h) {
595 const int y0 = y0_in < 0 ? 0 : y0_in;
596 const int y1 = y1_in >= h ? h : y1_in;
598 for (
int y = y0;
y < y1;
y++) {
600 float x_l = s_stable ? (s0.
x + (((s1.
x - s0.
x) * (
y - s0.
y)) / (s1.
y - s0.
y))) : s0.
x;
601 float x_r = l_stable ? (l0.
x + (((l1.
x - l0.
x) * (
y - l0.
y)) / (l1.
y - l0.
y))) : l0.
x;
606 int iXl = int(
ceilf(x_l));
607 int iXr = int(
ceilf(x_r));
609 if (iXr > 0 && iXl <
w) {
610 iXl = iXl < 0 ? 0 : iXl;
611 iXr = iXr >=
w ?
w : iXr;
613 for (
int x = iXl;
x < iXr;
x++) {
620static void rasterize_triangle(
const MultiresBaker &baker,
621 const RasterizeTile &
tile,
622 const RasterizeTriangle &triangle,
627 const float2 &st0_in = triangle.tex_uvs[0];
628 const float2 &st1_in = triangle.tex_uvs[1];
629 const float2 &st2_in = triangle.tex_uvs[2];
631 float2 p_low = st0_in * ibuf_size - 0.5f;
632 float2 p_mid = st1_in * ibuf_size - 0.5f;
633 float2 p_high = st2_in * ibuf_size - 0.5f;
636 if ((p_low.
x == p_mid.
x && p_low.
y == p_mid.
y) || (p_low.
x == p_mid.
x && p_low.
y == p_high.
y) ||
637 (p_mid.
x == p_high.
x && p_mid.
y == p_high.
y))
643 if (p_low.
y > p_mid.
y && p_low.
y > p_high.
y) {
644 std::swap(p_high.
x, p_low.
x);
645 std::swap(p_high.
y, p_low.
y);
647 else if (p_mid.
y > p_high.
y) {
648 std::swap(p_high.
x, p_mid.
x);
649 std::swap(p_high.
y, p_mid.
y);
652 if (p_low.
y > p_mid.
y) {
653 std::swap(p_low.
x, p_mid.
x);
654 std::swap(p_low.
y, p_mid.
y);
658 const bool is_mid_right =
math::cross(p_mid - p_high, p_high - p_low) > 0;
659 const int ylo = int(
ceilf(p_low.
y));
660 const int yhi_beg = int(
ceilf(p_mid.
y));
661 const int yhi = int(
ceilf(p_high.
y));
664 baker,
tile, triangle, p_low, p_mid, p_low, p_high, ylo, yhi_beg, is_mid_right,
result);
666 baker,
tile, triangle, p_mid, p_high, p_low, p_high, yhi_beg, yhi, is_mid_right,
result);
669static void rasterize_quad(
const MultiresBaker &baker,
670 const RasterizeTile &
tile,
671 const RasterizeQuad &quad,
674 RasterizeTriangle triangle;
675 triangle.grid_index = quad.grid_index;
676 triangle.is_flat = quad.is_flat;
677 triangle.has_uv_tangents = quad.has_uv_tangents;
679 const int3 quad_split_data[2] = {{0, 1, 2}, {2, 3, 0}};
680 for (
const int3 &triangle_idx :
Span(quad_split_data, 2)) {
681 triangle.grid_uvs[0] = quad.grid_uvs[triangle_idx.x];
682 triangle.grid_uvs[1] = quad.grid_uvs[triangle_idx.y];
683 triangle.grid_uvs[2] = quad.grid_uvs[triangle_idx.z];
685 triangle.tex_uvs[0] = quad.tex_uvs[triangle_idx.x];
686 triangle.tex_uvs[1] = quad.tex_uvs[triangle_idx.y];
687 triangle.tex_uvs[2] = quad.tex_uvs[triangle_idx.z];
689 triangle.positions[0] = quad.positions[triangle_idx.x];
690 triangle.positions[1] = quad.positions[triangle_idx.y];
691 triangle.positions[2] = quad.positions[triangle_idx.z];
693 triangle.normals[0] = quad.normals[triangle_idx.x];
694 triangle.normals[1] = quad.normals[triangle_idx.y];
695 triangle.normals[2] = quad.normals[triangle_idx.z];
697 if (triangle.has_uv_tangents) {
698 triangle.uv_tangents[0] = quad.uv_tangents[triangle_idx.x];
699 triangle.uv_tangents[1] = quad.uv_tangents[triangle_idx.y];
700 triangle.uv_tangents[2] = quad.uv_tangents[triangle_idx.z];
703 rasterize_triangle(baker,
tile, triangle,
result);
713class MultiresDisplacementBaker :
public MultiresBaker {
714 const SubdivCCG &high_subdiv_ccg_;
717 MultiresDisplacementBaker(
const SubdivCCG &subdiv_ccg,
719 ExtraBuffers &extra_buffers)
720 : high_subdiv_ccg_(subdiv_ccg)
723 extra_buffers.displacement_buffer.fill(0);
726 float3 bake_pixel(
const RasterizeTriangle &triangle,
729 RasterizeResult &
result)
const override
731 const float3 bake_level_position = triangle.get_position(bary_uv);
732 const float3 bake_level_normal = triangle.get_normal(bary_uv);
733 const float3 high_level_position = sample_position_on_subdiv_ccg(
734 high_subdiv_ccg_, triangle.grid_index, grid_uv);
736 const float length =
math::dot(bake_level_normal, (high_level_position - bake_level_position));
744 void write_pixel(
const RasterizeTile &
tile,
746 const float3 &value)
const override
748 const ImBuf &ibuf = *
tile.ibuf;
751 tile.extra_buffers->displacement_buffer[pixel] = value.
x;
753 write_pixel_to_image_buffer(*
tile.ibuf, coord, value);
757class MultiresVectorDisplacementBaker :
public MultiresBaker {
758 const SubdivCCG &high_subdiv_ccg_;
762 MultiresVectorDisplacementBaker(
const SubdivCCG &subdiv_ccg,
const eBakeSpace space)
763 : high_subdiv_ccg_(subdiv_ccg), space_(space)
767 float3 bake_pixel(
const RasterizeTriangle &triangle,
770 RasterizeResult & )
const override
772 const float3 bake_level_position = triangle.get_position(bary_uv);
774 const float3 high_level_position = sample_position_on_subdiv_ccg(
775 high_subdiv_ccg_, triangle.grid_index, grid_uv);
777 const float3 displacement = high_level_position - bake_level_position;
780 const float3x3 to_tangent = get_to_tangent_matrix_tnb(triangle, bary_uv);
781 return to_tangent * displacement;
787 void write_pixel(
const RasterizeTile &
tile,
789 const float3 &value)
const override
791 write_pixel_to_image_buffer(*
tile.ibuf, coord, value);
801class MultiresNormalsBaker :
public MultiresBaker {
802 const SubdivCCG &subdiv_ccg_;
805 explicit MultiresNormalsBaker(
const SubdivCCG &subdiv_ccg) : subdiv_ccg_(subdiv_ccg) {}
807 float3 bake_pixel(
const RasterizeTriangle &triangle,
810 RasterizeResult & )
const override
812 const float3x3 to_tangent = get_to_tangent_matrix_tbn(triangle, bary_uv);
813 const float3 normal = sample_normal_on_subdiv_ccg(subdiv_ccg_, triangle.grid_index, grid_uv);
817 void write_pixel(
const RasterizeTile &
tile,
819 const float3 &value)
const override
821 write_pixel_to_image_buffer(*
tile.ibuf, coord, value);
831static void initialize_images(MultiresBakeRender &bake)
835 for (Image *image : bake.ob_image) {
837 bake.images.add(image);
848static std::unique_ptr<MultiresBaker> create_baker(
const MultiresBakeRender &bake,
849 const SubdivCCG &subdiv_ccg,
851 ExtraBuffers &extra_buffers)
855 return std::make_unique<MultiresNormalsBaker>(subdiv_ccg);
857 return std::make_unique<MultiresDisplacementBaker>(subdiv_ccg, ibuf, extra_buffers);
859 return std::make_unique<MultiresVectorDisplacementBaker>(subdiv_ccg,
860 bake.displacement_space);
869static void rasterize_base_face(
const MultiresBaker &baker,
870 const RasterizeTile &
tile,
871 const MeshArrays &mesh_arrays,
872 const Span<float4> uv_tangents,
873 const int face_index,
876 const IndexRange &face = mesh_arrays.faces[face_index];
877 const Span<int> face_verts = mesh_arrays.corner_verts.slice(face);
886 quad.grid_uvs[0] =
float2(0.0f, 0.0f);
887 quad.grid_uvs[1] =
float2(1.0f, 0.0f);
888 quad.grid_uvs[2] =
float2(1.0f, 1.0f);
889 quad.grid_uvs[3] =
float2(0.0f, 1.0f);
891 quad.tex_uvs[0] = face_center_tex_uv_calc(mesh_arrays, face_index) -
tile.uv_offset;
896 quad.is_flat = mesh_arrays.sharp_faces[face_index];
898 quad.normals[0] = mesh_arrays.face_normals[face_index];
901 quad.normals[0] = face_center_smooth_normal_calc(mesh_arrays, face_index);
904 quad.has_uv_tangents = !uv_tangents.
is_empty();
905 if (quad.has_uv_tangents) {
906 quad.uv_tangents[0] = face_center_uv_tangent_calc(mesh_arrays, uv_tangents, face_index);
909 for (
const int corner : face) {
913 const float3 &
position = mesh_arrays.vert_positions[mesh_arrays.corner_verts[corner]];
914 const float3 &next_position =
915 mesh_arrays.vert_positions[mesh_arrays.corner_verts[next_corner]];
916 const float3 &prev_position =
917 mesh_arrays.vert_positions[mesh_arrays.corner_verts[prev_corner]];
919 quad.grid_index = corner;
921 quad.tex_uvs[1] = (mesh_arrays.uv_map[corner] + mesh_arrays.uv_map[next_corner]) * 0.5f -
923 quad.tex_uvs[2] = mesh_arrays.uv_map[corner] -
tile.uv_offset;
924 quad.tex_uvs[3] = (mesh_arrays.uv_map[prev_corner] + mesh_arrays.uv_map[corner]) * 0.5f -
927 quad.positions[1] = (
position + next_position) * 0.5f;
929 quad.positions[3] = (prev_position +
position) * 0.5f;
932 quad.normals[1] = quad.normals[0];
933 quad.normals[2] = quad.normals[0];
934 quad.normals[3] = quad.normals[0];
937 const float3 &normal = mesh_arrays.vert_normals[mesh_arrays.corner_verts[corner]];
938 const float3 &next_normal = mesh_arrays.vert_normals[mesh_arrays.corner_verts[next_corner]];
939 const float3 &prev_normal = mesh_arrays.vert_normals[mesh_arrays.corner_verts[prev_corner]];
945 quad.normals[1] = (normal + next_normal) * 0.5f;
946 quad.normals[2] = normal;
947 quad.normals[3] = (prev_normal + normal) * 0.5f;
950 if (quad.has_uv_tangents) {
951 const float4 &tangent = uv_tangents[corner];
952 const float4 &next_tangent = uv_tangents[next_corner];
953 const float4 &prev_tangent = uv_tangents[prev_corner];
955 quad.uv_tangents[1] = (tangent + next_tangent) * 0.5f;
956 quad.uv_tangents[2] = tangent;
957 quad.uv_tangents[3] = (prev_tangent + tangent) * 0.5f;
964static void bake_single_image_to_base_mesh(MultiresBakeRender &bake,
965 const Mesh &bake_level_mesh,
966 const SubdivCCG &subdiv_ccg,
968 ImageTile &image_tile,
970 ExtraBuffers &extra_buffers,
971 MultiresBakeResult &
result)
973 std::unique_ptr<MultiresBaker> baker = create_baker(bake, subdiv_ccg, ibuf, extra_buffers);
978 MeshArrays mesh_arrays(bake_level_mesh);
979 Array<float4> uv_tangents;
980 if (need_tangent(bake)) {
986 tile.extra_buffers = &extra_buffers;
987 tile.uv_offset = get_tile_uv(image, image_tile);
991 std::atomic<int> num_baked_faces = 0;
993 for (const int64_t face_index : range) {
994 if (multiresbake_test_break(bake)) {
999 const int mat_nr = mesh_arrays.material_indices[face_index];
1000 const Image *face_image = mat_nr < bake.ob_image.size() ? bake.ob_image[mat_nr] : nullptr;
1001 if (face_image != &image) {
1005 RasterizeResult rasterize_result;
1006 rasterize_base_face(*baker, tile, mesh_arrays, uv_tangents, face_index, rasterize_result);
1009 BLI_spin_lock(&spin_lock);
1010 result.height_min = std::min(result.height_min, rasterize_result.height_min);
1011 result.height_max = std::max(result.height_max, rasterize_result.height_max);
1012 if (bake.do_update) {
1013 *bake.do_update = true;
1015 if (bake.progress) {
1016 *bake.progress = (float(bake.num_baked_objects) +
1017 float(num_baked_faces) / mesh_arrays.faces.size()) /
1018 bake.num_total_objects;
1020 BLI_spin_unlock(&spin_lock);
1037static Array<GridCoord> get_subdivided_corner_grid_coords(subdiv::Subdiv &subdiv,
1038 const Mesh &coarse_mesh,
1041 struct SubdividedCornerGridCoordData {
1042 MeshArrays coarse_mesh_arrays;
1043 Array<GridCoord> corner_grid_coords;
1046 subdiv::ToMeshSettings mesh_settings;
1047 mesh_settings.resolution = (1 << level) + 1;
1049 SubdividedCornerGridCoordData
data;
1050 data.coarse_mesh_arrays = MeshArrays(coarse_mesh);
1052 subdiv::ForeachContext foreach_context;
1053 foreach_context.user_data = &
data;
1055 foreach_context.topology_info = [](
const subdiv::ForeachContext *
context,
1058 const int num_corners,
1060 const Span<int> ) ->
bool {
1061 SubdividedCornerGridCoordData *
data =
static_cast<SubdividedCornerGridCoordData *
>(
1063 data->corner_grid_coords.reinitialize(num_corners);
1067 foreach_context.loop = [](
const subdiv::ForeachContext *
context,
1073 const int coarse_face_index,
1074 const int coarse_corner,
1075 const int subdiv_corner_index,
1078 SubdividedCornerGridCoordData *
data =
static_cast<SubdividedCornerGridCoordData *
>(
1082 const IndexRange coarse_face =
data->coarse_mesh_arrays.faces[coarse_face_index];
1084 GridCoord &corner_grid_coord =
data->corner_grid_coords[subdiv_corner_index];
1085 corner_grid_coord.grid_index = coarse_face.start() + coarse_corner;
1087 if (coarse_face.size() == 4) {
1098 return data.corner_grid_coords;
1101static void rasterize_subdivided_face(
const MultiresBaker &baker,
1102 const RasterizeTile &
tile,
1103 const MeshArrays &mesh_arrays,
1104 const Span<GridCoord> &corner_grid_coords,
1105 const Span<float4> uv_tangents,
1106 const int face_index,
1109 const IndexRange &face = mesh_arrays.faces[face_index];
1119 quad.is_flat = mesh_arrays.sharp_faces[face_index];
1120 quad.has_uv_tangents = !uv_tangents.
is_empty();
1121 quad.grid_index = corner_grid_coords[face.start()].grid_index;
1123 for (
int i = 0; i < 4; ++i) {
1124 const int corner = face[i];
1125 const int vert = mesh_arrays.corner_verts[corner];
1127 BLI_assert(corner_grid_coords[corner].grid_index == quad.grid_index);
1128 quad.grid_uvs[i] = corner_grid_coords[corner].uv;
1130 quad.tex_uvs[i] = mesh_arrays.uv_map[corner] -
tile.uv_offset;
1131 quad.positions[i] = mesh_arrays.vert_positions[
vert];
1132 if (!quad.is_flat) {
1133 quad.normals[i] = mesh_arrays.vert_normals[
vert];
1136 if (quad.has_uv_tangents) {
1137 quad.uv_tangents[i] = uv_tangents[corner];
1142 quad.normals[0] = mesh_arrays.face_normals[face_index];
1143 quad.normals[1] = quad.normals[0];
1144 quad.normals[2] = quad.normals[0];
1145 quad.normals[3] = quad.normals[0];
1151static void bake_single_image_to_subdivided_mesh(MultiresBakeRender &bake,
1152 const Mesh &bake_level_mesh,
1153 const SubdivCCG &subdiv_ccg,
1155 ImageTile &image_tile,
1157 ExtraBuffers &extra_buffers,
1158 MultiresBakeResult &
result)
1160 std::unique_ptr<MultiresBaker> baker = create_baker(bake, subdiv_ccg, ibuf, extra_buffers);
1165 MeshArrays mesh_arrays(bake_level_mesh);
1166 Array<float4> uv_tangents;
1167 if (need_tangent(bake)) {
1173 tile.extra_buffers = &extra_buffers;
1174 tile.uv_offset = get_tile_uv(image, image_tile);
1176 const Array<GridCoord> corner_grid_coords = get_subdivided_corner_grid_coords(
1177 *subdiv_ccg.subdiv, *bake.base_mesh, bake.multires_modifier->lvl);
1181 std::atomic<int> num_baked_faces = 0;
1183 for (const int64_t face_index : range) {
1184 if (multiresbake_test_break(bake)) {
1189 const int mat_nr = mesh_arrays.material_indices[face_index];
1190 const Image *face_image = mat_nr < bake.ob_image.size() ? bake.ob_image[mat_nr] : nullptr;
1191 if (face_image != &image) {
1195 RasterizeResult rasterize_result;
1196 rasterize_subdivided_face(*baker,
1205 BLI_spin_lock(&spin_lock);
1206 result.height_min = std::min(result.height_min, rasterize_result.height_min);
1207 result.height_max = std::max(result.height_max, rasterize_result.height_max);
1208 if (bake.do_update) {
1209 *bake.do_update = true;
1211 if (bake.progress) {
1212 *bake.progress = (float(bake.num_baked_objects) +
1213 float(num_baked_faces) / mesh_arrays.faces.size()) /
1214 bake.num_total_objects;
1216 BLI_spin_unlock(&spin_lock);
1232static const Mesh *create_highres_mesh(
const Mesh &bake_level_mesh,
1235 const int top_level = multires_modifier.totlvl;
1236 const int bake_level = multires_modifier.lvl;
1237 const int subdivide_level = top_level - bake_level;
1238 if (subdivide_level == 0) {
1239 return &bake_level_mesh;
1242 subdiv::Settings subdiv_settings;
1246 subdiv::ToMeshSettings mesh_settings;
1247 mesh_settings.resolution = (1 << subdivide_level) + 1;
1260 const Mesh &base_mesh,
1261 const Mesh &bake_level_mesh,
1262 const Mesh &highres_bake_mesh)
1266 if (multires_modifier.lvl == 0) {
1268 return get_subdivided_corner_grid_coords(
1269 subdiv, bake_level_mesh, multires_modifier.totlvl - multires_modifier.lvl);
1289 struct HighresCornerGridCoordData {
1290 MeshArrays bake_level_mesh_arrays;
1291 Array<GridCoord> bake_level_corner_grid_coords;
1293 Array<GridCoord> corner_grid_coords;
1296 const int top_level = multires_modifier.totlvl;
1297 const int bake_level = multires_modifier.lvl;
1298 const int subdivide_level = top_level - bake_level;
1300 subdiv::ToMeshSettings mesh_settings;
1301 mesh_settings.resolution = (1 << subdivide_level) + 1;
1303 HighresCornerGridCoordData
data;
1304 data.bake_level_mesh_arrays = MeshArrays(bake_level_mesh);
1305 data.bake_level_corner_grid_coords = get_subdivided_corner_grid_coords(
1306 subdiv, base_mesh, multires_modifier.lvl);
1308 subdiv::ForeachContext foreach_context;
1309 foreach_context.user_data = &
data;
1311 foreach_context.topology_info = [](
const subdiv::ForeachContext *
context,
1314 const int num_corners,
1317 HighresCornerGridCoordData *
data =
static_cast<HighresCornerGridCoordData *
>(
1319 data->corner_grid_coords.reinitialize(num_corners);
1323 foreach_context.loop = [](
const subdiv::ForeachContext *
context,
1329 const int bake_level_face_index,
1331 const int highres_corner_index,
1334 HighresCornerGridCoordData *
data =
static_cast<HighresCornerGridCoordData *
>(
1337 const Span<GridCoord> bake_level_corner_grid_coords =
data->bake_level_corner_grid_coords;
1339 const IndexRange bake_level_face =
data->bake_level_mesh_arrays.faces[bake_level_face_index];
1342 const int bake_level_face_start = bake_level_face.start();
1344 GridCoord &corner_grid_coord =
data->corner_grid_coords[highres_corner_index];
1345 corner_grid_coord.grid_index = bake_level_corner_grid_coords[bake_level_face_start].grid_index;
1349 bake_level_corner_grid_coords[bake_level_face_start + 0].uv,
1350 bake_level_corner_grid_coords[bake_level_face_start + 1].uv,
1351 bake_level_corner_grid_coords[bake_level_face_start + 2].uv,
1352 bake_level_corner_grid_coords[bake_level_face_start + 3].uv);
1356 bake_level_corner_grid_coords[bake_level_face_start + 1].grid_index);
1358 bake_level_corner_grid_coords[bake_level_face_start + 2].grid_index);
1360 bake_level_corner_grid_coords[bake_level_face_start + 3].grid_index);
1365 BLI_assert(
data.corner_grid_coords.size() == highres_bake_mesh.corners_num);
1366 return data.corner_grid_coords;
1370 const Mesh &bake_level_mesh,
1375 ExtraBuffers &extra_buffers,
1376 MultiresBakeResult &
result)
1378 std::unique_ptr<MultiresBaker> baker = create_baker(
bake, subdiv_ccg, ibuf, extra_buffers);
1383 const Mesh *highres_bake_mesh =
result.highres_bake_mesh;
1384 if (!highres_bake_mesh) {
1385 highres_bake_mesh = create_highres_mesh(bake_level_mesh, *
bake.multires_modifier);
1386 result.highres_bake_mesh = highres_bake_mesh;
1389 const Array<GridCoord> corner_grid_coords = get_highres_mesh_loop_grid_coords(
1391 *
bake.multires_modifier,
1394 *highres_bake_mesh);
1396 MeshArrays mesh_arrays(*highres_bake_mesh);
1398 if (need_tangent(
bake)) {
1404 tile.extra_buffers = &extra_buffers;
1405 tile.uv_offset = get_tile_uv(
image, image_tile);
1409 std::atomic<int> num_baked_faces = 0;
1411 for (const int64_t face_index : range) {
1412 if (multiresbake_test_break(bake)) {
1417 const int mat_nr = mesh_arrays.material_indices[face_index];
1418 const Image *face_image = mat_nr < bake.ob_image.size() ? bake.ob_image[mat_nr] : nullptr;
1419 if (face_image != &image) {
1423 RasterizeResult rasterize_result;
1424 rasterize_subdivided_face(*baker,
1433 BLI_spin_lock(&spin_lock);
1434 result.height_min = std::min(result.height_min, rasterize_result.height_min);
1435 result.height_max = std::max(result.height_max, rasterize_result.height_max);
1436 if (bake.do_update) {
1437 *bake.do_update = true;
1439 if (bake.progress) {
1440 *bake.progress = (float(bake.num_baked_objects) +
1441 float(num_baked_faces) / mesh_arrays.faces.size()) /
1442 bake.num_total_objects;
1444 BLI_spin_unlock(&spin_lock);
1456static void bake_single_image(MultiresBakeRender &bake,
1457 const Mesh &bake_level_mesh,
1458 const SubdivCCG &subdiv_ccg,
1460 ImageTile &image_tile,
1462 ExtraBuffers &extra_buffers,
1463 MultiresBakeResult &result)
1465 if (
ELEM(bake.type, R_BAKE_DISPLACEMENT, R_BAKE_VECTOR_DISPLACEMENT) &&
1466 !bake.use_low_resolution_mesh &&
1467 bake.multires_modifier->lvl != bake.multires_modifier->totlvl)
1469 bake_single_image_displacement(
1470 bake, bake_level_mesh, subdiv_ccg,
image, image_tile, ibuf, extra_buffers, result);
1474 if (bake.multires_modifier->lvl == 0) {
1475 bake_single_image_to_base_mesh(
1476 bake, bake_level_mesh, subdiv_ccg,
image, image_tile, ibuf, extra_buffers, result);
1480 bake_single_image_to_subdivided_mesh(
1481 bake, bake_level_mesh, subdiv_ccg,
image, image_tile, ibuf, extra_buffers, result);
1484static void bake_images(MultiresBakeRender &bake,
1485 const Mesh &bake_level_mesh,
1486 const SubdivCCG &subdiv_ccg,
1487 MultiresBakeResult &result)
1490 for (ImageTile &image_tile :
image->tiles) {
1493 iuser.tile = image_tile.tile_number;
1496 if (ibuf && ibuf->x > 0 && ibuf->y > 0) {
1497 result.baked_ibufs.append({});
1499 BakedImBuf &baked_ibuf =
result.baked_ibufs.last();
1500 baked_ibuf.image =
image;
1501 baked_ibuf.ibuf = ibuf;
1502 baked_ibuf.uv_offset = get_tile_uv(*
image, image_tile);
1504 ExtraBuffers &extra_buffers = baked_ibuf.extra_buffers;
1505 extra_buffers.mask_buffer.reinitialize(
int64_t(ibuf->y) * ibuf->x);
1509 bake, bake_level_mesh, subdiv_ccg, *
image, image_tile, *ibuf, extra_buffers, result);
1521static void bake_ibuf_normalize_displacement(ImBuf &ibuf,
1522 const MutableSpan<float> displacement,
1524 const float displacement_min,
1525 const float displacement_max)
1527 const float *current_displacement = displacement.data();
1528 const char *current_mask =
mask.data();
1529 const float max_distance = math::max(math::abs(displacement_min), math::abs(displacement_max));
1531 if (max_distance <= 1e-5f) {
1532 const float col[4] = {0.5f, 0.5f, 0.5f, 1.0f};
1539 uchar *byte_data = ibuf.byte_data_for_write();
1540 float *float_data = ibuf.float_data_for_write();
1541 for (
size_t i = 0; i < ibuf_pixel_count; i++) {
1543 const float normalized_displacement = (*current_displacement + max_distance) /
1549 float *fp = float_data +
int64_t(i) * 4;
1550 fp[0] = fp[1] = fp[2] = normalized_displacement;
1561 current_displacement++;
1566static void bake_ibuf_filter(ImBuf &ibuf,
1567 const MutableSpan<char>
mask,
1568 const Mesh &bake_level_mesh,
1570 const eBakeMarginType margin_type,
1577 switch (margin_type) {
1583 bake_level_mesh.active_uv_map_name(),
1598 ibuf.color_mode = ImColorMode::RGBA;
1601 if (margin && !ibuf.can_contain_alpha()) {
1608static void finish_images(MultiresBakeRender &bake,
1609 const Mesh &bake_level_mesh,
1610 MultiresBakeResult &result)
1614 for (BakedImBuf &baked_ibuf :
result.baked_ibufs) {
1616 ImBuf *ibuf = baked_ibuf.ibuf;
1618 if (use_displacement_buffer) {
1619 bake_ibuf_normalize_displacement(*ibuf,
1620 baked_ibuf.extra_buffers.displacement_buffer,
1621 baked_ibuf.extra_buffers.mask_buffer,
1626 bake_ibuf_filter(*ibuf,
1627 baked_ibuf.extra_buffers.mask_buffer,
1630 bake.bake_margin_type,
1631 baked_ibuf.uv_offset);
1647static subdiv::Subdiv *create_subdiv(
const Mesh &mesh,
1648 const MultiresModifierData &multires_modifier)
1650 subdiv::Settings subdiv_settings;
1652 subdiv::Subdiv *
subdiv = subdiv::update_from_mesh(
nullptr, &subdiv_settings, &mesh);
1653 subdiv::displacement_attach_from_multires(
subdiv, &mesh, &multires_modifier);
1656 if (!subdiv::eval_begin_from_mesh(
subdiv, &mesh, subdiv::SUBDIV_EVALUATOR_TYPE_CPU)) {
1660 subdiv::eval_init_displacement(
subdiv);
1665static std::unique_ptr<SubdivCCG> create_subdiv_ccg(
const Mesh &mesh,
1666 const MultiresModifierData &multires_modifier)
1668 subdiv::Subdiv *
subdiv = create_subdiv(mesh, multires_modifier);
1673 SubdivToCCGSettings settings;
1674 settings.resolution = (1 << multires_modifier.totlvl) + 1;
1675 settings.need_normal =
true;
1676 settings.need_mask =
false;
1681static Mesh *create_bake_level_mesh(
const Mesh &base_mesh,
1682 const MultiresModifierData &multires_modifier)
1684 subdiv::Subdiv *
subdiv = create_subdiv(base_mesh, multires_modifier);
1689 subdiv::ToMeshSettings mesh_settings;
1690 mesh_settings.resolution = (1 << multires_modifier.lvl) + 1;
1691 subdiv::displacement_attach_from_multires(
subdiv, &base_mesh, &multires_modifier);
1706 std::unique_ptr<SubdivCCG> subdiv_ccg = create_subdiv_ccg(*
bake.base_mesh,
1707 *
bake.multires_modifier);
1709 Mesh *bake_level_mesh =
bake.base_mesh;
1710 if (
bake.multires_modifier->lvl != 0) {
1711 bake_level_mesh = create_bake_level_mesh(*
bake.base_mesh, *
bake.multires_modifier);
1714 MultiresBakeResult
result;
1715 initialize_images(
bake);
1716 bake_images(
bake, *bake_level_mesh, *subdiv_ccg,
result);
1718 const Mesh *filter_mesh =
result.highres_bake_mesh ?
result.highres_bake_mesh : bake_level_mesh;
1721 if (
result.highres_bake_mesh &&
result.highres_bake_mesh != bake_level_mesh) {
1724 if (bake_level_mesh !=
bake.base_mesh) {
CustomData interface, see also DNA_customdata_types.h.
#define BLI_assert_unreachable()
#define UNUSED_VARS_NDEBUG(...)
SIMD_FORCE_INLINE const btScalar & w() const
Return the w value.
SIMD_FORCE_INLINE btScalar length() const
Return the length of the vector.
constexpr bool is_empty() const
#define image(slot, qualifiers, format)
const ccl_global KernelWorkTile * tile
#define unit_float_to_uchar_clamp_v3(v1, v2)
ccl_device_inline float2 mask(const MaskType mask, const float2 a)
int face_corner_prev(const IndexRange face, const int corner)
Array< Array< float4 > > calc_uv_tangents(Span< float3 > vert_positions, OffsetIndices< int > faces, Span< int > corner_verts, Span< int3 > corner_tris, Span< int > corner_tri_faces, Span< bool > sharp_faces, Span< float3 > vert_normals, Span< float3 > face_normals, Span< float3 > corner_normals, Span< Span< float2 > > uv_maps)
float3 face_center_calc(Span< float3 > vert_positions, Span< int > face_verts)
int face_corner_next(const IndexRange face, const int corner)
void free(Subdiv *subdiv)
bool foreach_subdiv_geometry(Subdiv *subdiv, const ForeachContext *context, const ToMeshSettings *mesh_settings, const Mesh *coarse_mesh)
BLI_INLINE void ptex_face_uv_to_grid_uv(float ptex_u, float ptex_v, float *r_grid_u, float *r_grid_v)
BLI_INLINE int rotate_quad_to_corner(float quad_u, float quad_v, float *r_corner_u, float *r_corner_v)
Mesh * subdiv_to_mesh(Subdiv *subdiv, const ToMeshSettings *settings, const Mesh *coarse_mesh)
Subdiv * update_from_mesh(Subdiv *subdiv, const Settings *settings, const Mesh *mesh)
int context(const bContext *C, const char *member, bContextDataResult *result)
VecBase< T, 3 > interp_bilinear_quad(const VecBase< T, 3 > &v0, const VecBase< T, 3 > &v1, const VecBase< T, 3 > &v2, const VecBase< T, 3 > &v3, const T u, const T v)
T dot(const QuaternionBase< T > &a, const QuaternionBase< T > &b)
T min(const T &a, const T &b)
CartesianBasis invert(const CartesianBasis &basis)
AxisSigned cross(const AxisSigned a, const AxisSigned b)
MatBase< T, NumCol, NumRow > normalize(const MatBase< T, NumCol, NumRow > &a)
T max(const T &a, const T &b)
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
MINLINE unsigned char unit_float_to_uchar_clamp(float val)
void IMB_rectfill_alpha(ImBuf *ibuf, float value)
pthread_spinlock_t SpinLock
void RE_multires_bake_images(MultiresBakeRender &bake)
size_t IMB_get_pixel_count(const ImBuf *ibuf)
Get the length of the data of the given image buffer in pixels.
void RE_generate_texturemargin_adjacentfaces(ImBuf *ibuf, char *mask, const int margin, const Mesh *mesh, StringRef uv_layer, const float uv_offset[2], const bool conservative)
void IMB_mark_dirty(ImBuf *ibuf)
void IMB_rectfill(ImBuf *drect, const float col[4])
ATTR_WARN_UNUSED_RESULT const BMVert * v
VecBase< float, 4 > float4
void BKE_multires_subdiv_settings_init(bke::subdiv::Settings *settings, const MultiresModifierData *mmd)
void BLI_spin_end(SpinLock *spin)
VecBase< int32_t, 2 > int2
VecBase< float, 2 > float2
VecBase< int32_t, 3 > int3
void resolve_tri_uv_v2(float r_uv[2], const float st[2], const float st0[2], const float st1[2], const float st2[2])
void DEG_id_tag_update(ID *id, unsigned int flags)
BMesh const char void * data
bool BKE_imbuf_alpha_test(ImBuf *ibuf)
void IMB_partial_update_mark_full(ImBuf *ibuf)
MatBase< float, 3, 3 > float3x3
void BKE_id_free(Main *bmain, void *idv)
ImBuf * BKE_image_acquire_ibuf(Image *ima, ImageUser *iuser, void **r_lock)
@ R_BAKE_VECTOR_DISPLACEMENT
void BLI_spin_init(SpinLock *spin)
std::unique_ptr< SubdivCCG > BKE_subdiv_to_ccg(bke::subdiv::Subdiv &subdiv, const SubdivToCCGSettings &settings, const Mesh &coarse_mesh, SubdivCCGMaskEvaluator *mask_evaluator=nullptr)
void IMB_filter_extend(ImBuf *ibuf, char *mask, int filter)
VecBase< float, 3 > float3
void BKE_imageuser_default(ImageUser *iuser)
void BKE_image_get_tile_uv(const Image *ima, const int tile_number, float r_uv[2])
void BKE_image_release_ibuf(Image *ima, ImBuf *ibuf, void *lock)
void vert(const int vert_id, float4 &position)
static MatBase identity()