blender
/
blender
136
406
Fork 590
Code Issues 6.2k Pull Requests 760 Projects 19 Wiki Activity

Cleanup: use function style casts

This commit is contained in:
Campbell Barton 2023-01-23 17:31:46 +11:00
parent ab0be6ec24
commit eca4b991d8
11 changed files with 141 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
source/blender/blenkernel/intern/deform.cc
View File

@ -1053,7 +1053,7 @@ void BKE_defvert_extract_vgroup_to_edgeweights(const MDeformVert *dvert,
if (dvert && defgroup != -1) {
int i = edges_num;
float *tmp_weights = static_cast<float *>(
MEM_mallocN(sizeof(*tmp_weights) * (size_t)verts_num, __func__));
MEM_mallocN(sizeof(*tmp_weights) * size_t(verts_num), __func__));
BKE_defvert_extract_vgroup_to_vertweights(
dvert, defgroup, verts_num, invert_vgroup, tmp_weights);
@ -1082,7 +1082,7 @@ void BKE_defvert_extract_vgroup_to_loopweights(const MDeformVert *dvert,
if (dvert && defgroup != -1) {
int i = loops_num;
float *tmp_weights = static_cast<float *>(
MEM_mallocN(sizeof(*tmp_weights) * (size_t)verts_num, __func__));
MEM_mallocN(sizeof(*tmp_weights) * size_t(verts_num), __func__));
BKE_defvert_extract_vgroup_to_vertweights(
dvert, defgroup, verts_num, invert_vgroup, tmp_weights);
@ -1113,7 +1113,7 @@ void BKE_defvert_extract_vgroup_to_polyweights(const MDeformVert *dvert,
if (dvert && defgroup != -1) {
int i = polys_num;
float *tmp_weights = static_cast<float *>(
MEM_mallocN(sizeof(*tmp_weights) * (size_t)verts_num, __func__));
MEM_mallocN(sizeof(*tmp_weights) * size_t(verts_num), __func__));
BKE_defvert_extract_vgroup_to_vertweights(
dvert, defgroup, verts_num, invert_vgroup, tmp_weights);

84
source/blender/blenkernel/intern/dynamicpaint.cc
View File

@ -768,12 +768,12 @@ static void surfaceGenerateGrid(DynamicPaintSurface *surface)
volume = td[0] * td[1] * td[2];
/* determine final grid size by trying to fit average 10.000 points per grid cell */
dim_factor = (float)pow((double)volume / ((double)sData->total_points / 10000.0),
1.0 / (double)axis);
dim_factor = (float)pow(double(volume) / (double(sData->total_points) / 10000.0),
1.0 / double(axis));
/* define final grid size using dim_factor, use min 3 for active axes */
for (i = 0; i < 3; i++) {
grid->dim[i] = (int)floor(td[i] / dim_factor);
grid->dim[i] = int(floor(td[i] / dim_factor));
CLAMP(grid->dim[i], (dim[i] >= min_dim) ? 3 : 1, 100);
}
grid_cells = grid->dim[0] * grid->dim[1] * grid->dim[2];
@ -2101,7 +2101,7 @@ static void dynamicPaint_frameUpdate(
/* loop through surfaces */
for (; surface; surface = surface->next) {
int current_frame = (int)scene->r.cfra;
int current_frame = int(scene->r.cfra);
bool no_surface_data;
/* free bake data if not required anymore */
@ -2123,7 +2123,7 @@ static void dynamicPaint_frameUpdate(
CLAMP(current_frame, surface->start_frame, surface->end_frame);
if (no_surface_data || current_frame != surface->current_frame ||
(int)scene->r.cfra == surface->start_frame) {
int(scene->r.cfra) == surface->start_frame) {
PointCache *cache = surface->pointcache;
PTCacheID pid;
surface->current_frame = current_frame;
@ -2132,21 +2132,21 @@ static void dynamicPaint_frameUpdate(
BKE_ptcache_id_from_dynamicpaint(&pid, ob, surface);
pid.cache->startframe = surface->start_frame;
pid.cache->endframe = surface->end_frame;
BKE_ptcache_id_time(&pid, scene, (float)scene->r.cfra, nullptr, nullptr, nullptr);
BKE_ptcache_id_time(&pid, scene, float(scene->r.cfra), nullptr, nullptr, nullptr);
/* reset non-baked cache at first frame */
if ((int)scene->r.cfra == surface->start_frame && !(cache->flag & PTCACHE_BAKED)) {
if (int(scene->r.cfra) == surface->start_frame && !(cache->flag & PTCACHE_BAKED)) {
cache->flag |= PTCACHE_REDO_NEEDED;
BKE_ptcache_id_reset(scene, &pid, PTCACHE_RESET_OUTDATED);
cache->flag &= ~PTCACHE_REDO_NEEDED;
}
/* try to read from cache */
bool can_simulate = ((int)scene->r.cfra == current_frame) &&
bool can_simulate = (int(scene->r.cfra) == current_frame) &&
!(cache->flag & PTCACHE_BAKED);
if (BKE_ptcache_read(&pid, (float)scene->r.cfra, can_simulate)) {
BKE_ptcache_validate(cache, (int)scene->r.cfra);
if (BKE_ptcache_read(&pid, float(scene->r.cfra), can_simulate)) {
BKE_ptcache_validate(cache, int(scene->r.cfra));
}
/* if read failed and we're on surface range do recalculate */
else if (can_simulate) {
@ -2238,24 +2238,24 @@ static void dynamic_paint_create_uv_surface_direct_cb(void *__restrict userdata,
tPoint->pixel_index = index;
/* Actual pixel center, used when collision is found */
point[0][0] = ((float)tx + 0.5f) / w;
point[0][1] = ((float)ty + 0.5f) / h;
point[0][0] = (float(tx) + 0.5f) / w;
point[0][1] = (float(ty) + 0.5f) / h;
/*
* A pixel middle sample isn't enough to find very narrow polygons
* So using 4 samples of each corner too
*/
point[1][0] = ((float)tx) / w;
point[1][1] = ((float)ty) / h;
point[1][0] = (float(tx)) / w;
point[1][1] = (float(ty)) / h;
point[2][0] = ((float)tx + 1) / w;
point[2][1] = ((float)ty) / h;
point[2][0] = (float(tx) + 1) / w;
point[2][1] = (float(ty)) / h;
point[3][0] = ((float)tx) / w;
point[3][1] = ((float)ty + 1) / h;
point[3][0] = (float(tx)) / w;
point[3][1] = (float(ty) + 1) / h;
point[4][0] = ((float)tx + 1) / w;
point[4][1] = ((float)ty + 1) / h;
point[4][0] = (float(tx) + 1) / w;
point[4][1] = (float(ty) + 1) / h;
/* Loop through samples, starting from middle point */
for (int sample = 0; sample < 5; sample++) {
@ -2337,8 +2337,8 @@ static void dynamic_paint_create_uv_surface_neighbor_cb(void *__restrict userdat
const int v_min = (ty > 0) ? -1 : 0;
const int v_max = (ty < (h - 1)) ? 1 : 0;
point[0] = ((float)tx + 0.5f) / w;
point[1] = ((float)ty + 0.5f) / h;
point[0] = (float(tx) + 0.5f) / w;
point[1] = (float(ty) + 0.5f) / h;
/* search through defined area for neighbor, checking grid directions first */
for (int ni = 0; ni < 8; ni++) {
@ -2505,8 +2505,8 @@ static int dynamic_paint_find_neighbor_pixel(const DynamicPaintCreateUVSurfaceDa
float pixel[2];
pixel[0] = ((float)(px + neighX[n_index]) + 0.5f) / (float)w;
pixel[1] = ((float)(py + neighY[n_index]) + 0.5f) / (float)h;
pixel[0] = (float(px + neighX[n_index]) + 0.5f) / float(w);
pixel[1] = (float(py + neighY[n_index]) + 0.5f) / float(h);
/* Do a small recursive search for the best island edge. */
dynamic_paint_find_island_border(data, &bdata, cPoint->tri_index, pixel, -1, 5);
@ -2646,7 +2646,7 @@ static void dynamic_paint_find_island_border(const DynamicPaintCreateUVSurfaceDa
int w = bdata->w, h = bdata->h, px = bdata->px, py = bdata->py;
const int final_pixel[2] = {(int)floorf(tgt_pixel[0] * w), (int)floorf(tgt_pixel[1] * h)};
const int final_pixel[2] = {int(floorf(tgt_pixel[0] * w)), int(floorf(tgt_pixel[1] * h))};
/* If current pixel uv is outside of texture */
if (final_pixel[0] < 0 || final_pixel[0] >= w || final_pixel[1] < 0 || final_pixel[1] >= h) {
@ -3124,7 +3124,7 @@ int dynamicPaint_createUVSurface(Scene *scene,
sData->total_points = 0;
}
else {
sData->total_points = (int)active_points;
sData->total_points = int(active_points);
sData->format_data = f_data;
for (int index = 0, cursor = 0; index < (w * h); index++) {
@ -3960,7 +3960,7 @@ static void dynamic_paint_paint_mesh_cell_point_cb_ex(void *__restrict userdata,
const int index = grid->t_index[grid->s_pos[c_index] + id];
const int samples = bData->s_num[index];
int ss;
float total_sample = (float)samples;
float total_sample = float(samples);
float brushStrength = 0.0f; /* brush influence factor */
float depth = 0.0f; /* brush intersection depth */
float velocity_val = 0.0f;
@ -4322,7 +4322,7 @@ static bool dynamicPaint_paintMesh(Depsgraph *depsgraph,
}
if (brush->flags & MOD_DPAINT_PROX_PROJECT && brush->collision != MOD_DPAINT_COL_VOLUME) {
mul_v3_fl(avg_brushNor, 1.0f / (float)numOfVerts);
mul_v3_fl(avg_brushNor, 1.0f / float(numOfVerts));
/* instead of null vector use positive z */
if (UNLIKELY(normalize_v3(avg_brushNor) == 0.0f)) {
avg_brushNor[2] = 1.0f;
@ -4878,7 +4878,7 @@ static void dynamicPaint_prepareAdjacencyData(DynamicPaintSurface *surface, cons
int numOfNeighs = adj_data->n_num[index];
for (int i = 0; i < numOfNeighs; i++) {
bData->average_dist += (double)bNeighs[adj_data->n_index[index] + i].dist;
bData->average_dist += double(bNeighs[adj_data->n_index[index] + i].dist);
}
}
bData->average_dist /= adj_data->total_targets;
@ -4959,11 +4959,11 @@ static void surface_determineForceTargetPoints(const PaintSurfaceData *sData,
/* and multiply depending on how deeply force intersects surface */
temp = fabsf(force_intersect);
CLAMP(temp, 0.0f, 1.0f);
mul_v2_fl(closest_d, acosf(temp) / (float)M_PI_2);
mul_v2_fl(closest_d, acosf(temp) / float(M_PI_2));
}
else {
/* if only single neighbor, still linearize force intersection effect */
closest_d[0] = 1.0f - acosf(closest_d[0]) / (float)M_PI_2;
closest_d[0] = 1.0f - acosf(closest_d[0]) / float(M_PI_2);
}
}
@ -4986,9 +4986,9 @@ static void dynamicPaint_doSmudge(DynamicPaintSurface *surface,
CLAMP_MIN(max_velocity, vel);
}
int steps = (int)ceil((double)max_velocity / bData->average_dist * (double)timescale);
int steps = int(ceil(double(max_velocity) / bData->average_dist * double(timescale)));
CLAMP(steps, 0, 12);
float eff_scale = brush->smudge_strength / (float)steps * timescale;
float eff_scale = brush->smudge_strength / float(steps) * timescale;
for (int step = 0; step < steps; step++) {
for (int index = 0; index < sData->total_points; index++) {
@ -5188,9 +5188,9 @@ static int dynamicPaint_prepareEffectStep(Depsgraph *depsgraph,
}
fastest_effect = max_fff(spread_speed, shrink_speed, average_force);
avg_dist = bData->average_dist * (double)CANVAS_REL_SIZE / (double)getSurfaceDimension(sData);
avg_dist = bData->average_dist * double(CANVAS_REL_SIZE) / double(getSurfaceDimension(sData));
steps = (int)ceilf(1.5f * EFF_MOVEMENT_PER_FRAME * fastest_effect / avg_dist * timescale);
steps = int(ceilf(1.5f * EFF_MOVEMENT_PER_FRAME * fastest_effect / avg_dist * timescale));
CLAMP(steps, 1, 20);
return steps;
@ -5369,7 +5369,7 @@ static void dynamic_paint_effect_drip_cb(void *__restrict userdata,
float dir_factor, a_factor;
const float speed_scale = eff_scale * force[index * 4 + 3] / bNeighs[n_idx].dist;
const uint n_trgt = (uint)n_target[n_idx];
const uint n_trgt = uint(n_target[n_idx]);
/* Sort of spin-lock, but only for given ePoint.
* Since the odds a same ePoint is modified at the same time by several threads is very low,
@ -5740,14 +5740,14 @@ static void dynamicPaint_doWaveStep(DynamicPaintSurface *surface, float timescal
int numOfNeighs = sData->adj_data->n_num[index];
for (int i = 0; i < numOfNeighs; i++) {
average_dist += (double)bNeighs[sData->adj_data->n_index[index] + i].dist;
average_dist += double(bNeighs[sData->adj_data->n_index[index] + i].dist);
}
}
average_dist *= (double)wave_scale / sData->adj_data->total_targets;
average_dist *= double(wave_scale) / sData->adj_data->total_targets;
/* determine number of required steps */
steps = (int)ceil((double)(WAVE_TIME_FAC * timescale * surface->wave_timescale) /
(average_dist / (double)wave_speed / 3));
steps = (int)ceil(double(WAVE_TIME_FAC * timescale * surface->wave_timescale) /
(average_dist / double(wave_speed) / 3));
CLAMP(steps, 1, 20);
timescale /= steps;
@ -6346,7 +6346,7 @@ static int dynamicPaint_doStep(Depsgraph *depsgraph,
/* Prepare effects and get number of required steps */
steps = dynamicPaint_prepareEffectStep(depsgraph, surface, scene, ob, &force, timescale);
for (s = 0; s < steps; s++) {
dynamicPaint_doEffectStep(surface, force, prevPoint, timescale, (float)steps);
dynamicPaint_doEffectStep(surface, force, prevPoint, timescale, float(steps));
}
/* Free temporary effect data */
@ -6386,7 +6386,7 @@ int dynamicPaint_calculateFrame(
timescale = 1.0f / (surface->substeps + 1);
for (st = 1; st <= surface->substeps; st++) {
float subframe = ((float)st) / (surface->substeps + 1);
float subframe = (float(st)) / (surface->substeps + 1);
if (!dynamicPaint_doStep(depsgraph, scene, cObject, surface, timescale, subframe)) {
return 0;
}

106
source/blender/blenkernel/intern/fluid.cc
View File

@ -441,28 +441,28 @@ static void manta_set_domain_from_mesh(FluidDomainSettings *fds,
scale = res / size[0];
fds->scale = size[0] / fabsf(ob->scale[0]);
fds->base_res[0] = res;
fds->base_res[1] = max_ii((int)(size[1] * scale + 0.5f), 4);
fds->base_res[2] = max_ii((int)(size[2] * scale + 0.5f), 4);
fds->base_res[1] = max_ii(int(size[1] * scale + 0.5f), 4);
fds->base_res[2] = max_ii(int(size[2] * scale + 0.5f), 4);
}
else if (size[1] >= MAX2(size[0], size[2])) {
scale = res / size[1];
fds->scale = size[1] / fabsf(ob->scale[1]);
fds->base_res[0] = max_ii((int)(size[0] * scale + 0.5f), 4);
fds->base_res[0] = max_ii(int(size[0] * scale + 0.5f), 4);
fds->base_res[1] = res;
fds->base_res[2] = max_ii((int)(size[2] * scale + 0.5f), 4);
fds->base_res[2] = max_ii(int(size[2] * scale + 0.5f), 4);
}
else {
scale = res / size[2];
fds->scale = size[2] / fabsf(ob->scale[2]);
fds->base_res[0] = max_ii((int)(size[0] * scale + 0.5f), 4);
fds->base_res[1] = max_ii((int)(size[1] * scale + 0.5f), 4);
fds->base_res[0] = max_ii(int(size[0] * scale + 0.5f), 4);
fds->base_res[1] = max_ii(int(size[1] * scale + 0.5f), 4);
fds->base_res[2] = res;
}
/* Set cell size. */
fds->cell_size[0] /= (float)fds->base_res[0];
fds->cell_size[1] /= (float)fds->base_res[1];
fds->cell_size[2] /= (float)fds->base_res[2];
fds->cell_size[0] /= float(fds->base_res[0]);
fds->cell_size[1] /= float(fds->base_res[1]);
fds->cell_size[2] /= float(fds->base_res[2]);
}
static void update_final_gravity(FluidDomainSettings *fds, Scene *scene)
@ -479,7 +479,7 @@ static void update_final_gravity(FluidDomainSettings *fds, Scene *scene)
static bool fluid_modifier_init(
FluidModifierData *fmd, Depsgraph *depsgraph, Object *ob, Scene *scene, Mesh *me)
{
int scene_framenr = (int)DEG_get_ctime(depsgraph);
int scene_framenr = int(DEG_get_ctime(depsgraph));
if ((fmd->type & MOD_FLUID_TYPE_DOMAIN) && fmd->domain && !fmd->domain->fluid) {
FluidDomainSettings *fds = fmd->domain;
@ -590,10 +590,10 @@ static void clamp_bounds_in_domain(FluidDomainSettings *fds,
/* Adapt to velocity. */
if (min_vel && min_vel[i] < 0.0f) {
min[i] += (int)floor(min_vel[i] * dt);
min[i] += int(floor(min_vel[i] * dt));
}
if (max_vel && max_vel[i] > 0.0f) {
max[i] += (int)ceil(max_vel[i] * dt);
max[i] += int(ceil(max_vel[i] * dt));
}
/* Clamp within domain max size. */
@ -650,18 +650,18 @@ static void bb_boundInsert(FluidObjectBB *bb, const float point[3])
int i = 0;
if (!bb->valid) {
for (; i < 3; i++) {
bb->min[i] = (int)floor(point[i]);
bb->max[i] = (int)ceil(point[i]);
bb->min[i] = int(floor(point[i]));
bb->max[i] = int(ceil(point[i]));
}
bb->valid = 1;
}
else {
for (; i < 3; i++) {
if (point[i] < bb->min[i]) {
bb->min[i] = (int)floor(point[i]);
bb->min[i] = int(floor(point[i]));
}
if (point[i] > bb->max[i]) {
bb->max[i] = (int)ceil(point[i]);
bb->max[i] = int(ceil(point[i]));
}
}
}
@ -960,7 +960,7 @@ static void obstacles_from_mesh_task_cb(void *__restrict userdata,
for (int y = data->min[1]; y < data->max[1]; y++) {
const int index = manta_get_index(
x - bb->min[0], bb->res[0], y - bb->min[1], bb->res[1], z - bb->min[2]);
const float ray_start[3] = {(float)x + 0.5f, (float)y + 0.5f, (float)z + 0.5f};
const float ray_start[3] = {float(x) + 0.5f, float(y) + 0.5f, float(z) + 0.5f};
/* Calculate levelset values from meshes. Result in bb->distances. */
update_distances(index,
@ -1055,7 +1055,7 @@ static void obstacles_from_mesh(Object *coll_ob,
/* Set emission map.
* Use 3 cell diagonals as margin (3 * 1.732 = 5.196). */
int bounds_margin = (int)ceil(5.196);
int bounds_margin = int(ceil(5.196));
clamp_bounds_in_domain(fds, bb->min, bb->max, nullptr, nullptr, bounds_margin, dt);
bb_allocateData(bb, true, false);
@ -1216,7 +1216,7 @@ static void compute_obstaclesemission(Scene *scene,
}
/* More splitting because of emission subframe: If no subframes present, sample_size is 1. */
float sample_size = 1.0f / (float)(subframes + 1);
float sample_size = 1.0f / float(subframes + 1);
float subframe_dt = dt * sample_size;
/* Emission loop. When not using subframes this will loop only once. */
@ -1484,7 +1484,7 @@ static void emit_from_particles_task_cb(void *__restrict userdata,
for (int y = data->min[1]; y < data->max[1]; y++) {
const int index = manta_get_index(
x - bb->min[0], bb->res[0], y - bb->min[1], bb->res[1], z - bb->min[2]);
const float ray_start[3] = {((float)x) + 0.5f, ((float)y) + 0.5f, ((float)z) + 0.5f};
const float ray_start[3] = {(float(x)) + 0.5f, (float(y)) + 0.5f, (float(z)) + 0.5f};
/* Find particle distance from the kdtree. */
KDTreeNearest_3d nearest;
@ -1554,7 +1554,7 @@ static void emit_from_particles(Object *flow_ob,
/* setup particle radius emission if enabled */
if (ffs->flags & FLUID_FLOW_USE_PART_SIZE) {
tree = BLI_kdtree_3d_new(psys->totpart + psys->totchild);
bounds_margin = (int)ceil(solid + smooth);
bounds_margin = int(ceil(solid + smooth));
}
/* calculate local position for each particle */
@ -2008,7 +2008,7 @@ static void emit_from_mesh_task_cb(void *__restrict userdata,
for (int y = data->min[1]; y < data->max[1]; y++) {
const int index = manta_get_index(
x - bb->min[0], bb->res[0], y - bb->min[1], bb->res[1], z - bb->min[2]);
const float ray_start[3] = {((float)x) + 0.5f, ((float)y) + 0.5f, ((float)z) + 0.5f};
const float ray_start[3] = {(float(x)) + 0.5f, (float(y)) + 0.5f, (float(z)) + 0.5f};
/* Compute emission only for flow objects that produce fluid (i.e. skip outflow objects).
* Result in bb->influence. Also computes initial velocities. Result in bb->velocity. */
@ -2031,9 +2031,9 @@ static void emit_from_mesh_task_cb(void *__restrict userdata,
data->has_velocity,
data->defgrp_index,
data->dvert,
(float)x,
(float)y,
(float)z);
float(x),
float(y),
float(z));
}
/* Calculate levelset values from meshes. Result in bb->distances. */
@ -2123,7 +2123,7 @@ static void emit_from_mesh(
/* Set emission map.
* Use 3 cell diagonals as margin (3 * 1.732 = 5.196). */
int bounds_margin = (int)ceil(5.196);
int bounds_margin = int(ceil(5.196));
clamp_bounds_in_domain(fds, bb->min, bb->max, nullptr, nullptr, bounds_margin, dt);
bb_allocateData(bb, ffs->flags & FLUID_FLOW_INITVELOCITY, true);
@ -2199,9 +2199,9 @@ static void adaptive_domain_adjust(
/* add to total shift */
add_v3_v3(fds->shift_f, frame_shift_f);
/* convert to integer */
total_shift[0] = (int)floorf(fds->shift_f[0]);
total_shift[1] = (int)floorf(fds->shift_f[1]);
total_shift[2] = (int)floorf(fds->shift_f[2]);
total_shift[0] = int(floorf(fds->shift_f[0]));
total_shift[1] = int(floorf(fds->shift_f[1]));
total_shift[2] = int(floorf(fds->shift_f[2]));
int temp_shift[3];
copy_v3_v3_int(temp_shift, fds->shift);
sub_v3_v3v3_int(new_shift, total_shift, fds->shift);
@ -2733,7 +2733,7 @@ static void compute_flowsemission(Scene *scene,
}
/* More splitting because of emission subframe: If no subframes present, sample_size is 1. */
float sample_size = 1.0f / (float)(subframes + 1);
float sample_size = 1.0f / float(subframes + 1);
float subframe_dt = dt * sample_size;
/* Emission loop. When not using subframes this will loop only once. */
@ -3135,9 +3135,9 @@ static void update_effectors_task_cb(void *__restrict userdata,
normalize_v3(vel);
mul_v3_fl(vel, mag);
voxel_center[0] = fds->p0[0] + fds->cell_size[0] * ((float)(x + fds->res_min[0]) + 0.5f);
voxel_center[1] = fds->p0[1] + fds->cell_size[1] * ((float)(y + fds->res_min[1]) + 0.5f);
voxel_center[2] = fds->p0[2] + fds->cell_size[2] * ((float)(z + fds->res_min[2]) + 0.5f);
voxel_center[0] = fds->p0[0] + fds->cell_size[0] * (float(x + fds->res_min[0]) + 0.5f);
voxel_center[1] = fds->p0[1] + fds->cell_size[1] * (float(y + fds->res_min[1]) + 0.5f);
voxel_center[2] = fds->p0[2] + fds->cell_size[2] * (float(z + fds->res_min[2]) + 0.5f);
mul_m4_v3(fds->obmat, voxel_center);
/* Do effectors. */
@ -3297,7 +3297,7 @@ static Mesh *create_liquid_geometry(FluidDomainSettings *fds,
positions[i][2] = manta_liquid_get_vertex_z_at(fds->fluid, i);
/* Adjust coordinates from Mantaflow to match viewport scaling. */
float tmp[3] = {(float)fds->res[0], (float)fds->res[1], (float)fds->res[2]};
float tmp[3] = {float(fds->res[0]), float(fds->res[1]), float(fds->res[2])};
/* Scale to unit cube around 0. */
mul_v3_fl(tmp, fds->mesh_scale * 0.5f);
sub_v3_v3(positions[i], tmp);
@ -4078,7 +4078,7 @@ static void fluid_modifier_processDomain(FluidModifierData *fmd,
static void fluid_modifier_process(
FluidModifierData *fmd, Depsgraph *depsgraph, Scene *scene, Object *ob, Mesh *me)
{
const int scene_framenr = (int)DEG_get_ctime(depsgraph);
const int scene_framenr = int(DEG_get_ctime(depsgraph));
if (fmd->type & MOD_FLUID_TYPE_FLOW) {
fluid_modifier_processFlow(fmd, depsgraph, scene, ob, me, scene_framenr);
@ -4304,15 +4304,15 @@ static void manta_smoke_calc_transparency(FluidDomainSettings *fds,
/* Convert light pos to sim cell space. */
mul_m4_v3(fds->imat, light);
light[0] = (light[0] - fds->p0[0]) / fds->cell_size[0] - 0.5f - (float)fds->res_min[0];
light[1] = (light[1] - fds->p0[1]) / fds->cell_size[1] - 0.5f - (float)fds->res_min[1];
light[2] = (light[2] - fds->p0[2]) / fds->cell_size[2] - 0.5f - (float)fds->res_min[2];
light[0] = (light[0] - fds->p0[0]) / fds->cell_size[0] - 0.5f - float(fds->res_min[0]);
light[1] = (light[1] - fds->p0[1]) / fds->cell_size[1] - 0.5f - float(fds->res_min[1]);
light[2] = (light[2] - fds->p0[2]) / fds->cell_size[2] - 0.5f - float(fds->res_min[2]);
/* Calculate domain bounds in sim cell space. */
/* 0,2,4 = 0.0f */
bv[1] = (float)fds->res[0]; /* X */
bv[3] = (float)fds->res[1]; /* Y */
bv[5] = (float)fds->res[2]; /* Z */
bv[1] = float(fds->res[0]); /* X */
bv[3] = float(fds->res[1]); /* Y */
bv[5] = float(fds->res[2]); /* Z */
for (int z = 0; z < fds->res[2]; z++) {
size_t index = z * slabsize;
@ -4327,22 +4327,22 @@ static void manta_smoke_calc_transparency(FluidDomainSettings *fds,
/* Reset shadow value. */
shadow[index] = -1.0f;
voxel_center[0] = (float)x;
voxel_center[1] = (float)y;
voxel_center[2] = (float)z;
voxel_center[0] = float(x);
voxel_center[1] = float(y);
voxel_center[2] = float(z);
/* Get starting cell (light pos). */
if (BLI_bvhtree_bb_raycast(bv, light, voxel_center, pos) > FLT_EPSILON) {
/* We're outside -> use point on side of domain. */
cell[0] = (int)floor(pos[0]);
cell[1] = (int)floor(pos[1]);
cell[2] = (int)floor(pos[2]);
cell[0] = int(floor(pos[0]));
cell[1] = int(floor(pos[1]));
cell[2] = int(floor(pos[2]));
}
else {
/* We're inside -> use light itself. */
cell[0] = (int)floor(light[0]);
cell[1] = (int)floor(light[1]);
cell[2] = (int)floor(light[2]);
cell[0] = int(floor(light[0]));
cell[1] = int(floor(light[1]));
cell[2] = int(floor(light[2]));
}
/* Clamp within grid bounds */
CLAMP(cell[0], 0, fds->res[0] - 1);
@ -4394,9 +4394,9 @@ float BKE_fluid_get_velocity_at(Object *ob, float position[3], float velocity[3]
}
/* map pos between 0.0 - 1.0 */
pos[0] = (pos[0] - fds->res_min[0]) / ((float)fds->res[0]);
pos[1] = (pos[1] - fds->res_min[1]) / ((float)fds->res[1]);
pos[2] = (pos[2] - fds->res_min[2]) / ((float)fds->res[2]);
pos[0] = (pos[0] - fds->res_min[0]) / (float(fds->res[0]));
pos[1] = (pos[1] - fds->res_min[1]) / (float(fds->res[1]));
pos[2] = (pos[2] - fds->res_min[2]) / (float(fds->res[2]));
/* Check if position is outside active area. */
if (fds->type == FLUID_DOMAIN_TYPE_GAS && fds->flags & FLUID_DOMAIN_USE_ADAPTIVE_DOMAIN) {

14
source/blender/blenkernel/intern/subdiv_foreach.cc
View File

@ -424,7 +424,7 @@ static void subdiv_foreach_edge_vertices_regular_do(SubdivForeachTaskContext *ct
{
const int resolution = ctx->settings->resolution;
const int resolution_1 = resolution - 1;
const float inv_resolution_1 = 1.0f / (float)resolution_1;
const float inv_resolution_1 = 1.0f / float(resolution_1);
const int num_subdiv_vertices_per_coarse_edge = resolution - 2;
const int coarse_poly_index = coarse_poly - ctx->coarse_polys;
const int ptex_face_index = ctx->face_ptex_offset[coarse_poly_index];
@ -487,7 +487,7 @@ static void subdiv_foreach_edge_vertices_special_do(SubdivForeachTaskContext *ct
const int resolution = ctx->settings->resolution;
const int num_subdiv_vertices_per_coarse_edge = resolution - 2;
const int num_vertices_per_ptex_edge = ((resolution >> 1) + 1);
const float inv_ptex_resolution_1 = 1.0f / (float)(num_vertices_per_ptex_edge - 1);
const float inv_ptex_resolution_1 = 1.0f / float(num_vertices_per_ptex_edge - 1);
const int coarse_poly_index = coarse_poly - ctx->coarse_polys;
const int ptex_face_start_index = ctx->face_ptex_offset[coarse_poly_index];
int ptex_face_index = ptex_face_start_index;
@ -598,7 +598,7 @@ static void subdiv_foreach_inner_vertices_regular(SubdivForeachTaskContext *ctx,
const MPoly *coarse_poly)
{
const int resolution = ctx->settings->resolution;
const float inv_resolution_1 = 1.0f / (float)(resolution - 1);
const float inv_resolution_1 = 1.0f / float(resolution - 1);
const int coarse_poly_index = coarse_poly - ctx->coarse_polys;
const int ptex_face_index = ctx->face_ptex_offset[coarse_poly_index];
const int start_vertex_index = ctx->subdiv_vertex_offset[coarse_poly_index];
@ -625,7 +625,7 @@ static void subdiv_foreach_inner_vertices_special(SubdivForeachTaskContext *ctx,
{
const int resolution = ctx->settings->resolution;
const int ptex_face_resolution = ptex_face_resolution_get(coarse_poly, resolution);
const float inv_ptex_face_resolution_1 = 1.0f / (float)(ptex_face_resolution - 1);
const float inv_ptex_face_resolution_1 = 1.0f / float(ptex_face_resolution - 1);
const int coarse_poly_index = coarse_poly - ctx->coarse_polys;
int ptex_face_index = ctx->face_ptex_offset[coarse_poly_index];
const int start_vertex_index = ctx->subdiv_vertex_offset[coarse_poly_index];
@ -1096,7 +1096,7 @@ static void subdiv_foreach_loops_regular(SubdivForeachTaskContext *ctx,
const int ptex_inner_resolution = ptex_resolution - 2;
const int num_subdiv_edges_per_coarse_edge = resolution - 1;
const int num_subdiv_vertices_per_coarse_edge = resolution - 2;
const float inv_ptex_resolution_1 = 1.0f / (float)(ptex_resolution - 1);
const float inv_ptex_resolution_1 = 1.0f / float(ptex_resolution - 1);
const int ptex_face_index = ctx->face_ptex_offset[coarse_poly_index];
const int start_vertex_index = ctx->vertices_inner_offset +
ctx->subdiv_vertex_offset[coarse_poly_index];
@ -1285,7 +1285,7 @@ static void subdiv_foreach_loops_special(SubdivForeachTaskContext *ctx,
const int coarse_poly_index = coarse_poly - ctx->coarse_polys;
const int ptex_face_resolution = ptex_face_resolution_get(coarse_poly, resolution);
const int ptex_face_inner_resolution = ptex_face_resolution - 2;
const float inv_ptex_resolution_1 = 1.0f / (float)(ptex_face_resolution - 1);
const float inv_ptex_resolution_1 = 1.0f / float(ptex_face_resolution - 1);
const int num_inner_vertices_per_ptex = (ptex_face_resolution - 1) * (ptex_face_resolution - 2);
const int num_inner_edges_per_ptex_face = num_inner_edges_per_ptex_face_get(
ptex_face_inner_resolution + 1);
@ -1685,7 +1685,7 @@ static void subdiv_foreach_vertices_of_loose_edges_task(void *__restrict userdat
}
const int resolution = ctx->settings->resolution;
const int resolution_1 = resolution - 1;
const float inv_resolution_1 = 1.0f / (float)resolution_1;
const float inv_resolution_1 = 1.0f / float(resolution_1);
const int num_subdiv_vertices_per_coarse_edge = resolution - 2;
const MEdge *coarse_edge = &ctx->coarse_edges[coarse_edge_index];
/* Subdivision vertices which corresponds to edge's v1 and v2. */

16
source/blender/blenkernel/intern/subsurf_ccg.cc
View File

@ -482,13 +482,13 @@ static float *get_ss_weights(WeightTable *wtable, int gridCuts, int faceLen)
wtable->weight_table[faceLen].w = w = static_cast<float *>(
MEM_callocN(sizeof(float) * faceLen * faceLen * (gridCuts + 2) * (gridCuts + 2),
"weight table alloc"));
fac = 1.0f / (float)faceLen;
fac = 1.0f / float(faceLen);
for (i = 0; i < faceLen; i++) {
for (x = 0; x < gridCuts + 2; x++) {
for (y = 0; y < gridCuts + 2; y++) {
fx = 0.5f - (float)x / (float)(gridCuts + 1) / 2.0f;
fy = 0.5f - (float)y / (float)(gridCuts + 1) / 2.0f;
fx = 0.5f - float(x) / float(gridCuts + 1) / 2.0f;
fy = 0.5f - float(y) / float(gridCuts + 1) / 2.0f;
fac2 = faceLen - 4;
w1 = (1.0f - fx) * (1.0f - fy) + (-fac2 * fx * fy * fac);
@ -498,7 +498,7 @@ static float *get_ss_weights(WeightTable *wtable, int gridCuts, int faceLen)
/* these values aren't used for tri's and cause divide by zero */
if (faceLen > 3) {
fac2 = 1.0f - (w1 + w2 + w4);
fac2 = fac2 / (float)(faceLen - 3);
fac2 = fac2 / float(faceLen - 3);
for (j = 0; j < faceLen; j++) {
w[j] = fac2;
}
@ -537,7 +537,7 @@ static void ss_sync_ccg_from_derivedmesh(CCGSubSurf *ss,
float (*vertexCos)[3],
int useFlatSubdiv)
{
float creaseFactor = (float)ccgSubSurf_getSubdivisionLevels(ss);
float creaseFactor = float(ccgSubSurf_getSubdivisionLevels(ss));
blender::Vector<CCGVertHDL, 16> fverts;
float(*positions)[3] = (float(*)[3])dm->getVertArray(dm);
MEdge *medge = dm->getEdgeArray(dm);
@ -1004,7 +1004,7 @@ static void copyFinalLoopArray_task_cb(void *__restrict userdata,
CCGFace *f = ccgdm->faceMap[iter].face;
const int num_verts = ccgSubSurf_getFaceNumVerts(f);
const int grid_index = data->grid_offset[iter];
const size_t loop_index = 4 * (size_t)grid_index * (grid_size - 1) * (grid_size - 1);
const size_t loop_index = 4 * size_t(grid_index) * (grid_size - 1) * (grid_size - 1);
MLoop *ml = &data->mloop[loop_index];
for (int S = 0; S < num_verts; S++) {
for (int y = 0; y < grid_size - 1; y++) {
@ -1755,7 +1755,7 @@ static void set_ccgdm_all_geometry(CCGDerivedMesh *ccgdm,
for (x = 1; x < edgeSize - 1; x++) {
float w[2];
w[1] = (float)x / (edgeSize - 1);
w[1] = float(x) / (edgeSize - 1);
w[0] = 1 - w[1];
DM_interp_vert_data(dm, &ccgdm->dm, vertIdx, w, 2, vertNum);
if (vertOrigIndex) {
@ -2036,7 +2036,7 @@ void subsurf_calculate_limit_positions(Mesh *me, float (*r_positions)[3])
/* ad-hoc correction for boundary vertices, to at least avoid them
* moving completely out of place (brecht) */
if (numFaces && numFaces != N) {
mul_v3_fl(face_sum, (float)N / (float)numFaces);
mul_v3_fl(face_sum, float(N) / float(numFaces));
}
const float *co = static_cast<const float *>(ccgSubSurf_getVertData(ss, v));

10
source/blender/editors/armature/meshlaplacian.cc
View File

@ -108,16 +108,16 @@ static void laplacian_increase_edge_count(EdgeHash *edgehash, int v1, int v2)
void **p;
if (BLI_edgehash_ensure_p(edgehash, v1, v2, &p)) {
*p = (void *)((intptr_t)*p + (intptr_t)1);
*p = (void *)(intptr_t(*p) + intptr_t(1));
}
else {
*p = (void *)((intptr_t)1);
*p = (void *)(intptr_t(1));
}
}
static int laplacian_edge_count(EdgeHash *edgehash, int v1, int v2)
{
return (int)(intptr_t)BLI_edgehash_lookup(edgehash, v1, v2);
return int(intptr_t(BLI_edgehash_lookup(edgehash, v1, v2)));
}
static void laplacian_triangle_area(LaplacianSystem *sys, int i1, int i2, int i3)
@ -1248,7 +1248,7 @@ static float meshdeform_interp_w(MeshDeformBind *mdb,
float totweight = 0.0f;
for (int i = 0; i < 3; i++) {
ivec[i] = (int)gridvec[i];
ivec[i] = int(gridvec[i]);
dvec[i] = gridvec[i] - ivec[i];
}
@ -1564,7 +1564,7 @@ static void meshdeform_matrix_solve(MeshDeformModifierData *mmd, MeshDeformBind
"Mesh deform solve %d / %d |||",
a + 1,
mdb->cage_verts_num);
progress_bar((float)(a + 1) / (float)(mdb->cage_verts_num), message);
progress_bar(float(a + 1) / float(mdb->cage_verts_num), message);
}
#if 0

8
source/blender/editors/object/object_bake_api.cc
View File

@ -187,7 +187,7 @@ static bool write_internal_bake_pixels(Image *image,
void *lock;
bool is_float;
char *mask_buffer = nullptr;
const size_t pixels_num = (size_t)width * (size_t)height;
const size_t pixels_num = size_t(width) * size_t(height);
ImageUser iuser;
BKE_imageuser_default(&iuser);
@ -383,7 +383,7 @@ static bool write_external_bake_pixels(const char *filepath,
/* margins */
if (margin > 0) {
char *mask_buffer = nullptr;
const size_t pixels_num = (size_t)width * (size_t)height;
const size_t pixels_num = size_t(width) * size_t(height);
mask_buffer = static_cast<char *>(MEM_callocN(sizeof(char) * pixels_num, "Bake Mask"));
RE_bake_mask_fill(pixel_array, pixels_num, mask_buffer);
@ -765,7 +765,7 @@ static bool bake_targets_init_internal(const BakeAPIRender *bkr,
bk_image->offset = targets->pixels_num;
BKE_image_get_tile_uv(bk_image->image, bk_image->tile_number, bk_image->uv_offset);
targets->pixels_num += (size_t)ibuf->x * (size_t)ibuf->y;
targets->pixels_num += size_t(ibuf->x) * size_t(ibuf->y);
}
else {
BKE_image_release_ibuf(bk_image->image, ibuf, lock);
@ -840,7 +840,7 @@ static bool bake_targets_init_external(const BakeAPIRender *bkr,
bk_image->height = bkr->height;
bk_image->offset = targets->pixels_num;
targets->pixels_num += (size_t)bkr->width * (size_t)bkr->height;
targets->pixels_num += size_t(bkr->width) * size_t(bkr->height);
if (!bkr->is_split_materials) {
break;

2
source/blender/editors/sculpt_paint/sculpt_geodesic.cc
View File

@ -195,7 +195,7 @@ static float *SCULPT_geodesic_mesh_create(Object *ob,
edge_map_index++) {
const int e_other = ss->vemap[v_other].indices[edge_map_index];
int ev_other;
if (edges[e_other].v1 == (uint)v_other) {
if (edges[e_other].v1 == uint(v_other)) {
ev_other = edges[e_other].v2;
}
else {

24
source/blender/editors/sculpt_paint/sculpt_undo.cc
View File

@ -1235,7 +1235,7 @@ static size_t sculpt_undo_alloc_and_store_hidden(PBVH *pbvh, SculptUndoNode *uno
int *grid_indices, totgrid;
BKE_pbvh_node_get_grids(pbvh, node, &grid_indices, &totgrid, NULL, NULL, NULL);
size_t alloc_size = sizeof(*unode->grid_hidden) * (size_t)totgrid;
size_t alloc_size = sizeof(*unode->grid_hidden) * size_t(totgrid);
unode->grid_hidden = static_cast<BLI_bitmap **>(MEM_callocN(alloc_size, "unode->grid_hidden"));
for (int i = 0; i < totgrid; i++) {
@ -1335,24 +1335,24 @@ static SculptUndoNode *sculpt_undo_alloc_node(Object *ob, PBVHNode *node, Sculpt
unode->maxloop = 0;
unode->totloop = totloop;
size_t alloc_size = sizeof(int) * (size_t)totloop;
size_t alloc_size = sizeof(int) * size_t(totloop);
usculpt->undo_size += alloc_size;
}
if (need_faces) {
sculpt_undo_store_faces(ss, unode);
const size_t alloc_size = sizeof(*unode->faces) * (size_t)unode->faces_num;
const size_t alloc_size = sizeof(*unode->faces) * size_t(unode->faces_num);
usculpt->undo_size += alloc_size;
}
switch (type) {
case SCULPT_UNDO_COORDS: {
size_t alloc_size = sizeof(*unode->co) * (size_t)allvert;
size_t alloc_size = sizeof(*unode->co) * size_t(allvert);
unode->co = static_cast<float(*)[3]>(MEM_callocN(alloc_size, "SculptUndoNode.co"));
usculpt->undo_size += alloc_size;
/* Needed for original data lookup. */
alloc_size = sizeof(*unode->no) * (size_t)allvert;
alloc_size = sizeof(*unode->no) * size_t(allvert);
unode->no = static_cast<float(*)[3]>(MEM_callocN(alloc_size, "SculptUndoNode.no"));
usculpt->undo_size += alloc_size;
break;
@ -1369,7 +1369,7 @@ static SculptUndoNode *sculpt_undo_alloc_node(Object *ob, PBVHNode *node, Sculpt
break;
}
case SCULPT_UNDO_MASK: {
const size_t alloc_size = sizeof(*unode->mask) * (size_t)allvert;
const size_t alloc_size = sizeof(*unode->mask) * size_t(allvert);
unode->mask = static_cast<float *>(MEM_callocN(alloc_size, "SculptUndoNode.mask"));
usculpt->undo_size += alloc_size;
break;
@ -1377,13 +1377,13 @@ static SculptUndoNode *sculpt_undo_alloc_node(Object *ob, PBVHNode *node, Sculpt
case SCULPT_UNDO_COLOR: {
/* Allocate vertex colors, even for loop colors we still
* need this for original data lookup. */
const size_t alloc_size = sizeof(*unode->col) * (size_t)allvert;
const size_t alloc_size = sizeof(*unode->col) * size_t(allvert);
unode->col = static_cast<float(*)[4]>(MEM_callocN(alloc_size, "SculptUndoNode.col"));
usculpt->undo_size += alloc_size;
/* Allocate loop colors separately too. */
if (ss->vcol_domain == ATTR_DOMAIN_CORNER) {
size_t alloc_size_loop = sizeof(float) * 4 * (size_t)unode->totloop;
size_t alloc_size_loop = sizeof(float) * 4 * size_t(unode->totloop);
unode->loop_col = static_cast<float(*)[4]>(
MEM_calloc_arrayN(unode->totloop, sizeof(float) * 4, "SculptUndoNode.loop_col"));
@ -1399,7 +1399,7 @@ static SculptUndoNode *sculpt_undo_alloc_node(Object *ob, PBVHNode *node, Sculpt
case SCULPT_UNDO_GEOMETRY:
break;
case SCULPT_UNDO_FACE_SETS: {
const size_t alloc_size = sizeof(*unode->face_sets) * (size_t)unode->faces_num;
const size_t alloc_size = sizeof(*unode->face_sets) * size_t(unode->faces_num);
usculpt->undo_size += alloc_size;
break;
}
@ -1411,7 +1411,7 @@ static SculptUndoNode *sculpt_undo_alloc_node(Object *ob, PBVHNode *node, Sculpt
unode->totgrid = totgrid;
unode->gridsize = gridsize;
const size_t alloc_size = sizeof(*unode->grids) * (size_t)totgrid;
const size_t alloc_size = sizeof(*unode->grids) * size_t(totgrid);
unode->grids = static_cast<int *>(MEM_callocN(alloc_size, "SculptUndoNode.grids"));
usculpt->undo_size += alloc_size;
}
@ -1419,13 +1419,13 @@ static SculptUndoNode *sculpt_undo_alloc_node(Object *ob, PBVHNode *node, Sculpt
/* Regular mesh. */
unode->maxvert = ss->totvert;
const size_t alloc_size = sizeof(*unode->index) * (size_t)allvert;
const size_t alloc_size = sizeof(*unode->index) * size_t(allvert);
unode->index = static_cast<int *>(MEM_callocN(alloc_size, "SculptUndoNode.index"));
usculpt->undo_size += alloc_size;
}
if (ss->deform_modifiers_active) {
const size_t alloc_size = sizeof(*unode->orig_co) * (size_t)allvert;
const size_t alloc_size = sizeof(*unode->orig_co) * size_t(allvert);
unode->orig_co = static_cast<float(*)[3]>(MEM_callocN(alloc_size, "undoSculpt orig_cos"));
usculpt->undo_size += alloc_size;
}

2
source/blender/editors/undo/ed_undo.cc
View File

@ -138,7 +138,7 @@ void ED_undo_push(bContext *C, const char *str)
push_retval = BKE_undosys_step_push(wm->undo_stack, C, str);
if (U.undomemory != 0) {
const size_t memory_limit = (size_t)U.undomemory * 1024 * 1024;
const size_t memory_limit = size_t(U.undomemory) * 1024 * 1024;
BKE_undosys_stack_limit_steps_and_memory(wm->undo_stack, -1, memory_limit);
}

10
source/blender/windowmanager/intern/wm_files.cc
View File

@ -482,7 +482,7 @@ static void wm_init_userdef(Main *bmain)
SET_FLAG_FROM_TEST(G.f, (U.flag & USER_SCRIPT_AUTOEXEC_DISABLE) == 0, G_FLAG_SCRIPT_AUTOEXEC);
}
MEM_CacheLimiter_set_maximum(((size_t)U.memcachelimit) * 1024 * 1024);
MEM_CacheLimiter_set_maximum((size_t(U.memcachelimit)) * 1024 * 1024);
BKE_sound_init(bmain);
/* Update the temporary directory from the preferences or fallback to the system default. */
@ -1603,10 +1603,10 @@ static ImBuf *blend_file_thumb_from_screenshot(bContext *C, BlendThumbnail **r_t
int ex, ey;
if (ibuf->x > ibuf->y) {
ex = BLEN_THUMB_SIZE;
ey = max_ii(1, (int)(((float)ibuf->y / (float)ibuf->x) * BLEN_THUMB_SIZE));
ey = max_ii(1, int((float(ibuf->y) / float(ibuf->x)) * BLEN_THUMB_SIZE));
}
else {
ex = max_ii(1, (int)(((float)ibuf->x / (float)ibuf->y) * BLEN_THUMB_SIZE));
ex = max_ii(1, int((float(ibuf->x) / float(ibuf->y)) * BLEN_THUMB_SIZE));
ey = BLEN_THUMB_SIZE;
}
@ -2775,14 +2775,14 @@ static char *wm_open_mainfile_description(struct bContext * /*C*/,
char time_st[FILELIST_DIRENTRY_TIME_LEN];
bool is_today, is_yesterday;
BLI_filelist_entry_datetime_to_string(
nullptr, (int64_t)stats.st_mtime, false, time_st, date_st, &is_today, &is_yesterday);
nullptr, int64_t(stats.st_mtime), false, time_st, date_st, &is_today, &is_yesterday);
if (is_today || is_yesterday) {
BLI_strncpy(date_st, is_today ? TIP_("Today") : TIP_("Yesterday"), sizeof(date_st));
}
/* Size. */
char size_str[FILELIST_DIRENTRY_SIZE_LEN];
BLI_filelist_entry_size_to_string(nullptr, (uint64_t)stats.st_size, false, size_str);
BLI_filelist_entry_size_to_string(nullptr, uint64_t(stats.st_size), false, size_str);
return BLI_sprintfN(
"%s\n\n%s: %s %s\n%s: %s", path, TIP_("Modified"), date_st, time_st, TIP_("Size"), size_str);