#RequestAnimationFrame

The RequestAnimationFrame method, part of the VSyncObserver class, allows you to schedule a function to be executed just before the next screen repaint, synchronized with the vertical synchronization (VSync) signal. This is the standard and most efficient way to run animations or perform visual updates in Lynx, as it ensures that your code executes at the optimal time, avoiding unnecessary rendering and improving performance.

There are two overloads for this method, allowing you to use either a C++ std::function or a traditional C-style function pointer as a callback.

#Method Signature

#With std::function callback

void RequestAnimationFrame(uintptr_t id, lynx::pub::VSyncObserverCallback callback);

#With C-function callback

void RequestAnimationFrame(uintptr_t id,
                           vsync_observer_callback callback,
                           void* user_data);

#Parameters

#Callback Functions

The C++ lynx::pub::VSyncObserverCallback signature is:

void(int64_t frame_start_time, int64_t frame_end_time);

The C vsync_observer_callback signature is:

void(void* user_data, int64_t frame_start_time, int64_t frame_end_time);

• frame_start_time: The timestamp indicating the start of the VSync frame.
• frame_end_time: The timestamp indicating the end of the VSync frame.

#Example

Here's an example of how to use RequestAnimationFrame with a C++ lambda function.

// Assuming 'vsync_observer' is a valid std::unique_ptr<VSyncObserver>
// obtained from the OnRuntimeAttach lifecycle method.

uintptr_t request_id = 1; // A unique ID for this request

vsync_observer->RequestAnimationFrame(request_id, [](int64_t start_time, int64_t end_time) {
    // Perform animation logic or visual updates here.
    // This code will run just before the next repaint.
    printf("Frame rendered between %lld and %lld\\n", start_time, end_time);
});

#Compatibility