/* We need to set up our state when we realize the GtkGLArea widget */
static void
realize (GtkWidget *widget)
{
const char *vertex_path, *fragment_path;
GdkGLContext *context;
gtk_gl_area_make_current (GTK_GL_AREA (widget));
if (gtk_gl_area_get_error (GTK_GL_AREA (widget)) != NULL)
return;
context = gtk_gl_area_get_context (GTK_GL_AREA (widget));
if (gdk_gl_context_get_use_es (context))
{
vertex_path = "/glarea/glarea-gles.vs.glsl";
fragment_path = "/glarea/glarea-gles.fs.glsl";
}
else
{
vertex_path = "/glarea/glarea-gl.vs.glsl";
fragment_path = "/glarea/glarea-gl.fs.glsl";
}
init_buffers (&position_buffer, NULL);
init_shaders (vertex_path, fragment_path, &program, &mvp_location);
}
void
gl_window_orient_window(GtkGLArea *glarea)
{
gl_window_info *info = gtk_object_get_data(GTK_OBJECT(glarea), "info");
GLfloat median;
float m[4][4];
if (gtk_gl_area_make_current(GTK_GL_AREA(glarea))){
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glMatrixMode(GL_PROJECTION);
if(info->orientation == ORIENTATION_3D ||
info->orientation == ORIENTATION_TEXTURE ){
glMatrixMode(GL_PROJECTION);
glFrustum( -0.0005 * info->aspect_ratio, 0.0005 * info->aspect_ratio,
-0.0005 , 0.0005,
0.001, 1000
);
}else{
if(info->x_median >= info->y_median)
median = info->x_median;
else
median = info->y_median;
glOrtho(-1 * info->x_median, info->x_median, // left, right
-1 * info->y_median, info->y_median, // bottom, top
median * -3, median * 3 // near, far
);
}
switch(info->orientation)
{
case ORIENTATION_FRONT: break;
case ORIENTATION_3D:
case ORIENTATION_TEXTURE:
glMatrixMode(GL_MODELVIEW);
glTranslatef(0,0,-1 * info->zoom);
build_rotmatrix(m, info->quat);
glMultMatrixf(&m[0][0]);
break;
case ORIENTATION_TOP: glRotatef(-90, 1,0,0); break;
case ORIENTATION_BOTTOM: glRotatef( 90, 1,0,0); break;
case ORIENTATION_LEFT: glRotatef(90, 0,1,0); break;
case ORIENTATION_RIGHT: glRotatef(-90, 0,1,0); break;
case ORIENTATION_BACK: glRotatef(180, 0,1,0); break;
default: break;
}
}/*if(gtk_gl_area_make_current(glarea))*/
}
/* When widget is exposed it's contents are redrawn. */
gint draw(GtkWidget *widget, GdkEventExpose *event)
{
/* Draw only last expose. */
if (event->count > 0) {
return TRUE;
}
if (gtk_gl_area_make_current(GTK_GL_AREA(widget))) {
int i,j;
/* clear screen */
glClearColor(0,0,1,1);
glClear(GL_COLOR_BUFFER_BIT);
/* Draw some text */
glColor3f(1,1,1);
for (i=1; i<5; i++) {
glRasterPos2f(10, widget->allocation.height-i*fontheight);
for (j=' '; j<='Z'; j++) {
glCallList(fontbase+j);
}
}
/* show font name */
glColor3f(1,1,0);
glRasterPos2f(10,5);
glListBase(fontbase);
glCallLists(strlen(fontname), GL_UNSIGNED_BYTE, fontname);
gdk_gl_wait_gl();
}
return TRUE;
}
void
gl_window_change_orientation(GtkGLArea *glarea, o_enum orientation)
{
gl_window_info *info;
GdkRectangle area;
info = gtk_object_get_data(GTK_OBJECT(glarea), "info");
if (gtk_gl_area_make_current(GTK_GL_AREA(glarea))){
//if changing to 3d or texture orientation
if(orientation == ORIENTATION_3D ||
orientation == ORIENTATION_TEXTURE ){
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glShadeModel(GL_SMOOTH);
glClearColor(0.2, 0.5, 0.7, 1.0);
glClearDepth(1);
}else{
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glClearColor(0.6, 0.6, 0.6, 1);
}
}
info->orientation = orientation;
area.x = 0;
area.y = 0;
area.width = GTK_WIDGET (glarea)->allocation.width;
area.height = GTK_WIDGET (glarea)->allocation.height;
//orientation changed, redraw
gtk_widget_draw(GTK_WIDGET (glarea), &area);
}
int reshape (GtkWidget *widget, GdkEventConfigure *event)
{
if (gtk_gl_area_make_current (GTK_GL_AREA(widget))) {
glViewport(0,0, widget->allocation.width, widget->allocation.height);
}
return TRUE;
}
void gd_gl_area_scanout_texture(DisplayChangeListener *dcl,
uint32_t backing_id,
bool backing_y_0_top,
uint32_t backing_width,
uint32_t backing_height,
uint32_t x, uint32_t y,
uint32_t w, uint32_t h)
{
VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl);
vc->gfx.x = x;
vc->gfx.y = y;
vc->gfx.w = w;
vc->gfx.h = h;
vc->gfx.tex_id = backing_id;
vc->gfx.y0_top = backing_y_0_top;
gtk_gl_area_make_current(GTK_GL_AREA(vc->gfx.drawing_area));
if (vc->gfx.tex_id == 0 || vc->gfx.w == 0 || vc->gfx.h == 0) {
gtk_gl_area_set_scanout_mode(vc, false);
return;
}
gtk_gl_area_set_scanout_mode(vc, true);
if (!vc->gfx.fbo_id) {
glGenFramebuffers(1, &vc->gfx.fbo_id);
}
glBindFramebuffer(GL_FRAMEBUFFER_EXT, vc->gfx.fbo_id);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
GL_TEXTURE_2D, vc->gfx.tex_id, 0);
}
void gd_gl_area_switch(DisplayChangeListener *dcl,
DisplaySurface *surface)
{
VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl);
bool resized = true;
trace_gd_switch(vc->label, surface_width(surface), surface_height(surface));
if (vc->gfx.ds &&
surface_width(vc->gfx.ds) == surface_width(surface) &&
surface_height(vc->gfx.ds) == surface_height(surface)) {
resized = false;
}
if (vc->gfx.gls) {
gtk_gl_area_make_current(GTK_GL_AREA(vc->gfx.drawing_area));
surface_gl_destroy_texture(vc->gfx.gls, vc->gfx.ds);
surface_gl_create_texture(vc->gfx.gls, surface);
}
vc->gfx.ds = surface;
if (resized) {
gd_update_windowsize(vc);
}
}
gint init(GtkWidget *widget)
{
if (gtk_gl_area_make_current(GTK_GL_AREA(widget))) {
GdkFont *font;
/* set viewport */
glViewport(0,0, widget->allocation.width, widget->allocation.height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0,widget->allocation.width, 0,widget->allocation.height, -1.0, 1.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
/* generate font display lists */
fontbase = glGenLists( 128 );
font = gdk_font_load(fontname);
if (!font) {
g_print("Can't load font '%s'\n", fontname);
gtk_exit(1);
}
gdk_gl_use_gdk_font(font, 0, 128, fontbase);
fontheight = font->ascent+font->descent;
gdk_font_unref(font);
}
return TRUE;
}
static void
realize(GtkWidget *widget, gpointer user_data)
{
gtk_gl_area_make_current(GTK_GL_AREA(widget));
glDebugMessageCallback(debug, NULL);
char *str = pk_io_read_file("data/vs.glsl");
programs[0] = glCreateShaderProgramv(GL_VERTEX_SHADER, 1, &str);
free(str);
str = pk_io_read_file("data/fs.glsl");
programs[1] = glCreateShaderProgramv(GL_FRAGMENT_SHADER, 1, &str);
free(str);
/* set up pipeline for rendering fullscreen quad */
glCreateProgramPipelines(1, &pipeline);
glUseProgramStages(pipeline, GL_VERTEX_SHADER_BIT, programs[0]);
glUseProgramStages(pipeline, GL_FRAGMENT_SHADER_BIT, programs[1]);
glBindProgramPipeline(pipeline);
glCreateVertexArrays(1, &vao);
glBindVertexArray(vao);
}
/* When glarea widget size changes, viewport size is set to match the new size */
gint reshape(GtkWidget *widget, GdkEventConfigure *event)
{
/* OpenGL functions can be called only if make_current returns true */
if (gtk_gl_area_make_current(GTK_GL_AREA(widget)))
{
glViewport(0,0, widget->allocation.width, widget->allocation.height);
}
return TRUE;
}
gint draw(GtkWidget *glarea, GdkEventExpose *event) {
if(gtk_gl_area_make_current(GTK_GL_AREA(glarea))) {
mainwin->redraw();
return TRUE;
} else {
// could not set context
return FALSE;
}
}
static void
unrealize(GtkWidget *widget, gpointer user_data)
{
gtk_gl_area_make_current(GTK_GL_AREA(widget));
glDeleteProgram(programs[0]);
glDeleteProgram(programs[1]);
glDeleteProgramPipelines(1, &pipeline);
glDeleteVertexArrays(1, &vao);
}
gint switch_fullscreen(GtkWidget *gl_area)
{
static GtkWidget *fullscreenwidget = NULL;
if (!fullscreenwidget)
{
/* Grab keyboard and pointer so that user does not wander off the game
window while in fullscreen mode.
*/
if (gdk_keyboard_grab(gl_area->window, FALSE, GDK_CURRENT_TIME) == 0)
{
if (gdk_pointer_grab(gl_area->window, FALSE, 0, NULL, NULL, GDK_CURRENT_TIME) == 0)
{
gtk_widget_grab_focus(gl_area);
if (gtk_gl_area_make_current(GTK_GL_AREA(gl_area)))
{
if (XMesaSetFXmode((XMESA_FX_FULLSCREEN)))
{
fullscreenwidget = gl_area;
return TRUE;
}
}
gdk_pointer_ungrab(GDK_CURRENT_TIME);
}
gdk_keyboard_ungrab(GDK_CURRENT_TIME);
}
return FALSE;
}
if (fullscreenwidget == gl_area)
{
if (gtk_gl_area_make_current(GTK_GL_AREA(gl_area)))
XMesaSetFXmode(XMESA_FX_WINDOW);
gdk_keyboard_ungrab(GDK_CURRENT_TIME);
gdk_pointer_ungrab(GDK_CURRENT_TIME);
fullscreenwidget = NULL;
return TRUE;
}
return FALSE;
}
static gboolean reshape( GtkWidget *widget, GdkEvent *event, gpointer native_data ) {
#ifndef _WIN32
if ( !gtk_gl_area_make_current(GTK_GL_AREA(widget)) )
return TRUE;
//printf( "reshape!\n" );
#endif
_chisel_native_openglview_reshape_callback( (native_handle)widget );
return TRUE;
}
static void
finalise(GObject* obj)
{
GtPlayerMpv* self = GT_PLAYER_MPV(obj);
GtPlayerMpvPrivate* priv = gt_player_mpv_get_instance_private(self);
gtk_gl_area_make_current(GTK_GL_AREA(priv->opengl_area));
mpv_opengl_cb_uninit_gl(priv->mpv_opengl);
G_OBJECT_CLASS(gt_player_mpv_parent_class)->finalize(obj);
}
/* We should tear down the state when unrealizing */
static void
unrealize (GtkWidget *widget)
{
gtk_gl_area_make_current (GTK_GL_AREA (widget));
if (gtk_gl_area_get_error (GTK_GL_AREA (widget)) != NULL)
return;
glDeleteBuffers (1, &position_buffer);
glDeleteProgram (program);
}
int init (GtkWidget *widget)
{
if (gtk_gl_area_make_current (GTK_GL_AREA(widget))) {
glViewport(0,0, widget->allocation.width, widget->allocation.height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0,100, 100,0, -1,1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
return TRUE;
}
gint init (GtkWidget *widget)
{
gtk_gl_area_make_current (GTK_GL_AREA(widget));
glViewport(0,0, gtk_widget_get_allocated_width(widget), gtk_widget_get_allocated_height (widget));
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0,100, 100,0, -1,1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
return TRUE;
}
void gd_gl_area_update(DisplayChangeListener *dcl,
int x, int y, int w, int h)
{
VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl);
if (!vc->gfx.gls || !vc->gfx.ds) {
return;
}
gtk_gl_area_make_current(GTK_GL_AREA(vc->gfx.drawing_area));
surface_gl_update_texture(vc->gfx.gls, vc->gfx.ds, x, y, w, h);
vc->gfx.glupdates++;
}
/* When widget is exposed it's contents are redrawn. */
gint draw(GtkWidget *widget, GdkEventExpose *event)
{
/* Draw only last expose. */
if (event->count > 0)
return TRUE;
if (gtk_gl_area_make_current(GTK_GL_AREA(widget)))
game_render();
/* Swap backbuffer to front */
gtk_gl_area_swapbuffers(GTK_GL_AREA(widget));
return TRUE;
}
static void
gtk_gears_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
GtkGLArea *glarea = GTK_GL_AREA (widget);
GTK_WIDGET_CLASS (gtk_gears_parent_class)->size_allocate (widget, allocation);
if (gtk_widget_get_realized (widget))
{
gtk_gl_area_make_current (glarea);
reshape (allocation->width, allocation->height);
}
}
static void
realise_oneshot_cb(GtkWidget* widget,
gpointer udata)
{
GtPlayerBackendMpvOpenGL* self = GT_PLAYER_BACKEND_MPV_OPENGL(udata);
GtPlayerBackendMpvOpenGLPrivate* priv = gt_player_backend_mpv_opengl_get_instance_private(self);
gtk_gl_area_make_current(GTK_GL_AREA(priv->widget));
check_mpv_error(mpv_opengl_cb_init_gl(priv->mpv_opengl, NULL,
get_proc_address, NULL));
g_signal_handlers_disconnect_by_func(widget, realise_oneshot_cb, udata);
}
/* When glarea widget size changes, viewport size is set to match the new size */
gint reshape(GtkWidget *widget, GdkEventConfigure *event)
{
if (gtk_gl_area_make_current(GTK_GL_AREA(widget))) {
glViewport(0,0, widget->allocation.width, widget->allocation.height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0,widget->allocation.width, 0,widget->allocation.height, -1.0, 1.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
return TRUE;
}
void gd_gl_area_draw(VirtualConsole *vc)
{
int ww, wh, y1, y2;
if (!vc->gfx.gls) {
return;
}
gtk_gl_area_make_current(GTK_GL_AREA(vc->gfx.drawing_area));
ww = gtk_widget_get_allocated_width(vc->gfx.drawing_area);
wh = gtk_widget_get_allocated_height(vc->gfx.drawing_area);
if (vc->gfx.scanout_mode) {
if (!vc->gfx.fbo_id) {
return;
}
glBindFramebuffer(GL_READ_FRAMEBUFFER, vc->gfx.fbo_id);
/* GtkGLArea sets GL_DRAW_FRAMEBUFFER for us */
glViewport(0, 0, ww, wh);
y1 = vc->gfx.y0_top ? 0 : vc->gfx.h;
y2 = vc->gfx.y0_top ? vc->gfx.h : 0;
glBlitFramebuffer(0, y1, vc->gfx.w, y2,
0, 0, ww, wh,
GL_COLOR_BUFFER_BIT, GL_NEAREST);
} else {
if (!vc->gfx.ds) {
return;
}
gtk_gl_area_make_current(GTK_GL_AREA(vc->gfx.drawing_area));
surface_gl_setup_viewport(vc->gfx.gls, vc->gfx.ds, ww, wh);
surface_gl_render_texture(vc->gfx.gls, vc->gfx.ds);
}
}
static void
gtk_gears_realize (GtkWidget *widget)
{
GtkGLArea *glarea = GTK_GL_AREA (widget);
GtkGears *gears = GTK_GEARS(widget);
GtkGearsPrivate *priv = gtk_gears_get_instance_private (gears);
GtkAllocation allocation;
static GLfloat pos[4] = { 5.0, 5.0, 10.0, 0.0 };
static GLfloat red[4] = { 0.8, 0.1, 0.0, 1.0 };
static GLfloat green[4] = { 0.0, 0.8, 0.2, 1.0 };
static GLfloat blue[4] = { 0.2, 0.2, 1.0, 1.0 };
GTK_WIDGET_CLASS (gtk_gears_parent_class)->realize (widget);
gtk_gl_area_make_current (glarea);
glLightfv(GL_LIGHT0, GL_POSITION, pos);
glEnable(GL_CULL_FACE);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_DEPTH_TEST);
/* make the gears */
priv->gear1 = glGenLists(1);
glNewList(priv->gear1, GL_COMPILE);
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, red);
gear(1.0, 4.0, 1.0, 20, 0.7);
glEndList();
priv->gear2 = glGenLists(1);
glNewList(priv->gear2, GL_COMPILE);
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, green);
gear(0.5, 2.0, 2.0, 10, 0.7);
glEndList();
priv->gear3 = glGenLists(1);
glNewList(priv->gear3, GL_COMPILE);
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, blue);
gear(1.3, 2.0, 0.5, 10, 0.7);
glEndList();
glEnable(GL_NORMALIZE);
gtk_widget_get_allocation (widget, &allocation);
reshape (allocation.width, allocation.height);
}
static gboolean expose( GtkWidget *widget, GdkEventExpose *event, gpointer native_data ) {
/*if (event->count > 0)
return TRUE;*/
#ifndef _WIN32
if ( !gtk_gl_area_make_current(GTK_GL_AREA(widget)) )
return TRUE;
#endif
Rect rect;
rect.origin.x = event->area.x;
rect.origin.y = event->area.y;
rect.size.width = event->area.width;
rect.size.height = event->area.height;
//printf( "expose!\n" );
_chisel_native_view_draw_rect_callback( (native_handle)widget, rect );
return TRUE;
}
QEMUGLContext gd_gl_area_create_context(DisplayChangeListener *dcl,
QEMUGLParams *params)
{
VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl);
GdkWindow *window;
GdkGLContext *ctx;
GError *err = NULL;
gtk_gl_area_make_current(GTK_GL_AREA(vc->gfx.drawing_area));
window = gtk_widget_get_window(vc->gfx.drawing_area);
ctx = gdk_window_create_gl_context(window, &err);
gdk_gl_context_set_required_version(ctx,
params->major_ver,
params->minor_ver);
gdk_gl_context_realize(ctx, &err);
return ctx;
}
int draw (GtkWidget *widget, GdkEventExpose *event)
{
if (event->count > 0) return TRUE;
if (gtk_gl_area_make_current (GTK_GL_AREA(widget))) {
glClearColor(0,0,0,1);
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(0,0.2,0.8);
glBegin(GL_TRIANGLES);
glVertex2f(10,10);
glVertex2f(10,90);
glVertex2f(90,90);
glEnd();
gtk_gl_area_swap_buffers (GTK_GL_AREA(widget));
}
return TRUE;
}
gint reshape(GtkWidget *glarea, GdkEventConfigure *event) {
if(gtk_gl_area_make_current(GTK_GL_AREA(glarea))) {
glViewport(0, 0, glarea->allocation.width, glarea->allocation.height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0, (double) glarea->allocation.width / (double) glarea->allocation.height, 3.0, 2500.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
mainwin->redraw();
return TRUE;
} else {
// could not set context
return FALSE;
}
}
void
gl_window_draw_axis(GtkGLArea *glarea)
{
if (gtk_gl_area_make_current(GTK_GL_AREA(glarea))){
glBegin(GL_LINES);
glColor3f(1.0, 1.0, 0.0);
glVertex3f(0,0,0);
glVertex3f(10,0,0);
glColor3f(0.0, 1.0, 1.0);
glVertex3f(0,0,0);
glVertex3f(0,10,0);
glColor3f(1.0, 0.0, 1.0);
glVertex3f(0,0,0);
glVertex3f(0,0,10);
glEnd();
}
}
