[GTK3] Implement GbScreen widget for rendering
This commit is contained in:
parent
a39937aeb2
commit
d63560d3c1
GPG Key ID:
F71D56A3151C4FB3
|
|
@ -0,0 +1,339 @@
|
|||
#include "gb_screen.h"
|
||||
#include "config.h"
|
||||
#include "util.h"
|
||||
#include <stdint.h>
|
||||
|
||||
struct _GbScreen {
|
||||
GtkBin parent;
|
||||
|
||||
GtkGLArea *gl_area;
|
||||
GtkDrawingArea *fallback;
|
||||
|
||||
bool use_gl;
|
||||
shader_t shader;
|
||||
|
||||
uint32_t *image_buffers[3];
|
||||
unsigned char current_buffer;
|
||||
|
||||
unsigned screen_width;
|
||||
unsigned screen_height;
|
||||
|
||||
GB_frame_blending_mode_t blending_mode;
|
||||
};
|
||||
|
||||
G_DEFINE_TYPE(GbScreen, gb_screen, GTK_TYPE_BIN);
|
||||
|
||||
typedef enum {
|
||||
PROP_USE_GL = 1,
|
||||
N_PROPERTIES
|
||||
} GbScreenProperty;
|
||||
|
||||
static GParamSpec *obj_properties[N_PROPERTIES] = { NULL, };
|
||||
|
||||
static void gb_screen_finalize(GObject *object) {
|
||||
GbScreen *self = (GbScreen *) object;
|
||||
|
||||
if (self->image_buffers[0]) g_free(self->image_buffers[0]);
|
||||
if (self->image_buffers[1]) g_free(self->image_buffers[1]);
|
||||
if (self->image_buffers[2]) g_free(self->image_buffers[2]);
|
||||
|
||||
free_shader(&self->shader);
|
||||
free_master_shader();
|
||||
|
||||
G_OBJECT_CLASS(gb_screen_parent_class)->finalize(object);
|
||||
}
|
||||
|
||||
static void gb_screen_get_natural_size(GbScreen *self, gint *natural_width, gint *natural_height, double *scale_x_ptr, double *scale_y_ptr) {
|
||||
int width = gtk_widget_get_allocated_width(GTK_WIDGET(self));
|
||||
int height = gtk_widget_get_allocated_height(GTK_WIDGET(self));
|
||||
|
||||
double scale_x = width / (double)self->screen_width;
|
||||
double scale_y = height / (double)self->screen_height;
|
||||
|
||||
if (config.video.use_integer_scaling) {
|
||||
scale_x = (unsigned)(scale_x);
|
||||
scale_y = (unsigned)(scale_y);
|
||||
}
|
||||
|
||||
if (config.video.keep_aspect_ratio) {
|
||||
if (scale_x > scale_y) {
|
||||
scale_x = scale_y;
|
||||
}
|
||||
else {
|
||||
scale_y = scale_x;
|
||||
}
|
||||
}
|
||||
|
||||
scale_x = max_double(1.0, scale_x);
|
||||
scale_y = max_double(1.0, scale_y);
|
||||
|
||||
if (natural_width) *natural_width = self->screen_width * scale_x;
|
||||
if (natural_height) *natural_height = self->screen_height * scale_y;
|
||||
if (scale_x_ptr) *scale_x_ptr = scale_x;
|
||||
if (scale_y_ptr) *scale_y_ptr = scale_y;
|
||||
}
|
||||
|
||||
static gboolean gb_screen_draw(GtkWidget *widget, cairo_t *cr) {
|
||||
GTK_WIDGET_CLASS(gb_screen_parent_class)->draw(widget, cr);
|
||||
|
||||
static gint scaled_width, scaled_height;
|
||||
static double scale_x, scale_y;
|
||||
|
||||
GbScreen *self = (GbScreen *) widget;
|
||||
|
||||
GtkStyleContext *context = gtk_widget_get_style_context(widget);
|
||||
int width = gtk_widget_get_allocated_width(widget);
|
||||
int height = gtk_widget_get_allocated_height(widget);
|
||||
|
||||
gtk_render_background(context, cr, 0, 0, width, height);
|
||||
gtk_render_frame(context, cr, 0, 0, width, height);
|
||||
gb_screen_get_natural_size(self, &scaled_width, &scaled_height, &scale_x, &scale_y);
|
||||
|
||||
Rect viewport = {
|
||||
(width - scaled_width) / 2,
|
||||
(height - scaled_height) / 2,
|
||||
scaled_width,
|
||||
scaled_height
|
||||
};
|
||||
|
||||
if (self->use_gl) {
|
||||
glViewport(viewport.x, viewport.y, scaled_width, scaled_height);
|
||||
|
||||
uint32_t *pixels = gb_screen_get_current_buffer(self);
|
||||
uint32_t *previous = gb_screen_get_previous_buffer(self);
|
||||
|
||||
static void *_pixels = NULL;
|
||||
|
||||
if (pixels) {
|
||||
_pixels = pixels;
|
||||
}
|
||||
|
||||
glClearColor(0, 0, 0, 1);
|
||||
glClear(GL_COLOR_BUFFER_BIT);
|
||||
|
||||
render_bitmap_with_shader(
|
||||
&self->shader, _pixels, previous,
|
||||
self->screen_width, self->screen_height,
|
||||
viewport.x, viewport.y, viewport.width, viewport.height,
|
||||
self->blending_mode
|
||||
);
|
||||
|
||||
// gtk_gl_area_queue_render(self->gl_area);
|
||||
}
|
||||
else {
|
||||
cairo_surface_t *surface = cairo_image_surface_create_for_data(
|
||||
(unsigned char *) gb_screen_get_current_buffer(self),
|
||||
CAIRO_FORMAT_RGB24,
|
||||
self->screen_width,
|
||||
self->screen_height,
|
||||
cairo_format_stride_for_width(CAIRO_FORMAT_RGB24, self->screen_width)
|
||||
);
|
||||
|
||||
cairo_translate(cr, viewport.x, viewport.y);
|
||||
cairo_scale(cr, scale_x, scale_y);
|
||||
cairo_set_source_surface(cr, surface, 0, 0);
|
||||
cairo_pattern_set_filter(cairo_get_source(cr), CAIRO_FILTER_NEAREST);
|
||||
cairo_paint(cr);
|
||||
|
||||
cairo_surface_destroy(surface);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
static void gb_screen_get_preferred_width(GtkWidget *widget, gint *minimum_width, gint *natural_width) {
|
||||
GbScreen *self = (GbScreen *)widget;
|
||||
|
||||
*minimum_width = self->screen_width;
|
||||
gb_screen_get_natural_size(self, natural_width, NULL, NULL, NULL);
|
||||
}
|
||||
|
||||
static void gb_screen_get_preferred_height(GtkWidget *widget, gint *minimum_height, gint *natural_height) {
|
||||
GbScreen *self = (GbScreen *)widget;
|
||||
|
||||
*minimum_height = self->screen_height;
|
||||
gb_screen_get_natural_size(self, NULL, natural_height, NULL, NULL);
|
||||
}
|
||||
|
||||
static void gb_screen_set_property(GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) {
|
||||
GbScreen *self = (GbScreen *) object;
|
||||
|
||||
switch ((GbScreenProperty) property_id) {
|
||||
case PROP_USE_GL:
|
||||
self->use_gl = g_value_get_boolean(value);
|
||||
break;
|
||||
|
||||
default:
|
||||
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
|
||||
}
|
||||
}
|
||||
|
||||
static void gb_screen_get_property(GObject *object, guint property_id, GValue *value, GParamSpec *pspec) {
|
||||
GbScreen *self = (GbScreen *) object;
|
||||
|
||||
switch ((GbScreenProperty) property_id) {
|
||||
case PROP_USE_GL:
|
||||
g_value_set_boolean(value, self->use_gl);
|
||||
break;
|
||||
|
||||
default:
|
||||
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
|
||||
}
|
||||
}
|
||||
|
||||
static void gb_screen_gl_area_realized(GtkWidget *widget, GObject *object) {
|
||||
GbScreen *self = (GbScreen *)object;
|
||||
GtkGLArea *gl_area = GTK_GL_AREA(widget);
|
||||
|
||||
g_debug("GL Context: %p", gtk_gl_area_get_context(self->gl_area));
|
||||
|
||||
gtk_gl_area_make_current(self->gl_area);
|
||||
if (gtk_gl_area_get_error(self->gl_area) != NULL) {
|
||||
goto error;
|
||||
}
|
||||
|
||||
const char *renderer = (char *)glGetString(GL_RENDERER);
|
||||
g_debug("GtkGLArea on %s", renderer ? renderer : "Unknown");
|
||||
|
||||
if (config.video.shader == NULL || (!init_shader_with_name(&self->shader, config.video.shader) && !init_shader_with_name(&self->shader, "NearestNeighbor"))) {
|
||||
GError *error = g_error_new_literal(g_quark_from_string("sameboy-gl-error"), 1, "Failed to initialize shaders");
|
||||
gtk_gl_area_set_error(self->gl_area, error);
|
||||
}
|
||||
else {
|
||||
g_info("Using OpenGL for rendering");
|
||||
G_OBJECT_CLASS(gb_screen_parent_class)->constructed(object);
|
||||
return;
|
||||
}
|
||||
|
||||
error:
|
||||
if (gtk_gl_area_get_error(self->gl_area) != NULL) {
|
||||
g_warning("GtkGLArea: %s", gtk_gl_area_get_error(self->gl_area)->message);
|
||||
}
|
||||
gtk_widget_destroy(GTK_WIDGET(self->gl_area));
|
||||
self->gl_area = NULL;
|
||||
self->use_gl = false;
|
||||
|
||||
g_info("Using Cairo for rendering");
|
||||
G_OBJECT_CLASS(gb_screen_parent_class)->constructed(object);
|
||||
}
|
||||
|
||||
static void gb_screen_constructed(GObject *object) {
|
||||
GbScreen *self = (GbScreen *)object;
|
||||
|
||||
// Very ugly workaround for GtkGlArea!
|
||||
// When a GtkGlArea is realized and it creates a legacy GL 1.4 context
|
||||
// it tries to use GL 2.0 functions to render the window which leads to the application crashing.
|
||||
// So we initialize GTK, create a dummy GtkWindow object, attach a `realize` callback and
|
||||
// in this callback create a GdkGLContext on this window. But instead of running the GTK main loop
|
||||
// we just realize and destroy the dummy window and compare the context’s version in the realize callback.
|
||||
self->use_gl = self->use_gl && test_gl_support();
|
||||
|
||||
if (self->use_gl) {
|
||||
self->gl_area = GTK_GL_AREA(gtk_gl_area_new());
|
||||
g_signal_connect(self->gl_area, "realize", G_CALLBACK(gb_screen_gl_area_realized), object);
|
||||
|
||||
gtk_gl_area_set_required_version(self->gl_area, 3, 2);
|
||||
gtk_gl_area_set_auto_render(self->gl_area, false);
|
||||
gtk_gl_area_set_has_alpha(self->gl_area, false);
|
||||
gtk_gl_area_set_has_depth_buffer(self->gl_area, false);
|
||||
gtk_gl_area_set_has_stencil_buffer(self->gl_area, false);
|
||||
gtk_container_add(GTK_CONTAINER(self), GTK_WIDGET(self->gl_area));
|
||||
}
|
||||
else {
|
||||
g_info("Using Cairo for rendering");
|
||||
G_OBJECT_CLASS(gb_screen_parent_class)->constructed(object);
|
||||
}
|
||||
}
|
||||
|
||||
static void gb_screen_class_init(GbScreenClass *class) {
|
||||
obj_properties[PROP_USE_GL] = g_param_spec_boolean(
|
||||
"use-gl", "Use OpenGL", "Whether to use OpenGL for rendering.",
|
||||
true,
|
||||
G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_PRIVATE
|
||||
);
|
||||
|
||||
G_OBJECT_CLASS(class)->finalize = gb_screen_finalize;
|
||||
G_OBJECT_CLASS(class)->set_property = gb_screen_set_property;
|
||||
G_OBJECT_CLASS(class)->get_property = gb_screen_get_property;
|
||||
G_OBJECT_CLASS(class)->constructed = gb_screen_constructed;
|
||||
|
||||
GTK_WIDGET_CLASS(class)->draw = gb_screen_draw;
|
||||
GTK_WIDGET_CLASS(class)->get_preferred_width = gb_screen_get_preferred_width;
|
||||
GTK_WIDGET_CLASS(class)->get_preferred_height = gb_screen_get_preferred_height;
|
||||
|
||||
g_object_class_install_properties(G_OBJECT_CLASS(class), N_PROPERTIES, obj_properties);
|
||||
}
|
||||
|
||||
static void gb_screen_init(GbScreen *self) {
|
||||
gb_screen_set_resolution(self, 160, 144);
|
||||
gb_screen_clear(self);
|
||||
}
|
||||
|
||||
GbScreen *gb_screen_new(bool force_fallback) {
|
||||
g_debug("force_fallback: %d", force_fallback);
|
||||
return g_object_new(GB_SCREEN_TYPE, "use-gl", !force_fallback, NULL);
|
||||
}
|
||||
|
||||
void gb_screen_clear(GbScreen *self) {
|
||||
for (unsigned i = 0; i < 3; i++) {
|
||||
memset(self->image_buffers[i], 0, self->screen_width * self->screen_height * sizeof(uint32_t));
|
||||
}
|
||||
}
|
||||
|
||||
bool gb_screen_uses_fallback(GbScreen *self) {
|
||||
return !self->use_gl;
|
||||
}
|
||||
|
||||
// Determines how many frame buffers to use
|
||||
static uint8_t number_of_buffers(GbScreen *self) {
|
||||
if (!self->use_gl) return 2;
|
||||
|
||||
bool should_blend = config_get_frame_blending_mode() != GB_FRAME_BLENDING_MODE_DISABLED;
|
||||
|
||||
return should_blend? 3 : 2;
|
||||
}
|
||||
|
||||
// Returns the buffer that should be used by the Core to render a new frame to
|
||||
uint32_t *gb_screen_get_pixels(GbScreen *self) {
|
||||
return self->image_buffers[(self->current_buffer + 1) % number_of_buffers(self)];
|
||||
}
|
||||
|
||||
// Returns the current finished frame
|
||||
uint32_t *gb_screen_get_current_buffer(GbScreen *self) {
|
||||
return self->image_buffers[self->current_buffer];
|
||||
}
|
||||
|
||||
// Returns the previous finished frame
|
||||
uint32_t *gb_screen_get_previous_buffer(GbScreen *self) {
|
||||
return self->image_buffers[(self->current_buffer + 2) % number_of_buffers(self)];
|
||||
}
|
||||
|
||||
// Cycles the buffers
|
||||
void gb_screen_flip(GbScreen *self) {
|
||||
self->current_buffer = (self->current_buffer + 1) % number_of_buffers(self);
|
||||
}
|
||||
|
||||
void gb_screen_set_resolution(GbScreen *self, unsigned width, unsigned height) {
|
||||
self->screen_width = width;
|
||||
self->screen_height = height;
|
||||
|
||||
for (unsigned i = 0; i < 3; i++) {
|
||||
self->image_buffers[i] = g_realloc_n(
|
||||
self->image_buffers[i],
|
||||
self->screen_width * self->screen_height, sizeof(uint32_t)
|
||||
);
|
||||
}
|
||||
|
||||
gtk_widget_queue_resize(GTK_WIDGET(self));
|
||||
}
|
||||
|
||||
void gb_screen_set_blending_mode(GbScreen *self, GB_frame_blending_mode_t mode) {
|
||||
self->blending_mode = mode;
|
||||
}
|
||||
|
||||
void gb_screen_set_shader(GbScreen *self, const char *shader_name) {
|
||||
if (!self->use_gl) return;
|
||||
|
||||
free_shader(&self->shader);
|
||||
init_shader_with_name(&self->shader, shader_name);
|
||||
}
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
#ifndef gb_screen_h
|
||||
#define gb_screen_h
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
#include <gtk/gtk.h>
|
||||
#include <Core/gb.h>
|
||||
#include "shader.h"
|
||||
|
||||
#define GB_SCREEN_TYPE (gb_screen_get_type())
|
||||
G_DECLARE_FINAL_TYPE(GbScreen, gb_screen, SAMEBOY, BIN, GtkBin)
|
||||
|
||||
GbScreen *gb_screen_new(bool force_fallback);
|
||||
void gb_screen_clear(GbScreen *self);
|
||||
bool gb_screen_uses_fallback(GbScreen *self);
|
||||
|
||||
uint32_t *gb_screen_get_pixels(GbScreen *self);
|
||||
uint32_t *gb_screen_get_current_buffer(GbScreen *self);
|
||||
uint32_t *gb_screen_get_previous_buffer(GbScreen *self);
|
||||
void gb_screen_flip(GbScreen *self);
|
||||
void gb_screen_set_resolution(GbScreen *self, unsigned width, unsigned height);
|
||||
void gb_screen_set_blending_mode(GbScreen *self, GB_frame_blending_mode_t mode);
|
||||
void gb_screen_set_shader(GbScreen *self, const char *shader_name);
|
||||
|
||||
#endif
|
||||
349
gtk3/main.c
349
gtk3/main.c
|
|
@ -11,9 +11,9 @@
|
|||
#include "types.h"
|
||||
#include "config.h"
|
||||
#include "util.h"
|
||||
#include "shader.h"
|
||||
#include "check_menu_radio_group.h"
|
||||
|
||||
#include "gb_screen.h"
|
||||
#include "vram_viewer_window.h"
|
||||
|
||||
// used for audio and game controllers
|
||||
|
|
@ -641,73 +641,6 @@ static void set_combo_box_row_separator_func(GtkContainer *container) {
|
|||
g_list_free(children);
|
||||
}
|
||||
|
||||
// Determines how many frame buffers to use
|
||||
static unsigned char number_of_buffers(void) {
|
||||
if (gui_data.fallback_canvas) return 2;
|
||||
|
||||
bool should_blend = config_get_frame_blending_mode() != GB_FRAME_BLENDING_MODE_DISABLED;
|
||||
|
||||
return should_blend? 3 : 2;
|
||||
}
|
||||
|
||||
// Returns the buffer that should be used by the Core to render a new frame to
|
||||
static uint32_t *get_pixels(void) {
|
||||
return gui_data.image_buffers[(gui_data.current_buffer + 1) % number_of_buffers()];
|
||||
}
|
||||
|
||||
// Returns the current finished frame
|
||||
static uint32_t *get_current_buffer(void) {
|
||||
return gui_data.image_buffers[gui_data.current_buffer];
|
||||
}
|
||||
|
||||
// Returns the previous finished frame
|
||||
static uint32_t *get_previous_buffer(void) {
|
||||
return gui_data.image_buffers[(gui_data.current_buffer + 2) % number_of_buffers()];
|
||||
}
|
||||
|
||||
// Cycles the buffers
|
||||
static void flip(void) {
|
||||
gui_data.current_buffer = (gui_data.current_buffer + 1) % number_of_buffers();
|
||||
}
|
||||
|
||||
static void update_viewport(void) {
|
||||
GtkWidget *w = gui_data.fallback_canvas ? GTK_WIDGET(gui_data.fallback_canvas) : GTK_WIDGET(gui_data.gl_area);
|
||||
|
||||
int win_width = gtk_widget_get_allocated_width(w);
|
||||
int win_height = gtk_widget_get_allocated_height(w);
|
||||
|
||||
double x_factor = win_width / (double) GB_get_screen_width(&gb);
|
||||
double y_factor = win_height / (double) GB_get_screen_height(&gb);
|
||||
|
||||
if (config.video.use_integer_scaling) {
|
||||
x_factor = (int)(x_factor);
|
||||
y_factor = (int)(y_factor);
|
||||
}
|
||||
|
||||
if (config.video.keep_aspect_ratio) {
|
||||
if (x_factor > y_factor) {
|
||||
x_factor = y_factor;
|
||||
}
|
||||
else {
|
||||
y_factor = x_factor;
|
||||
}
|
||||
}
|
||||
|
||||
unsigned new_width = x_factor * GB_get_screen_width(&gb);
|
||||
unsigned new_height = y_factor * GB_get_screen_height(&gb);
|
||||
|
||||
gui_data.viewport = (Rect){
|
||||
(win_width - new_width) / 2,
|
||||
(win_height - new_height) / 2,
|
||||
new_width,
|
||||
new_height
|
||||
};
|
||||
|
||||
if (gui_data.gl_area) {
|
||||
glViewport(gui_data.viewport.x, gui_data.viewport.y, gui_data.viewport.width, gui_data.viewport.height);
|
||||
}
|
||||
}
|
||||
|
||||
// WHY DO WE NEED SUCH AN UGLY METHOD, GTK?!
|
||||
static void action_entries_set_enabled(const GActionEntry *entries, unsigned n_entries, bool value) {
|
||||
// Assumes null-terminated if n_entries == -1
|
||||
|
|
@ -719,55 +652,6 @@ static void action_entries_set_enabled(const GActionEntry *entries, unsigned n_e
|
|||
}
|
||||
}
|
||||
|
||||
static void update_window_geometry(void) {
|
||||
g_debug("update_window_geometry: %u×%u → %u×%u", gui_data.last_screen_width, gui_data.last_screen_height, GB_get_screen_width(&gb), GB_get_screen_height(&gb));
|
||||
|
||||
GtkWidget *w = gui_data.fallback_canvas ? GTK_WIDGET(gui_data.fallback_canvas) : GTK_WIDGET(gui_data.gl_area);
|
||||
signed win_width = gtk_widget_get_allocated_width(w);
|
||||
signed win_height = gtk_widget_get_allocated_height(w);
|
||||
signed menu_height = gtk_widget_get_allocated_height(builder_get(GTK_WIDGET, "main_menu"));
|
||||
|
||||
unsigned _factor = win_width > win_height ? win_width / GB_get_screen_width(&gb) : win_height / GB_get_screen_height(&gb);
|
||||
unsigned factor = _factor < 2 ? 2 : _factor;
|
||||
|
||||
unsigned new_width = GB_get_screen_width(&gb) * factor;
|
||||
unsigned new_height = GB_get_screen_height(&gb) * factor + menu_height;
|
||||
|
||||
// Set size hints
|
||||
GdkGeometry hints;
|
||||
hints.min_width = GB_get_screen_width(&gb);
|
||||
hints.min_height = GB_get_screen_height(&gb) + menu_height;
|
||||
|
||||
gtk_window_set_geometry_hints(
|
||||
GTK_WINDOW(gui_data.main_window),
|
||||
NULL,
|
||||
&hints,
|
||||
(GdkWindowHints)(GDK_HINT_MIN_SIZE)
|
||||
);
|
||||
|
||||
if (new_width > win_width || new_height > win_height) {
|
||||
gtk_window_resize(GTK_WINDOW(gui_data.main_window), new_width, new_height);
|
||||
}
|
||||
|
||||
// Setup our image buffers
|
||||
if (gui_data.image_buffers[0]) g_free(gui_data.image_buffers[0]);
|
||||
if (gui_data.image_buffers[1]) g_free(gui_data.image_buffers[1]);
|
||||
if (gui_data.image_buffers[2]) g_free(gui_data.image_buffers[2]);
|
||||
|
||||
size_t buffer_size = sizeof(gui_data.image_buffers[0][0]) * GB_get_screen_width(&gb) * GB_get_screen_height(&gb);
|
||||
|
||||
gui_data.image_buffers[0] = g_malloc0(buffer_size);
|
||||
gui_data.image_buffers[1] = g_malloc0(buffer_size);
|
||||
gui_data.image_buffers[2] = g_malloc0(buffer_size);
|
||||
|
||||
gui_data.last_screen_width = GB_get_screen_width(&gb);
|
||||
gui_data.last_screen_height = GB_get_screen_height(&gb);
|
||||
|
||||
if (GB_is_inited(&gb)) {
|
||||
GB_set_pixels_output(&gb, get_pixels());
|
||||
}
|
||||
}
|
||||
|
||||
static void stop(void) {
|
||||
if (!gui_data.running) return;
|
||||
|
||||
|
|
@ -787,30 +671,25 @@ static void stop(void) {
|
|||
}
|
||||
|
||||
static gboolean on_vblank(GB_gameboy_t *gb) {
|
||||
// Queue drawing of the current frame
|
||||
if (gui_data.fallback_canvas) {
|
||||
gtk_widget_queue_draw(GTK_WIDGET(gui_data.main_window));
|
||||
}
|
||||
else if (gui_data.gl_area) {
|
||||
gtk_gl_area_queue_render(gui_data.gl_area);
|
||||
}
|
||||
|
||||
gtk_widget_queue_draw(GTK_WIDGET(gui_data.screen));
|
||||
gtk_widget_queue_draw(GTK_WIDGET(gui_data.vram_viewer));
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
static void vblank(GB_gameboy_t *gb) {
|
||||
flip();
|
||||
gb_screen_flip(gui_data.screen);
|
||||
|
||||
if (gui_data.border_mode_changed) {
|
||||
GB_set_border_mode(gb, config_get_display_border_mode());
|
||||
update_window_geometry();
|
||||
|
||||
gb_screen_set_resolution(gui_data.screen, GB_get_screen_width(gb), GB_get_screen_height(gb));
|
||||
GB_set_pixels_output(gb, gb_screen_get_pixels(gui_data.screen));
|
||||
|
||||
gui_data.border_mode_changed = false;
|
||||
}
|
||||
|
||||
GB_set_pixels_output(gb, get_pixels());
|
||||
GB_set_pixels_output(gb, gb_screen_get_pixels(gui_data.screen));
|
||||
|
||||
// Handle the speed modifiers:
|
||||
// The binary slowdown is limited to half speed.
|
||||
|
|
@ -837,6 +716,24 @@ static void vblank(GB_gameboy_t *gb) {
|
|||
|
||||
vram_viewer_update(gui_data.vram_viewer, gb);
|
||||
|
||||
GB_frame_blending_mode_t mode = config_get_frame_blending_mode();
|
||||
|
||||
if (!gb_screen_get_previous_buffer(gui_data.screen)) {
|
||||
mode = GB_FRAME_BLENDING_MODE_DISABLED;
|
||||
}
|
||||
else if (mode == GB_FRAME_BLENDING_MODE_ACCURATE) {
|
||||
mode = GB_FRAME_BLENDING_MODE_DISABLED;
|
||||
|
||||
if (GB_is_sgb(gb)) {
|
||||
mode = GB_FRAME_BLENDING_MODE_SIMPLE;
|
||||
}
|
||||
else {
|
||||
mode = GB_is_odd_frame(gb)? GB_FRAME_BLENDING_MODE_ACCURATE_ODD : GB_FRAME_BLENDING_MODE_ACCURATE_EVEN;
|
||||
}
|
||||
}
|
||||
|
||||
gb_screen_set_blending_mode(gui_data.screen, mode);
|
||||
|
||||
g_idle_add((GSourceFunc) on_vblank, gb);
|
||||
}
|
||||
|
||||
|
|
@ -1005,7 +902,7 @@ static void init(void) {
|
|||
GB_init(&gb, config_get_model_type(&gui_data));
|
||||
|
||||
GB_set_vblank_callback(&gb, vblank);
|
||||
GB_set_pixels_output(&gb, get_current_buffer());
|
||||
GB_set_pixels_output(&gb, gb_screen_get_current_buffer(gui_data.screen));
|
||||
GB_set_rgb_encode_callback(&gb, rgb_encode);
|
||||
GB_set_sample_rate(&gb, GB_audio_get_sample_rate());
|
||||
GB_set_color_correction_mode(&gb, config_get_color_correction_mode());
|
||||
|
|
@ -1024,8 +921,6 @@ static void init(void) {
|
|||
if (config_get_display_border_mode() <= GB_BORDER_ALWAYS) {
|
||||
GB_set_border_mode(&gb, config_get_display_border_mode());
|
||||
}
|
||||
|
||||
update_window_geometry();
|
||||
}
|
||||
|
||||
static void reset(void) {
|
||||
|
|
@ -1045,7 +940,8 @@ static void reset(void) {
|
|||
|
||||
// Check SGB -> non-SGB and non-SGB to SGB transitions
|
||||
if (GB_get_screen_width(&gb) != gui_data.last_screen_width || GB_get_screen_height(&gb) != gui_data.last_screen_height) {
|
||||
update_window_geometry();
|
||||
gb_screen_set_resolution(gui_data.screen, GB_get_screen_width(&gb), GB_get_screen_height(&gb));
|
||||
GB_set_pixels_output(&gb, gb_screen_get_pixels(gui_data.screen));
|
||||
}
|
||||
|
||||
bool success = false;
|
||||
|
|
@ -1290,20 +1186,6 @@ static void startup(GApplication *app, gpointer null_ptr) {
|
|||
|
||||
g_debug("GTK version %u.%u.%u", gtk_get_major_version(), gtk_get_minor_version(), gtk_get_micro_version());
|
||||
|
||||
if (gui_data.cli_options.force_software_renderer) {
|
||||
g_message("Forcing fallback renderer!");
|
||||
}
|
||||
else {
|
||||
// Very ugly workaround for GtkGlArea!
|
||||
// When a GtkGlArea is realized and it creates a legacy GL 1.4 context
|
||||
// it tries to use GL 2.0 functions to render the window which leads to the application crashing.
|
||||
// So we initialize GTK, create a dummy GtkWindow object, attach a `realize` callback and
|
||||
// in this callback create a GdkGLContext on this window. But instead of running the GTK main loop
|
||||
// we just realize and destroy the dummy window and compare the context’s version in the realize callback.
|
||||
gui_data.supports_gl = test_gl_support();
|
||||
g_debug("OpenGL supported: %s", gui_data.supports_gl? "Yes" : "No");
|
||||
}
|
||||
|
||||
gui_data.builder = gtk_builder_new_from_resource(RESOURCE_PREFIX "ui/window.ui");
|
||||
gtk_builder_connect_signals(gui_data.builder, NULL);
|
||||
|
||||
|
|
@ -1319,6 +1201,7 @@ static void startup(GApplication *app, gpointer null_ptr) {
|
|||
g_signal_connect(gui_data.preferences, "realize", G_CALLBACK(on_preferences_realize), (gpointer) gui_data.builder);
|
||||
init_config(app, gui_data.cli_options.config_path, &gui_data.config_modification_date, gui_data.preferences);
|
||||
|
||||
gui_data.screen = gb_screen_new(gui_data.cli_options.force_software_renderer);
|
||||
gui_data.vram_viewer = vram_viewer_new();
|
||||
gui_data.memory_viewer = GTK_WINDOW(get_object("memory_viewer"));
|
||||
|
||||
|
|
@ -1339,6 +1222,7 @@ static void startup(GApplication *app, gpointer null_ptr) {
|
|||
gtk_window_set_title(GTK_WINDOW(gui_data.main_window), "SameBoy");
|
||||
gtk_application_window_set_show_menubar(gui_data.main_window, false);
|
||||
gtk_container_add(GTK_CONTAINER(gui_data.main_window), GTK_WIDGET(gui_data.main_window_container));
|
||||
gtk_box_pack_end(GTK_BOX(gui_data.main_window_container), GTK_WIDGET(gui_data.screen), true, true, 0);
|
||||
|
||||
setup_menu(app);
|
||||
|
||||
|
|
@ -1374,6 +1258,11 @@ static void startup(GApplication *app, gpointer null_ptr) {
|
|||
gtk_about_dialog_set_logo(about_dialog, gdk_pixbuf_new_from_resource(icons[2], NULL)); // reuse the 64x64 icon
|
||||
gtk_about_dialog_set_version(about_dialog, "v" xstr(VERSION));
|
||||
g_list_free_full(icon_list, g_object_unref);
|
||||
|
||||
GdkScreen *screen = gdk_screen_get_default();
|
||||
GtkCssProvider *provider = gtk_css_provider_new();
|
||||
gtk_css_provider_load_from_resource(provider, RESOURCE_PREFIX "css/main.css");
|
||||
gtk_style_context_add_provider_for_screen(screen, GTK_STYLE_PROVIDER(provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
|
||||
}
|
||||
|
||||
G_MODULE_EXPORT void on_quit_activate(GtkWidget *w, gpointer user_data_ptr) {
|
||||
|
|
@ -1443,145 +1332,6 @@ static void connect_signal_handlers(GApplication *app) {
|
|||
g_signal_connect(gui_data.printer, "delete-event", G_CALLBACK(gtk_widget_hide_on_delete), NULL);
|
||||
}
|
||||
|
||||
// TODO: Comment
|
||||
static void gl_draw(void) {
|
||||
uint32_t *pixels = get_current_buffer();
|
||||
uint32_t *previous = get_previous_buffer();
|
||||
|
||||
static void *_pixels = NULL;
|
||||
|
||||
if (pixels) {
|
||||
_pixels = pixels;
|
||||
}
|
||||
|
||||
glClearColor(0, 0, 0, 1);
|
||||
glClear(GL_COLOR_BUFFER_BIT);
|
||||
|
||||
GB_frame_blending_mode_t mode = config_get_frame_blending_mode();
|
||||
if (!previous) {
|
||||
mode = GB_FRAME_BLENDING_MODE_DISABLED;
|
||||
}
|
||||
else if (mode == GB_FRAME_BLENDING_MODE_ACCURATE) {
|
||||
if (GB_is_sgb(&gb)) {
|
||||
mode = GB_FRAME_BLENDING_MODE_SIMPLE;
|
||||
}
|
||||
else {
|
||||
mode = GB_is_odd_frame(&gb)? GB_FRAME_BLENDING_MODE_ACCURATE_ODD : GB_FRAME_BLENDING_MODE_ACCURATE_EVEN;
|
||||
}
|
||||
}
|
||||
|
||||
render_bitmap_with_shader(
|
||||
&gui_data.shader, _pixels, previous,
|
||||
GB_get_screen_width(&gb), GB_get_screen_height(&gb),
|
||||
gui_data.viewport.x, gui_data.viewport.y, gui_data.viewport.width, gui_data.viewport.height,
|
||||
mode
|
||||
);
|
||||
}
|
||||
|
||||
// TODO: Comment
|
||||
static void gl_finish(void) { }
|
||||
|
||||
// TODO: Comment
|
||||
static void resize(void) {
|
||||
update_viewport();
|
||||
}
|
||||
|
||||
// TODO: Comment
|
||||
static gboolean on_draw_fallback(GtkWidget *widget, cairo_t *cr, gpointer data) {
|
||||
GtkStyleContext *context = gtk_widget_get_style_context(widget);
|
||||
guint width = gtk_widget_get_allocated_width(widget);
|
||||
guint height = gtk_widget_get_allocated_height(widget);
|
||||
|
||||
guint screen_width = GB_get_screen_width(&gb);
|
||||
guint screen_height = GB_get_screen_height(&gb);
|
||||
|
||||
gtk_render_background(context, cr, 0, 0, width, height);
|
||||
gtk_render_frame(context, cr, 0, 0, width, height);
|
||||
|
||||
cairo_surface_t *surface = cairo_image_surface_create_for_data(
|
||||
(unsigned char *) get_current_buffer(),
|
||||
CAIRO_FORMAT_RGB24,
|
||||
screen_width,
|
||||
screen_height,
|
||||
cairo_format_stride_for_width(CAIRO_FORMAT_RGB24, screen_width)
|
||||
);
|
||||
|
||||
cairo_translate(cr, gui_data.viewport.x, gui_data.viewport.y);
|
||||
cairo_scale(cr, gui_data.viewport.width / screen_width, gui_data.viewport.height / screen_height);
|
||||
cairo_set_source_surface(cr, surface, 0, 0);
|
||||
cairo_pattern_set_filter(cairo_get_source(cr), CAIRO_FILTER_NEAREST);
|
||||
cairo_paint(cr);
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
// Create a GtkDrawingArea as a fallback in case we can’t use OpenGL
|
||||
static void create_fallback_canvas(void) {
|
||||
gui_data.fallback_canvas = GTK_DRAWING_AREA(gtk_drawing_area_new());
|
||||
g_signal_connect(gui_data.fallback_canvas, "draw", G_CALLBACK(on_draw_fallback), NULL);
|
||||
g_signal_connect(gui_data.fallback_canvas, "size-allocate", G_CALLBACK(resize), NULL);
|
||||
gtk_box_pack_end(GTK_BOX(gui_data.main_window_container), GTK_WIDGET(gui_data.fallback_canvas), true, true, 0);
|
||||
}
|
||||
|
||||
// TODO: Comment
|
||||
static void gl_init(GtkWidget *w) {
|
||||
GtkGLArea *gl_area = GTK_GL_AREA(w);
|
||||
|
||||
g_debug("GL_INIT");
|
||||
const char *renderer;
|
||||
|
||||
g_debug("GL Context: %p", gtk_gl_area_get_context(gl_area));
|
||||
|
||||
gtk_gl_area_make_current(gl_area);
|
||||
|
||||
if (gtk_gl_area_get_error(gl_area) != NULL) {
|
||||
goto error;
|
||||
}
|
||||
|
||||
renderer = (char *)glGetString(GL_RENDERER);
|
||||
g_debug("GtkGLArea on %s", renderer ? renderer : "Unknown");
|
||||
|
||||
if (config.video.shader == NULL || (!init_shader_with_name(&gui_data.shader, config.video.shader) && !init_shader_with_name(&gui_data.shader, "NearestNeighbor"))) {
|
||||
GError *error = g_error_new_literal(g_quark_from_string("sameboy-gl-error"), 1, "Failed to initialize shaders");
|
||||
gtk_gl_area_set_error(gl_area, error);
|
||||
}
|
||||
else {
|
||||
g_signal_connect(gl_area, "render", G_CALLBACK(gl_draw), NULL);
|
||||
g_signal_connect(gl_area, "resize", G_CALLBACK(resize), NULL);
|
||||
g_signal_connect(gl_area, "unrealize", G_CALLBACK(gl_finish), NULL);
|
||||
return;
|
||||
}
|
||||
|
||||
error:
|
||||
if (gtk_gl_area_get_error(gl_area) != NULL) {
|
||||
g_warning("GtkGLArea: %s", gtk_gl_area_get_error(gl_area)->message);
|
||||
}
|
||||
|
||||
create_fallback_canvas();
|
||||
}
|
||||
|
||||
static void create_canvas(void) {
|
||||
// create our renderer area
|
||||
if (gui_data.supports_gl) {
|
||||
gui_data.gl_area = GTK_GL_AREA(gtk_gl_area_new());
|
||||
gtk_gl_area_set_required_version(gui_data.gl_area, 3, 2);
|
||||
gtk_gl_area_set_auto_render(gui_data.gl_area, false);
|
||||
gtk_gl_area_set_has_alpha(gui_data.gl_area, false);
|
||||
gtk_gl_area_set_has_depth_buffer(gui_data.gl_area, false);
|
||||
gtk_gl_area_set_has_stencil_buffer(gui_data.gl_area, false);
|
||||
g_signal_connect(gui_data.gl_area, "realize", G_CALLBACK(gl_init), NULL);
|
||||
gtk_box_pack_end(GTK_BOX(gui_data.main_window_container), GTK_WIDGET(gui_data.gl_area), true, true, 0);
|
||||
}
|
||||
else {
|
||||
create_fallback_canvas();
|
||||
}
|
||||
|
||||
GdkScreen *screen = gdk_screen_get_default();
|
||||
GtkCssProvider *provider = gtk_css_provider_new();
|
||||
gtk_css_provider_load_from_resource(provider, RESOURCE_PREFIX "css/main.css");
|
||||
gtk_style_context_add_provider_for_screen(screen, GTK_STYLE_PROVIDER(provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
|
||||
}
|
||||
|
||||
static void setup_console(void) {
|
||||
GtkTextView *text_view = builder_get(GTK_TEXT_VIEW, "console_screen");
|
||||
GtkTextBuffer *text_buf = gtk_text_view_get_buffer(text_view);
|
||||
|
|
@ -1614,7 +1364,7 @@ static void activate(GApplication *app, gpointer null_ptr) {
|
|||
init_controllers();
|
||||
|
||||
connect_signal_handlers(app);
|
||||
create_canvas();
|
||||
// create_canvas();
|
||||
setup_console();
|
||||
|
||||
if (gui_data.cli_options.fullscreen) {
|
||||
|
|
@ -1624,8 +1374,6 @@ static void activate(GApplication *app, gpointer null_ptr) {
|
|||
gtk_application_add_window(GTK_APPLICATION(app), GTK_WINDOW(gui_data.main_window));
|
||||
gtk_widget_show_all(GTK_WIDGET(gui_data.main_window));
|
||||
|
||||
update_window_geometry();
|
||||
|
||||
// Start the emulation thread
|
||||
run();
|
||||
}
|
||||
|
|
@ -1637,12 +1385,7 @@ static void shutdown(GApplication *app, GFile **files, gint n_files, const gchar
|
|||
stop();
|
||||
SDL_Quit();
|
||||
|
||||
if (gui_data.image_buffers[0]) g_free(gui_data.image_buffers[0]);
|
||||
if (gui_data.image_buffers[1]) g_free(gui_data.image_buffers[1]);
|
||||
if (gui_data.image_buffers[2]) g_free(gui_data.image_buffers[2]);
|
||||
free_shader(&gui_data.shader);
|
||||
free_master_shader();
|
||||
|
||||
gtk_widget_destroy(GTK_WIDGET(gui_data.screen));
|
||||
GB_free(&gb);
|
||||
|
||||
g_object_unref(gui_data.builder);
|
||||
|
|
@ -1705,19 +1448,10 @@ static void close_rom(void) {
|
|||
stop();
|
||||
GB_free(&gb);
|
||||
|
||||
// Clear the screen as side effect
|
||||
update_window_geometry();
|
||||
|
||||
if (gui_data.fallback_canvas) {
|
||||
gtk_widget_queue_draw(GTK_WIDGET(gui_data.main_window));
|
||||
}
|
||||
else if (gui_data.gl_area) {
|
||||
gtk_gl_area_queue_render(gui_data.gl_area);
|
||||
}
|
||||
gb_screen_clear(gui_data.screen);
|
||||
gtk_widget_queue_draw(GTK_WIDGET(gui_data.screen));
|
||||
|
||||
vram_viewer_clear(gui_data.vram_viewer);
|
||||
|
||||
// Redraw the VRAM viewer
|
||||
gtk_widget_queue_draw(GTK_WIDGET(gui_data.vram_viewer));
|
||||
|
||||
// Update menu action states
|
||||
|
|
@ -1884,8 +1618,7 @@ G_MODULE_EXPORT void on_graphic_filter_changed(GtkWidget *w, gpointer user_data_
|
|||
GtkComboBox *box = GTK_COMBO_BOX(w);
|
||||
config.video.shader = (gchar *)gtk_combo_box_get_active_id(box);
|
||||
|
||||
free_shader(&gui_data.shader);
|
||||
init_shader_with_name(&gui_data.shader, config.video.shader);
|
||||
gb_screen_set_shader(gui_data.screen, config.video.shader);
|
||||
}
|
||||
|
||||
G_MODULE_EXPORT void on_highpass_filter_changed(GtkWidget *w, gpointer user_data_ptr) {
|
||||
|
|
@ -1900,7 +1633,6 @@ G_MODULE_EXPORT void on_keep_aspect_ratio_changed(GtkWidget *w, gpointer user_da
|
|||
GtkCheckButton *button = GTK_CHECK_BUTTON(w);
|
||||
gboolean value = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button));
|
||||
config.video.keep_aspect_ratio = value;
|
||||
update_viewport();
|
||||
}
|
||||
|
||||
G_MODULE_EXPORT void on_rewind_duration_changed(GtkWidget *w, gpointer user_data_ptr) {
|
||||
|
|
@ -1932,7 +1664,6 @@ G_MODULE_EXPORT void on_use_integer_scaling_changed(GtkWidget *w, gpointer user_
|
|||
GtkCheckButton *button = GTK_CHECK_BUTTON(w);
|
||||
gboolean value = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button));
|
||||
config.video.use_integer_scaling = value;
|
||||
update_viewport();
|
||||
}
|
||||
|
||||
G_MODULE_EXPORT void console_on_enter(GtkWidget *w, gpointer user_data_ptr) {
|
||||
|
|
|
|||
12
gtk3/types.h
12
gtk3/types.h
|
|
@ -2,7 +2,7 @@
|
|||
#define types_h
|
||||
|
||||
#include "SDL.h"
|
||||
#include "shader.h"
|
||||
#include "gb_screen.h"
|
||||
#include "vram_viewer_window.h"
|
||||
|
||||
typedef struct{
|
||||
|
|
@ -38,8 +38,9 @@ typedef struct GuiData {
|
|||
GtkBuilder *builder;
|
||||
GtkApplicationWindow *main_window;
|
||||
GtkBox *main_window_container;
|
||||
GtkGLArea *gl_area;
|
||||
GtkDrawingArea *fallback_canvas;
|
||||
|
||||
GbScreen *screen;
|
||||
|
||||
GtkWindow *preferences;
|
||||
VramViewerWindow *vram_viewer;
|
||||
GtkWindow *memory_viewer;
|
||||
|
|
@ -59,13 +60,8 @@ typedef struct GuiData {
|
|||
|
||||
// Audio and video
|
||||
bool audio_initialized;
|
||||
uint32_t *image_buffers[3];
|
||||
unsigned char current_buffer;
|
||||
Rect viewport;
|
||||
bool border_mode_changed;
|
||||
bool is_fullscreen;
|
||||
bool supports_gl;
|
||||
shader_t shader;
|
||||
unsigned last_screen_width;
|
||||
unsigned last_screen_height;
|
||||
|
||||
|
|
|
|||
|
|
@ -52,8 +52,8 @@ static void visible_tab_changed(GObject *stack, GParamSpec *pspec, VramViewerWin
|
|||
|
||||
static gboolean draw_tileset_canvas(GtkWidget *widget, cairo_t *cr, VramViewerWindow *window) {
|
||||
GtkStyleContext *context = gtk_widget_get_style_context(widget);
|
||||
guint width = gtk_widget_get_allocated_width(widget);
|
||||
guint height = gtk_widget_get_allocated_height(widget);
|
||||
int width = gtk_widget_get_allocated_width(widget);
|
||||
int height = gtk_widget_get_allocated_height(widget);
|
||||
|
||||
gtk_render_background(context, cr, 0, 0, width, height);
|
||||
gtk_render_frame(context, cr, 0, 0, width, height);
|
||||
|
|
@ -100,8 +100,8 @@ static gboolean draw_tileset_canvas(GtkWidget *widget, cairo_t *cr, VramViewerWi
|
|||
|
||||
static gboolean draw_tilemap_canvas(GtkWidget *widget, cairo_t *cr, VramViewerWindow *window) {
|
||||
GtkStyleContext *context = gtk_widget_get_style_context(widget);
|
||||
guint width = gtk_widget_get_allocated_width(widget);
|
||||
guint height = gtk_widget_get_allocated_height(widget);
|
||||
int width = gtk_widget_get_allocated_width(widget);
|
||||
int height = gtk_widget_get_allocated_height(widget);
|
||||
|
||||
gtk_render_background(context, cr, 0, 0, width, height);
|
||||
gtk_render_frame(context, cr, 0, 0, width, height);
|
||||
|
|
|
|||
Loading…
Reference in New Issue