Merge branch 'master' into blender2.8

intern/cycles/render/constant_fold.cpp

@@ -160,6 +160,14 @@ bool ConstantFolder::try_bypass_or_make_constant(ShaderInput *input, bool clamp)
 		bypass(input->link);
 		return true;
 	}
+	else {
+		/* disconnect other inputs if we can't fully bypass due to clamp */
+		foreach(ShaderInput *other, node->inputs) {
+			if(other != input && other->link) {
+				graph->disconnect(other);
+			}
+		}
+	}
 
 	return false;
 }

intern/cycles/render/light.cpp

@@ -224,6 +224,10 @@ void LightManager::disable_ineffective_light(Device *device, Scene *scene)
 
 bool LightManager::object_usable_as_light(Object *object) {
 	Mesh *mesh = object->mesh;
+	/* Skip objects with NaNs */
+	if (!object->bounds.valid()) {
+		return false;
+	}
 	/* Skip if we are not visible for BSDFs. */
 	if(!(object->visibility & (PATH_RAY_DIFFUSE|PATH_RAY_GLOSSY|PATH_RAY_TRANSMIT))) {
 		return false;

intern/elbeem/intern/solver_util.cpp

@@ -855,6 +855,10 @@ void LbmFsgrSolver::advanceParticles() {
 				if(k<=mSizez-1-cutval){ 
 					CellFlagType pflag = RFLAG(level, i,j,k, workSet);
 					//errMsg("PIT move"," at "<<PRINT_IJK<<" flag"<<convertCellFlagType2String(pflag) );
+					if (pflag & CFMbndOutflow) {
+						DEL_PART;
+						continue;
+					}
 					if(pflag & (CFBnd)) {
 						handleObstacleParticle(p);
 						continue;

source/blender/alembic/intern/abc_object.h

@@ -90,7 +90,7 @@ struct ImportSettings {
 
 	/* Length and frame offset of file sequences. */
 	int sequence_len;
-	int offset;
+	int sequence_offset;
 
 	/* From MeshSeqCacheModifierData.read_flag */
 	int read_flag;
@@ -107,7 +107,7 @@ struct ImportSettings {
 	    , is_sequence(false)
 	    , set_frame_range(false)
 	    , sequence_len(1)
-	    , offset(0)
+	    , sequence_offset(0)
 	    , read_flag(0)
 	    , validate_meshes(false)
 	    , cache_file(NULL)

source/blender/alembic/intern/alembic_capi.cc

@@ -762,7 +762,7 @@ static void import_startjob(void *user_data, short *stop, short *do_update, floa
 		Scene *scene = data->scene;
 
 		if (data->settings.is_sequence) {
-			SFRA = data->settings.offset;
+			SFRA = data->settings.sequence_offset;
 			EFRA = SFRA + (data->settings.sequence_len - 1);
 			CFRA = SFRA;
 		}
@@ -902,7 +902,7 @@ bool ABC_import(bContext *C, const char *filepath, float scale, bool is_sequence
 	job->settings.is_sequence = is_sequence;
 	job->settings.set_frame_range = set_frame_range;
 	job->settings.sequence_len = sequence_len;
-	job->settings.offset = offset;
+	job->settings.sequence_offset = offset;
 	job->settings.validate_meshes = validate_meshes;
 	job->error_code = ABC_NO_ERROR;
 	job->was_cancelled = false;

source/blender/blenkernel/BKE_DerivedMesh.h

@@ -199,7 +199,7 @@ struct DerivedMesh {
 	/* use for converting to BMesh which doesn't store bevel weight and edge crease by default */
 	char cd_flag;
 
-	char tangent_mask; /* which tangent layers are calculated */
+	short tangent_mask; /* which tangent layers are calculated */
 
 	/** Calculate vert and face normals */
 	void (*calcNormals)(DerivedMesh *dm);
@@ -768,6 +768,10 @@ void DM_calc_tangents_names_from_gpu(
         const struct GPUVertexAttribs *gattribs,
         char (*tangent_names)[MAX_NAME], int *tangent_names_count);
 
+void DM_add_named_tangent_layer_for_uv(
+        CustomData *uv_data, CustomData *tan_data, int numLoopData,
+        const char *layer_name);
+
 void DM_calc_loop_tangents(
         DerivedMesh *dm, bool calc_active_tangent, const char (*tangent_names)[MAX_NAME],
         int tangent_names_count);

source/blender/blenkernel/BKE_editmesh_tangent.h

@@ -35,6 +35,6 @@ void BKE_editmesh_loop_tangent_calc(
         const float (*vert_orco)[3],
         CustomData *dm_loopdata_out,
         const uint dm_loopdata_out_len,
-        char *tangent_mask_curr_p);
+        short *tangent_mask_curr_p);
 
 #endif /* __BKE_EDITMESH_TANGENT_H__ */

source/blender/blenkernel/BKE_mesh_tangent.h

@@ -43,17 +43,19 @@ void BKE_mesh_calc_loop_tangent_ex(
         /* result */
         struct CustomData *loopdata_out,
         const uint  loopdata_out_len,
-        char *tangent_mask_curr_p);
+        short *tangent_mask_curr_p);
 
 /* Helpers */
 void BKE_mesh_add_loop_tangent_named_layer_for_uv(
         struct CustomData *uv_data, struct CustomData *tan_data, int numLoopData,
         const char *layer_name);
+
+#define DM_TANGENT_MASK_ORCO (1 << 9)
 void BKE_mesh_calc_loop_tangent_step_0(
         const struct CustomData *loopData, bool calc_active_tangent,
         const char (*tangent_names)[64], int tangent_names_count,
         bool *rcalc_act, bool *rcalc_ren, int *ract_uv_n, int *rren_uv_n,
-        char *ract_uv_name, char *rren_uv_name, char *rtangent_mask);
+        char *ract_uv_name, char *rren_uv_name, short *rtangent_mask);
 
 #endif /* __BKE_MESH_TANGENT_H__ */
 

source/blender/blenkernel/intern/DerivedMesh.c

@@ -3054,14 +3054,23 @@ void DM_calc_tangents_names_from_gpu(
 	*r_tangent_names_count = count;
 }
 
+void DM_add_named_tangent_layer_for_uv(
+        CustomData *uv_data, CustomData *tan_data, int numLoopData,
+        const char *layer_name)
+{
+	if (CustomData_get_named_layer_index(tan_data, CD_TANGENT, layer_name) == -1 &&
+	    CustomData_get_named_layer_index(uv_data, CD_MLOOPUV, layer_name) != -1)
+	{
+		CustomData_add_layer_named(
+		        tan_data, CD_TANGENT, CD_CALLOC, NULL,
+		        numLoopData, layer_name);
+	}
+}
+
 void DM_calc_loop_tangents(
         DerivedMesh *dm, bool calc_active_tangent,
         const char (*tangent_names)[MAX_NAME], int tangent_names_len)
 {
-	if (CustomData_number_of_layers(&dm->loopData, CD_MLOOPUV) == 0) {
-		return;
-	}
-
 	BKE_mesh_calc_loop_tangent_ex(
 	        dm->getVertArray(dm),
 	        dm->getPolyArray(dm), dm->getNumPolys(dm),

source/blender/blenkernel/intern/cachefile.c

@@ -166,10 +166,12 @@ void BKE_cachefile_update_frame(Main *bmain, Scene *scene, const float ctime, co
 		const float time = BKE_cachefile_time_offset(cache_file, ctime, fps);
 
 		if (BKE_cachefile_filepath_get(bmain, cache_file, time, filename)) {
+			BKE_cachefile_clean(scene, cache_file);
 #ifdef WITH_ALEMBIC
 			ABC_free_handle(cache_file->handle);
 			cache_file->handle = ABC_create_handle(filename, NULL);
 #endif
+			break;
 		}
 	}
 }

source/blender/blenkernel/intern/editmesh_tangent.c

@@ -283,7 +283,7 @@ void BKE_editmesh_loop_tangent_calc(
         /* result */
         CustomData *loopdata_out,
         const uint  loopdata_out_len,
-        char *tangent_mask_curr_p)
+        short *tangent_mask_curr_p)
 {
 	BMesh *bm = em->bm;
 
@@ -295,8 +295,8 @@ void BKE_editmesh_loop_tangent_calc(
 	bool calc_ren = false;
 	char act_uv_name[MAX_NAME];
 	char ren_uv_name[MAX_NAME];
-	char tangent_mask = 0;
+	short tangent_mask = 0;
-	char tangent_mask_curr = *tangent_mask_curr_p;
+	short tangent_mask_curr = *tangent_mask_curr_p;
 
 	BKE_mesh_calc_loop_tangent_step_0(
 	        &bm->ldata, calc_active_tangent, tangent_names, tangent_names_len,
@@ -305,11 +305,13 @@ void BKE_editmesh_loop_tangent_calc(
 	if ((tangent_mask_curr | tangent_mask) != tangent_mask_curr) {
 		for (int i = 0; i < tangent_names_len; i++)
 			if (tangent_names[i][0])
-				BKE_mesh_add_loop_tangent_named_layer_for_uv(&bm->ldata, loopdata_out, loopdata_out_len, tangent_names[i]);
+				BKE_mesh_add_loop_tangent_named_layer_for_uv(&bm->ldata, loopdata_out, (int)loopdata_out_len, tangent_names[i]);
+		if ((tangent_mask & DM_TANGENT_MASK_ORCO) && CustomData_get_named_layer_index(loopdata_out, CD_TANGENT, "") == -1)
+					CustomData_add_layer_named(loopdata_out, CD_TANGENT, CD_CALLOC, NULL, (int)loopdata_out_len, "");
 		if (calc_act && act_uv_name[0])
-			BKE_mesh_add_loop_tangent_named_layer_for_uv(&bm->ldata, loopdata_out, loopdata_out_len, act_uv_name);
+			BKE_mesh_add_loop_tangent_named_layer_for_uv(&bm->ldata, loopdata_out, (int)loopdata_out_len, act_uv_name);
 		if (calc_ren && ren_uv_name[0])
-			BKE_mesh_add_loop_tangent_named_layer_for_uv(&bm->ldata, loopdata_out, loopdata_out_len, ren_uv_name);
+			BKE_mesh_add_loop_tangent_named_layer_for_uv(&bm->ldata, loopdata_out, (int)loopdata_out_len, ren_uv_name);
 		int totface = em->tottri;
 #ifdef USE_LOOPTRI_DETECT_QUADS
 		int num_face_as_quad_map;
@@ -372,6 +374,15 @@ void BKE_editmesh_loop_tangent_calc(
 						continue;
 					/* needed for orco lookups */
 					htype_index |= BM_VERT;
+					*tangent_mask_curr_p |= DM_TANGENT_MASK_ORCO;
+				}
+				else {
+					/* Fill the resulting tangent_mask */
+					int uv_ind = CustomData_get_named_layer_index(&bm->ldata, CD_MLOOPUV, loopdata_out->layers[index].name);
+					int uv_start = CustomData_get_layer_index(&bm->ldata, CD_MLOOPUV);
+					BLI_assert(uv_ind != -1 && uv_start != -1);
+					BLI_assert(uv_ind - uv_start < MAX_MTFACE);
+					*tangent_mask_curr_p |= 1 << (uv_ind - uv_start);
 				}
 				if (mesh2tangent->precomputedFaceNormals) {
 					/* needed for face normal lookups */
@@ -382,13 +393,6 @@ void BKE_editmesh_loop_tangent_calc(
 				mesh2tangent->looptris = (const BMLoop *(*)[3])em->looptris;
 				mesh2tangent->tangent = loopdata_out->layers[index].data;
 
-				/* Fill the resulting tangent_mask */
-				int uv_ind = CustomData_get_named_layer_index(
-				        &bm->ldata, CD_MLOOPUV, loopdata_out->layers[index].name);
-				int uv_start = CustomData_get_layer_index(&bm->ldata, CD_MLOOPUV);
-				BLI_assert(uv_ind != -1 && uv_start != -1);
-				BLI_assert(uv_ind - uv_start < MAX_MTFACE);
-				tangent_mask_curr |= 1 << (uv_ind - uv_start);
 				BLI_task_pool_push(task_pool, emDM_calc_loop_tangents_thread, mesh2tangent, false, TASK_PRIORITY_LOW);
 			}
 
@@ -409,15 +413,18 @@ void BKE_editmesh_loop_tangent_calc(
 
 	*tangent_mask_curr_p = tangent_mask_curr;
 
-	/* Update active layer index */
+	int act_uv_index = CustomData_get_layer_index_n(&bm->ldata, CD_MLOOPUV, act_uv_n);
-	int uv_index = CustomData_get_layer_index_n(&bm->ldata, CD_MLOOPUV, act_uv_n);
+	if (act_uv_index >= 0) {
-	int tan_index = CustomData_get_named_layer_index(loopdata_out, CD_TANGENT, bm->ldata.layers[uv_index].name);
+		int tan_index = CustomData_get_named_layer_index(loopdata_out, CD_TANGENT, bm->ldata.layers[act_uv_index].name);
-	CustomData_set_layer_active_index(loopdata_out, CD_TANGENT, tan_index);
+		CustomData_set_layer_active_index(loopdata_out, CD_TANGENT, tan_index);
+	} /* else tangent has been built from orco */
 
 	/* Update render layer index */
-	uv_index = CustomData_get_layer_index_n(&bm->ldata, CD_MLOOPUV, ren_uv_n);
+	int ren_uv_index = CustomData_get_layer_index_n(&bm->ldata, CD_MLOOPUV, ren_uv_n);
-	tan_index = CustomData_get_named_layer_index(loopdata_out, CD_TANGENT, bm->ldata.layers[uv_index].name);
+	if (ren_uv_index >= 0) {
-	CustomData_set_layer_render_index(loopdata_out, CD_TANGENT, tan_index);
+		int tan_index = CustomData_get_named_layer_index(loopdata_out, CD_TANGENT, bm->ldata.layers[ren_uv_index].name);
+		CustomData_set_layer_render_index(loopdata_out, CD_TANGENT, tan_index);
+	} /* else tangent has been built from orco */
 }
 
 /** \} */

source/blender/blenkernel/intern/mesh_tangent.c

@@ -474,7 +474,7 @@ void BKE_mesh_calc_loop_tangent_step_0(
         const CustomData *loopData, bool calc_active_tangent,
         const char (*tangent_names)[MAX_NAME], int tangent_names_count,
         bool *rcalc_act, bool *rcalc_ren, int *ract_uv_n, int *rren_uv_n,
-        char *ract_uv_name, char *rren_uv_name, char *rtangent_mask) {
+        char *ract_uv_name, char *rren_uv_name, short *rtangent_mask) {
 	/* Active uv in viewport */
 	int layer_index = CustomData_get_layer_index(loopData, CD_MLOOPUV);
 	*ract_uv_n = CustomData_get_active_layer(loopData, CD_MLOOPUV);
@@ -549,18 +549,16 @@ void BKE_mesh_calc_loop_tangent_ex(
         /* result */
         CustomData *loopdata_out,
         const uint  loopdata_out_len,
-        char *tangent_mask_curr_p)
+        short *tangent_mask_curr_p)
 {
-	BLI_assert(CustomData_number_of_layers(loopdata, CD_MLOOPUV) != 0);
-
 	int act_uv_n = -1;
 	int ren_uv_n = -1;
 	bool calc_act = false;
 	bool calc_ren = false;
 	char act_uv_name[MAX_NAME];
 	char ren_uv_name[MAX_NAME];
-	char tangent_mask = 0;
+	short tangent_mask = 0;
-	char tangent_mask_curr = *tangent_mask_curr_p;
+	short tangent_mask_curr = *tangent_mask_curr_p;
 
 	BKE_mesh_calc_loop_tangent_step_0(
 	        loopdata, calc_active_tangent, tangent_names, tangent_names_len,
@@ -571,6 +569,8 @@ void BKE_mesh_calc_loop_tangent_ex(
 		for (int i = 0; i < tangent_names_len; i++)
 			if (tangent_names[i][0])
 				BKE_mesh_add_loop_tangent_named_layer_for_uv(loopdata, loopdata_out, (int)loopdata_out_len, tangent_names[i]);
+		if ((tangent_mask & DM_TANGENT_MASK_ORCO) && CustomData_get_named_layer_index(loopdata, CD_TANGENT, "") == -1)
+			    CustomData_add_layer_named(loopdata, CD_TANGENT, CD_CALLOC, NULL, (int)loopdata_out_len, "");
 		if (calc_act && act_uv_name[0])
 			BKE_mesh_add_loop_tangent_named_layer_for_uv(loopdata, loopdata_out, (int)loopdata_out_len, act_uv_name);
 		if (calc_ren && ren_uv_name[0])
@@ -632,20 +632,24 @@ void BKE_mesh_calc_loop_tangent_ex(
 
 				mesh2tangent->orco = NULL;
 				mesh2tangent->mloopuv = CustomData_get_layer_named(loopdata, CD_MLOOPUV, loopdata_out->layers[index].name);
-				if (!mesh2tangent->mloopuv) {
-					mesh2tangent->orco = vert_orco;
-					if (!mesh2tangent->orco)
-						continue;
-				}
-				mesh2tangent->tangent = loopdata_out->layers[index].data;
 
 				/* Fill the resulting tangent_mask */
-				int uv_ind = CustomData_get_named_layer_index(
+				if (!mesh2tangent->mloopuv) {
-				        loopdata, CD_MLOOPUV, loopdata_out->layers[index].name);
+				    mesh2tangent->orco = vert_orco;
-				int uv_start = CustomData_get_layer_index(loopdata, CD_MLOOPUV);
+				    if (!mesh2tangent->orco)
-				BLI_assert(uv_ind != -1 && uv_start != -1);
+					    continue;
-				BLI_assert(uv_ind - uv_start < MAX_MTFACE);
+
-				tangent_mask_curr |= (char)(1 << (uv_ind - uv_start));
+				    *tangent_mask_curr_p |= DM_TANGENT_MASK_ORCO;
+				}
+				else {
+				    int uv_ind = CustomData_get_named_layer_index(loopdata, CD_MLOOPUV, loopdata->layers[index].name);
+				    int uv_start = CustomData_get_layer_index(loopdata, CD_MLOOPUV);
+				    BLI_assert(uv_ind != -1 && uv_start != -1);
+				    BLI_assert(uv_ind - uv_start < MAX_MTFACE);
+				    *tangent_mask_curr_p |= 1 << (uv_ind - uv_start);
+				}
+
+				mesh2tangent->tangent = loopdata_out->layers[index].data;
 				BLI_task_pool_push(task_pool, DM_calc_loop_tangents_thread, mesh2tangent, false, TASK_PRIORITY_LOW);
 			}
 
@@ -666,21 +670,19 @@ void BKE_mesh_calc_loop_tangent_ex(
 
 		*tangent_mask_curr_p = tangent_mask_curr;
 
-		int uv_index, tan_index;
-
 		/* Update active layer index */
-		uv_index = CustomData_get_layer_index_n(loopdata, CD_MLOOPUV, act_uv_n);
+		int act_uv_index = CustomData_get_layer_index_n(loopdata, CD_MLOOPUV, act_uv_n);
-		if (uv_index != -1) {
+		if (act_uv_index != -1) {
-			tan_index = CustomData_get_named_layer_index(loopdata_out, CD_TANGENT, loopdata->layers[uv_index].name);
+		    int tan_index = CustomData_get_named_layer_index(loopdata, CD_TANGENT, loopdata->layers[act_uv_index].name);
-			CustomData_set_layer_active_index(loopdata_out, CD_TANGENT, tan_index);
+		    CustomData_set_layer_active_index(loopdata, CD_TANGENT, tan_index);
-		}
+		}/* else tangent has been built from orco */
 
 		/* Update render layer index */
-		uv_index = CustomData_get_layer_index_n(loopdata, CD_MLOOPUV, ren_uv_n);
+		int ren_uv_index = CustomData_get_layer_index_n(loopdata, CD_MLOOPUV, ren_uv_n);
-		if (uv_index != -1) {
+		if (ren_uv_index != -1) {
-			tan_index = CustomData_get_named_layer_index(loopdata_out, CD_TANGENT, loopdata->layers[uv_index].name);
+		    int tan_index = CustomData_get_named_layer_index(loopdata, CD_TANGENT, loopdata->layers[ren_uv_index].name);
-			CustomData_set_layer_render_index(loopdata_out, CD_TANGENT, tan_index);
+		    CustomData_set_layer_render_index(loopdata, CD_TANGENT, tan_index);
-		}
+		}/* else tangent has been built from orco */
 	}
 }
 

source/blender/blenlib/intern/noise.c

@@ -1394,6 +1394,11 @@ static float voronoi_CrS(float x, float y, float z)
 /* returns unsigned cellnoise */
 static float cellNoiseU(float x, float y, float z)
 {
+	/* avoid precision issues on unit coordinates */
+	x = (x + 0.000001f)*0.999999f;
+	y = (y + 0.000001f)*0.999999f;
+	z = (z + 0.000001f)*0.999999f;
+
 	int xi = (int)(floor(x));
 	int yi = (int)(floor(y));
 	int zi = (int)(floor(z));
@@ -1411,6 +1416,11 @@ float cellNoise(float x, float y, float z)
 /* returns a vector/point/color in ca, using point hasharray directly */
 void cellNoiseV(float x, float y, float z, float ca[3])
 {
+	/* avoid precision issues on unit coordinates */
+	x = (x + 0.000001f)*0.999999f;
+	y = (y + 0.000001f)*0.999999f;
+	z = (z + 0.000001f)*0.999999f;
+
 	int xi = (int)(floor(x));
 	int yi = (int)(floor(y));
 	int zi = (int)(floor(z));

source/blender/draw/intern/draw_cache_impl_mesh.c

@@ -174,7 +174,7 @@ typedef struct MeshRenderData {
 		struct {
 			CustomData ldata;
 			/* grr, special case variable (use in place of 'dm->tangent_mask') */
-			char tangent_mask;
+			short tangent_mask;
 		} output;
 	} cd;
 

source/blender/editors/io/io_alembic.c

@@ -31,6 +31,9 @@
 #  include "BLI_winstuff.h"
 #endif
 
+#include <string.h>
+#include <errno.h>
+
 #include "MEM_guardedalloc.h"
 
 #include "DNA_mesh_types.h"
@@ -417,9 +420,20 @@ static int get_sequence_len(char *filename, int *ofs)
 	}
 
 	char path[FILE_MAX];
+	BLI_path_abs(filename, G.main->name);
 	BLI_split_dir_part(filename, path, FILE_MAX);
 
+	if (path[0] == '\0') {
+		/* The filename had no path, so just use the blend file path. */
+		BLI_split_dir_part(G.main->name, path, FILE_MAX);
+	}
+
 	DIR *dir = opendir(path);
+	if (dir == NULL) {
+		fprintf(stderr, "Error opening directory '%s': %s\n",
+		        path, errno ? strerror(errno) : "unknown error");
+		return -1;
+	}
 
 	const char *ext = ".abc";
 	const char *basename = BLI_path_basename(filename);
@@ -523,6 +537,10 @@ static int wm_alembic_import_exec(bContext *C, wmOperator *op)
 
 	if (is_sequence) {
 		sequence_len = get_sequence_len(filename, &offset);
+		if (sequence_len < 0) {
+			BKE_report(op->reports, RPT_ERROR, "Unable to determine ABC sequence length");
+			return OPERATOR_CANCELLED;
+		}
 	}
 
 	bool ok = ABC_import(C, filename, scale, is_sequence, set_frame_range,

source/blender/editors/object/object_add.c

@@ -1541,8 +1541,6 @@ static void make_object_duplilist_real(bContext *C, Scene *scene, Base *base,
 			}
 
 			if (ob_dst->parent) {
-				invert_m4_m4(ob_dst->parentinv, dob->mat);
-
 				/* note, this may be the parent of other objects, but it should
 				 * still work out ok */
 				BKE_object_apply_mat4(ob_dst, dob->mat, false, true);
@@ -1563,7 +1561,6 @@ static void make_object_duplilist_real(bContext *C, Scene *scene, Base *base,
 			ob_dst->partype = PAROBJECT;
 
 			/* similer to the code above, see comments */
-			invert_m4_m4(ob_dst->parentinv, dob->mat);
 			BKE_object_apply_mat4(ob_dst, dob->mat, false, true);
 			DEG_id_tag_update(&ob_dst->id, OB_RECALC_OB);
 		}

source/blender/editors/render/render_preview.c

@@ -1252,7 +1252,7 @@ void ED_preview_icon_render(Main *bmain, Scene *scene, ID *id, unsigned int *rec
 
 	ip.bmain = bmain;
 	ip.scene = scene;
-	ip.owner = id;
+	ip.owner = BKE_previewimg_id_ensure(id);
 	ip.id = id;
 
 	icon_preview_add_size(&ip, rect, sizex, sizey);

source/blender/render/intern/include/render_types.h

@@ -337,7 +337,7 @@ typedef struct ObjectRen {
 	char (*mcol)[MAX_CUSTOMDATA_LAYER_NAME];
 	int  actmtface, actmcol, bakemtface;
 
-	char tangent_mask; /* which tangent layer should be calculated */
+	short tangent_mask; /* which tangent layer should be calculated */
 
 	float obmat[4][4];	/* only used in convertblender.c, for instancing */
 

source/blender/render/intern/source/convertblender.c

@@ -3440,10 +3440,9 @@ static void init_render_mesh(Render *re, ObjectRen *obr, int timeoffset)
 										if (need_nmap_tangent_concrete || need_tangent) {
 											int uv_start = CustomData_get_layer_index(&dm->faceData, CD_MTFACE);
 											int uv_index = CustomData_get_named_layer_index(&dm->faceData, CD_MTFACE, layer->name);
-											BLI_assert(uv_start >= 0 && uv_index >= 0);
+
-											if ((uv_start < 0 || uv_index < 0))
+											/* if there are no UVs, orco tangents are in first slot */
-												continue;
+											int n = (uv_start >= 0 && uv_index >= 0) ? uv_index - uv_start : 0;
-											int n = uv_index - uv_start;
 
 											const float *tangent = (const float *) layer->data;
 											float *ftang = RE_vlakren_get_nmap_tangent(obr, vlr, n, true);

source/blender/windowmanager/intern/wm_files.c

@@ -326,7 +326,7 @@ static void wm_window_match_do(bContext *C, ListBase *oldwmlist)
 }
 
 /* in case UserDef was read, we re-initialize all, and do versioning */
-static void wm_init_userdef(Main *bmain, const bool use_factory_settings)
+static void wm_init_userdef(Main *bmain, const bool read_userdef_from_memory)
 {
 	/* versioning is here */
 	UI_init_userdef();
@@ -344,7 +344,7 @@ static void wm_init_userdef(Main *bmain, const bool use_factory_settings)
 	}
 
 	/* avoid re-saving for every small change to our prefs, allow overrides */
-	if (use_factory_settings) {
+	if (read_userdef_from_memory) {
 		BLO_update_defaults_userpref_blend();
 	}
 
@@ -675,7 +675,7 @@ int wm_homefile_read(
 	 *
 	 * And in this case versioning code is to be run.
 	 */
-	bool read_userdef_from_memory = true;
+	bool read_userdef_from_memory = false;
 	eBLOReadSkip skip_flags = 0;
 
 	/* options exclude eachother */
@@ -721,7 +721,6 @@ int wm_homefile_read(
 			BKE_blender_userdef_set_data(userdef);
 			MEM_freeN(userdef);
 
-			read_userdef_from_memory = false;
 			skip_flags |= BLO_READ_SKIP_USERDEF;
 			printf("Read prefs: %s\n", filepath_userdef);
 		}
@@ -783,6 +782,9 @@ int wm_homefile_read(
 		success = BKE_blendfile_read_from_memory(
 		        C, datatoc_startup_blend, datatoc_startup_blend_size,
 		        NULL, skip_flags, true);
+		if (success && !(skip_flags & BLO_READ_SKIP_USERDEF)) {
+			read_userdef_from_memory = true;
+		}
 		if (BLI_listbase_is_empty(&wmbase)) {
 			wm_clear_default_size(C);
 		}
@@ -818,6 +820,7 @@ int wm_homefile_read(
 			/* we need to have preferences load to overwrite preferences from previous template */
 			userdef_template = BKE_blendfile_userdef_read_from_memory(
 			        datatoc_startup_blend, datatoc_startup_blend_size, NULL);
+			read_userdef_from_memory = true;
 		}
 		if (userdef_template) {
 			BKE_blender_userdef_set_app_template(userdef_template);

tests/gtests/blenlib/BLI_kdopbvh_test.cc

@@ -58,7 +58,10 @@ static void find_nearest_points_test(int points_len, float scale, int round, int
 {
 	struct RNG *rng = BLI_rng_new(random_seed);
 	BVHTree *tree = BLI_bvhtree_new(points_len, 0.0, 8, 8);
-	float (*points)[3] = (float (*)[3])MEM_mallocN(sizeof(float[3]) * points_len, __func__);
+
+	void *mem = MEM_mallocN(sizeof(float[3]) * points_len, __func__);
+	float (*points)[3] = (float (*)[3])mem;
+
 	for (int i = 0; i < points_len; i++) {
 		rng_v3_round(points[i], 3, rng, round, scale);
 		BLI_bvhtree_insert(tree, i, points[i], 1);