spottedcat 1.0.0

Rusty SpottedCat simple game engine
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use crate::{Context, Key, MouseButton, PlatformEvent, Pt};

/// Returns true if the specified key was just released this frame.
pub fn key_released(ctx: &Context, key: Key) -> bool {
    ctx.input().key_released(key)
}

/// Returns true if the specified mouse button is currently held down.
pub fn mouse_button_down(ctx: &Context, button: MouseButton) -> bool {
    ctx.input().mouse_down(button)
}

/// Returns true if the specified mouse button was just pressed this frame.
pub fn mouse_button_pressed(ctx: &Context, button: MouseButton) -> bool {
    ctx.input().mouse_pressed(button)
}

/// Returns true if the specified mouse button was just released this frame.
pub fn mouse_button_released(ctx: &Context, button: MouseButton) -> bool {
    ctx.input().mouse_released(button)
}

/// Returns the cursor position if the mouse button was just pressed this frame.
pub fn mouse_button_pressed_position(ctx: &Context, button: MouseButton) -> Option<(Pt, Pt)> {
    if mouse_button_pressed(ctx, button) {
        cursor_position(ctx)
    } else {
        None
    }
}

/// Returns the current hardware cursor position in logical coordinates.
pub fn cursor_position(ctx: &Context) -> Option<(Pt, Pt)> {
    ctx.input().cursor_position()
}

/// Returns true if text input (IME) is currently enabled.
pub fn text_input_enabled(ctx: &Context) -> bool {
    ctx.input().text_input_enabled()
}

/// Enables or disables text input (IME) for the window.
pub fn set_text_input_enabled(ctx: &mut Context, enabled: bool) {
    ctx.input_mut().set_text_input_enabled(enabled);
}

/// Returns the accumulated text input string for the current frame.
pub fn text_input(ctx: &Context) -> &str {
    ctx.input().text_input()
}

/// Compatibility alias for `text_input`.
pub fn get_input(ctx: &Context) -> &str {
    ctx.input().text_input()
}

#[cfg(feature = "sensors")]
/// Returns the current gyroscope readings [x, y, z] if available.
pub fn gyroscope(ctx: &Context) -> Option<[f32; 3]> {
    ctx.input().gyroscope()
}

#[cfg(feature = "sensors")]
/// Returns the current accelerometer readings [x, y, z] if available.
pub fn accelerometer(ctx: &Context) -> Option<[f32; 3]> {
    ctx.input().accelerometer()
}

#[cfg(feature = "sensors")]
/// Returns the current magnetometer readings [x, y, z] if available.
pub fn magnetometer(ctx: &Context) -> Option<[f32; 3]> {
    ctx.input().magnetometer()
}

#[cfg(feature = "sensors")]
/// Returns the current device rotation as a quaternion [x, y, z, w].
pub fn rotation(ctx: &Context) -> Option<[f32; 4]> {
    ctx.input().rotation()
}

#[cfg(feature = "sensors")]
/// Returns the current day's step count when the platform provides it.
///
/// On iOS this is sourced from `CMPedometer` starting at the beginning of the
/// current local day. On Android this is derived from the step counter sensor
/// while the app keeps the sensor registered.
pub fn today_step_count(ctx: &Context) -> Option<f32> {
    ctx.input().today_step_count()
}

#[cfg(feature = "sensors")]
/// Compatibility alias for `today_step_count`.
///
/// This is not a lifetime or historical total.
pub fn step_count(ctx: &Context) -> Option<f32> {
    today_step_count(ctx)
}

#[cfg(feature = "sensors")]
/// Returns the step count for the previous local day.
pub fn yesterday_step_count(ctx: &Context) -> Option<f32> {
    ctx.input().yesterday_step_count()
}

#[cfg(feature = "sensors")]
/// Returns true if a single step was detected this frame.
pub fn step_detected(ctx: &Context) -> bool {
    ctx.input().step_detected()
}

/// Returns a list of raw platform events received this frame.
pub fn poll_platform_events(_ctx: &Context) -> Vec<PlatformEvent> {
    crate::platform_events::poll_events()
}

/// Pushes a custom platform event into the event queue.
pub fn push_platform_event(event: PlatformEvent) {
    crate::platform_events::push_event(event);
}

/// Returns true if any touch point is currently active.
pub fn touch_down(ctx: &Context) -> bool {
    !ctx.input().touches().is_empty()
}

/// Returns the current IME pre-edit string (uncommitted text).
pub fn ime_preedit(ctx: &Context) -> Option<&str> {
    ctx.input().ime_preedit()
}