nappgui-sys 0.2.0

Rust raw bindings to NAppGUI
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

/*
 * NAppGUI Cross-platform C SDK
 * 2015-2025 Francisco Garcia Collado
 * MIT Licence
 * https://nappgui.com/en/legal/license.html
 *
 * File: clock.c
 *
 */

/* Clock (Frame counter) */

#include "clock.h"
#include "heap.h"
#include <osbs/btime.h>
#include <sewer/cassert.h>
#include <sewer/ptr.h>

struct _clock_t
{
    real64_t start_second;
    real64_t frame_rate;
    real64_t handling_time_stamp;
    real64_t last_event_time_stamp;
    real64_t last_update_time_stamp;
    bool_t is_running;
};

/*---------------------------------------------------------------------------*/

#define i_TIME_SEC(microseconds) ((real64_t)microseconds / 1000000.)


/*---------------------------------------------------------------------------*/

static Clock *i_create_clock(
    const bool_t is_running,
    const real64_t start_second,
    const real64_t frame_rate,
    const real64_t handling_time_stamp,
    const real64_t last_event_time_stamp,
    const real64_t last_update_time_stamp)
{
    Clock *clk = heap_new(Clock);
    clk->is_running = is_running;
    clk->start_second = start_second;
    clk->frame_rate = frame_rate;
    clk->handling_time_stamp = handling_time_stamp;
    clk->last_event_time_stamp = last_event_time_stamp;
    clk->last_update_time_stamp = last_update_time_stamp;
    return clk;
}

/*---------------------------------------------------------------------------*/

Clock *clock_create(const real64_t interval)
{
    uint64_t now = btime_now();
    cassert(interval >= 0.);

    return i_create_clock(
        PARAM(is_running, FALSE),
        i_TIME_SEC(now), interval,
        PARAM(handling_time_stamp, 0.),
        PARAM(last_event_time_stamp, 0.),
        PARAM(last_update_time_stamp, 0.));
}

/*---------------------------------------------------------------------------*/

void clock_destroy(Clock **clk)
{
    heap_delete(clk, Clock);
}

/*---------------------------------------------------------------------------*/

bool_t clock_frame(Clock *clk, real64_t *prev_frame, real64_t *curr_frame)
{
    bool_t must_update;
    real64_t tms_new;

    cassert_no_null(clk);

    {
        uint64_t now = btime_now();
        tms_new = i_TIME_SEC(now) - clk->start_second;
    }

    if (clk->is_running == FALSE)
    {
        cassert(clk->handling_time_stamp == 0.);
        clk->is_running = TRUE;
        clk->last_event_time_stamp = tms_new;
        must_update = FALSE;
    }
    else
    {
        if (tms_new < clk->last_update_time_stamp)
        {
            clk->last_update_time_stamp = tms_new;
            clk->last_event_time_stamp = tms_new;
        }

        cassert(clk->last_update_time_stamp >= clk->last_event_time_stamp);

        if (tms_new - clk->last_event_time_stamp < clk->frame_rate)
        {
            /*! <Is early for event launch> */
            must_update = FALSE;
        }
        else
        {
            if (tms_new - clk->last_update_time_stamp > clk->frame_rate)
            {
                /*! <More time since last update (application pause or similar...)> */
                clk->last_event_time_stamp = tms_new;
            }
            else
            {
                clk->last_event_time_stamp += clk->frame_rate;
            }

            ptr_assign(prev_frame, clk->handling_time_stamp);
            clk->handling_time_stamp += clk->frame_rate;
            ptr_assign(curr_frame, clk->handling_time_stamp);
            must_update = TRUE;
        }
    }

    clk->last_update_time_stamp = tms_new;
    return must_update;
}

/*---------------------------------------------------------------------------*/

void clock_reset(Clock *clk)
{
    uint64_t now;
    cassert_no_null(clk);
    now = btime_now();
    clk->start_second = i_TIME_SEC(now);
}

/*---------------------------------------------------------------------------*/

real64_t clock_elapsed(const Clock *clk)
{
    uint64_t now;
    cassert_no_null(clk);
    now = btime_now();
    return i_TIME_SEC(now) - clk->start_second;
}