void motion_reset(int16_t position) // Reset the motion buffer to the specified position. The enabled state is preserved. { // Reset the counter. motion_counter = 0; // Reset the duration. motion_duration = 0; // Reset the queue. motion_head = 0; motion_tail = 0; // Reset the keypoint. keys[0].delta = 0; keys[0].position = int_to_float(position); keys[0].in_velocity = 0.0; keys[0].out_velocity = 0.0; // Initialize an empty hermite curve. This is a degenerate case for the hermite // curve that will always return the position of the curve without velocity. curve_init(0, 0, keys[0].position, keys[0].position, 0.0, 0.0); // Reset the registers. motion_registers_reset(); }
float __floatsisf(int i) { float_t res; res.data = int_to_float(i); return res.val; }
int text_entry::get_cursor_caret_pos(const point& cursor_pos) const { int cursor_caret_pos = _visible_pos; int text_area_left = get_text_area().get_left(); if (cursor_pos._x >= text_area_left) { auto& font = get_font(); float font_size = get_font_size(); std::wstring visible_text = _text; raw_text_to_visible_text(visible_text); int text_length = uint_to_int(visible_text.length()); while (cursor_caret_pos < text_length) { float width_a = font.get_text_width(font_size, visible_text.c_str(), _visible_pos, cursor_caret_pos - _visible_pos); float width_b = font.get_text_width(font_size, visible_text.c_str(), _visible_pos, cursor_caret_pos - _visible_pos + 1); float width_extra = (width_b - width_a) / 2.f; if (cursor_pos._x < (int_to_float(text_area_left) + width_a + width_extra)) { break; } cursor_caret_pos++; } } return cursor_caret_pos; }
uint8_t motion_append(void) // Append a new curve keypoint from data stored in the curve registers. The keypoint // is offset from the previous curve by the specified delta. An error is returned if // there is no more room to store the new keypoint in the buffer or if the delta is // less than one (a zero delta is not allowed). { int16_t position; int16_t in_velocity; int16_t out_velocity; uint8_t next; uint16_t delta; // Get the next index in the buffer. next = (motion_head + 1) & MOTION_BUFFER_MASK; // Return error if we have looped the head to the tail and the buffer is filled. if (next == motion_tail) return 0; // Get the position, velocity and time delta values from the registers. position = (int16_t) registers_read_word(REG_CURVE_POSITION_HI, REG_CURVE_POSITION_LO); in_velocity = (int16_t) registers_read_word(REG_CURVE_IN_VELOCITY_HI, REG_CURVE_IN_VELOCITY_LO); out_velocity = (int16_t) registers_read_word(REG_CURVE_OUT_VELOCITY_HI, REG_CURVE_OUT_VELOCITY_LO); delta = (uint16_t) registers_read_word(REG_CURVE_DELTA_HI, REG_CURVE_DELTA_LO); // Keypoint delta must be greater than zero. if (delta < 1) return 0; // Fill in the next keypoint. keys[next].delta = delta; keys[next].position = int_to_float(position); keys[next].in_velocity = fixed_to_float(in_velocity); keys[next].out_velocity = fixed_to_float(out_velocity); // Is this keypoint being added to an empty buffer? if (motion_tail == motion_head) { // Initialize a new hermite curve that gets us from the current position to the new position. // We use a velocity of zero at each end to smoothly transition from one to the other. curve_init(0, delta, curve_get_p1(), keys[next].position, 0.0, 0.0); } // Increase the duration of the buffer. motion_duration += delta; // Set the new head index. motion_head = next; // Reset the motion registers and update the buffer status. motion_registers_reset(); return 1; }
bool viewport::try_unproject(vec3& world_position, const mat44& view_projection_transform, const point& screen_position) const { if (_width == 0 || _height == 0) { return false; } vec4 in; in._x = ((int_to_float(screen_position._x - uint_to_int(_x)) / uint_to_float(_width)) * 2.f) - 1.f; in._y = ((int_to_float(screen_position._y - uint_to_int(_y)) / uint_to_float(_height)) * 2.f) - 1.f; in._y *= -1.f; in._z = 0.f; //0 = near plane, 1 = far plane in._w = 1.f; vec4 out = in * make_mat44_inverted(view_projection_transform); if (is_approx(out._w, 0.f, 0.0001f)) { return false; } world_position._x = out._x / out._w; world_position._y = out._y / out._w; world_position._z = out._z / out._w; return true; }
float calculate_best_area_scale(const size& desired_size, const size& current_size) { if ( desired_size._width <= 0 || desired_size._height <= 0 || current_size._width <= 0 || current_size._height <= 0) { return 1.f; } float desired_aspect_ratio = int_to_float(desired_size._width) / int_to_float(desired_size._height); float current_aspect_ratio = int_to_float(current_size._width) / int_to_float(current_size._height); if (current_aspect_ratio >= desired_aspect_ratio) { return int_to_float(current_size._height) / int_to_float(desired_size._height); } else { return int_to_float(current_size._width) / int_to_float(desired_size._width); } }