ShuriZma
/
xenia
mirror of https://github.com/xenia-project/xenia.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Fix travis LINT

This commit is contained in:
scribam 2017-09-20 22:39:49 +02:00
parent fa3edace6a
commit b6e7e66fbe
27 changed files with 176 additions and 258 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/xenia/base/exception_handler_linux.cc
View File

@ -24,13 +24,12 @@ constexpr size_t kMaxHandlerCount = 8;
// Executed in order.
std::pair<ExceptionHandler::Handler, void*> handlers_[kMaxHandlerCount];
void ExceptionHandler::Install(Handler fn, void* data) {
//TODO(dougvj) stub
// TODO(dougvj) stub
}
void ExceptionHandler::Uninstall(Handler fn, void* data) {
//TODO(dougvj) stub
// TODO(dougvj) stub
}
} // namespace xe

33
src/xenia/base/filesystem_posix.cc
View File

@ -12,11 +12,11 @@
#include "xenia/base/string.h"
#include <dirent.h>
#include <fcntl.h>
#include <ftw.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <ftw.h>
#include <fcntl.h>
namespace xe {
namespace filesystem {
@ -26,7 +26,6 @@ bool PathExists(const std::wstring& path) {
return stat(xe::to_string(path).c_str(), &st) == 0;
}
FILE* OpenFile(const std::wstring& path, const char* mode) {
auto fixed_path = xe::fix_path_separators(path);
return fopen(xe::to_string(fixed_path).c_str(), mode);
@ -36,23 +35,25 @@ bool CreateFolder(const std::wstring& path) {
return mkdir(xe::to_string(path).c_str(), 0774);
}
static int removeCallback(const char *fpath, const struct stat* sb,
int typeflag, struct FTW* ftwbuf) {
static int removeCallback(const char* fpath, const struct stat* sb,
int typeflag, struct FTW* ftwbuf) {
int rv = remove(fpath);
return rv;
}
bool DeleteFolder(const std::wstring& path) {
return nftw(xe::to_string(path).c_str(), removeCallback, 64,
FTW_DEPTH | FTW_PHYS) == 0 ? true : false;
FTW_DEPTH | FTW_PHYS) == 0
? true
: false;
}
static uint64_t convertUnixtimeToWinFiletime(time_t unixtime) {
//Linux uses number of seconds since 1/1/1970, and Windows uses
//number of nanoseconds since 1/1/1601
//so we convert linux time to nanoseconds and then add the number of
//nanoseconds from 1601 to 1970
//see https://msdn.microsoft.com/en-us/library/ms724228
// Linux uses number of seconds since 1/1/1970, and Windows uses
// number of nanoseconds since 1/1/1601
// so we convert linux time to nanoseconds and then add the number of
// nanoseconds from 1601 to 1970
// see https://msdn.microsoft.com/en-us/library/ms724228
uint64_t filetime = filetime = (unixtime * 10000000) + 116444736000000000;
return filetime;
}
@ -60,8 +61,7 @@ static uint64_t convertUnixtimeToWinFiletime(time_t unixtime) {
bool IsFolder(const std::wstring& path) {
struct stat st;
if (stat(xe::to_string(path).c_str(), &st) == 0) {
if (S_ISDIR(st.st_mode))
return true;
if (S_ISDIR(st.st_mode)) return true;
}
return false;
}
@ -89,11 +89,9 @@ class PosixFileHandle : public FileHandle {
}
bool Read(size_t file_offset, void* buffer, size_t buffer_length,
size_t* out_bytes_read) override {
ssize_t out = pread(handle_, buffer, buffer_length, file_offset);
*out_bytes_read = out;
return out >= 0 ? true : false;
}
bool Write(size_t file_offset, const void* buffer, size_t buffer_length,
size_t* out_bytes_written) override {
@ -144,8 +142,7 @@ bool GetInfo(const std::wstring& path, FileInfo* out_info) {
if (stat(xe::to_string(path).c_str(), &st) == 0) {
if (S_ISDIR(st.st_mode)) {
out_info->type = FileInfo::Type::kDirectory;
}
else {
} else {
out_info->type = FileInfo::Type::kFile;
}
out_info->create_timestamp = convertUnixtimeToWinFiletime(st.st_ctime);
@ -186,7 +183,5 @@ std::vector<FileInfo> ListFiles(const std::wstring& path) {
return result;
}
} // namespace filesystem
} // namespace xe

2
src/xenia/base/math.h
View File

@ -11,10 +11,10 @@
#define XENIA_BASE_MATH_H_
#include <algorithm>
#include <cmath>
#include <cstdint>
#include <cstring>
#include <type_traits>
#include <cmath>
#include "xenia/base/platform.h"
#if XE_ARCH_AMD64

1
src/xenia/base/platform_linux.cc
View File

@ -18,5 +18,4 @@ void LaunchBrowser(const char* url) {
system(cmd.c_str());
}
} // namespace xe

10
src/xenia/base/platform_linux.h
View File

@ -18,15 +18,15 @@
// Xlib/Xcb is used only for GLX/Vulkan interaction, the window management
// and input events are done with gtk/gdk
#include <X11/Xlib.h>
#include <X11/Xlib-xcb.h>
#include <X11/Xutil.h>
#include <X11/Xlib.h>
#include <X11/Xos.h>
#include <X11/Xutil.h>
#include <xcb/xcb.h>
//Used for window management. Gtk is for GUI and wigets, gdk is for lower
//level events like key presses, mouse events, window handles, etc
#include <gtk/gtk.h>
// Used for window management. Gtk is for GUI and wigets, gdk is for lower
// level events like key presses, mouse events, window handles, etc
#include <gdk/gdkx.h>
#include <gtk/gtk.h>
#endif // XENIA_BASE_PLATFORM_X11_H_

2
src/xenia/base/threading.h
View File

@ -16,13 +16,13 @@
#include <climits>
#include <condition_variable>
#include <cstdint>
#include <functional>
#include <memory>
#include <mutex>
#include <string>
#include <thread>
#include <utility>
#include <vector>
#include <functional>
namespace xe {
namespace threading {

5
src/xenia/base/threading_linux.cc
View File

@ -13,8 +13,5 @@
#include <time.h>
namespace xe {
namespace threading {
} // namespace threading
namespace threading {} // namespace threading
} // namespace xe

99
src/xenia/base/threading_posix.cc
View File

@ -14,18 +14,16 @@
#include <pthread.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/types.h>
#include <time.h>
#include <unistd.h>
namespace xe {
namespace threading {
//TODO(dougvj)
void EnableAffinityConfiguration() {
}
// TODO(dougvj)
void EnableAffinityConfiguration() {}
// uint64_t ticks() { return mach_absolute_time(); }
@ -46,9 +44,7 @@ void MaybeYield() {
__sync_synchronize();
}
void SyncMemory() {
__sync_synchronize();
}
void SyncMemory() { __sync_synchronize(); }
void Sleep(std::chrono::microseconds duration) {
timespec rqtp = {time_t(duration.count() / 1000000),
@ -57,35 +53,28 @@ void Sleep(std::chrono::microseconds duration) {
// TODO(benvanik): spin while rmtp >0?
}
//TODO(dougvj) Not sure how to implement the equivalent of this on POSIX.
// TODO(dougvj) Not sure how to implement the equivalent of this on POSIX.
SleepResult AlertableSleep(std::chrono::microseconds duration) {
sleep(duration.count() / 1000);
return SleepResult::kSuccess;
}
//TODO(dougvj) We can probably wrap this with pthread_key_t but the type of
//TlsHandle probably needs to be refactored
TlsHandle AllocateTlsHandle() {
assert_always();
}
// TODO(dougvj) We can probably wrap this with pthread_key_t but the type of
// TlsHandle probably needs to be refactored
TlsHandle AllocateTlsHandle() { assert_always(); }
bool FreeTlsHandle(TlsHandle handle) { return true; }
uintptr_t GetTlsValue(TlsHandle handle) {
assert_always();
}
uintptr_t GetTlsValue(TlsHandle handle) { assert_always(); }
bool SetTlsValue(TlsHandle handle, uintptr_t value) {
assert_always();
}
bool SetTlsValue(TlsHandle handle, uintptr_t value) { assert_always(); }
//TODO(dougvj)
// TODO(dougvj)
class PosixHighResolutionTimer : public HighResolutionTimer {
public:
PosixHighResolutionTimer(std::function<void()> callback)
: callback_(callback) {}
~PosixHighResolutionTimer() override {
}
~PosixHighResolutionTimer() override {}
bool Initialize(std::chrono::milliseconds period) {
assert_always();
@ -111,7 +100,7 @@ std::unique_ptr<HighResolutionTimer> HighResolutionTimer::CreateRepeating(
// some more functionality
class PosixCondition {
public:
PosixCondition(): signal_(false) {
PosixCondition() : signal_(false) {
pthread_mutex_init(&mutex_, NULL);
pthread_cond_init(&cond_, NULL);
}
@ -135,7 +124,7 @@ class PosixCondition {
}
bool Wait(unsigned int timeout_ms) {
//Assume 0 means no timeout, not instant timeout
// Assume 0 means no timeout, not instant timeout
if (timeout_ms == 0) {
Wait();
}
@ -143,42 +132,40 @@ class PosixCondition {
struct timeval now;
gettimeofday(&now, NULL);
//Add the number of seconds we want to wait to the current time
time_to_wait.tv_sec = now.tv_sec + (timeout_ms/1000);
//Add the number of nanoseconds we want to wait to the current nanosecond
//stride
long nsec = (now.tv_usec+(timeout_ms % 1000)) * 1000;
//If we overflowed the nanosecond count then we add a second
time_to_wait.tv_sec += nsec/1000000000UL;
//We only add nanoseconds within the 1 second stride
// Add the number of seconds we want to wait to the current time
time_to_wait.tv_sec = now.tv_sec + (timeout_ms / 1000);
// Add the number of nanoseconds we want to wait to the current nanosecond
// stride
long nsec = (now.tv_usec + (timeout_ms % 1000)) * 1000;
// If we overflowed the nanosecond count then we add a second
time_to_wait.tv_sec += nsec / 1000000000UL;
// We only add nanoseconds within the 1 second stride
time_to_wait.tv_nsec = nsec % 1000000000UL;
pthread_mutex_lock(&mutex_);
while(!signal_) {
while (!signal_) {
int status = pthread_cond_timedwait(&cond_, &mutex_, &time_to_wait);
if (status == ETIMEDOUT)
return false; //We timed out
if (status == ETIMEDOUT) return false; // We timed out
}
pthread_mutex_unlock(&mutex_);
return true; //We didn't time out
return true; // We didn't time out
}
bool Wait() {
pthread_mutex_lock(&mutex_);
while(!signal_) {
while (!signal_) {
pthread_cond_wait(&cond_, &mutex_);
}
pthread_mutex_unlock(&mutex_);
return true; //Did not time out;
return true; // Did not time out;
}
private:
bool signal_;
pthread_cond_t cond_;
pthread_mutex_t mutex_;
};
//Native posix thread handle
// Native posix thread handle
template <typename T>
class PosixThreadHandle : public T {
public:
@ -193,8 +180,8 @@ class PosixThreadHandle : public T {
pthread_t handle_;
};
//This is wraps a condition object as our handle because posix has no single
//native handle for higher level concurrency constructs such as semaphores
// This is wraps a condition object as our handle because posix has no single
// native handle for higher level concurrency constructs such as semaphores
template <typename T>
class PosixConditionHandle : public T {
public:
@ -208,10 +195,9 @@ class PosixConditionHandle : public T {
PosixCondition handle_;
};
// TODO(dougvj)
WaitResult Wait(WaitHandle* wait_handle, bool is_alertable,
std::chrono::milliseconds timeout) {
std::chrono::milliseconds timeout) {
assert_always();
return WaitResult::kFailed;
}
@ -233,15 +219,15 @@ std::pair<WaitResult, size_t> WaitMultiple(WaitHandle* wait_handles[],
return std::pair<WaitResult, size_t>(WaitResult::kFailed, 0);
}
//TODO(dougvj)
class PosixEvent: public PosixConditionHandle<Event> {
// TODO(dougvj)
class PosixEvent : public PosixConditionHandle<Event> {
public:
PosixEvent(bool initial_state, int auto_reset) { assert_always(); }
~PosixEvent() override = default;
void Set() override { assert_always(); }
void Reset() override { assert_always(); }
void Pulse() override { assert_always(); }
private:
PosixCondition condition_;
};
@ -254,7 +240,7 @@ std::unique_ptr<Event> Event::CreateAutoResetEvent(bool initial_state) {
return std::make_unique<PosixEvent>(PosixEvent(initial_state, true));
}
//TODO(dougvj)
// TODO(dougvj)
class PosixSemaphore : public PosixConditionHandle<Semaphore> {
public:
PosixSemaphore(int initial_count, int maximum_count) { assert_always(); }
@ -270,22 +256,22 @@ std::unique_ptr<Semaphore> Semaphore::Create(int initial_count,
return std::make_unique<PosixSemaphore>(initial_count, maximum_count);
}
//TODO(dougvj)
// TODO(dougvj)
class PosixMutant : public PosixConditionHandle<Mutant> {
public:
PosixMutant(bool initial_owner) {
assert_always();
}
PosixMutant(bool initial_owner) { assert_always(); }
~PosixMutant() = default;
bool Release() override { assert_always(); return false; }
private:
bool Release() override {
assert_always();
return false;
}
};
std::unique_ptr<Mutant> Mutant::Create(bool initial_owner) {
return std::make_unique<PosixMutant>(initial_owner);
}
//TODO(dougvj)
// TODO(dougvj)
class PosixTimer : public PosixConditionHandle<Timer> {
public:
PosixTimer(bool manual_reset) { assert_always(); }
@ -305,7 +291,6 @@ class PosixTimer : public PosixConditionHandle<Timer> {
assert_always();
return false;
}
};
std::unique_ptr<Timer> Timer::CreateManualResetTimer() {

2
src/xenia/cpu/compiler/passes/data_flow_analysis_pass.cc
View File

@ -23,8 +23,8 @@
#include <llvm/ADT/BitVector.h>
#pragma warning(pop)
#else
#include <cmath>
#include <llvm/ADT/BitVector.h>
#include <cmath>
#endif // XE_COMPILER_MSVC
namespace xe {

2
src/xenia/cpu/compiler/passes/value_reduction_pass.cc
View File

@ -22,8 +22,8 @@
#include <llvm/ADT/BitVector.h>
#pragma warning(pop)
#else
#include <cmath>
#include <llvm/ADT/BitVector.h>
#include <cmath>
#endif // XE_COMPILER_MSVC
namespace xe {

1
src/xenia/gpu/command_processor.h
View File

@ -240,4 +240,3 @@ class CommandProcessor {
} // namespace xe
#endif // XENIA_GPU_COMMAND_PROCESSOR_H_

2
src/xenia/gpu/gl4/gl4_shader_cache.h
View File

@ -11,10 +11,10 @@
#define XENIA_GPU_GL4_SHADER_CACHE_H_
#include <cstdint>
#include <vector>
#include <cstring>
#include <memory>
#include <unordered_map>
#include <vector>
#include "xenia/gpu/xenos.h"

6
src/xenia/gpu/vulkan/render_cache.cc
View File

@ -761,7 +761,7 @@ bool RenderCache::ParseConfiguration(RenderConfiguration* config) {
config->color[i].format = ColorRenderTargetFormat::k_2_10_10_10_FLOAT;
break;
default:
//The rest are good
// The rest are good
break;
}
}
@ -1149,7 +1149,7 @@ void RenderCache::BlitToImage(VkCommandBuffer command_buffer,
format = uint32_t(ColorRenderTargetFormat::k_2_10_10_10_FLOAT);
break;
default:
//Rest are OK
// Rest are OK
break;
}
}
@ -1265,7 +1265,7 @@ void RenderCache::ClearEDRAMColor(VkCommandBuffer command_buffer,
format = ColorRenderTargetFormat::k_2_10_10_10_FLOAT;
break;
default:
//Rest are OK
// Rest are OK
break;
}

35
src/xenia/ui/file_picker_gtk.cc
View File

@ -9,11 +9,11 @@
#include "xenia/ui/file_picker.h"
#include <codecvt>
#include <locale>
#include <string>
#include "xenia/base/assert.h"
#include "xenia/base/platform_linux.h"
#include <locale>
#include <codecvt>
#include <string>
namespace xe {
namespace ui {
@ -36,39 +36,34 @@ GtkFilePicker::GtkFilePicker() = default;
GtkFilePicker::~GtkFilePicker() = default;
bool GtkFilePicker::Show(void* parent_window_handle) {
// TODO(benvanik): FileSaveDialog.
assert_true(mode() == Mode::kOpen);
// TODO(benvanik): folder dialogs.
assert_true(type() == Type::kFile);
GtkWidget *dialog;
GtkWidget* dialog;
gint res;
dialog = gtk_file_chooser_dialog_new ("Open File",
(GtkWindow*)parent_window_handle,
GTK_FILE_CHOOSER_ACTION_OPEN,
"_Cancel",
GTK_RESPONSE_CANCEL,
"_Open",
GTK_RESPONSE_ACCEPT,
NULL);
dialog = gtk_file_chooser_dialog_new(
"Open File", (GtkWindow*)parent_window_handle,
GTK_FILE_CHOOSER_ACTION_OPEN, "_Cancel", GTK_RESPONSE_CANCEL, "_Open",
GTK_RESPONSE_ACCEPT, NULL);
res = gtk_dialog_run (GTK_DIALOG (dialog));
char *filename;
res = gtk_dialog_run(GTK_DIALOG(dialog));
char* filename;
if (res == GTK_RESPONSE_ACCEPT) {
GtkFileChooser *chooser = GTK_FILE_CHOOSER (dialog);
filename = gtk_file_chooser_get_filename (chooser);
GtkFileChooser* chooser = GTK_FILE_CHOOSER(dialog);
filename = gtk_file_chooser_get_filename(chooser);
std::vector<std::wstring> selected_files;
std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
std::wstring ws_filename = converter.from_bytes(filename);
selected_files.push_back(ws_filename);
set_selected_files(selected_files);
gtk_widget_destroy (dialog);
gtk_widget_destroy(dialog);
return true;
}
gtk_widget_destroy (dialog);
return false;;
gtk_widget_destroy(dialog);
return false;
}
} // namespace ui

8
src/xenia/ui/gl/gl_context.cc
View File

@ -21,7 +21,6 @@
#include "xenia/ui/gl/gl_immediate_drawer.h"
#include "xenia/ui/window.h"
DEFINE_bool(thread_safe_gl, false,
"Only allow one GL context to be active at a time.");
@ -40,7 +39,6 @@ namespace xe {
namespace ui {
namespace gl {
std::recursive_mutex GLContext::global_gl_mutex_;
void GLContext::FatalGLError(std::string error) {
@ -51,10 +49,8 @@ void GLContext::FatalGLError(std::string error) {
"of supported GPUs.");
}
GLContext::GLContext(GraphicsProvider* provider, Window* target_window)
: GraphicsContext(provider, target_window) { }
: GraphicsContext(provider, target_window) {}
GLContext::~GLContext() {}
@ -218,8 +214,6 @@ ImmediateDrawer* GLContext::immediate_drawer() {
return immediate_drawer_.get();
}
bool GLContext::WasLost() {
if (!robust_access_supported_) {
// Can't determine if we lost the context.

6
src/xenia/ui/gl/gl_context.h
View File

@ -29,7 +29,6 @@ DECLARE_bool(gl_debug);
DECLARE_bool(gl_debug_output);
DECLARE_bool(gl_debug_output_synchronous);
namespace xe {
namespace ui {
namespace gl {
@ -69,6 +68,7 @@ class GLContext : public GraphicsContext {
void AssertExtensionsPresent();
void DebugMessage(GLenum source, GLenum type, GLuint id, GLenum severity,
GLsizei length, const GLchar* message);
private:
friend class GLProvider;
@ -79,15 +79,11 @@ class GLContext : public GraphicsContext {
GLContext* parent_context);
private:
static void GLAPIENTRY DebugMessageThunk(GLenum source, GLenum type,
GLuint id, GLenum severity,
GLsizei length,
const GLchar* message,
GLvoid* user_param);
};
} // namespace gl

11
src/xenia/ui/gl/gl_context_win.cc
View File

@ -24,23 +24,20 @@
#include "third_party/GL/wglew.h"
namespace xe {
namespace ui {
namespace gl {
thread_local GLEWContext* tls_glew_context_ = nullptr;
thread_local WGLEWContext* tls_wglew_context_ = nullptr;
extern "C" GLEWContext* glewGetContext() { return tls_glew_context_; }
extern "C" WGLEWContext* wglewGetContext() { return tls_wglew_context_; }
std::unique_ptr<GLContext> GLContext::Create(GraphicsProvider* provider,
Window* target_window,
GLContext* share_context) {
auto context =
std::unique_ptr<GLContext>(new WGLContext(provider, target_window));
std::unique_ptr<GLContext>(new WGLContext(provider, target_window));
if (!context->Initialize(share_context)) {
return nullptr;
}
@ -48,11 +45,10 @@ std::unique_ptr<GLContext> GLContext::Create(GraphicsProvider* provider,
return context;
}
std::unique_ptr<GLContext> GLContext::CreateOffscreen(
GraphicsProvider* provider, GLContext* parent_context) {
GraphicsProvider* provider, GLContext* parent_context) {
return WGLContext::CreateOffscreen(provider,
static_cast<WGLContext*>(parent_context));
static_cast<WGLContext*>(parent_context));
}
WGLContext::WGLContext(GraphicsProvider* provider, Window* target_window)
@ -296,7 +292,6 @@ void WGLContext::ClearCurrent() {
}
}
void WGLContext::BeginSwap() {
SCOPE_profile_cpu_i("gpu", "xe::ui::gl::WGLContext::BeginSwap");
float clear_color[] = {238 / 255.0f, 238 / 255.0f, 238 / 255.0f, 1.0f};

13
src/xenia/ui/gl/gl_context_win.h
View File

@ -14,9 +14,9 @@
#include <memory>
#include "xenia/ui/gl/gl_context.h"
#include "xenia/ui/gl/blitter.h"
#include "xenia/ui/gl/gl.h"
#include "xenia/ui/gl/gl_context.h"
#include "xenia/ui/graphics_context.h"
typedef struct HDC__* HDC;
@ -33,7 +33,6 @@ class WGLContext : public GLContext {
public:
~WGLContext() override;
bool is_current() override;
bool MakeCurrent() override;
void ClearCurrent() override;
@ -41,25 +40,21 @@ class WGLContext : public GLContext {
void BeginSwap() override;
void EndSwap() override;
protected:
friend class GLContext;
WGLContext(GraphicsProvider* provider, Window* target_window);
static std::unique_ptr<WGLContext> CreateOffscreen(GraphicsProvider* provider,
WGLContext* parent_context);
static std::unique_ptr<WGLContext> CreateOffscreen(
GraphicsProvider* provider, WGLContext* parent_context);
bool Initialize(GLContext* share_context) override;
void* handle() override {return glrc_;};
void* handle() override { return glrc_; }
private:
HDC dc_ = nullptr;
HGLRC glrc_ = nullptr;
std::unique_ptr<GLEWContext> glew_context_;
std::unique_ptr<WGLEWContext> wglew_context_;
};
} // namespace gl

31
src/xenia/ui/gl/gl_context_x11.cc
View File

@ -11,9 +11,11 @@
#include <gflags/gflags.h>
#include <gdk/gdkx.h>
#include <mutex>
#include <string>
#include "third_party/GL/glxew.h"
#include "xenia/base/assert.h"
#include "xenia/base/logging.h"
#include "xenia/base/math.h"
@ -21,27 +23,21 @@
#include "xenia/base/profiling.h"
#include "xenia/ui/gl/gl_immediate_drawer.h"
#include "xenia/ui/window.h"
#include "third_party/GL/glxew.h"
#include <gdk/gdkx.h>
namespace xe {
namespace ui {
namespace gl {
thread_local GLEWContext* tls_glew_context_ = nullptr;
thread_local GLXEWContext* tls_glxew_context_ = nullptr;
extern "C" GLEWContext* glewGetContext() { return tls_glew_context_; }
extern "C" GLXEWContext* glxewGetContext() { return tls_glxew_context_; }
std::unique_ptr<GLContext> GLContext::Create(GraphicsProvider* provider,
Window* target_window,
GLContext* share_context) {
auto context =
std::unique_ptr<GLContext>(new GLXContext(provider, target_window));
std::unique_ptr<GLContext>(new GLXContext(provider, target_window));
if (!context->Initialize(share_context)) {
return nullptr;
}
@ -50,9 +46,9 @@ std::unique_ptr<GLContext> GLContext::Create(GraphicsProvider* provider,
}
std::unique_ptr<GLContext> GLContext::CreateOffscreen(
GraphicsProvider* provider, GLContext* parent_context) {
GraphicsProvider* provider, GLContext* parent_context) {
return GLXContext::CreateOffscreen(provider,
static_cast<GLXContext*>(parent_context));
static_cast<GLXContext*>(parent_context));
}
GLXContext::GLXContext(GraphicsProvider* provider, Window* target_window)
@ -74,8 +70,6 @@ GLXContext::~GLXContext() {
}
}
bool GLXContext::Initialize(GLContext* share_context) {
GtkWidget* window = GTK_WIDGET(target_window_->native_handle());
GtkWidget* draw_area = gtk_drawing_area_new();
@ -90,8 +84,8 @@ bool GLXContext::Initialize(GLContext* share_context) {
Display* display = gdk_x11_display_get_xdisplay(gdk_display);
disp_ = display;
::Window root = gdk_x11_get_default_root_xwindow();
static int vis_attrib_list[] =
{GLX_RGBA, GLX_DEPTH_SIZE, 24, GLX_DOUBLEBUFFER, None};
static int vis_attrib_list[] = {GLX_RGBA, GLX_DEPTH_SIZE, 24,
GLX_DOUBLEBUFFER, None};
XVisualInfo* vi = glXChooseVisual(display, 0, vis_attrib_list);
if (vi == NULL) {
FatalGLError("No matching visuals for X display");
@ -151,8 +145,8 @@ bool GLXContext::Initialize(GLContext* share_context) {
GLXContext* share_context_glx = static_cast<GLXContext*>(share_context);
glx_context_ = glXCreateContextAttribsARB(
display, nullptr,
share_context ? share_context_glx->glx_context_ : nullptr, True,
attrib_list);
share_context ? share_context_glx->glx_context_ : nullptr, True,
attrib_list);
glXMakeCurrent(display, 0, nullptr);
glXDestroyContext(display, temp_context);
if (!glx_context_) {
@ -222,7 +216,8 @@ std::unique_ptr<GLXContext> GLXContext::CreateOffscreen(
robust_access_supported ? GLX_LOSE_CONTEXT_ON_RESET_ARB : 0,
0};
new_glrc = glXCreateContextAttribsARB(parent_context->disp_, nullptr,
parent_context->glx_context_, True, attrib_list);
parent_context->glx_context_, True,
attrib_list);
if (!new_glrc) {
FatalGLError("Could not create shared context.");
return nullptr;
@ -271,13 +266,10 @@ std::unique_ptr<GLXContext> GLXContext::CreateOffscreen(
return new_context;
}
bool GLXContext::is_current() {
return tls_glew_context_ == glew_context_.get();
}
bool GLXContext::MakeCurrent() {
SCOPE_profile_cpu_f("gpu");
if (FLAGS_thread_safe_gl) {
@ -308,7 +300,6 @@ void GLXContext::ClearCurrent() {
}
}
void GLXContext::BeginSwap() {
SCOPE_profile_cpu_i("gpu", "xe::ui::gl::GLXContext::BeginSwap");
float clear_color[] = {238 / 255.0f, 238 / 255.0f, 238 / 255.0f, 1.0f};

17
src/xenia/ui/gl/gl_context_x11.h
View File

@ -14,16 +14,15 @@
#include <memory>
#include "xenia/ui/gl/gl_context.h"
#include "xenia/ui/gl/blitter.h"
#include "xenia/ui/gl/gl.h"
#include "xenia/ui/graphics_context.h"
#include "third_party/GL/glxew.h"
#include "xenia/base/platform_linux.h"
#include "xenia/ui/gl/blitter.h"
#include "xenia/ui/gl/gl.h"
#include "xenia/ui/gl/gl_context.h"
#include "xenia/ui/graphics_context.h"
DECLARE_bool(thread_safe_gl);
namespace xe {
namespace ui {
namespace gl {
@ -35,7 +34,6 @@ class GLXContext : public GLContext {
public:
~GLXContext() override;
bool is_current() override;
bool MakeCurrent() override;
@ -44,13 +42,12 @@ class GLXContext : public GLContext {
void BeginSwap() override;
void EndSwap() override;
protected:
static std::unique_ptr<GLXContext> CreateOffscreen(GraphicsProvider* provider,
GLXContext* parent_context);
static std::unique_ptr<GLXContext> CreateOffscreen(
GraphicsProvider* provider, GLXContext* parent_context);
bool Initialize(GLContext* share_context) override;
void* handle() override {return glx_context_;}
void* handle() override { return glx_context_; }
private:
friend class GLContext;

29
src/xenia/ui/loop_gtk.cc
View File

@ -14,7 +14,6 @@
namespace xe {
namespace ui {
class PostedFn {
public:
explicit PostedFn(std::function<void()> fn) : fn_(std::move(fn)) {}
@ -28,7 +27,7 @@ std::unique_ptr<Loop> Loop::Create() { return std::make_unique<GTKLoop>(); }
GTKLoop::GTKLoop() : thread_id_() {
gtk_init(nullptr, nullptr);
xe::threading::Fence init_fence;
xe::threading::Fence init_fence;
thread_ = std::thread([&init_fence, this]() {
xe::threading::set_name("GTK Loop");
@ -47,39 +46,31 @@ GTKLoop::~GTKLoop() {
thread_.join();
}
void GTKLoop::ThreadMain() {
gtk_main();
}
void GTKLoop::ThreadMain() { gtk_main(); }
bool GTKLoop::is_on_loop_thread() {
return thread_id_ == std::this_thread::get_id();
}
gboolean _posted_fn_thunk(gpointer posted_fn) {
PostedFn* Fn = reinterpret_cast<PostedFn*>(posted_fn);
Fn->Call();
return G_SOURCE_REMOVE;
PostedFn* Fn = reinterpret_cast<PostedFn*>(posted_fn);
Fn->Call();
return G_SOURCE_REMOVE;
}
void GTKLoop::Post(std::function<void()> fn) {
assert_true(thread_id_ != std::thread::id());
gdk_threads_add_idle(_posted_fn_thunk,
reinterpret_cast<gpointer>(new PostedFn(std::move(fn))));
reinterpret_cast<gpointer>(new PostedFn(std::move(fn))));
}
void GTKLoop::PostDelayed(std::function<void()> fn, uint64_t delay_millis) {
gdk_threads_add_timeout(delay_millis, _posted_fn_thunk,
reinterpret_cast<gpointer>(new PostedFn(std::move(fn))));
gdk_threads_add_timeout(
delay_millis, _posted_fn_thunk,
reinterpret_cast<gpointer>(new PostedFn(std::move(fn))));
}
void GTKLoop::Quit() {
assert_true(thread_id_ != std::thread::id());
}
void GTKLoop::Quit() { assert_true(thread_id_ != std::thread::id()); }
void GTKLoop::AwaitQuit() { quit_fence_.Wait(); }

4
src/xenia/ui/loop_gtk.h
View File

@ -35,15 +35,13 @@ class GTKLoop : public Loop {
void Quit() override;
void AwaitQuit() override;
private:
private:
void ThreadMain();
std::thread::id thread_id_;
std::thread thread_;
xe::threading::Fence quit_fence_;
};
} // namespace ui

2
src/xenia/ui/menu_item.h
View File

@ -12,8 +12,8 @@
#include <functional>
#include <memory>
#include <vector>
#include <string>
#include <vector>
#include "xenia/ui/ui_event.h"

11
src/xenia/ui/vulkan/vulkan_context.cc
View File

@ -73,16 +73,15 @@ bool VulkanContext::Initialize() {
assert(GDK_IS_X11_DISPLAY(gdk_display));
xcb_connection_t* connection =
XGetXCBConnection(gdk_x11_display_get_xdisplay(gdk_display));
xcb_window_t window = gdk_x11_window_get_xid(
gtk_widget_get_window(window_handle));
xcb_window_t window =
gdk_x11_window_get_xid(gtk_widget_get_window(window_handle));
VkXcbSurfaceCreateInfoKHR create_info;
create_info.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
create_info.pNext = nullptr;
create_info.flags = 0;
create_info.connection = static_cast<xcb_connection_t*>
(target_window_->native_platform_handle());
create_info.window =
static_cast<xcb_window_t>(window);
create_info.connection = static_cast<xcb_connection_t*>(
target_window_->native_platform_handle());
create_info.window = static_cast<xcb_window_t>(window);
auto err = vkCreateXcbSurfaceKHR(*provider->instance(), &create_info,
nullptr, &surface);
CheckResult(err, "vkCreateXcbSurfaceKHR");

15
src/xenia/ui/vulkan/vulkan_instance.cc
View File

@ -397,18 +397,17 @@ bool VulkanInstance::QueryDevices(Window* any_target_window) {
assert(GDK_IS_X11_DISPLAY(gdk_display));
xcb_connection_t* connection =
XGetXCBConnection(gdk_x11_display_get_xdisplay(gdk_display));
xcb_window_t window = gdk_x11_window_get_xid(
gtk_widget_get_window(window_handle));
xcb_window_t window =
gdk_x11_window_get_xid(gtk_widget_get_window(window_handle));
VkXcbSurfaceCreateInfoKHR create_info;
create_info.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
create_info.pNext = nullptr;
create_info.flags = 0;
create_info.connection = static_cast<xcb_connection_t*>
(any_target_window->native_platform_handle());
create_info.window =
static_cast<xcb_window_t>(window);
auto err = vkCreateXcbSurfaceKHR(handle, &create_info,
nullptr, &any_surface);
create_info.connection = static_cast<xcb_connection_t*>(
any_target_window->native_platform_handle());
create_info.window = static_cast<xcb_window_t>(window);
auto err =
vkCreateXcbSurfaceKHR(handle, &create_info, nullptr, &any_surface);
CheckResult(err, "vkCreateXcbSurfaceKHR");
#else
#error Unsupported GDK Backend on Linux.

67
src/xenia/ui/window_gtk.cc
View File

@ -17,7 +17,6 @@
namespace xe {
namespace ui {
class FnWrapper {
public:
explicit FnWrapper(std::function<void()> fn) : fn_(std::move(fn)) {}
@ -161,12 +160,12 @@ void GTKWindow::set_focus(bool value) {
if (value) {
gtk_window_activate_focus(GTK_WINDOW(window_));
} else {
// TODO(dougvj) Check to see if we need to do somethign here to unset
// TODO(dougvj) Check to see if we need to do something here to unset
// the focus.
}
} else {
has_focus_ = value;
}
} else {
has_focus_ = value;
}
}
void GTKWindow::Resize(int32_t width, int32_t height) {
@ -219,8 +218,6 @@ void GTKWindow::OnMainMenuChange() {
}
}
bool GTKWindow::HandleWindowOwnerChange(GdkEventOwnerChange* event) {
if (event->type == GDK_OWNER_CHANGE) {
if (event->reason == GDK_OWNER_CHANGE_DESTROY) {
@ -231,8 +228,8 @@ bool GTKWindow::HandleWindowOwnerChange(GdkEventOwnerChange* event) {
OnClose();
}
return true;
}
return false;
}
return false;
}
bool GTKWindow::HandleWindowResize(GdkEventConfigure* event) {
@ -244,8 +241,6 @@ bool GTKWindow::HandleWindowResize(GdkEventConfigure* event) {
return false;
}
bool GTKWindow::HandleWindowVisibility(GdkEventVisibility* event) {
// TODO(dougvj) The gdk docs say that this is deprecated because modern window
// managers composite everything and nothing is truly hidden.
@ -258,8 +253,8 @@ bool GTKWindow::HandleWindowVisibility(GdkEventVisibility* event) {
OnHidden(&e);
}
return true;
}
return false;
}
return false;
}
bool GTKWindow::HandleWindowFocus(GdkEventFocus* event) {
@ -274,8 +269,8 @@ bool GTKWindow::HandleWindowFocus(GdkEventFocus* event) {
OnGotFocus(&e);
}
return true;
}
return false;
}
return false;
}
bool GTKWindow::HandleMouse(GdkEventAny* event) {
@ -326,26 +321,26 @@ bool GTKWindow::HandleMouse(GdkEventAny* event) {
dy = e->delta_y;
break;
}
}
}
auto e = MouseEvent(this, button, x, y, dx, dy);
switch (event->type) {
case GDK_BUTTON_PRESS:
OnMouseDown(&e);
break;
case GDK_BUTTON_RELEASE:
OnMouseUp(&e);
break;
case GDK_MOTION_NOTIFY:
OnMouseMove(&e);
break;
case GDK_SCROLL:
OnMouseWheel(&e);
break;
default:
return false;
}
return e.is_handled();
auto e = MouseEvent(this, button, x, y, dx, dy);
switch (event->type) {
case GDK_BUTTON_PRESS:
OnMouseDown(&e);
break;
case GDK_BUTTON_RELEASE:
OnMouseUp(&e);
break;
case GDK_MOTION_NOTIFY:
OnMouseMove(&e);
break;
case GDK_SCROLL:
OnMouseWheel(&e);
break;
default:
return false;
}
return e.is_handled();
}
bool GTKWindow::HandleKeyboard(GdkEventKey* event) {
@ -364,8 +359,8 @@ bool GTKWindow::HandleKeyboard(GdkEventKey* event) {
case GDK_KEY_RELEASE:
OnKeyUp(&e);
break;
// TODO(dougvj) GDK doesn't have a KEY CHAR event, so we will have to
// figure out its equivalent here to call OnKeyChar(&e);
// TODO(dougvj) GDK doesn't have a KEY CHAR event, so we will have to
// figure out its equivalent here to call OnKeyChar(&e);
default:
return false;
}

15
src/xenia/ui/window_gtk.h
View File

@ -13,9 +13,9 @@
#include <memory>
#include <string>
#include "xenia/base/platform_linux.h"
#include "xenia/ui/menu_item.h"
#include "xenia/ui/window.h"
#include "xenia/base/platform_linux.h"
namespace xe {
namespace ui {
@ -27,9 +27,10 @@ class GTKWindow : public Window {
GTKWindow(Loop* loop, const std::wstring& title);
~GTKWindow() override;
NativePlatformHandle native_platform_handle() const override {return nullptr;}
NativeWindowHandle native_handle() const override { return window_;}
NativePlatformHandle native_platform_handle() const override {
return nullptr;
}
NativeWindowHandle native_handle() const override { return window_; }
bool set_title(const std::wstring& title) override;
@ -60,7 +61,6 @@ class GTKWindow : public Window {
void OnResize(UIEvent* e) override;
private:
void Create();
GtkWidget* window_;
@ -75,16 +75,15 @@ class GTKWindow : public Window {
bool closing_ = false;
bool fullscreen_ = false;
};
class GTKMenuItem : public MenuItem {
public:
GTKMenuItem(Type type, const std::wstring& text, const std::wstring& hotkey,
std::function<void()> callback);
std::function<void()> callback);
~GTKMenuItem() override;
GtkWidget* handle() {return menu_;}
GtkWidget* handle() { return menu_; }
using MenuItem::OnSelected;
protected: