/home/engon/gama/gama/lib/gama/gama.h

Processes events, updates input state, and prepares for the next frame.

Processes events, updates input state, and prepares for the next frame.This function should be called at the end of the main game loop. It handles window events, polls for input, updates mouse and keyboard states, and swaps the graphics buffers.

Returns

1 if the game should continue to the next frame, 0 if the window has been closed.

while (gm_yield()) { // Your game logic and rendering here }

/**
 * @file gama.h
 * @brief Core header file for the Gama engine.
 *
 * This file includes all the necessary headers and provides the main
 * functions for initializing the engine, managing the game loop, and handling
 * basic window operations.
 */
 
#pragma once
 
#include "draw.h"
#include "gapi.h"
#include "stdio.h"
#include "widgets/frame.h"
 
#ifdef GM_ARGC_MAIN
int main(int, char **);
#else
int main();
#endif
 
/**
 * @internal
 * @brief Main entry point for the Gama application, called by the platform runner.
 * This function calls the user-defined main().
 */
int32_t
#ifdef __ZIG_CC__
    __attribute__((export_name("gama_run")))
#endif
    gama_run() {
#ifdef GM_ARGC_MAIN
  return main(0, NULL);
#else
  return main();
#endif
}
 
/**
 * @brief Puts the window in fullscreen.
 *
 * @param fullscreen Boolean flag to enable (1) or disable (0) fullscreen.
 */
void gm_fullscreen(int fullscreen) { return gapi_fullscreen(fullscreen); }
 
/**
 * @brief Draws the Gama logo.
 *
 * @param x The center x position to draw the logo.
 * @param y The center y position to draw the logo.
 * @param s The size (side length) of the logo.
 */
void gm_logo(double x, double y, double s) {
  double top_thickness = 0.15 * s;
  double left_thickness = 0.1 * s;
  double ratio = 0.6;
  // top bar
  gm_draw_rectangle(x, y + s / 2 - top_thickness / 2, s * ratio, top_thickness,
                    GM_GAMA);
  gm_draw_rectangle(x + (-s / 2) + (left_thickness / 2) + (s / 2 * (1 - ratio)),
                    y, left_thickness, s, GM_GAMA);
}
 
 
/**
 * @brief Logs a message to the platform's console.
 * @param txt The text message to log.
 */
void gm_log(const char *txt) { return gapi_log(txt); }
 
/**
 * @brief Checks if the main game loop should continue running.
 * @return 1 if the window is open and the game should continue, 0 otherwise.
 * @deprecated This function is deprecated and will be removed. Use gm_yield()
 * instead.
 */
static inline int gm_runs() { return gapi_runs(); }
 
/**
 * @brief Enables or disables the built-in FPS counter display.
 * @param show Boolean flag to show (1) or hide (0) the FPS counter.
 */
int __gm_show_fps = 0;
void gm_show_fps(int show) { __gm_show_fps = show; }
 
/**
 * @brief Processes events, updates input state, and prepares for the next
 * frame.
 *
 * This function should be called at the end of the main game loop. It handles
 * window events, polls for input, updates mouse and keyboard states, and
 * swaps the graphics buffers.
 *
 * @return 1 if the game should continue to the next frame, 0 if the window has
 * been closed.
 * @example
 * while (gm_yield()) {
 *   // Your game logic and rendering here
 * }
 */
static inline int gm_yield() {
  static const double alpha = 2.0 / 3.0;
  static double _fps = 0;
  static double dt = 1;
  static double _display_fps = 0;
  double current_dt = gm_dt();
  dt += current_dt;
  double fps = 1 / current_dt;
  if (current_dt == 0)
    fps = _fps;
  if (_fps == 0)
    _fps = 60;
  else
    _fps = (_fps * alpha) + (fps * (1 - alpha));
  if (dt >= 0.5) {
    dt = 0;
    _display_fps = _fps;
  }
 
  if (__gm_show_fps) {
    char fps_text[20] = {0}; // ERROR: use fps
    snprintf(fps_text, sizeof(fps_text), "fps: %.2f", _display_fps);
    gmw_frame(0.9, -0.9, 0.4, 0.1);
    gm_draw_text(0.9, -0.9, fps_text, "", 0.1, GM_WHITE);
  }
 
  const int ret = gapi_yield(&_gm_dt);
  _gm_t += _gm_dt;
  gm_mouse.lastPosition = gm_mouse.position;
  gapi_mouse_get(&gm_mouse.position.x, &gm_mouse.position.y);
  gm_mouse.movement.x = gm_mouse.position.x - gm_mouse.lastPosition.x;
  gm_mouse.movement.y = gm_mouse.position.y - gm_mouse.lastPosition.y;
  gm_mouse.down = gapi_mouse_down();
  static int last_mouse_down = 0;
  gm_mouse.clicked = !last_mouse_down && gm_mouse.down;
  last_mouse_down = gm_mouse.down;
 
  return ret;
}
 
/**
 * @brief Closes the window and terminates the Gama engine.
 */
static inline void gm_quit() { return gapi_quit(); }
 
/**
 * @brief Sets the background color of the window.
 * @param c The color to set as the background.
 */
void gm_background(gmColor c) { return gapi_set_background_color(c); }
 
 
/**
 * @brief Resizes the application window.
 * @param width The new width of the window in pixels.
 * @param height The new height of the window in pixels.
 */
void gm_resize(int width, int height) { return gapi_resize(width, height); }
 
/**
 * @brief Initializes the Gama engine and opens a window.
 *
 * This must be the first Gama function called. It sets up the graphics context
 * and creates a window with the specified dimensions and title.
 *
 * @param width The width of the window in pixels. Use 0 for automatic sizing.
 * @param height The height of the window in pixels. Use 0 for automatic sizing.
 * @param title The title of the window.
 */
void gm_init(int width, int height, const char *title) {
  int code = gapi_init(width, height, title);
  char msg[100];
 
  if (code != 0) {
    snprintf(msg, sizeof(msg),
             "Error starting gama, initialization exited with non zero code %d",
             code);
    gapi_log(msg);
  }
  gm_background(GM_BLACK);
}
 
/**
 * @brief Pauses execution for a specified duration.
 *
 * This function blocks the calling thread for approximately the given number
 * of milliseconds.
 *
 * @param milliseconds The number of milliseconds to sleep.
 */
void gm_sleep(int milliseconds);
 
#ifdef __ZIG_CC__
void gm_sleep(int m) {};
#else
#ifdef _WIN32
#include <windows.h>
void gm_sleep(int milliseconds) { Sleep(milliseconds); }
#else
#include <unistd.h>
void gm_sleep(int milliseconds) { usleep(milliseconds * 1000); }
#endif
#endif