lpnf
/
lovr
mirror of https://github.com/bjornbytes/lovr.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

rm EGL/X11; Android fixes;

This commit is contained in:
bjorn 2022-06-20 18:23:28 -07:00
parent 0306096577
commit fe31431016
3 changed files with 22 additions and 187 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
CMakeLists.txt
View File

@ -24,7 +24,6 @@ option(LOVR_USE_WEBXR "Enable the WebXR backend for the headset module" OFF)
option(LOVR_USE_DESKTOP "Enable the keyboard/mouse backend for the headset module" ON)
option(LOVR_USE_STEAM_AUDIO "Enable the Steam Audio spatializer (be sure to also set LOVR_STEAM_AUDIO_PATH)" OFF)
option(LOVR_USE_OCULUS_AUDIO "Enable the Oculus Audio spatializer (be sure to also set LOVR_OCULUS_AUDIO_PATH)" OFF)
option(LOVR_USE_LINUX_EGL "Use the EGL graphics extension on Linux" OFF)
option(LOVR_SANITIZE "Enable Address Sanitizer" OFF)
option(LOVR_SYSTEM_GLFW "Use the system-provided glfw" OFF)
@ -686,7 +685,7 @@ elseif(EMSCRIPTEN)
configure_file(etc/lovr.ico favicon.ico COPYONLY)
elseif(ANDROID)
target_sources(lovr PRIVATE src/core/os_android.c)
target_link_libraries(lovr log EGL android dl)
target_link_libraries(lovr log android dl)
target_include_directories(lovr PRIVATE "${ANDROID_NDK}/sources/android/native_app_glue")
# Dynamically linked targets output libraries in raw/lib/<ABI> for easy including in apk with aapt
@ -779,11 +778,6 @@ elseif(ANDROID)
add_dependencies(buildAPK move_libraries)
endif()
elseif(UNIX)
if(LOVR_USE_LINUX_EGL)
target_compile_definitions(lovr PRIVATE LOVR_LINUX_EGL)
else()
target_compile_definitions(lovr PRIVATE LOVR_LINUX_X11)
endif()
target_sources(lovr PRIVATE src/core/os_linux.c)
set_target_properties(lovr PROPERTIES
RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin"

123
src/core/os_android.c
View File

@ -4,8 +4,7 @@
#include <time.h>
#include <unistd.h>
#include <pthread.h>
#include <EGL/egl.h>
#include <EGL/eglext.h>
#include <sys/mman.h>
// This is probably bad, but makes things easier to build
#include <android_native_app_glue.c>
@ -13,10 +12,6 @@
static struct {
struct android_app* app;
JNIEnv* jni;
EGLDisplay display;
EGLContext context;
EGLConfig config;
EGLSurface surface;
fn_quit* onQuit;
fn_key* onKeyboardEvent;
fn_text* onTextEvent;
@ -175,10 +170,6 @@ bool os_init() {
}
void os_destroy() {
if (state.display) eglMakeCurrent(state.display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
if (state.surface) eglDestroySurface(state.display, state.surface);
if (state.context) eglDestroyContext(state.display, state.context);
if (state.display) eglTerminate(state.display);
memset(&state, 0, sizeof(state));
}
@ -255,6 +246,22 @@ void os_request_permission(os_permission permission) {
}
}
void* os_vm_init(size_t size) {
return mmap(NULL, size, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
}
bool os_vm_free(void* p, size_t size) {
return !munmap(p, size);
}
bool os_vm_commit(void* p, size_t size) {
return !mprotect(p, size, PROT_READ | PROT_WRITE);
}
bool os_vm_release(void* p, size_t size) {
return !madvise(p, size, MADV_DONTNEED);
}
// Notes about polling:
// - Stop polling if a destroy is requested to give the application a chance to shut down.
// Otherwise this loop would still wait for an event and the app would seem unresponsive.
@ -305,86 +312,6 @@ void os_on_permission(fn_permission* callback) {
}
bool os_window_open(const os_window_config* config) {
if (state.display) {
return true;
}
if ((state.display = eglGetDisplay(EGL_DEFAULT_DISPLAY)) == EGL_NO_DISPLAY) {
return false;
}
if (eglInitialize(state.display, NULL, NULL) == EGL_FALSE) {
return false;
}
EGLConfig configs[1024];
EGLint configCount;
if (eglGetConfigs(state.display, configs, sizeof(configs) / sizeof(configs[0]), &configCount) == EGL_FALSE) {
return false;
}
const EGLint attributes[] = {
EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_ALPHA_SIZE, 8,
EGL_DEPTH_SIZE, 0,
EGL_STENCIL_SIZE, 0,
EGL_SAMPLES, 0,
EGL_NONE
};
state.config = 0;
for (EGLint i = 0; i < configCount && state.config == 0; i++) {
EGLint value, mask;
mask = EGL_OPENGL_ES3_BIT_KHR;
if (!eglGetConfigAttrib(state.display, configs[i], EGL_RENDERABLE_TYPE, &value) || (value & mask) != mask) {
continue;
}
mask = EGL_PBUFFER_BIT | EGL_WINDOW_BIT;
if (!eglGetConfigAttrib(state.display, configs[i], EGL_SURFACE_TYPE, &value) || (value & mask) != mask) {
continue;
}
for (size_t a = 0; a < sizeof(attributes) / sizeof(attributes[0]); a += 2) {
if (attributes[a] == EGL_NONE) {
state.config = configs[i];
break;
}
if (!eglGetConfigAttrib(state.display, configs[i], attributes[a], &value) || value != attributes[a + 1]) {
break;
}
}
}
EGLint contextAttributes[] = {
EGL_CONTEXT_CLIENT_VERSION, 3,
EGL_NONE
};
if ((state.context = eglCreateContext(state.display, state.config, EGL_NO_CONTEXT, contextAttributes)) == EGL_NO_CONTEXT) {
return false;
}
EGLint surfaceAttributes[] = {
EGL_WIDTH, 16,
EGL_HEIGHT, 16,
EGL_NONE
};
if ((state.surface = eglCreatePbufferSurface(state.display, state.config, surfaceAttributes)) == EGL_NO_SURFACE) {
eglDestroyContext(state.display, state.context);
return false;
}
if (eglMakeCurrent(state.display, state.surface, state.surface, state.context) == EGL_FALSE) {
eglDestroySurface(state.display, state.surface);
eglDestroyContext(state.display, state.context);
}
return true;
}
@ -490,22 +417,6 @@ JNIEnv* os_get_jni() {
return state.jni;
}
EGLDisplay os_get_egl_display() {
return state.display;
}
EGLContext os_get_egl_context() {
return state.context;
}
EGLContext os_get_egl_config() {
return state.config;
}
EGLSurface os_get_egl_surface() {
return state.surface;
}
const char** os_vk_get_instance_extensions(uint32_t* count) {
return *count = 0, NULL;
}

78
src/core/os_glfw.h
View File

@ -8,24 +8,10 @@
#include <GLFW/glfw3.h>
#ifndef EMSCRIPTEN
# ifdef _WIN32
# define GLFW_EXPOSE_NATIVE_WIN32
# define GLFW_EXPOSE_NATIVE_WGL
# endif
# ifdef _WIN32
# define GLFW_EXPOSE_NATIVE_WIN32
# define GLFW_EXPOSE_NATIVE_WGL
# endif
# ifdef LOVR_LINUX_EGL
# define EGL_NO_X11
# include <EGL/egl.h>
# define GLFW_EXPOSE_NATIVE_EGL
# endif
# ifdef LOVR_LINUX_X11
# define GLFW_EXPOSE_NATIVE_X11
# define GLFW_EXPOSE_NATIVE_GLX
# endif
# include <GLFW/glfw3native.h>
#ifdef _WIN32
#define GLFW_EXPOSE_NATIVE_WIN32
#endif
#include <GLFW/glfw3native.h>
#endif
static struct {
@ -217,9 +203,6 @@ bool os_window_open(const os_window_config* config) {
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
#endif
#ifdef LOVR_LINUX_EGL
glfwWindowHint(GLFW_CONTEXT_CREATION_API, GLFW_EGL_CONTEXT_API);
#endif
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
@ -253,9 +236,6 @@ bool os_window_open(const os_window_config* config) {
});
}
#ifndef LOVR_VK
glfwMakeContextCurrent(glfwState.window);
#endif
glfwSetWindowCloseCallback(glfwState.window, onWindowClose);
glfwSetWindowFocusCallback(glfwState.window, onWindowFocus);
glfwSetWindowSizeCallback(glfwState.window, onWindowResize);
@ -333,56 +313,6 @@ bool os_is_key_down(os_key key) {
HANDLE os_get_win32_window() {
return (HANDLE) glfwGetWin32Window(glfwState.window);
}
HGLRC os_get_win32_context() {
return glfwGetWGLContext(glfwState.window);
}
#endif
#ifdef LOVR_LINUX_EGL
PFNEGLGETPROCADDRESSPROC os_get_egl_proc_addr() {
return (PFNEGLGETPROCADDRESSPROC) glfwGetProcAddress;
}
EGLDisplay os_get_egl_display() {
return glfwGetEGLDisplay();
}
EGLContext os_get_egl_context() {
return glfwGetEGLContext(glfwState.window);
}
EGLConfig os_get_egl_config() {
EGLDisplay dpy = os_get_egl_display();
EGLContext ctx = os_get_egl_context();
EGLint cfg_id = -1;
EGLint num_cfgs = -1;
EGLConfig cfg = NULL;
PFNEGLQUERYCONTEXTPROC eglQueryContext = (PFNEGLQUERYCONTEXTPROC)glfwGetProcAddress("eglQueryContext");
PFNEGLCHOOSECONFIGPROC eglChooseConfig = (PFNEGLCHOOSECONFIGPROC)glfwGetProcAddress("eglChooseConfig");
eglQueryContext(dpy, ctx, EGL_CONFIG_ID, &cfg_id);
EGLint attrs [4] = {
EGL_CONFIG_ID, cfg_id,
EGL_NONE, EGL_NONE,
};
eglChooseConfig(dpy, attrs, &cfg, 1, &num_cfgs);
return cfg;
}
#endif
#ifdef LOVR_LINUX_X11
Display* os_get_x11_display() {
return glfwGetX11Display();
}
GLXDrawable os_get_glx_drawable() {
return glfwGetGLXWindow(glfwState.window);
}
GLXContext os_get_glx_context() {
return glfwGetGLXContext(glfwState.window);
}
#endif
#ifdef LOVR_VK