886 lines
39 KiB
C
886 lines
39 KiB
C
#include <stdlib.h>
|
|
|
|
#include "raylib.h"
|
|
#include "rcore.h"
|
|
|
|
#include <fcntl.h> // POSIX file control definitions - open(), creat(), fcntl()
|
|
#include <unistd.h> // POSIX standard function definitions - read(), close(), STDIN_FILENO
|
|
#include <termios.h> // POSIX terminal control definitions - tcgetattr(), tcsetattr()
|
|
#include <pthread.h> // POSIX threads management (inputs reading)
|
|
#include <dirent.h> // POSIX directory browsing
|
|
|
|
#include <sys/ioctl.h> // Required for: ioctl() - UNIX System call for device-specific input/output operations
|
|
#include <linux/kd.h> // Linux: KDSKBMODE, K_MEDIUMRAM constants definition
|
|
#include <linux/input.h> // Linux: Keycodes constants definition (KEY_A, ...)
|
|
#include <linux/joystick.h> // Linux: Joystick support library
|
|
|
|
#include <gbm.h> // Generic Buffer Management (native platform for EGL on DRM)
|
|
#include <xf86drm.h> // Direct Rendering Manager user-level library interface
|
|
#include <xf86drmMode.h> // Direct Rendering Manager mode setting (KMS) interface
|
|
|
|
#include "EGL/egl.h" // Native platform windowing system interface
|
|
#include "EGL/eglext.h" // EGL extensions
|
|
|
|
typedef struct
|
|
{
|
|
pthread_t threadId; // Event reading thread id
|
|
int fd; // File descriptor to the device it is assigned to
|
|
int eventNum; // Number of 'event<N>' device
|
|
Rectangle absRange; // Range of values for absolute pointing devices (touchscreens)
|
|
int touchSlot; // Hold the touch slot number of the currently being sent multitouch block
|
|
bool isMouse; // True if device supports relative X Y movements
|
|
bool isTouch; // True if device supports absolute X Y movements and has BTN_TOUCH
|
|
bool isMultitouch; // True if device supports multiple absolute movevents and has BTN_TOUCH
|
|
bool isKeyboard; // True if device has letter keycodes
|
|
bool isGamepad; // True if device has gamepad buttons
|
|
} InputEventWorker;
|
|
|
|
static bool InitGraphicsDevice(int width, int height); // Initialize graphics device
|
|
|
|
// Initialize window and OpenGL context
|
|
// NOTE: data parameter could be used to pass any kind of required data to the initialization
|
|
void InitWindow(int width, int height, const char *title)
|
|
{
|
|
TRACELOG(LOG_INFO, "Initializing raylib %s", RAYLIB_VERSION);
|
|
|
|
TRACELOG(LOG_INFO, "Supported raylib modules:");
|
|
TRACELOG(LOG_INFO, " > rcore:..... loaded (mandatory)");
|
|
TRACELOG(LOG_INFO, " > rlgl:...... loaded (mandatory)");
|
|
#if defined(SUPPORT_MODULE_RSHAPES)
|
|
TRACELOG(LOG_INFO, " > rshapes:... loaded (optional)");
|
|
#else
|
|
TRACELOG(LOG_INFO, " > rshapes:... not loaded (optional)");
|
|
#endif
|
|
#if defined(SUPPORT_MODULE_RTEXTURES)
|
|
TRACELOG(LOG_INFO, " > rtextures:. loaded (optional)");
|
|
#else
|
|
TRACELOG(LOG_INFO, " > rtextures:. not loaded (optional)");
|
|
#endif
|
|
#if defined(SUPPORT_MODULE_RTEXT)
|
|
TRACELOG(LOG_INFO, " > rtext:..... loaded (optional)");
|
|
#else
|
|
TRACELOG(LOG_INFO, " > rtext:..... not loaded (optional)");
|
|
#endif
|
|
#if defined(SUPPORT_MODULE_RMODELS)
|
|
TRACELOG(LOG_INFO, " > rmodels:... loaded (optional)");
|
|
#else
|
|
TRACELOG(LOG_INFO, " > rmodels:... not loaded (optional)");
|
|
#endif
|
|
#if defined(SUPPORT_MODULE_RAUDIO)
|
|
TRACELOG(LOG_INFO, " > raudio:.... loaded (optional)");
|
|
#else
|
|
TRACELOG(LOG_INFO, " > raudio:.... not loaded (optional)");
|
|
#endif
|
|
|
|
if ((title != NULL) && (title[0] != 0))
|
|
CORE.Window.title = title;
|
|
|
|
// Initialize global input state
|
|
memset(&CORE.Input, 0, sizeof(CORE.Input));
|
|
CORE.Input.Keyboard.exitKey = KEY_ESCAPE;
|
|
CORE.Input.Mouse.scale = (Vector2){1.0f, 1.0f};
|
|
CORE.Input.Mouse.cursor = MOUSE_CURSOR_ARROW;
|
|
CORE.Input.Gamepad.lastButtonPressed = 0; // GAMEPAD_BUTTON_UNKNOWN
|
|
#if defined(SUPPORT_EVENTS_WAITING)
|
|
CORE.Window.eventWaiting = true;
|
|
#endif
|
|
|
|
// Initialize graphics device (display device and OpenGL context)
|
|
// NOTE: returns true if window and graphic device has been initialized successfully
|
|
CORE.Window.ready = InitGraphicsDevice(width, height);
|
|
|
|
// If graphic device is no properly initialized, we end program
|
|
if (!CORE.Window.ready)
|
|
{
|
|
TRACELOG(LOG_FATAL, "Failed to initialize Graphic Device");
|
|
return;
|
|
}
|
|
else
|
|
SetWindowPosition(GetMonitorWidth(GetCurrentMonitor()) / 2 - CORE.Window.screen.width / 2, GetMonitorHeight(GetCurrentMonitor()) / 2 - CORE.Window.screen.height / 2);
|
|
|
|
// Initialize hi-res timer
|
|
InitTimer();
|
|
|
|
// Initialize random seed
|
|
srand((unsigned int)time(NULL));
|
|
|
|
// Initialize base path for storage
|
|
CORE.Storage.basePath = GetWorkingDirectory();
|
|
|
|
#if defined(SUPPORT_MODULE_RTEXT) && defined(SUPPORT_DEFAULT_FONT)
|
|
// Load default font
|
|
// WARNING: External function: Module required: rtext
|
|
LoadFontDefault();
|
|
#if defined(SUPPORT_MODULE_RSHAPES)
|
|
// Set font white rectangle for shapes drawing, so shapes and text can be batched together
|
|
// WARNING: rshapes module is required, if not available, default internal white rectangle is used
|
|
Rectangle rec = GetFontDefault().recs[95];
|
|
if (CORE.Window.flags & FLAG_MSAA_4X_HINT)
|
|
{
|
|
// NOTE: We try to maxime rec padding to avoid pixel bleeding on MSAA filtering
|
|
SetShapesTexture(GetFontDefault().texture, (Rectangle){rec.x + 2, rec.y + 2, 1, 1});
|
|
}
|
|
else
|
|
{
|
|
// NOTE: We set up a 1px padding on char rectangle to avoid pixel bleeding
|
|
SetShapesTexture(GetFontDefault().texture, (Rectangle){rec.x + 1, rec.y + 1, rec.width - 2, rec.height - 2});
|
|
}
|
|
#endif
|
|
#else
|
|
#if defined(SUPPORT_MODULE_RSHAPES)
|
|
// Set default texture and rectangle to be used for shapes drawing
|
|
// NOTE: rlgl default texture is a 1x1 pixel UNCOMPRESSED_R8G8B8A8
|
|
Texture2D texture = {rlGetTextureIdDefault(), 1, 1, 1, PIXELFORMAT_UNCOMPRESSED_R8G8B8A8};
|
|
SetShapesTexture(texture, (Rectangle){0.0f, 0.0f, 1.0f, 1.0f}); // WARNING: Module required: rshapes
|
|
#endif
|
|
#endif
|
|
#if defined(SUPPORT_MODULE_RTEXT) && defined(SUPPORT_DEFAULT_FONT)
|
|
if ((CORE.Window.flags & FLAG_WINDOW_HIGHDPI) > 0)
|
|
{
|
|
// Set default font texture filter for HighDPI (blurry)
|
|
// RL_TEXTURE_FILTER_LINEAR - tex filter: BILINEAR, no mipmaps
|
|
rlTextureParameters(GetFontDefault().texture.id, RL_TEXTURE_MIN_FILTER, RL_TEXTURE_FILTER_LINEAR);
|
|
rlTextureParameters(GetFontDefault().texture.id, RL_TEXTURE_MAG_FILTER, RL_TEXTURE_FILTER_LINEAR);
|
|
}
|
|
#endif
|
|
|
|
// Initialize raw input system
|
|
InitEvdevInput(); // Evdev inputs initialization
|
|
InitGamepad(); // Gamepad init
|
|
InitKeyboard(); // Keyboard init (stdin)
|
|
|
|
#if defined(SUPPORT_EVENTS_AUTOMATION)
|
|
events = (AutomationEvent *)RL_CALLOC(MAX_CODE_AUTOMATION_EVENTS, sizeof(AutomationEvent));
|
|
CORE.Time.frameCounter = 0;
|
|
#endif
|
|
}
|
|
|
|
|
|
// Initialize display device and framebuffer
|
|
// NOTE: width and height represent the screen (framebuffer) desired size, not actual display size
|
|
// If width or height are 0, default display size will be used for framebuffer size
|
|
// NOTE: returns false in case graphic device could not be created
|
|
static bool InitGraphicsDevice(int width, int height)
|
|
{
|
|
CORE.Window.screen.width = width; // User desired width
|
|
CORE.Window.screen.height = height; // User desired height
|
|
CORE.Window.screenScale = MatrixIdentity(); // No draw scaling required by default
|
|
|
|
// Set the window minimum and maximum default values to 0
|
|
CORE.Window.windowMin.width = 0;
|
|
CORE.Window.windowMin.height = 0;
|
|
CORE.Window.windowMax.width = 0;
|
|
CORE.Window.windowMax.height = 0;
|
|
|
|
// NOTE: Framebuffer (render area - CORE.Window.render.width, CORE.Window.render.height) could include black bars...
|
|
// ...in top-down or left-right to match display aspect ratio (no weird scaling)
|
|
|
|
#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB)
|
|
glfwSetErrorCallback(ErrorCallback);
|
|
/*
|
|
// TODO: Setup GLFW custom allocators to match raylib ones
|
|
const GLFWallocator allocator = {
|
|
.allocate = MemAlloc,
|
|
.deallocate = MemFree,
|
|
.reallocate = MemRealloc,
|
|
.user = NULL
|
|
};
|
|
|
|
glfwInitAllocator(&allocator);
|
|
*/
|
|
#if defined(__APPLE__)
|
|
glfwInitHint(GLFW_COCOA_CHDIR_RESOURCES, GLFW_FALSE);
|
|
#endif
|
|
|
|
if (!glfwInit())
|
|
{
|
|
TRACELOG(LOG_WARNING, "GLFW: Failed to initialize GLFW");
|
|
return false;
|
|
}
|
|
|
|
glfwDefaultWindowHints(); // Set default windows hints
|
|
//glfwWindowHint(GLFW_RED_BITS, 8); // Framebuffer red color component bits
|
|
//glfwWindowHint(GLFW_GREEN_BITS, 8); // Framebuffer green color component bits
|
|
//glfwWindowHint(GLFW_BLUE_BITS, 8); // Framebuffer blue color component bits
|
|
//glfwWindowHint(GLFW_ALPHA_BITS, 8); // Framebuffer alpha color component bits
|
|
//glfwWindowHint(GLFW_DEPTH_BITS, 24); // Depthbuffer bits
|
|
//glfwWindowHint(GLFW_REFRESH_RATE, 0); // Refresh rate for fullscreen window
|
|
//glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_API); // OpenGL API to use. Alternative: GLFW_OPENGL_ES_API
|
|
//glfwWindowHint(GLFW_AUX_BUFFERS, 0); // Number of auxiliar buffers
|
|
|
|
// Check window creation flags
|
|
if ((CORE.Window.flags & FLAG_FULLSCREEN_MODE) > 0) CORE.Window.fullscreen = true;
|
|
|
|
if ((CORE.Window.flags & FLAG_WINDOW_HIDDEN) > 0) glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE); // Visible window
|
|
else glfwWindowHint(GLFW_VISIBLE, GLFW_TRUE); // Window initially hidden
|
|
|
|
if ((CORE.Window.flags & FLAG_WINDOW_UNDECORATED) > 0) glfwWindowHint(GLFW_DECORATED, GLFW_FALSE); // Border and buttons on Window
|
|
else glfwWindowHint(GLFW_DECORATED, GLFW_TRUE); // Decorated window
|
|
|
|
if ((CORE.Window.flags & FLAG_WINDOW_RESIZABLE) > 0) glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE); // Resizable window
|
|
else glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE); // Avoid window being resizable
|
|
|
|
// Disable FLAG_WINDOW_MINIMIZED, not supported on initialization
|
|
if ((CORE.Window.flags & FLAG_WINDOW_MINIMIZED) > 0) CORE.Window.flags &= ~FLAG_WINDOW_MINIMIZED;
|
|
|
|
// Disable FLAG_WINDOW_MAXIMIZED, not supported on initialization
|
|
if ((CORE.Window.flags & FLAG_WINDOW_MAXIMIZED) > 0) CORE.Window.flags &= ~FLAG_WINDOW_MAXIMIZED;
|
|
|
|
if ((CORE.Window.flags & FLAG_WINDOW_UNFOCUSED) > 0) glfwWindowHint(GLFW_FOCUSED, GLFW_FALSE);
|
|
else glfwWindowHint(GLFW_FOCUSED, GLFW_TRUE);
|
|
|
|
if ((CORE.Window.flags & FLAG_WINDOW_TOPMOST) > 0) glfwWindowHint(GLFW_FLOATING, GLFW_TRUE);
|
|
else glfwWindowHint(GLFW_FLOATING, GLFW_FALSE);
|
|
|
|
// NOTE: Some GLFW flags are not supported on HTML5
|
|
#if defined(PLATFORM_DESKTOP)
|
|
if ((CORE.Window.flags & FLAG_WINDOW_TRANSPARENT) > 0) glfwWindowHint(GLFW_TRANSPARENT_FRAMEBUFFER, GLFW_TRUE); // Transparent framebuffer
|
|
else glfwWindowHint(GLFW_TRANSPARENT_FRAMEBUFFER, GLFW_FALSE); // Opaque framebuffer
|
|
|
|
if ((CORE.Window.flags & FLAG_WINDOW_HIGHDPI) > 0)
|
|
{
|
|
// Resize window content area based on the monitor content scale.
|
|
// NOTE: This hint only has an effect on platforms where screen coordinates and pixels always map 1:1 such as Windows and X11.
|
|
// On platforms like macOS the resolution of the framebuffer is changed independently of the window size.
|
|
glfwWindowHint(GLFW_SCALE_TO_MONITOR, GLFW_TRUE); // Scale content area based on the monitor content scale where window is placed on
|
|
#if defined(__APPLE__)
|
|
glfwWindowHint(GLFW_COCOA_RETINA_FRAMEBUFFER, GLFW_TRUE);
|
|
#endif
|
|
}
|
|
else glfwWindowHint(GLFW_SCALE_TO_MONITOR, GLFW_FALSE);
|
|
|
|
// Mouse passthrough
|
|
if ((CORE.Window.flags & FLAG_WINDOW_MOUSE_PASSTHROUGH) > 0) glfwWindowHint(GLFW_MOUSE_PASSTHROUGH, GLFW_TRUE);
|
|
else glfwWindowHint(GLFW_MOUSE_PASSTHROUGH, GLFW_FALSE);
|
|
#endif
|
|
|
|
if (CORE.Window.flags & FLAG_MSAA_4X_HINT)
|
|
{
|
|
// NOTE: MSAA is only enabled for main framebuffer, not user-created FBOs
|
|
TRACELOG(LOG_INFO, "DISPLAY: Trying to enable MSAA x4");
|
|
glfwWindowHint(GLFW_SAMPLES, 4); // Tries to enable multisampling x4 (MSAA), default is 0
|
|
}
|
|
|
|
// NOTE: When asking for an OpenGL context version, most drivers provide the highest supported version
|
|
// with backward compatibility to older OpenGL versions.
|
|
// For example, if using OpenGL 1.1, driver can provide a 4.3 backwards compatible context.
|
|
|
|
// Check selection OpenGL version
|
|
if (rlGetVersion() == RL_OPENGL_21)
|
|
{
|
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2); // Choose OpenGL major version (just hint)
|
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1); // Choose OpenGL minor version (just hint)
|
|
}
|
|
else if (rlGetVersion() == RL_OPENGL_33)
|
|
{
|
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); // Choose OpenGL major version (just hint)
|
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); // Choose OpenGL minor version (just hint)
|
|
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); // Profiles Hint: Only 3.3 and above!
|
|
// Values: GLFW_OPENGL_CORE_PROFILE, GLFW_OPENGL_ANY_PROFILE, GLFW_OPENGL_COMPAT_PROFILE
|
|
#if defined(__APPLE__)
|
|
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GLFW_TRUE); // OSX Requires forward compatibility
|
|
#else
|
|
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GLFW_FALSE); // Forward Compatibility Hint: Only 3.3 and above!
|
|
#endif
|
|
//glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GLFW_TRUE); // Request OpenGL DEBUG context
|
|
}
|
|
else if (rlGetVersion() == RL_OPENGL_43)
|
|
{
|
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4); // Choose OpenGL major version (just hint)
|
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); // Choose OpenGL minor version (just hint)
|
|
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
|
|
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GLFW_FALSE);
|
|
#if defined(RLGL_ENABLE_OPENGL_DEBUG_CONTEXT)
|
|
glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GLFW_TRUE); // Enable OpenGL Debug Context
|
|
#endif
|
|
}
|
|
else if (rlGetVersion() == RL_OPENGL_ES_20) // Request OpenGL ES 2.0 context
|
|
{
|
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2);
|
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
|
|
glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API);
|
|
#if defined(PLATFORM_DESKTOP)
|
|
glfwWindowHint(GLFW_CONTEXT_CREATION_API, GLFW_EGL_CONTEXT_API);
|
|
#else
|
|
glfwWindowHint(GLFW_CONTEXT_CREATION_API, GLFW_NATIVE_CONTEXT_API);
|
|
#endif
|
|
}
|
|
else if (rlGetVersion() == RL_OPENGL_ES_30) // Request OpenGL ES 3.0 context
|
|
{
|
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
|
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
|
|
glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API);
|
|
#if defined(PLATFORM_DESKTOP)
|
|
glfwWindowHint(GLFW_CONTEXT_CREATION_API, GLFW_EGL_CONTEXT_API);
|
|
#else
|
|
glfwWindowHint(GLFW_CONTEXT_CREATION_API, GLFW_NATIVE_CONTEXT_API);
|
|
#endif
|
|
}
|
|
|
|
#if defined(PLATFORM_DESKTOP)
|
|
// NOTE: GLFW 3.4+ defers initialization of the Joystick subsystem on the first call to any Joystick related functions.
|
|
// Forcing this initialization here avoids doing it on PollInputEvents() called by EndDrawing() after first frame has been just drawn.
|
|
// The initialization will still happen and possible delays still occur, but before the window is shown, which is a nicer experience.
|
|
// REF: https://github.com/raysan5/raylib/issues/1554
|
|
if (MAX_GAMEPADS > 0) glfwSetJoystickCallback(NULL);
|
|
#endif
|
|
|
|
#if defined(PLATFORM_DESKTOP)
|
|
// Find monitor resolution
|
|
GLFWmonitor *monitor = glfwGetPrimaryMonitor();
|
|
if (!monitor)
|
|
{
|
|
TRACELOG(LOG_WARNING, "GLFW: Failed to get primary monitor");
|
|
return false;
|
|
}
|
|
|
|
const GLFWvidmode *mode = glfwGetVideoMode(monitor);
|
|
|
|
CORE.Window.display.width = mode->width;
|
|
CORE.Window.display.height = mode->height;
|
|
|
|
// Set screen width/height to the display width/height if they are 0
|
|
if (CORE.Window.screen.width == 0) CORE.Window.screen.width = CORE.Window.display.width;
|
|
if (CORE.Window.screen.height == 0) CORE.Window.screen.height = CORE.Window.display.height;
|
|
#endif // PLATFORM_DESKTOP
|
|
|
|
#if defined(PLATFORM_WEB)
|
|
// NOTE: Getting video modes is not implemented in emscripten GLFW3 version
|
|
CORE.Window.display.width = CORE.Window.screen.width;
|
|
CORE.Window.display.height = CORE.Window.screen.height;
|
|
#endif // PLATFORM_WEB
|
|
|
|
if (CORE.Window.fullscreen)
|
|
{
|
|
// remember center for switchinging from fullscreen to window
|
|
if ((CORE.Window.screen.height == CORE.Window.display.height) && (CORE.Window.screen.width == CORE.Window.display.width))
|
|
{
|
|
// If screen width/height equal to the display, we can't calculate the window pos for toggling full-screened/windowed.
|
|
// Toggling full-screened/windowed with pos(0, 0) can cause problems in some platforms, such as X11.
|
|
CORE.Window.position.x = CORE.Window.display.width/4;
|
|
CORE.Window.position.y = CORE.Window.display.height/4;
|
|
}
|
|
else
|
|
{
|
|
CORE.Window.position.x = CORE.Window.display.width/2 - CORE.Window.screen.width/2;
|
|
CORE.Window.position.y = CORE.Window.display.height/2 - CORE.Window.screen.height/2;
|
|
}
|
|
|
|
if (CORE.Window.position.x < 0) CORE.Window.position.x = 0;
|
|
if (CORE.Window.position.y < 0) CORE.Window.position.y = 0;
|
|
|
|
// Obtain recommended CORE.Window.display.width/CORE.Window.display.height from a valid videomode for the monitor
|
|
int count = 0;
|
|
const GLFWvidmode *modes = glfwGetVideoModes(glfwGetPrimaryMonitor(), &count);
|
|
|
|
// Get closest video mode to desired CORE.Window.screen.width/CORE.Window.screen.height
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
if ((unsigned int)modes[i].width >= CORE.Window.screen.width)
|
|
{
|
|
if ((unsigned int)modes[i].height >= CORE.Window.screen.height)
|
|
{
|
|
CORE.Window.display.width = modes[i].width;
|
|
CORE.Window.display.height = modes[i].height;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
TRACELOG(LOG_WARNING, "SYSTEM: Closest fullscreen videomode: %i x %i", CORE.Window.display.width, CORE.Window.display.height);
|
|
|
|
// NOTE: ISSUE: Closest videomode could not match monitor aspect-ratio, for example,
|
|
// for a desired screen size of 800x450 (16:9), closest supported videomode is 800x600 (4:3),
|
|
// framebuffer is rendered correctly but once displayed on a 16:9 monitor, it gets stretched
|
|
// by the sides to fit all monitor space...
|
|
|
|
// Try to setup the most appropriate fullscreen framebuffer for the requested screenWidth/screenHeight
|
|
// It considers device display resolution mode and setups a framebuffer with black bars if required (render size/offset)
|
|
// Modified global variables: CORE.Window.screen.width/CORE.Window.screen.height - CORE.Window.render.width/CORE.Window.render.height - CORE.Window.renderOffset.x/CORE.Window.renderOffset.y - CORE.Window.screenScale
|
|
// TODO: It is a quite cumbersome solution to display size vs requested size, it should be reviewed or removed...
|
|
// HighDPI monitors are properly considered in a following similar function: SetupViewport()
|
|
SetupFramebuffer(CORE.Window.display.width, CORE.Window.display.height);
|
|
|
|
CORE.Window.handle = glfwCreateWindow(CORE.Window.display.width, CORE.Window.display.height, (CORE.Window.title != 0)? CORE.Window.title : " ", glfwGetPrimaryMonitor(), NULL);
|
|
|
|
// NOTE: Full-screen change, not working properly...
|
|
//glfwSetWindowMonitor(CORE.Window.handle, glfwGetPrimaryMonitor(), 0, 0, CORE.Window.screen.width, CORE.Window.screen.height, GLFW_DONT_CARE);
|
|
}
|
|
else
|
|
{
|
|
#if defined(PLATFORM_DESKTOP)
|
|
// If we are windowed fullscreen, ensures that window does not minimize when focus is lost
|
|
if ((CORE.Window.screen.height == CORE.Window.display.height) && (CORE.Window.screen.width == CORE.Window.display.width))
|
|
{
|
|
glfwWindowHint(GLFW_AUTO_ICONIFY, 0);
|
|
}
|
|
#endif
|
|
// No-fullscreen window creation
|
|
CORE.Window.handle = glfwCreateWindow(CORE.Window.screen.width, CORE.Window.screen.height, (CORE.Window.title != 0)? CORE.Window.title : " ", NULL, NULL);
|
|
|
|
if (CORE.Window.handle)
|
|
{
|
|
CORE.Window.render.width = CORE.Window.screen.width;
|
|
CORE.Window.render.height = CORE.Window.screen.height;
|
|
}
|
|
}
|
|
|
|
if (!CORE.Window.handle)
|
|
{
|
|
glfwTerminate();
|
|
TRACELOG(LOG_WARNING, "GLFW: Failed to initialize Window");
|
|
return false;
|
|
}
|
|
|
|
// glfwCreateWindow title doesn't work with emscripten.
|
|
#if defined(PLATFORM_WEB)
|
|
emscripten_set_window_title((CORE.Window.title != 0)? CORE.Window.title : " ");
|
|
#endif
|
|
|
|
// Set window callback events
|
|
glfwSetWindowSizeCallback(CORE.Window.handle, WindowSizeCallback); // NOTE: Resizing not allowed by default!
|
|
#if !defined(PLATFORM_WEB)
|
|
glfwSetWindowMaximizeCallback(CORE.Window.handle, WindowMaximizeCallback);
|
|
#endif
|
|
glfwSetWindowIconifyCallback(CORE.Window.handle, WindowIconifyCallback);
|
|
glfwSetWindowFocusCallback(CORE.Window.handle, WindowFocusCallback);
|
|
glfwSetDropCallback(CORE.Window.handle, WindowDropCallback);
|
|
|
|
// Set input callback events
|
|
glfwSetKeyCallback(CORE.Window.handle, KeyCallback);
|
|
glfwSetCharCallback(CORE.Window.handle, CharCallback);
|
|
glfwSetMouseButtonCallback(CORE.Window.handle, MouseButtonCallback);
|
|
glfwSetCursorPosCallback(CORE.Window.handle, MouseCursorPosCallback); // Track mouse position changes
|
|
glfwSetScrollCallback(CORE.Window.handle, MouseScrollCallback);
|
|
glfwSetCursorEnterCallback(CORE.Window.handle, CursorEnterCallback);
|
|
|
|
glfwMakeContextCurrent(CORE.Window.handle);
|
|
|
|
#if !defined(PLATFORM_WEB)
|
|
glfwSetInputMode(CORE.Window.handle, GLFW_LOCK_KEY_MODS, GLFW_TRUE); // Enable lock keys modifiers (CAPS, NUM)
|
|
|
|
glfwSwapInterval(0); // No V-Sync by default
|
|
#endif
|
|
|
|
// Try to enable GPU V-Sync, so frames are limited to screen refresh rate (60Hz -> 60 FPS)
|
|
// NOTE: V-Sync can be enabled by graphic driver configuration, it doesn't need
|
|
// to be activated on web platforms since VSync is enforced there.
|
|
#if !defined(PLATFORM_WEB)
|
|
if (CORE.Window.flags & FLAG_VSYNC_HINT)
|
|
{
|
|
// WARNING: It seems to hit a critical render path in Intel HD Graphics
|
|
glfwSwapInterval(1);
|
|
TRACELOG(LOG_INFO, "DISPLAY: Trying to enable VSYNC");
|
|
}
|
|
#endif
|
|
|
|
int fbWidth = CORE.Window.screen.width;
|
|
int fbHeight = CORE.Window.screen.height;
|
|
|
|
#if defined(PLATFORM_DESKTOP)
|
|
if ((CORE.Window.flags & FLAG_WINDOW_HIGHDPI) > 0)
|
|
{
|
|
// NOTE: On APPLE platforms system should manage window/input scaling and also framebuffer scaling.
|
|
// Framebuffer scaling should be activated with: glfwWindowHint(GLFW_COCOA_RETINA_FRAMEBUFFER, GLFW_TRUE);
|
|
#if !defined(__APPLE__)
|
|
glfwGetFramebufferSize(CORE.Window.handle, &fbWidth, &fbHeight);
|
|
|
|
// Screen scaling matrix is required in case desired screen area is different from display area
|
|
CORE.Window.screenScale = MatrixScale((float)fbWidth/CORE.Window.screen.width, (float)fbHeight/CORE.Window.screen.height, 1.0f);
|
|
|
|
// Mouse input scaling for the new screen size
|
|
SetMouseScale((float)CORE.Window.screen.width/fbWidth, (float)CORE.Window.screen.height/fbHeight);
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
CORE.Window.render.width = fbWidth;
|
|
CORE.Window.render.height = fbHeight;
|
|
CORE.Window.currentFbo.width = fbWidth;
|
|
CORE.Window.currentFbo.height = fbHeight;
|
|
|
|
TRACELOG(LOG_INFO, "DISPLAY: Device initialized successfully");
|
|
TRACELOG(LOG_INFO, " > Display size: %i x %i", CORE.Window.display.width, CORE.Window.display.height);
|
|
TRACELOG(LOG_INFO, " > Screen size: %i x %i", CORE.Window.screen.width, CORE.Window.screen.height);
|
|
TRACELOG(LOG_INFO, " > Render size: %i x %i", CORE.Window.render.width, CORE.Window.render.height);
|
|
TRACELOG(LOG_INFO, " > Viewport offsets: %i, %i", CORE.Window.renderOffset.x, CORE.Window.renderOffset.y);
|
|
|
|
#endif // PLATFORM_DESKTOP || PLATFORM_WEB
|
|
|
|
#if defined(PLATFORM_ANDROID) || defined(PLATFORM_DRM)
|
|
CORE.Window.fullscreen = true;
|
|
CORE.Window.flags |= FLAG_FULLSCREEN_MODE;
|
|
|
|
#if defined(PLATFORM_DRM)
|
|
CORE.Window.fd = -1;
|
|
CORE.Window.connector = NULL;
|
|
CORE.Window.modeIndex = -1;
|
|
CORE.Window.crtc = NULL;
|
|
CORE.Window.gbmDevice = NULL;
|
|
CORE.Window.gbmSurface = NULL;
|
|
CORE.Window.prevBO = NULL;
|
|
CORE.Window.prevFB = 0;
|
|
|
|
#if defined(DEFAULT_GRAPHIC_DEVICE_DRM)
|
|
CORE.Window.fd = open(DEFAULT_GRAPHIC_DEVICE_DRM, O_RDWR);
|
|
#else
|
|
TRACELOG(LOG_INFO, "DISPLAY: No graphic card set, trying platform-gpu-card");
|
|
CORE.Window.fd = open("/dev/dri/by-path/platform-gpu-card", O_RDWR); // VideoCore VI (Raspberry Pi 4)
|
|
|
|
if ((-1 == CORE.Window.fd) || (drmModeGetResources(CORE.Window.fd) == NULL))
|
|
{
|
|
TRACELOG(LOG_INFO, "DISPLAY: Failed to open platform-gpu-card, trying card1");
|
|
CORE.Window.fd = open("/dev/dri/card1", O_RDWR); // Other Embedded
|
|
}
|
|
|
|
if ((-1 == CORE.Window.fd) || (drmModeGetResources(CORE.Window.fd) == NULL))
|
|
{
|
|
TRACELOG(LOG_INFO, "DISPLAY: Failed to open graphic card1, trying card0");
|
|
CORE.Window.fd = open("/dev/dri/card0", O_RDWR); // VideoCore IV (Raspberry Pi 1-3)
|
|
}
|
|
#endif
|
|
if (-1 == CORE.Window.fd)
|
|
{
|
|
TRACELOG(LOG_WARNING, "DISPLAY: Failed to open graphic card");
|
|
return false;
|
|
}
|
|
|
|
drmModeRes *res = drmModeGetResources(CORE.Window.fd);
|
|
if (!res)
|
|
{
|
|
TRACELOG(LOG_WARNING, "DISPLAY: Failed get DRM resources");
|
|
return false;
|
|
}
|
|
|
|
TRACELOG(LOG_TRACE, "DISPLAY: Connectors found: %i", res->count_connectors);
|
|
for (size_t i = 0; i < res->count_connectors; i++)
|
|
{
|
|
TRACELOG(LOG_TRACE, "DISPLAY: Connector index %i", i);
|
|
drmModeConnector *con = drmModeGetConnector(CORE.Window.fd, res->connectors[i]);
|
|
TRACELOG(LOG_TRACE, "DISPLAY: Connector modes detected: %i", con->count_modes);
|
|
if ((con->connection == DRM_MODE_CONNECTED) && (con->encoder_id))
|
|
{
|
|
TRACELOG(LOG_TRACE, "DISPLAY: DRM mode connected");
|
|
CORE.Window.connector = con;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
TRACELOG(LOG_TRACE, "DISPLAY: DRM mode NOT connected (deleting)");
|
|
drmModeFreeConnector(con);
|
|
}
|
|
}
|
|
|
|
if (!CORE.Window.connector)
|
|
{
|
|
TRACELOG(LOG_WARNING, "DISPLAY: No suitable DRM connector found");
|
|
drmModeFreeResources(res);
|
|
return false;
|
|
}
|
|
|
|
drmModeEncoder *enc = drmModeGetEncoder(CORE.Window.fd, CORE.Window.connector->encoder_id);
|
|
if (!enc)
|
|
{
|
|
TRACELOG(LOG_WARNING, "DISPLAY: Failed to get DRM mode encoder");
|
|
drmModeFreeResources(res);
|
|
return false;
|
|
}
|
|
|
|
CORE.Window.crtc = drmModeGetCrtc(CORE.Window.fd, enc->crtc_id);
|
|
if (!CORE.Window.crtc)
|
|
{
|
|
TRACELOG(LOG_WARNING, "DISPLAY: Failed to get DRM mode crtc");
|
|
drmModeFreeEncoder(enc);
|
|
drmModeFreeResources(res);
|
|
return false;
|
|
}
|
|
|
|
// If InitWindow should use the current mode find it in the connector's mode list
|
|
if ((CORE.Window.screen.width <= 0) || (CORE.Window.screen.height <= 0))
|
|
{
|
|
TRACELOG(LOG_TRACE, "DISPLAY: Selecting DRM connector mode for current used mode...");
|
|
|
|
CORE.Window.modeIndex = FindMatchingConnectorMode(CORE.Window.connector, &CORE.Window.crtc->mode);
|
|
|
|
if (CORE.Window.modeIndex < 0)
|
|
{
|
|
TRACELOG(LOG_WARNING, "DISPLAY: No matching DRM connector mode found");
|
|
drmModeFreeEncoder(enc);
|
|
drmModeFreeResources(res);
|
|
return false;
|
|
}
|
|
|
|
CORE.Window.screen.width = CORE.Window.display.width;
|
|
CORE.Window.screen.height = CORE.Window.display.height;
|
|
}
|
|
|
|
const bool allowInterlaced = CORE.Window.flags & FLAG_INTERLACED_HINT;
|
|
const int fps = (CORE.Time.target > 0) ? (1.0/CORE.Time.target) : 60;
|
|
|
|
// Try to find an exact matching mode
|
|
CORE.Window.modeIndex = FindExactConnectorMode(CORE.Window.connector, CORE.Window.screen.width, CORE.Window.screen.height, fps, allowInterlaced);
|
|
|
|
// If nothing found, try to find a nearly matching mode
|
|
if (CORE.Window.modeIndex < 0) CORE.Window.modeIndex = FindNearestConnectorMode(CORE.Window.connector, CORE.Window.screen.width, CORE.Window.screen.height, fps, allowInterlaced);
|
|
|
|
// If nothing found, try to find an exactly matching mode including interlaced
|
|
if (CORE.Window.modeIndex < 0) CORE.Window.modeIndex = FindExactConnectorMode(CORE.Window.connector, CORE.Window.screen.width, CORE.Window.screen.height, fps, true);
|
|
|
|
// If nothing found, try to find a nearly matching mode including interlaced
|
|
if (CORE.Window.modeIndex < 0) CORE.Window.modeIndex = FindNearestConnectorMode(CORE.Window.connector, CORE.Window.screen.width, CORE.Window.screen.height, fps, true);
|
|
|
|
// If nothing found, there is no suitable mode
|
|
if (CORE.Window.modeIndex < 0)
|
|
{
|
|
TRACELOG(LOG_WARNING, "DISPLAY: Failed to find a suitable DRM connector mode");
|
|
drmModeFreeEncoder(enc);
|
|
drmModeFreeResources(res);
|
|
return false;
|
|
}
|
|
|
|
CORE.Window.display.width = CORE.Window.connector->modes[CORE.Window.modeIndex].hdisplay;
|
|
CORE.Window.display.height = CORE.Window.connector->modes[CORE.Window.modeIndex].vdisplay;
|
|
|
|
TRACELOG(LOG_INFO, "DISPLAY: Selected DRM connector mode %s (%ux%u%c@%u)", CORE.Window.connector->modes[CORE.Window.modeIndex].name,
|
|
CORE.Window.connector->modes[CORE.Window.modeIndex].hdisplay, CORE.Window.connector->modes[CORE.Window.modeIndex].vdisplay,
|
|
(CORE.Window.connector->modes[CORE.Window.modeIndex].flags & DRM_MODE_FLAG_INTERLACE) ? 'i' : 'p',
|
|
CORE.Window.connector->modes[CORE.Window.modeIndex].vrefresh);
|
|
|
|
// Use the width and height of the surface for render
|
|
CORE.Window.render.width = CORE.Window.screen.width;
|
|
CORE.Window.render.height = CORE.Window.screen.height;
|
|
|
|
drmModeFreeEncoder(enc);
|
|
enc = NULL;
|
|
|
|
drmModeFreeResources(res);
|
|
res = NULL;
|
|
|
|
CORE.Window.gbmDevice = gbm_create_device(CORE.Window.fd);
|
|
if (!CORE.Window.gbmDevice)
|
|
{
|
|
TRACELOG(LOG_WARNING, "DISPLAY: Failed to create GBM device");
|
|
return false;
|
|
}
|
|
|
|
CORE.Window.gbmSurface = gbm_surface_create(CORE.Window.gbmDevice, CORE.Window.connector->modes[CORE.Window.modeIndex].hdisplay,
|
|
CORE.Window.connector->modes[CORE.Window.modeIndex].vdisplay, GBM_FORMAT_ARGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING);
|
|
if (!CORE.Window.gbmSurface)
|
|
{
|
|
TRACELOG(LOG_WARNING, "DISPLAY: Failed to create GBM surface");
|
|
return false;
|
|
}
|
|
#endif
|
|
|
|
EGLint samples = 0;
|
|
EGLint sampleBuffer = 0;
|
|
if (CORE.Window.flags & FLAG_MSAA_4X_HINT)
|
|
{
|
|
samples = 4;
|
|
sampleBuffer = 1;
|
|
TRACELOG(LOG_INFO, "DISPLAY: Trying to enable MSAA x4");
|
|
}
|
|
|
|
const EGLint framebufferAttribs[] =
|
|
{
|
|
EGL_RENDERABLE_TYPE, (rlGetVersion() == RL_OPENGL_ES_30)? EGL_OPENGL_ES3_BIT : EGL_OPENGL_ES2_BIT, // Type of context support
|
|
#if defined(PLATFORM_DRM)
|
|
EGL_SURFACE_TYPE, EGL_WINDOW_BIT, // Don't use it on Android!
|
|
#endif
|
|
EGL_RED_SIZE, 8, // RED color bit depth (alternative: 5)
|
|
EGL_GREEN_SIZE, 8, // GREEN color bit depth (alternative: 6)
|
|
EGL_BLUE_SIZE, 8, // BLUE color bit depth (alternative: 5)
|
|
#if defined(PLATFORM_DRM)
|
|
EGL_ALPHA_SIZE, 8, // ALPHA bit depth (required for transparent framebuffer)
|
|
#endif
|
|
//EGL_TRANSPARENT_TYPE, EGL_NONE, // Request transparent framebuffer (EGL_TRANSPARENT_RGB does not work on RPI)
|
|
EGL_DEPTH_SIZE, 16, // Depth buffer size (Required to use Depth testing!)
|
|
//EGL_STENCIL_SIZE, 8, // Stencil buffer size
|
|
EGL_SAMPLE_BUFFERS, sampleBuffer, // Activate MSAA
|
|
EGL_SAMPLES, samples, // 4x Antialiasing if activated (Free on MALI GPUs)
|
|
EGL_NONE
|
|
};
|
|
|
|
const EGLint contextAttribs[] =
|
|
{
|
|
EGL_CONTEXT_CLIENT_VERSION, 2,
|
|
EGL_NONE
|
|
};
|
|
|
|
#if defined(PLATFORM_ANDROID) || defined(PLATFORM_DRM)
|
|
EGLint numConfigs = 0;
|
|
|
|
// Get an EGL device connection
|
|
#if defined(PLATFORM_DRM)
|
|
CORE.Window.device = eglGetDisplay((EGLNativeDisplayType)CORE.Window.gbmDevice);
|
|
#else
|
|
CORE.Window.device = eglGetDisplay(EGL_DEFAULT_DISPLAY);
|
|
#endif
|
|
if (CORE.Window.device == EGL_NO_DISPLAY)
|
|
{
|
|
TRACELOG(LOG_WARNING, "DISPLAY: Failed to initialize EGL device");
|
|
return false;
|
|
}
|
|
|
|
// Initialize the EGL device connection
|
|
if (eglInitialize(CORE.Window.device, NULL, NULL) == EGL_FALSE)
|
|
{
|
|
// If all of the calls to eglInitialize returned EGL_FALSE then an error has occurred.
|
|
TRACELOG(LOG_WARNING, "DISPLAY: Failed to initialize EGL device");
|
|
return false;
|
|
}
|
|
|
|
#if defined(PLATFORM_DRM)
|
|
if (!eglChooseConfig(CORE.Window.device, NULL, NULL, 0, &numConfigs))
|
|
{
|
|
TRACELOG(LOG_WARNING, "DISPLAY: Failed to get EGL config count: 0x%x", eglGetError());
|
|
return false;
|
|
}
|
|
|
|
TRACELOG(LOG_TRACE, "DISPLAY: EGL configs available: %d", numConfigs);
|
|
|
|
EGLConfig *configs = RL_CALLOC(numConfigs, sizeof(*configs));
|
|
if (!configs)
|
|
{
|
|
TRACELOG(LOG_WARNING, "DISPLAY: Failed to get memory for EGL configs");
|
|
return false;
|
|
}
|
|
|
|
EGLint matchingNumConfigs = 0;
|
|
if (!eglChooseConfig(CORE.Window.device, framebufferAttribs, configs, numConfigs, &matchingNumConfigs))
|
|
{
|
|
TRACELOG(LOG_WARNING, "DISPLAY: Failed to choose EGL config: 0x%x", eglGetError());
|
|
free(configs);
|
|
return false;
|
|
}
|
|
|
|
TRACELOG(LOG_TRACE, "DISPLAY: EGL matching configs available: %d", matchingNumConfigs);
|
|
|
|
// find the EGL config that matches the previously setup GBM format
|
|
int found = 0;
|
|
for (EGLint i = 0; i < matchingNumConfigs; ++i)
|
|
{
|
|
EGLint id = 0;
|
|
if (!eglGetConfigAttrib(CORE.Window.device, configs[i], EGL_NATIVE_VISUAL_ID, &id))
|
|
{
|
|
TRACELOG(LOG_WARNING, "DISPLAY: Failed to get EGL config attribute: 0x%x", eglGetError());
|
|
continue;
|
|
}
|
|
|
|
if (GBM_FORMAT_ARGB8888 == id)
|
|
{
|
|
TRACELOG(LOG_TRACE, "DISPLAY: Using EGL config: %d", i);
|
|
CORE.Window.config = configs[i];
|
|
found = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
RL_FREE(configs);
|
|
|
|
if (!found)
|
|
{
|
|
TRACELOG(LOG_WARNING, "DISPLAY: Failed to find a suitable EGL config");
|
|
return false;
|
|
}
|
|
#else
|
|
// Get an appropriate EGL framebuffer configuration
|
|
eglChooseConfig(CORE.Window.device, framebufferAttribs, &CORE.Window.config, 1, &numConfigs);
|
|
#endif
|
|
|
|
// Set rendering API
|
|
eglBindAPI(EGL_OPENGL_ES_API);
|
|
|
|
// Create an EGL rendering context
|
|
CORE.Window.context = eglCreateContext(CORE.Window.device, CORE.Window.config, EGL_NO_CONTEXT, contextAttribs);
|
|
if (CORE.Window.context == EGL_NO_CONTEXT)
|
|
{
|
|
TRACELOG(LOG_WARNING, "DISPLAY: Failed to create EGL context");
|
|
return false;
|
|
}
|
|
#endif
|
|
|
|
// Create an EGL window surface
|
|
//---------------------------------------------------------------------------------
|
|
#if defined(PLATFORM_ANDROID)
|
|
EGLint displayFormat = 0;
|
|
|
|
// EGL_NATIVE_VISUAL_ID is an attribute of the EGLConfig that is guaranteed to be accepted by ANativeWindow_setBuffersGeometry()
|
|
// As soon as we picked a EGLConfig, we can safely reconfigure the ANativeWindow buffers to match, using EGL_NATIVE_VISUAL_ID
|
|
eglGetConfigAttrib(CORE.Window.device, CORE.Window.config, EGL_NATIVE_VISUAL_ID, &displayFormat);
|
|
|
|
// At this point we need to manage render size vs screen size
|
|
// NOTE: This function use and modify global module variables:
|
|
// -> CORE.Window.screen.width/CORE.Window.screen.height
|
|
// -> CORE.Window.render.width/CORE.Window.render.height
|
|
// -> CORE.Window.screenScale
|
|
SetupFramebuffer(CORE.Window.display.width, CORE.Window.display.height);
|
|
|
|
ANativeWindow_setBuffersGeometry(CORE.Android.app->window, CORE.Window.render.width, CORE.Window.render.height, displayFormat);
|
|
//ANativeWindow_setBuffersGeometry(CORE.Android.app->window, 0, 0, displayFormat); // Force use of native display size
|
|
|
|
CORE.Window.surface = eglCreateWindowSurface(CORE.Window.device, CORE.Window.config, CORE.Android.app->window, NULL);
|
|
#endif // PLATFORM_ANDROID
|
|
|
|
#if defined(PLATFORM_DRM)
|
|
CORE.Window.surface = eglCreateWindowSurface(CORE.Window.device, CORE.Window.config, (EGLNativeWindowType)CORE.Window.gbmSurface, NULL);
|
|
if (EGL_NO_SURFACE == CORE.Window.surface)
|
|
{
|
|
TRACELOG(LOG_WARNING, "DISPLAY: Failed to create EGL window surface: 0x%04x", eglGetError());
|
|
return false;
|
|
}
|
|
|
|
// At this point we need to manage render size vs screen size
|
|
// NOTE: This function use and modify global module variables:
|
|
// -> CORE.Window.screen.width/CORE.Window.screen.height
|
|
// -> CORE.Window.render.width/CORE.Window.render.height
|
|
// -> CORE.Window.screenScale
|
|
SetupFramebuffer(CORE.Window.display.width, CORE.Window.display.height);
|
|
#endif // PLATFORM_DRM
|
|
|
|
// There must be at least one frame displayed before the buffers are swapped
|
|
//eglSwapInterval(CORE.Window.device, 1);
|
|
|
|
if (eglMakeCurrent(CORE.Window.device, CORE.Window.surface, CORE.Window.surface, CORE.Window.context) == EGL_FALSE)
|
|
{
|
|
TRACELOG(LOG_WARNING, "DISPLAY: Failed to attach EGL rendering context to EGL surface");
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
CORE.Window.render.width = CORE.Window.screen.width;
|
|
CORE.Window.render.height = CORE.Window.screen.height;
|
|
CORE.Window.currentFbo.width = CORE.Window.render.width;
|
|
CORE.Window.currentFbo.height = CORE.Window.render.height;
|
|
|
|
TRACELOG(LOG_INFO, "DISPLAY: Device initialized successfully");
|
|
TRACELOG(LOG_INFO, " > Display size: %i x %i", CORE.Window.display.width, CORE.Window.display.height);
|
|
TRACELOG(LOG_INFO, " > Screen size: %i x %i", CORE.Window.screen.width, CORE.Window.screen.height);
|
|
TRACELOG(LOG_INFO, " > Render size: %i x %i", CORE.Window.render.width, CORE.Window.render.height);
|
|
TRACELOG(LOG_INFO, " > Viewport offsets: %i, %i", CORE.Window.renderOffset.x, CORE.Window.renderOffset.y);
|
|
}
|
|
#endif // PLATFORM_ANDROID || PLATFORM_DRM
|
|
|
|
// Load OpenGL extensions
|
|
// NOTE: GL procedures address loader is required to load extensions
|
|
#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB)
|
|
rlLoadExtensions(glfwGetProcAddress);
|
|
#else
|
|
rlLoadExtensions(eglGetProcAddress);
|
|
#endif
|
|
|
|
// Initialize OpenGL context (states and resources)
|
|
// NOTE: CORE.Window.currentFbo.width and CORE.Window.currentFbo.height not used, just stored as globals in rlgl
|
|
rlglInit(CORE.Window.currentFbo.width, CORE.Window.currentFbo.height);
|
|
|
|
// Setup default viewport
|
|
// NOTE: It updated CORE.Window.render.width and CORE.Window.render.height
|
|
SetupViewport(CORE.Window.currentFbo.width, CORE.Window.currentFbo.height);
|
|
|
|
#if defined(PLATFORM_ANDROID)
|
|
CORE.Window.ready = true;
|
|
#endif
|
|
|
|
if ((CORE.Window.flags & FLAG_WINDOW_MINIMIZED) > 0) MinimizeWindow();
|
|
|
|
return true;
|
|
}
|