raylib/src/platforms/rcore_none.c

430 lines
16 KiB
C

#include "rcore_none.h"
#include <stddef.h>
//----------------------------------------------------------------------------------
// Global Variables Definition
//----------------------------------------------------------------------------------
extern CoreData CORE; // Global CORE state context
static PlatformData platform = { 0 }; // Platform specific data
#define GEN_CALLBACK_BODY(fn_ret, ret_value, fn_name, named_args, args) \
fn_ret fn_name(LIST named_args) { \
if(internal##fn_name##Callback == NULL) {\
FUNCTION_MISSING_WARNING(fn_name) \
return ret_value; \
} else {\
return (*internal##fn_name##Callback)(LIST args); \
}\
}
// Generate a callback that returns a void.
#define GEN_CALLBACK_BODY_VOID(fn_name, named_args, args) \
void fn_name(LIST named_args) { \
if(internal##fn_name##Callback == NULL) {\
FUNCTION_MISSING_WARNING(fn_name) \
} else {\
(*internal##fn_name##Callback)(LIST args); \
}\
}
// Generate any of the if/else statements in OverrideInternalFunction.
#define GEN_CASE(fn_name) \
if (strcmp(funcName, #fn_name) == 0) { \
internal##fn_name##Callback = &(func-> fn_name); \
return; \
}
// For the functions that have default behavior on PLATFORM_OFFSCREEN, check if the function exists
// first.
#define CHECK_AND_CALL(fn_name, args) \
if(internal##fn_name##Callback != NULL) {\
return (*internal##fn_name##Callback)(LIST args); \
}
// For the functions that have default behavior on PLATFORM_OFFSCREEN, check if the function exists
// first (void version).
#define CHECK_AND_CALL_VOID(fn_name, args) \
if(internal##fn_name##Callback != NULL) {\
(*internal##fn_name##Callback)(LIST args); \
}
GEN_CALLBACK_BODY_VOID(ClosePlatform, (void), ())
GEN_CALLBACK_BODY_VOID(ToggleFullscreen, (void), ())
GEN_CALLBACK_BODY_VOID(ToggleBorderlessWindowed, (void), ())
GEN_CALLBACK_BODY_VOID(MaximizeWindow, (void), ())
GEN_CALLBACK_BODY_VOID(MinimizeWindow, (void), ())
GEN_CALLBACK_BODY_VOID(RestoreWindow, (void), ())
GEN_CALLBACK_BODY_VOID(SetWindowIcon, (Image image), (image))
GEN_CALLBACK_BODY_VOID(SetWindowIcons, (Image *images, int count), (images, count))
GEN_CALLBACK_BODY_VOID(SetWindowTitle, (const char *title), (title))
GEN_CALLBACK_BODY_VOID(SetWindowPosition, (int x, int y), (x,y))
GEN_CALLBACK_BODY_VOID(SetWindowMonitor, (int monitor), (monitor))
GEN_CALLBACK_BODY_VOID(SetWindowOpacity, (float opacity), (opacity))
GEN_CALLBACK_BODY_VOID(SetWindowFocused, (void), ())
GEN_CALLBACK_BODY_VOID(EnableCursor, (void), ())
GEN_CALLBACK_BODY_VOID(DisableCursor, (void), ())
GEN_CALLBACK_BODY_VOID(SwapScreenBuffer, (void), ())
GEN_CALLBACK_BODY_VOID(SetGamepadVibration, (int gamepad, float leftMotor, float rightMotor), (gamepad,leftMotor,rightMotor))
GEN_CALLBACK_BODY_VOID(SetMousePosition, (int x, int y), (x,y))
GEN_CALLBACK_BODY_VOID(SetMouseCursor, (int cursor), (cursor))
GEN_CALLBACK_BODY_VOID(PollInputEvents, (void), ())
GEN_CALLBACK_BODY_VOID(SetClipboardText, (const char *text), (text))
GEN_CALLBACK_BODY(int, 0, SetGamepadMappings, (const char *mappings), (mappings))
GEN_CALLBACK_BODY(void *, NULL, GetWindowHandle, (void), ())
GEN_CALLBACK_BODY(Vector2, Vector2Zero(), GetMonitorPosition, (int monitor), (monitor))
GEN_CALLBACK_BODY(int, 0, GetMonitorWidth, (int monitor), (monitor))
GEN_CALLBACK_BODY(int, 0, GetMonitorHeight, (int monitor), (monitor))
GEN_CALLBACK_BODY(int, 0, GetMonitorPhysicalWidth, (int monitor), (monitor))
GEN_CALLBACK_BODY(int, 0, GetMonitorPhysicalHeight, (int monitor), (monitor))
GEN_CALLBACK_BODY(int, 0, GetMonitorRefreshRate, (int monitor), (monitor))
GEN_CALLBACK_BODY(const char*, "", GetMonitorName, (int monitor), (monitor))
GEN_CALLBACK_BODY(Vector2, Vector2Zero(), GetWindowPosition, (void), ())
GEN_CALLBACK_BODY(Vector2, Vector2Zero(), GetWindowScaleDPI, (void), ())
GEN_CALLBACK_BODY(const char *, "", GetClipboardText, (void), ())
GEN_CALLBACK_BODY(const char *, "", GetKeyName, (int key), (key))
GEN_CALLBACK_BODY(double, 0.0, GetTime, (void), ())
GEN_CALLBACK_BODY_VOID(OpenURL, (const char *url), (url))
// Override an internal platform function with your own (PLATFORM_OFFSCREEN and PLATFORM_NONE only).
// Note that there is no responsibility here for the Raylib maintainers to keep a stable API for core functions
void OverrideInternalFunction(const char * funcName, union OverridableFunctionPointer * func) {
GEN_CASE(InitPlatform)
GEN_CASE(WindowShouldClose)
GEN_CASE(GetMonitorCount)
GEN_CASE(GetCurrentMonitor)
GEN_CASE(ShowCursor)
GEN_CASE(HideCursor)
GEN_CASE(SetWindowState)
GEN_CASE(ClearWindowState)
GEN_CASE(SetWindowMinSize)
GEN_CASE(SetWindowMaxSize)
GEN_CASE(SetWindowSize)
GEN_CASE(ClosePlatform)
GEN_CASE(ToggleFullscreen)
GEN_CASE(ToggleBorderlessWindowed)
GEN_CASE(MaximizeWindow)
GEN_CASE(MinimizeWindow)
GEN_CASE(RestoreWindow)
GEN_CASE(SetWindowIcon)
GEN_CASE(SetWindowIcons)
GEN_CASE(SetWindowTitle)
GEN_CASE(SetWindowPosition)
GEN_CASE(SetWindowMonitor)
GEN_CASE(SetWindowOpacity)
GEN_CASE(SetWindowFocused)
GEN_CASE(EnableCursor)
GEN_CASE(DisableCursor)
GEN_CASE(SwapScreenBuffer)
GEN_CASE(SetGamepadVibration)
GEN_CASE(SetMousePosition)
GEN_CASE(SetMouseCursor)
GEN_CASE(PollInputEvents)
GEN_CASE(SetClipboardText)
GEN_CASE(SetGamepadMappings)
GEN_CASE(GetWindowHandle)
GEN_CASE(GetMonitorPosition)
GEN_CASE(GetMonitorWidth)
GEN_CASE(GetMonitorHeight)
GEN_CASE(GetMonitorPhysicalWidth)
GEN_CASE(GetMonitorPhysicalHeight)
GEN_CASE(GetMonitorRefreshRate)
GEN_CASE(GetMonitorName)
GEN_CASE(GetWindowPosition)
GEN_CASE(GetWindowScaleDPI)
GEN_CASE(GetClipboardText)
GEN_CASE(GetKeyName)
GEN_CASE(GetTime)
TraceLog(LOG_ERROR, "Unknown function name \"%s\", did not bind.",funcName);
};
#ifdef PLATFORM_OFFSCREEN
//
int InitPlatform(void) {
printf("j\n");
CHECK_AND_CALL(InitPlatform, ());
printf("test\n");
CORE.Window.ready = true;
return 0;
}
// Check if application should close
// NOTE: By default, if KEY_ESCAPE pressed or window close icon clicked
bool WindowShouldClose(void)
{
CHECK_AND_CALL(WindowShouldClose, ());
if (CORE.Window.ready) return CORE.Window.shouldClose;
else return true;
}
// Set window configuration state using flags
void SetWindowState(unsigned int flags)
{
CHECK_AND_CALL_VOID(SetWindowState, (flags));
// Check previous state and requested state to apply required changes
// NOTE: In most cases the functions already change the flags internally
// State change: FLAG_VSYNC_HINT
if (((CORE.Window.flags & FLAG_VSYNC_HINT) != (flags & FLAG_VSYNC_HINT)) && ((flags & FLAG_VSYNC_HINT) > 0))
{
CORE.Window.flags |= FLAG_VSYNC_HINT;
}
// State change: FLAG_BORDERLESS_WINDOWED_MODE
// NOTE: This must be handled before FLAG_FULLSCREEN_MODE because ToggleBorderlessWindowed() needs to get some fullscreen values if fullscreen is running
if (((CORE.Window.flags & FLAG_BORDERLESS_WINDOWED_MODE) != (flags & FLAG_BORDERLESS_WINDOWED_MODE)) && ((flags & FLAG_BORDERLESS_WINDOWED_MODE) > 0))
{
ToggleBorderlessWindowed(); // NOTE: Window state flag updated inside function
}
// State change: FLAG_FULLSCREEN_MODE
if ((CORE.Window.flags & FLAG_FULLSCREEN_MODE) != (flags & FLAG_FULLSCREEN_MODE))
{
ToggleFullscreen(); // NOTE: Window state flag updated inside function
}
// State change: FLAG_WINDOW_RESIZABLE
if (((CORE.Window.flags & FLAG_WINDOW_RESIZABLE) != (flags & FLAG_WINDOW_RESIZABLE)) && ((flags & FLAG_WINDOW_RESIZABLE) > 0))
{
CORE.Window.flags |= FLAG_WINDOW_RESIZABLE;
}
// State change: FLAG_WINDOW_UNDECORATED
if (((CORE.Window.flags & FLAG_WINDOW_UNDECORATED) != (flags & FLAG_WINDOW_UNDECORATED)) && (flags & FLAG_WINDOW_UNDECORATED))
{
CORE.Window.flags |= FLAG_WINDOW_UNDECORATED;
}
// State change: FLAG_WINDOW_HIDDEN
if (((CORE.Window.flags & FLAG_WINDOW_HIDDEN) != (flags & FLAG_WINDOW_HIDDEN)) && ((flags & FLAG_WINDOW_HIDDEN) > 0))
{
CORE.Window.flags |= FLAG_WINDOW_HIDDEN;
}
// State change: FLAG_WINDOW_MINIMIZED
if (((CORE.Window.flags & FLAG_WINDOW_MINIMIZED) != (flags & FLAG_WINDOW_MINIMIZED)) && ((flags & FLAG_WINDOW_MINIMIZED) > 0))
{
//MinimizeWindow(); // NOTE: Window state flag updated inside function
}
// State change: FLAG_WINDOW_MAXIMIZED
if (((CORE.Window.flags & FLAG_WINDOW_MAXIMIZED) != (flags & FLAG_WINDOW_MAXIMIZED)) && ((flags & FLAG_WINDOW_MAXIMIZED) > 0))
{
//MaximizeWindow(); // NOTE: Window state flag updated inside function
}
// State change: FLAG_WINDOW_UNFOCUSED
if (((CORE.Window.flags & FLAG_WINDOW_UNFOCUSED) != (flags & FLAG_WINDOW_UNFOCUSED)) && ((flags & FLAG_WINDOW_UNFOCUSED) > 0))
{
CORE.Window.flags |= FLAG_WINDOW_UNFOCUSED;
}
// State change: FLAG_WINDOW_TOPMOST
if (((CORE.Window.flags & FLAG_WINDOW_TOPMOST) != (flags & FLAG_WINDOW_TOPMOST)) && ((flags & FLAG_WINDOW_TOPMOST) > 0))
{
CORE.Window.flags |= FLAG_WINDOW_TOPMOST;
}
// State change: FLAG_WINDOW_ALWAYS_RUN
if (((CORE.Window.flags & FLAG_WINDOW_ALWAYS_RUN) != (flags & FLAG_WINDOW_ALWAYS_RUN)) && ((flags & FLAG_WINDOW_ALWAYS_RUN) > 0))
{
CORE.Window.flags |= FLAG_WINDOW_ALWAYS_RUN;
}
// The following states can not be changed after window creation
// State change: FLAG_WINDOW_TRANSPARENT
if (((CORE.Window.flags & FLAG_WINDOW_TRANSPARENT) != (flags & FLAG_WINDOW_TRANSPARENT)) && ((flags & FLAG_WINDOW_TRANSPARENT) > 0))
{
TRACELOG(LOG_WARNING, "WINDOW: Framebuffer transparency can only be configured before window initialization");
}
// State change: FLAG_WINDOW_HIGHDPI
if (((CORE.Window.flags & FLAG_WINDOW_HIGHDPI) != (flags & FLAG_WINDOW_HIGHDPI)) && ((flags & FLAG_WINDOW_HIGHDPI) > 0))
{
TRACELOG(LOG_WARNING, "WINDOW: High DPI can only be configured before window initialization");
}
// State change: FLAG_WINDOW_MOUSE_PASSTHROUGH
if (((CORE.Window.flags & FLAG_WINDOW_MOUSE_PASSTHROUGH) != (flags & FLAG_WINDOW_MOUSE_PASSTHROUGH)) && ((flags & FLAG_WINDOW_MOUSE_PASSTHROUGH) > 0))
{
CORE.Window.flags |= FLAG_WINDOW_MOUSE_PASSTHROUGH;
}
// State change: FLAG_MSAA_4X_HINT
if (((CORE.Window.flags & FLAG_MSAA_4X_HINT) != (flags & FLAG_MSAA_4X_HINT)) && ((flags & FLAG_MSAA_4X_HINT) > 0))
{
TRACELOG(LOG_WARNING, "WINDOW: MSAA can only be configured before window initialization");
}
// State change: FLAG_INTERLACED_HINT
if (((CORE.Window.flags & FLAG_INTERLACED_HINT) != (flags & FLAG_INTERLACED_HINT)) && ((flags & FLAG_INTERLACED_HINT) > 0))
{
TRACELOG(LOG_WARNING, "RPI: Interlaced mode can only be configured before window initialization");
}
}
// Clear window configuration state flags
void ClearWindowState(unsigned int flags)
{
CHECK_AND_CALL_VOID(ClearWindowState, (flags));
// Check previous state and requested state to apply required changes
// NOTE: In most cases the functions already change the flags internally
// State change: FLAG_VSYNC_HINT
if (((CORE.Window.flags & FLAG_VSYNC_HINT) > 0) && ((flags & FLAG_VSYNC_HINT) > 0))
{
CORE.Window.flags &= ~FLAG_VSYNC_HINT;
}
// State change: FLAG_BORDERLESS_WINDOWED_MODE
// NOTE: This must be handled before FLAG_FULLSCREEN_MODE because ToggleBorderlessWindowed() needs to get some fullscreen values if fullscreen is running
if (((CORE.Window.flags & FLAG_BORDERLESS_WINDOWED_MODE) > 0) && ((flags & FLAG_BORDERLESS_WINDOWED_MODE) > 0))
{
ToggleBorderlessWindowed(); // NOTE: Window state flag updated inside function
}
// State change: FLAG_FULLSCREEN_MODE
if (((CORE.Window.flags & FLAG_FULLSCREEN_MODE) > 0) && ((flags & FLAG_FULLSCREEN_MODE) > 0))
{
ToggleFullscreen(); // NOTE: Window state flag updated inside function
}
// State change: FLAG_WINDOW_RESIZABLE
if (((CORE.Window.flags & FLAG_WINDOW_RESIZABLE) > 0) && ((flags & FLAG_WINDOW_RESIZABLE) > 0))
{
CORE.Window.flags &= ~FLAG_WINDOW_RESIZABLE;
}
// State change: FLAG_WINDOW_HIDDEN
if (((CORE.Window.flags & FLAG_WINDOW_HIDDEN) > 0) && ((flags & FLAG_WINDOW_HIDDEN) > 0))
{
CORE.Window.flags &= ~FLAG_WINDOW_HIDDEN;
}
// State change: FLAG_WINDOW_MINIMIZED
if (((CORE.Window.flags & FLAG_WINDOW_MINIMIZED) > 0) && ((flags & FLAG_WINDOW_MINIMIZED) > 0))
{
RestoreWindow(); // NOTE: Window state flag updated inside function
}
// State change: FLAG_WINDOW_MAXIMIZED
if (((CORE.Window.flags & FLAG_WINDOW_MAXIMIZED) > 0) && ((flags & FLAG_WINDOW_MAXIMIZED) > 0))
{
RestoreWindow(); // NOTE: Window state flag updated inside function
}
// State change: FLAG_WINDOW_UNDECORATED
if (((CORE.Window.flags & FLAG_WINDOW_UNDECORATED) > 0) && ((flags & FLAG_WINDOW_UNDECORATED) > 0))
{
CORE.Window.flags &= ~FLAG_WINDOW_UNDECORATED;
}
// State change: FLAG_WINDOW_UNFOCUSED
if (((CORE.Window.flags & FLAG_WINDOW_UNFOCUSED) > 0) && ((flags & FLAG_WINDOW_UNFOCUSED) > 0))
{
CORE.Window.flags &= ~FLAG_WINDOW_UNFOCUSED;
}
// State change: FLAG_WINDOW_TOPMOST
if (((CORE.Window.flags & FLAG_WINDOW_TOPMOST) > 0) && ((flags & FLAG_WINDOW_TOPMOST) > 0))
{
CORE.Window.flags &= ~FLAG_WINDOW_TOPMOST;
}
// State change: FLAG_WINDOW_ALWAYS_RUN
if (((CORE.Window.flags & FLAG_WINDOW_ALWAYS_RUN) > 0) && ((flags & FLAG_WINDOW_ALWAYS_RUN) > 0))
{
CORE.Window.flags &= ~FLAG_WINDOW_ALWAYS_RUN;
}
// The following states can not be changed after window creation
// State change: FLAG_WINDOW_TRANSPARENT
if (((CORE.Window.flags & FLAG_WINDOW_TRANSPARENT) > 0) && ((flags & FLAG_WINDOW_TRANSPARENT) > 0))
{
TRACELOG(LOG_WARNING, "WINDOW: Framebuffer transparency can only be configured before window initialization");
}
// State change: FLAG_WINDOW_HIGHDPI
if (((CORE.Window.flags & FLAG_WINDOW_HIGHDPI) > 0) && ((flags & FLAG_WINDOW_HIGHDPI) > 0))
{
TRACELOG(LOG_WARNING, "WINDOW: High DPI can only be configured before window initialization");
}
// State change: FLAG_WINDOW_MOUSE_PASSTHROUGH
if (((CORE.Window.flags & FLAG_WINDOW_MOUSE_PASSTHROUGH) > 0) && ((flags & FLAG_WINDOW_MOUSE_PASSTHROUGH) > 0))
{
CORE.Window.flags &= ~FLAG_WINDOW_MOUSE_PASSTHROUGH;
}
// State change: FLAG_MSAA_4X_HINT
if (((CORE.Window.flags & FLAG_MSAA_4X_HINT) > 0) && ((flags & FLAG_MSAA_4X_HINT) > 0))
{
TRACELOG(LOG_WARNING, "WINDOW: MSAA can only be configured before window initialization");
}
// State change: FLAG_INTERLACED_HINT
if (((CORE.Window.flags & FLAG_INTERLACED_HINT) > 0) && ((flags & FLAG_INTERLACED_HINT) > 0))
{
TRACELOG(LOG_WARNING, "RPI: Interlaced mode can only be configured before window initialization");
}
}
// Set window minimum dimensions (FLAG_WINDOW_RESIZABLE)
void SetWindowMinSize(int width, int height)
{
CHECK_AND_CALL_VOID(SetWindowMinSize, (width, height));
CORE.Window.screenMin.width = width;
CORE.Window.screenMin.height = height;
}
// Set window maximum dimensions (FLAG_WINDOW_RESIZABLE)
void SetWindowMaxSize(int width, int height)
{
CHECK_AND_CALL_VOID(SetWindowMaxSize, (width, height));
CORE.Window.screenMax.width = width;
CORE.Window.screenMax.height = height;
}
// Set window dimensions
void SetWindowSize(int width, int height)
{
CHECK_AND_CALL_VOID(SetWindowSize, (width, height));
CORE.Window.screen.width = width;
CORE.Window.screen.height = height;
}
// Get number of monitors
int GetMonitorCount(void)
{
CHECK_AND_CALL(GetMonitorCount, ());
return 1;
}
// Get number of monitors
int GetCurrentMonitor(void)
{
CHECK_AND_CALL(GetCurrentMonitor, ());
return 0;
}
// Show mouse cursor
void ShowCursor(void)
{
CHECK_AND_CALL_VOID(ShowCursor, ());
CORE.Input.Mouse.cursorHidden = false;
}
// Hides mouse cursor
void HideCursor(void)
{
CHECK_AND_CALL_VOID(HideCursor, ());
CORE.Input.Mouse.cursorHidden = true;
}
#endif