void BKE_object_eval_done(EvaluationContext *UNUSED(eval_ctx), Object *ob)
{
DEBUG_PRINT("%s on %s\n", __func__, ob->id.name);
/* Set negative scale flag in object. */
if (is_negative_m4(ob->obmat)) ob->transflag |= OB_NEG_SCALE;
else ob->transflag &= ~OB_NEG_SCALE;
}
void ED_view3d_calc_clipping(BoundBox *bb, float planes[4][4], bglMats *mats, const rcti *rect)
{
float modelview[4][4];
double xs, ys, p[3];
int val, flip_sign, a;
/* near zero floating point values can give issues with gluUnProject
in side view on some implementations */
if(fabs(mats->modelview[0]) < 1e-6) mats->modelview[0]= 0.0;
if(fabs(mats->modelview[5]) < 1e-6) mats->modelview[5]= 0.0;
/* Set up viewport so that gluUnProject will give correct values */
mats->viewport[0] = 0;
mats->viewport[1] = 0;
/* four clipping planes and bounding volume */
/* first do the bounding volume */
for(val=0; val<4; val++) {
xs= (val==0||val==3)?rect->xmin:rect->xmax;
ys= (val==0||val==1)?rect->ymin:rect->ymax;
gluUnProject(xs, ys, 0.0, mats->modelview, mats->projection, mats->viewport, &p[0], &p[1], &p[2]);
VECCOPY(bb->vec[val], p);
gluUnProject(xs, ys, 1.0, mats->modelview, mats->projection, mats->viewport, &p[0], &p[1], &p[2]);
VECCOPY(bb->vec[4+val], p);
}
/* verify if we have negative scale. doing the transform before cross
product flips the sign of the vector compared to doing cross product
before transform then, so we correct for that. */
for(a=0; a<16; a++)
((float*)modelview)[a] = mats->modelview[a];
flip_sign = is_negative_m4(modelview);
/* then plane equations */
for(val=0; val<4; val++) {
normal_tri_v3(planes[val], bb->vec[val], bb->vec[val==3?0:val+1], bb->vec[val+4]);
if(flip_sign)
negate_v3(planes[val]);
planes[val][3]= - planes[val][0]*bb->vec[val][0]
- planes[val][1]*bb->vec[val][1]
- planes[val][2]*bb->vec[val][2];
}
}
static int bake(
Render *re, Main *bmain, Scene *scene, Object *ob_low, ListBase *selected_objects, ReportList *reports,
const ScenePassType pass_type, const int margin,
const BakeSaveMode save_mode, const bool is_clear, const bool is_split_materials,
const bool is_automatic_name, const bool is_selected_to_active, const bool is_cage,
const float cage_extrusion, const int normal_space, const BakeNormalSwizzle normal_swizzle[],
const char *custom_cage, const char *filepath, const int width, const int height,
const char *identifier, ScrArea *sa, const char *uv_layer)
{
int op_result = OPERATOR_CANCELLED;
bool ok = false;
Object *ob_cage = NULL;
BakeHighPolyData *highpoly = NULL;
int tot_highpoly = 0;
char restrict_flag_low = ob_low->restrictflag;
char restrict_flag_cage = 0;
Mesh *me_low = NULL;
Mesh *me_cage = NULL;
float *result = NULL;
BakePixel *pixel_array_low = NULL;
BakePixel *pixel_array_high = NULL;
const bool is_save_internal = (save_mode == R_BAKE_SAVE_INTERNAL);
const bool is_noncolor = is_noncolor_pass(pass_type);
const int depth = RE_pass_depth(pass_type);
BakeImages bake_images = {NULL};
size_t num_pixels;
int tot_materials;
RE_bake_engine_set_engine_parameters(re, bmain, scene);
if (!RE_bake_has_engine(re)) {
BKE_report(reports, RPT_ERROR, "Current render engine does not support baking");
goto cleanup;
}
tot_materials = ob_low->totcol;
if (uv_layer && uv_layer[0] != '\0') {
Mesh *me = (Mesh *)ob_low->data;
if (CustomData_get_named_layer(&me->ldata, CD_MLOOPUV, uv_layer) == -1) {
BKE_reportf(reports, RPT_ERROR,
"No UV layer named \"%s\" found in the object \"%s\"", uv_layer, ob_low->id.name + 2);
goto cleanup;
}
}
if (tot_materials == 0) {
if (is_save_internal) {
BKE_report(reports, RPT_ERROR,
"No active image found, add a material or bake to an external file");
goto cleanup;
}
else if (is_split_materials) {
BKE_report(reports, RPT_ERROR,
"No active image found, add a material or bake without the Split Materials option");
goto cleanup;
}
else {
/* baking externally without splitting materials */
tot_materials = 1;
}
}
/* we overallocate in case there is more materials than images */
bake_images.data = MEM_mallocN(sizeof(BakeImage) * tot_materials, "bake images dimensions (width, height, offset)");
bake_images.lookup = MEM_mallocN(sizeof(int) * tot_materials, "bake images lookup (from material to BakeImage)");
build_image_lookup(bmain, ob_low, &bake_images);
if (is_save_internal) {
num_pixels = initialize_internal_images(&bake_images, reports);
if (num_pixels == 0) {
goto cleanup;
}
}
else {
/* when saving extenally always use the size specified in the UI */
num_pixels = (size_t)width * (size_t)height * bake_images.size;
for (int i = 0; i < bake_images.size; i++) {
bake_images.data[i].width = width;
bake_images.data[i].height = height;
bake_images.data[i].offset = (is_split_materials ? num_pixels : 0);
bake_images.data[i].image = NULL;
}
if (!is_split_materials) {
/* saving a single image */
for (int i = 0; i < tot_materials; i++) {
bake_images.lookup[i] = 0;
}
}
}
if (is_selected_to_active) {
CollectionPointerLink *link;
tot_highpoly = 0;
for (link = selected_objects->first; link; link = link->next) {
Object *ob_iter = link->ptr.data;
if (ob_iter == ob_low)
continue;
tot_highpoly ++;
}
if (is_cage && custom_cage[0] != '\0') {
ob_cage = BLI_findstring(&bmain->object, custom_cage, offsetof(ID, name) + 2);
if (ob_cage == NULL || ob_cage->type != OB_MESH) {
BKE_report(reports, RPT_ERROR, "No valid cage object");
goto cleanup;
}
else {
restrict_flag_cage = ob_cage->restrictflag;
ob_cage->restrictflag |= OB_RESTRICT_RENDER;
}
}
}
pixel_array_low = MEM_mallocN(sizeof(BakePixel) * num_pixels, "bake pixels low poly");
pixel_array_high = MEM_mallocN(sizeof(BakePixel) * num_pixels, "bake pixels high poly");
result = MEM_callocN(sizeof(float) * depth * num_pixels, "bake return pixels");
/* get the mesh as it arrives in the renderer */
me_low = BKE_mesh_new_from_object(bmain, scene, ob_low, 1, 2, 0, 0);
BKE_mesh_split_faces(me_low);
/* populate the pixel array with the face data */
if ((is_selected_to_active && (ob_cage == NULL) && is_cage) == false)
RE_bake_pixels_populate(me_low, pixel_array_low, num_pixels, &bake_images, uv_layer);
/* else populate the pixel array with the 'cage' mesh (the smooth version of the mesh) */
if (is_selected_to_active) {
CollectionPointerLink *link;
ModifierData *md, *nmd;
ListBase modifiers_tmp, modifiers_original;
int i = 0;
/* prepare cage mesh */
if (ob_cage) {
me_cage = BKE_mesh_new_from_object(bmain, scene, ob_cage, 1, 2, 0, 0);
BKE_mesh_split_faces(me_cage);
if ((me_low->totpoly != me_cage->totpoly) || (me_low->totloop != me_cage->totloop)) {
BKE_report(reports, RPT_ERROR,
"Invalid cage object, the cage mesh must have the same number "
"of faces as the active object");
goto cleanup;
}
}
else if (is_cage) {
modifiers_original = ob_low->modifiers;
BLI_listbase_clear(&modifiers_tmp);
for (md = ob_low->modifiers.first; md; md = md->next) {
/* Edge Split cannot be applied in the cage,
* the cage is supposed to have interpolated normals
* between the faces unless the geometry is physically
* split. So we create a copy of the low poly mesh without
* the eventual edge split.*/
if (md->type == eModifierType_EdgeSplit)
continue;
nmd = modifier_new(md->type);
BLI_strncpy(nmd->name, md->name, sizeof(nmd->name));
modifier_copyData(md, nmd);
BLI_addtail(&modifiers_tmp, nmd);
}
/* temporarily replace the modifiers */
ob_low->modifiers = modifiers_tmp;
/* get the cage mesh as it arrives in the renderer */
me_cage = BKE_mesh_new_from_object(bmain, scene, ob_low, 1, 2, 0, 0);
BKE_mesh_split_faces(me_cage);
RE_bake_pixels_populate(me_cage, pixel_array_low, num_pixels, &bake_images, uv_layer);
}
highpoly = MEM_callocN(sizeof(BakeHighPolyData) * tot_highpoly, "bake high poly objects");
/* populate highpoly array */
for (link = selected_objects->first; link; link = link->next) {
TriangulateModifierData *tmd;
Object *ob_iter = link->ptr.data;
if (ob_iter == ob_low)
continue;
/* initialize highpoly_data */
highpoly[i].ob = ob_iter;
highpoly[i].restrict_flag = ob_iter->restrictflag;
/* triangulating so BVH returns the primitive_id that will be used for rendering */
highpoly[i].tri_mod = ED_object_modifier_add(
reports, bmain, scene, highpoly[i].ob,
"TmpTriangulate", eModifierType_Triangulate);
tmd = (TriangulateModifierData *)highpoly[i].tri_mod;
tmd->quad_method = MOD_TRIANGULATE_QUAD_FIXED;
tmd->ngon_method = MOD_TRIANGULATE_NGON_EARCLIP;
highpoly[i].me = BKE_mesh_new_from_object(bmain, scene, highpoly[i].ob, 1, 2, 0, 0);
highpoly[i].ob->restrictflag &= ~OB_RESTRICT_RENDER;
BKE_mesh_split_faces(highpoly[i].me);
/* lowpoly to highpoly transformation matrix */
copy_m4_m4(highpoly[i].obmat, highpoly[i].ob->obmat);
invert_m4_m4(highpoly[i].imat, highpoly[i].obmat);
highpoly[i].is_flip_object = is_negative_m4(highpoly[i].ob->obmat);
i++;
}
BLI_assert(i == tot_highpoly);
ob_low->restrictflag |= OB_RESTRICT_RENDER;
/* populate the pixel arrays with the corresponding face data for each high poly object */
if (!RE_bake_pixels_populate_from_objects(
me_low, pixel_array_low, pixel_array_high, highpoly, tot_highpoly, num_pixels, ob_cage != NULL,
cage_extrusion, ob_low->obmat, (ob_cage ? ob_cage->obmat : ob_low->obmat), me_cage))
{
BKE_report(reports, RPT_ERROR, "Error handling selected objects");
goto cage_cleanup;
}
/* the baking itself */
for (i = 0; i < tot_highpoly; i++) {
ok = RE_bake_engine(re, highpoly[i].ob, i, pixel_array_high,
num_pixels, depth, pass_type, result);
if (!ok) {
BKE_reportf(reports, RPT_ERROR, "Error baking from object \"%s\"", highpoly[i].ob->id.name + 2);
goto cage_cleanup;
}
}
cage_cleanup:
/* reverting data back */
if ((ob_cage == NULL) && is_cage) {
ob_low->modifiers = modifiers_original;
while ((md = BLI_pophead(&modifiers_tmp))) {
modifier_free(md);
}
}
if (!ok) {
goto cleanup;
}
}
else {
/* make sure low poly renders */
ob_low->restrictflag &= ~OB_RESTRICT_RENDER;
if (RE_bake_has_engine(re)) {
ok = RE_bake_engine(re, ob_low, 0, pixel_array_low, num_pixels, depth, pass_type, result);
}
else {
BKE_report(reports, RPT_ERROR, "Current render engine does not support baking");
goto cleanup;
}
}
/* normal space conversion
* the normals are expected to be in world space, +X +Y +Z */
if (ok && pass_type == SCE_PASS_NORMAL) {
switch (normal_space) {
case R_BAKE_SPACE_WORLD:
{
/* Cycles internal format */
if ((normal_swizzle[0] == R_BAKE_POSX) &&
(normal_swizzle[1] == R_BAKE_POSY) &&
(normal_swizzle[2] == R_BAKE_POSZ))
{
break;
}
else {
RE_bake_normal_world_to_world(pixel_array_low, num_pixels, depth, result, normal_swizzle);
}
break;
}
case R_BAKE_SPACE_OBJECT:
{
RE_bake_normal_world_to_object(pixel_array_low, num_pixels, depth, result, ob_low, normal_swizzle);
break;
}
case R_BAKE_SPACE_TANGENT:
{
if (is_selected_to_active) {
RE_bake_normal_world_to_tangent(pixel_array_low, num_pixels, depth, result, me_low, normal_swizzle, ob_low->obmat);
}
else {
/* from multiresolution */
Mesh *me_nores = NULL;
ModifierData *md = NULL;
int mode;
md = modifiers_findByType(ob_low, eModifierType_Multires);
if (md) {
mode = md->mode;
md->mode &= ~eModifierMode_Render;
}
me_nores = BKE_mesh_new_from_object(bmain, scene, ob_low, 1, 2, 0, 0);
BKE_mesh_split_faces(me_nores);
RE_bake_pixels_populate(me_nores, pixel_array_low, num_pixels, &bake_images, uv_layer);
RE_bake_normal_world_to_tangent(pixel_array_low, num_pixels, depth, result, me_nores, normal_swizzle, ob_low->obmat);
BKE_libblock_free(bmain, me_nores);
if (md)
md->mode = mode;
}
break;
}
default:
break;
}
}
if (!ok) {
BKE_reportf(reports, RPT_ERROR, "Problem baking object \"%s\"", ob_low->id.name + 2);
op_result = OPERATOR_CANCELLED;
}
else {
/* save the results */
for (int i = 0; i < bake_images.size; i++) {
BakeImage *bk_image = &bake_images.data[i];
if (is_save_internal) {
ok = write_internal_bake_pixels(
bk_image->image,
pixel_array_low + bk_image->offset,
result + bk_image->offset * depth,
bk_image->width, bk_image->height,
margin, is_clear, is_noncolor);
/* might be read by UI to set active image for display */
bake_update_image(sa, bk_image->image);
if (!ok) {
BKE_reportf(reports, RPT_ERROR,
"Problem saving the bake map internally for object \"%s\"", ob_low->id.name + 2);
op_result = OPERATOR_CANCELLED;
}
else {
BKE_report(reports, RPT_INFO,
"Baking map saved to internal image, save it externally or pack it");
op_result = OPERATOR_FINISHED;
}
}
/* save externally */
else {
BakeData *bake = &scene->r.bake;
char name[FILE_MAX];
BKE_image_path_from_imtype(name, filepath, bmain->name, 0, bake->im_format.imtype, true, false, NULL);
if (is_automatic_name) {
BLI_path_suffix(name, FILE_MAX, ob_low->id.name + 2, "_");
BLI_path_suffix(name, FILE_MAX, identifier, "_");
}
if (is_split_materials) {
if (bk_image->image) {
BLI_path_suffix(name, FILE_MAX, bk_image->image->id.name + 2, "_");
}
else {
if (ob_low->mat[i]) {
BLI_path_suffix(name, FILE_MAX, ob_low->mat[i]->id.name + 2, "_");
}
else if (me_low->mat[i]) {
BLI_path_suffix(name, FILE_MAX, me_low->mat[i]->id.name + 2, "_");
}
else {
/* if everything else fails, use the material index */
char tmp[4];
sprintf(tmp, "%d", i % 1000);
BLI_path_suffix(name, FILE_MAX, tmp, "_");
}
}
}
/* save it externally */
ok = write_external_bake_pixels(
name,
pixel_array_low + bk_image->offset,
result + bk_image->offset * depth,
bk_image->width, bk_image->height,
margin, &bake->im_format, is_noncolor);
if (!ok) {
BKE_reportf(reports, RPT_ERROR, "Problem saving baked map in \"%s\"", name);
op_result = OPERATOR_CANCELLED;
}
else {
BKE_reportf(reports, RPT_INFO, "Baking map written to \"%s\"", name);
op_result = OPERATOR_FINISHED;
}
if (!is_split_materials) {
break;
}
}
}
}
if (is_save_internal)
refresh_images(&bake_images);
cleanup:
if (highpoly) {
int i;
for (i = 0; i < tot_highpoly; i++) {
highpoly[i].ob->restrictflag = highpoly[i].restrict_flag;
if (highpoly[i].tri_mod)
ED_object_modifier_remove(reports, bmain, highpoly[i].ob, highpoly[i].tri_mod);
if (highpoly[i].me)
BKE_libblock_free(bmain, highpoly[i].me);
}
MEM_freeN(highpoly);
}
ob_low->restrictflag = restrict_flag_low;
if (ob_cage)
ob_cage->restrictflag = restrict_flag_cage;
if (pixel_array_low)
MEM_freeN(pixel_array_low);
if (pixel_array_high)
MEM_freeN(pixel_array_high);
if (bake_images.data)
MEM_freeN(bake_images.data);
if (bake_images.lookup)
MEM_freeN(bake_images.lookup);
if (result)
MEM_freeN(result);
if (me_low)
BKE_libblock_free(bmain, me_low);
if (me_cage)
BKE_libblock_free(bmain, me_cage);
return op_result;
}
