VbError_t VbExDiskGetInfo(VbDiskInfo **infos_ptr, uint32_t *count,
uint32_t disk_flags)
{
int i;
int num_disks = 0;
VBDEBUG(("My %s\n", __FUNCTION__));
*infos_ptr = mock_disks;
for(i = 0; i < MAX_TEST_DISKS; i++) {
if (is_nonzero(&t->disks_to_provide[i],
sizeof(t->disks_to_provide[i]))) {
mock_disks[num_disks].bytes_per_lba =
t->disks_to_provide[i].bytes_per_lba;
mock_disks[num_disks].lba_count =
mock_disks[num_disks].streaming_lba_count =
t->disks_to_provide[i].lba_count;
mock_disks[num_disks].flags =
t->disks_to_provide[i].flags;
mock_disks[num_disks].handle = (VbExDiskHandle_t)
t->disks_to_provide[i].diskname;
VBDEBUG((" mock_disk[%d] %" PRIu64 " %" PRIu64
" 0x%x %s\n", i,
mock_disks[num_disks].bytes_per_lba,
mock_disks[num_disks].lba_count,
mock_disks[num_disks].flags,
(mock_disks[num_disks].handle
? (char *)mock_disks[num_disks].handle
: "0")));
num_disks++;
} else {
mock_disks[num_disks].handle =
(VbExDiskHandle_t)"INVALID";
}
}
if (t->disk_count_to_return >= 0)
*count = t->disk_count_to_return;
else
*count = num_disks;
VBDEBUG((" *count=%" PRIu32 "\n", *count));
VBDEBUG((" return 0x%x\n", t->diskgetinfo_return_val));
return t->diskgetinfo_return_val;
}
damping_mults calc_damping_mults(const E& handle, const invariants::rigid_body& def) {
damping_mults damping = def.damping;
handle.template dispatch_on_having_all<components::movement>([&damping](const auto& typed_handle) {
const auto& movement = typed_handle.template get<components::movement>();
const auto& movement_def = typed_handle.template get<invariants::movement>();
const bool is_inert = movement.const_inertia_ms > 0.f || movement.linear_inertia_ms > 0.f;
if (movement.const_inertia_ms > 0.f) {
damping.linear = 2;
}
else {
damping.linear = movement_def.standard_linear_damping;
}
{
const auto m = movement_def.max_linear_inertia_when_movement_possible;
const auto inertia_mult = std::clamp(1.f - movement.linear_inertia_ms / m, 0.f, 1.f);
damping.linear *= inertia_mult;
}
const auto requested_by_input = movement.get_force_requested_by_input(movement_def.input_acceleration_axes);
if (requested_by_input.is_nonzero()) {
if (movement.was_sprint_effective) {
if (!is_inert) {
damping.linear /= 4;
}
}
}
const bool make_inert = movement.const_inertia_ms > 0.f;
/* the player feels less like a physical projectile if we brake per-axis */
if (!make_inert) {
damping.linear_axis_aligned += vec2(
requested_by_input.x_non_zero() ? 0.f : movement_def.braking_damping,
requested_by_input.y_non_zero() ? 0.f : movement_def.braking_damping
);
}
});
return damping.sanitize();
}
bool isolate_var(app* arg, app_ref& var, expr_ref& div, unsigned i, app* lhs, expr* rhs) {
if (!m_a_util.is_mul(arg)) return false;
unsigned n = arg->get_num_args();
for (unsigned j = 0; j < n; ++j) {
expr* e = arg->get_arg(j);
bool ok = is_uninterp_const(e) && check_occs(e) && !occurs(e, rhs) && !occurs_except(e, lhs, i);
if (!ok) continue;
var = to_app(e);
for (unsigned k = 0; ok && k < n; ++k) {
expr* arg_k = arg->get_arg(k);
ok = k == j || (!occurs(var, arg_k) && is_nonzero(arg_k));
}
if (!ok) continue;
ptr_vector<expr> args;
for (unsigned k = 0; k < n; ++k) {
if (k != j) args.push_back(arg->get_arg(k));
}
div = m_a_util.mk_mul(args.size(), args.c_ptr());
return true;
}
return false;
}
static void test_case(int x) {
printf("is_nonzero(%d) is %d, correct answer is %d\n", x, is_nonzero(x), x != 0);
}
