/* Configure the OpenGL framebuffer.*/
static GdkGLConfig *configure_gl()
{
GdkGLConfig *glconfig;
GdkGLConfigMode modedouble = GDK_GL_MODE_RGB | GDK_GL_MODE_DEPTH | GDK_GL_MODE_DOUBLE;
GdkGLConfigMode modesimple = GDK_GL_MODE_RGB | GDK_GL_MODE_DEPTH;
GdkGLConfigMode mode = GDK_GL_MODE_RGB;
OpenGLOptions openGLOptions = get_opengl_options();
/* Try the user visual */
if(openGLOptions.rgba !=0) mode = GDK_GL_MODE_RGBA;
if(openGLOptions.depthSize!=0) mode |= GDK_GL_MODE_DEPTH;
if(openGLOptions.alphaSize!=0) mode |= GDK_GL_MODE_ALPHA;
if(openGLOptions.doubleBuffer!=0) mode |= GDK_GL_MODE_DOUBLE;
glconfig = gdk_gl_config_new_by_mode (mode);
if(glconfig!=NULL) return glconfig;
/* Try double-buffered visual */
glconfig = gdk_gl_config_new_by_mode (modedouble);
if (glconfig == NULL)
{
printf ("\n*** Cannot find the double-buffered visual.\n");
printf ("\n*** Trying single-buffered visual.\n");
/* Try single-buffered visual */
glconfig = gdk_gl_config_new_by_mode (modesimple);
if (glconfig == NULL)
{
printf ("*** No appropriate OpenGL-capable visual found.\n");
exit (1);
}
}
return glconfig;
}
/***
*** Configure the OpenGL framebuffer.
***/
static GdkGLConfig *
configure_gl (void)
{
GdkGLConfig *glconfig;
/* Try double-buffered visual */
glconfig = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGB |
GDK_GL_MODE_DEPTH |
GDK_GL_MODE_DOUBLE);
if (glconfig == NULL)
{
g_print ("\n*** Cannot find the double-buffered visual.\n");
g_print ("\n*** Trying single-buffered visual.\n");
/* Try single-buffered visual */
glconfig = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGB |
GDK_GL_MODE_DEPTH);
if (glconfig == NULL)
{
g_print ("*** No appropriate OpenGL-capable visual found.\n");
exit (1);
}
}
return glconfig;
}
bool
GtkGlExtGlue::init(int argc, char** argv[])
{
// GNASH_REPORT_FUNCTION;
gtk_gl_init (&argc, argv);
gint major, minor;
gdk_gl_query_version (&major, &minor);
log_debug ("OpenGL extension version - %d.%d", (int)major, (int)minor);
GdkGLConfigMode glcmode = (GdkGLConfigMode)(GDK_GL_MODE_RGB |
GDK_GL_MODE_STENCIL |
GDK_GL_MODE_DOUBLE |
GDK_GL_MODE_ACCUM);
_glconfig = gdk_gl_config_new_by_mode (glcmode);
if (!_glconfig) {
log_error (_("Cannot find the double-buffered visual.\n"
"Trying single-buffered visual."));
glcmode = (GdkGLConfigMode)(GDK_GL_MODE_RGB | GDK_GL_MODE_DEPTH);
_glconfig = gdk_gl_config_new_by_mode (glcmode);
if (!_glconfig) {
log_error (_("No appropriate OpenGL-capable visual found."));
gtk_main_quit(); // XXX
} else {
log_debug ("Got single-buffered visual.");
}
} else {
log_debug ("Got double-buffered visual.");
}
return true;
}
/**
* gwy_widgets_gl_init:
*
* Configures an OpenGL-capable visual for 3D widgets.
*
* Use gwy_widgets_get_gl_config() to get the framebuffer configuration.
*
* This function must be called before OpenGL widgets can be used.
*
* Returns: %TRUE if an appropriate visual was found. If Gwyddion was compiled
* without OpenGL support, it always returns %FALSE.
**/
gboolean
gwy_widgets_gl_init(void)
{
/* when called twice, fail but successfully :o) */
g_return_val_if_fail(glconfig == NULL, TRUE);
#ifdef HAVE_GTKGLEXT
glconfig = gdk_gl_config_new_by_mode(GDK_GL_MODE_RGB
| GDK_GL_MODE_DEPTH
| GDK_GL_MODE_DOUBLE);
/* Try double-buffered visual */
if (!glconfig) {
g_warning("Cannot find a double-buffered OpenGL visual, "
"Trying single-buffered visual.");
/* Try single-buffered visual */
glconfig = gdk_gl_config_new_by_mode(GDK_GL_MODE_RGB
| GDK_GL_MODE_DEPTH);
if (!glconfig) {
g_warning("No appropriate OpenGL-capable visual found.");
}
}
#endif
return glconfig != NULL;
}
int
main(int argc,
char **argv)
{
/* initialize gtk */
gtk_init(&argc, &argv);
/* initialize gtkglext */
gtk_gl_init(&argc, &argv);
/* Configure OpenGL-capable visual. */
/* Try double-buffered visual */
glconfig = gdk_gl_config_new_by_mode(GDK_GL_MODE_RGB |
GDK_GL_MODE_DEPTH |
GDK_GL_MODE_DOUBLE);
if (glconfig == NULL)
{
g_print("*** Cannot find the double-buffered visual.\n");
g_print("*** Trying single-buffered visual.\n");
/* Try single-buffered visual */
glconfig = gdk_gl_config_new_by_mode(GDK_GL_MODE_RGB |
GDK_GL_MODE_DEPTH);
if (glconfig == NULL)
{
g_print("*** No appropriate OpenGL-capable visual found.\n");
exit(1);
}
}
/* help? */
if (argc >= 2 && strcmp(argv[1],"--help")==0)
{
g_print("%s", help_text);
return 0;
}
if (argc == 1)
{
/* no filenames, show filerequester */
select_lwobject();
}
else
{
/* show requested files */
int i;
for (i=1; i<argc; i++)
show_lwobject(argv[i]);
}
if (window_count > 0)
gtk_main();
return 0;
}
void Interface_iniciar() {
GtkWidget *window;
GdkGLConfig *glconfig;
gtk_init(NULL, NULL);
gtk_gl_init(NULL, NULL);
GtkBuilder *builderPrincipal=Interface_carregarXML(INTERFACE_PRINCIPAL);
window = GTK_WIDGET(gtk_builder_get_object (builderPrincipal, "window"));
drawOpengl=GTK_WIDGET(gtk_builder_get_object(builderPrincipal, "drawOpengl"));
frameProgresso=GTK_WIDGET(gtk_builder_get_object(builderPrincipal, "frameProgresso"));
progress=GTK_PROGRESS_BAR(gtk_builder_get_object(builderPrincipal, "progressbar"));
labelPosicaoXY=GTK_LABEL(gtk_builder_get_object(builderPrincipal, "labelPosicaoXY"));
ajustScrollHorizGL=GTK_ADJUSTMENT(gtk_builder_get_object(builderPrincipal, "ajustScrollHorizGL"));
ajustScrollVertGL=GTK_ADJUSTMENT(gtk_builder_get_object(builderPrincipal, "ajustScrollVertGL"));
adjustAlpha=GTK_ADJUSTMENT(gtk_builder_get_object(builderPrincipal, "adjustAlpha"));
tbAddEntidade=GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(builderPrincipal, "tbAddEntidade"));
tbAddImagem=GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(builderPrincipal, "tbAddImagem"));
tbAddTexto=GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(builderPrincipal, "tbAddTexto"));
tbAmpliar=GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(builderPrincipal, "tbAmpliar"));
tbReduzir=GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(builderPrincipal, "tbReduzir"));
frameFerramentas=GTK_WIDGET(gtk_builder_get_object(builderPrincipal, "frameFerramentas"));
/*gtk_adjustment_set_value(GTK_ADJUSTMENT(gtk_builder_get_object(builderPrincipal, "ajustScrollHorizGL")),500);
gtk_adjustment_set_value(GTK_ADJUSTMENT(gtk_builder_get_object(builderPrincipal, "ajustScrollVertGL")),500);*/
//Configura widget para opengl
glconfig = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGB |
GDK_GL_MODE_DEPTH |
GDK_GL_MODE_DOUBLE);
if (!glconfig) {
g_print ("*** Cannot find the double-buffered visual.\n");
g_print ("*** Trying single-buffered visual.\n");
/* Try single-buffered visual */
glconfig = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGB | GDK_GL_MODE_DEPTH);
if (!glconfig) {
g_print ("*** No appropriate OpenGL-capable visual found.\n");
g_assert_not_reached();
}
}
if (!gtk_widget_set_gl_capability(drawOpengl, glconfig, NULL, TRUE, GDK_GL_RGBA_TYPE))
g_assert_not_reached();
gtk_builder_connect_signals(builderPrincipal, NULL);
gtk_widget_show(window);
g_object_unref(G_OBJECT(builderPrincipal));
}
Render::Render (View *view, Glib::RefPtr<Gtk::TreeSelection> selection) :
m_arcBall(new ArcBall()), m_view (view), m_selection(selection)
{
set_events (Gdk::POINTER_MOTION_MASK |
Gdk::BUTTON_MOTION_MASK |
Gdk::BUTTON_PRESS_MASK |
Gdk::BUTTON_RELEASE_MASK |
Gdk::BUTTON1_MOTION_MASK |
Gdk::BUTTON2_MOTION_MASK |
Gdk::BUTTON3_MOTION_MASK);
GdkGLConfig *glconfig;
// glconfig is leaked at program exit
glconfig = gdk_gl_config_new_by_mode
((GdkGLConfigMode) (GDK_GL_MODE_RGBA |
GDK_GL_MODE_ALPHA |
GDK_GL_MODE_STENCIL |
GDK_GL_MODE_DEPTH |
GDK_GL_MODE_DOUBLE));
if (!glconfig) // try single buffered
glconfig = gdk_gl_config_new_by_mode
((GdkGLConfigMode) (GDK_GL_MODE_RGBA |
GDK_GL_MODE_ALPHA |
GDK_GL_MODE_STENCIL |
GDK_GL_MODE_DEPTH));
if (!gtk_widget_set_gl_capability (get_widget(), glconfig,
NULL, TRUE, GDK_GL_RGBA_TYPE))
g_error (_("failed to init gl area\n"));
memset (&m_transform.M, 0, sizeof (m_transform.M));
Matrix3fT identity;
Matrix3fSetIdentity(&identity);
// set initial rotation 30 degrees around Y axis
identity.s.M11 = identity.s.M22 = 0.5253; // cos -45
identity.s.M12 = 0.851; // -sin -45
identity.s.M21 = -0.851; // sin -45
Matrix4fSetRotationScaleFromMatrix3f(&m_transform, &identity);
m_transform.s.SW = 1.0;
m_zoom = 120.0;
for (uint i = 0; i < N_LIGHTS; i++)
m_lights[i] = NULL;
m_selection->signal_changed().connect (sigc::mem_fun(*this, &Render::selection_changed));
}
int main(int argc, char **argv)
{
gtk_init(&argc, &argv);
GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
GtkWidget *drawing = gtk_drawing_area_new();
GdkGLConfig *glconfig = gdk_gl_config_new_by_mode((GdkGLConfigMode)(
GDK_GL_MODE_RGBA | GDK_GL_MODE_DEPTH |
GDK_GL_MODE_DOUBLE | GDK_GL_MODE_ALPHA));
g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(window, "key-press-event", G_CALLBACK(on_key_press), NULL);
g_signal_connect(drawing, "expose-event", G_CALLBACK(on_expose), NULL);
g_signal_connect(drawing, "configure-event", G_CALLBACK(on_configure), NULL);
gtk_widget_set_gl_capability(drawing, glconfig, NULL, TRUE, GDK_GL_RGBA_TYPE);
gtk_container_add(GTK_CONTAINER(window), drawing);
gtk_widget_show_all(window);
/* OpenGL setup */
GdkGLContext *glcontext = gtk_widget_get_gl_context(GTK_WIDGET(drawing));
GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable(GTK_WIDGET(drawing));
gdk_gl_drawable_gl_begin(gldrawable, glcontext);
/* Go */
gtk_main();
gdk_gl_drawable_gl_end(gldrawable);
}
int window_system_initialise(int argc, char ***argv)
{
gtk_init(&argc, argv);
gtk_gl_init(&argc, argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW (window), DEFAULT_WIN_WIDTH, DEFAULT_WIN_HEIGHT);
drawing_area = gtk_drawing_area_new();
gtk_container_add(GTK_CONTAINER(window), drawing_area);
g_signal_connect_swapped(window, "destroy",
G_CALLBACK (gtk_main_quit), NULL);
gtk_widget_set_events(drawing_area, GDK_EXPOSURE_MASK);
gl_config = gdk_gl_config_new_by_mode(GDK_GL_MODE_RGB |
GDK_GL_MODE_DEPTH |
GDK_GL_MODE_DOUBLE);
if (!gl_config) {
printf("Messed up the config :(\n");
exit(1);
}
if (!gtk_widget_set_gl_capability(drawing_area, gl_config, NULL, TRUE,
GDK_GL_RGBA_TYPE)) {
printf("Couldn't get capabilities we needed :(\n");
exit(1);
}
return 0;
}
native_handle _chisel_native_openglview_create( ) {
static int glsetup = 0;
if ( !glsetup ) {
gtk_gl_init_check( NULL, NULL );
glsetup = 1;
}
GtkWidget *widget = gtk_drawing_area_new( );
gtk_widget_set_size_request (widget, 120, 120);
_chisel_gtk_setup_events( widget );
//g_signal_connect( G_OBJECT(widget), "size_allocate", G_CALLBACK(_chisel_native_openglview_resize_event), NULL );
//g_signal_connect_after( G_OBJECT(widget), "configure-event", G_CALLBACK(_chisel_native_openglview_configure_event), NULL );
//
gtk_widget_set_events( widget, GDK_EXPOSURE_MASK );
GdkGLConfigMode glcmode = (GdkGLConfigMode)(GDK_GL_MODE_RGB
| GDK_GL_MODE_DEPTH
| GDK_GL_MODE_DOUBLE);
GdkGLConfig *glconfig = gdk_gl_config_new_by_mode( glcmode );
assert( glconfig != NULL );
assert( gtk_widget_set_gl_capability( widget, glconfig, NULL, TRUE, GDK_GL_RGBA_TYPE ) );
g_signal_connect( G_OBJECT(widget), "expose-event", G_CALLBACK(_chisel_native_openglview_expose_event), NULL );
return widget;
}
int main (int argc, char* argv[])
{
GtkWidget* window;
GtkWidget* drawarea;
GdkGLConfig* glconfig;
gtk_init (&argc, &argv);
gdk_gl_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
drawarea = gtk_drawing_area_new ();
gtk_widget_set_size_request (drawarea, 400, 300);
gtk_container_add (GTK_CONTAINER (window), drawarea);
g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), NULL);
gtk_widget_set_events (drawarea, GDK_EXPOSURE_MASK);
glconfig = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGB | GDK_GL_MODE_DEPTH | GDK_GL_MODE_DOUBLE);
gtk_widget_set_gl_capability (drawarea, glconfig, NULL, TRUE, GDK_GL_RGBA_TYPE);
gtk_signal_connect (GTK_OBJECT (drawarea), "expose-event", G_CALLBACK (display), NULL);
gtk_signal_connect (GTK_OBJECT (drawarea), "configure-event", G_CALLBACK (reshape), NULL);
g_idle_add (idle, drawarea);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
int
main (int argc,
char *argv[])
{
unicap_handle_t handle;
unicap_format_t format;
/* Initialize */
gtk_init (&argc, &argv);
g_thread_init(NULL);
gdk_threads_init ();
gtk_gl_init (&argc, &argv);
init_extensions ();
init_gl_resources ();
handle = open_device();
set_format( handle );
unicap_get_format( handle, &format );
if( ( format.size.width != 640 ) ||
( format.size.height != 480 ) )
{
g_warning( "The default .cg file assumes a video format of 640x480 pixels. \nYou need to change the yuv.cg file to match your size.\n" );
}
prepare_yuv_buffer(&yuvbuffer, &format);
unicap_register_callback( handle, UNICAP_EVENT_NEW_FRAME, (unicap_callback_t)new_frame_cb, NULL );
unicap_start_capture( handle );
/* Gtk window & container */
GtkWindow *window = GTK_WINDOW (gtk_window_new (GTK_WINDOW_TOPLEVEL));
glarea = gtk_drawing_area_new ();
gtk_widget_set_size_request (GTK_WIDGET (glarea), WINDOW_WIDTH, WINDOW_HEIGHT);
g_signal_connect (glarea, "expose-event", G_CALLBACK (on_expose), NULL);
g_signal_connect (glarea, "configure-event", G_CALLBACK (on_configure), NULL);
g_signal_connect (glarea, "map-event", G_CALLBACK (on_mapped), NULL);
g_signal_connect (window, "delete-event", G_CALLBACK (gtk_main_quit), NULL);
GdkGLConfig *gl_config;
gl_config = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGBA | GDK_GL_MODE_DOUBLE);
if (gl_config == NULL)
g_critical ("Failed to setup a double-buffered RGB visual");
if (! gtk_widget_set_gl_capability (GTK_WIDGET (glarea),
gl_config,
NULL,
TRUE,
GDK_GL_RGBA_TYPE))
g_critical ("Failed to add gl capability");
gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (glarea));
gtk_widget_show_all (GTK_WIDGET (window));
/* Main loop */
gtk_main ();
return 0;
}
OSRWindow::OSRWindow(OSRBrowserProvider* browser_provider,
bool transparent,
ClientWindowHandle parentView)
: renderer_(transparent),
browser_provider_(browser_provider),
gl_enabled_(false),
painting_popup_(false),
render_task_pending_(false) {
glarea_ = gtk_drawing_area_new();
DCHECK(glarea_);
GdkGLConfig* glconfig = gdk_gl_config_new_by_mode(
static_cast<GdkGLConfigMode>(GDK_GL_MODE_RGB |
GDK_GL_MODE_DEPTH |
GDK_GL_MODE_DOUBLE));
DCHECK(glconfig);
gtk_widget_set_gl_capability(glarea_, glconfig, NULL, TRUE,
GDK_GL_RGBA_TYPE);
gtk_widget_set_can_focus(glarea_, TRUE);
g_signal_connect(G_OBJECT(glarea_), "size_allocate",
G_CALLBACK(glarea_size_allocation), this);
gtk_widget_set_events(glarea_,
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
GDK_KEY_PRESS_MASK |
GDK_KEY_RELEASE_MASK |
GDK_ENTER_NOTIFY_MASK |
GDK_LEAVE_NOTIFY_MASK |
GDK_POINTER_MOTION_MASK |
GDK_POINTER_MOTION_HINT_MASK |
GDK_SCROLL_MASK |
GDK_FOCUS_CHANGE_MASK);
g_signal_connect(G_OBJECT(glarea_), "button_press_event",
G_CALLBACK(glarea_click_event), this);
g_signal_connect(G_OBJECT(glarea_), "button_release_event",
G_CALLBACK(glarea_click_event), this);
g_signal_connect(G_OBJECT(glarea_), "key_press_event",
G_CALLBACK(glarea_key_event), this);
g_signal_connect(G_OBJECT(glarea_), "key_release_event",
G_CALLBACK(glarea_key_event), this);
g_signal_connect(G_OBJECT(glarea_), "enter_notify_event",
G_CALLBACK(glarea_move_event), this);
g_signal_connect(G_OBJECT(glarea_), "leave_notify_event",
G_CALLBACK(glarea_move_event), this);
g_signal_connect(G_OBJECT(glarea_), "motion_notify_event",
G_CALLBACK(glarea_move_event), this);
g_signal_connect(G_OBJECT(glarea_), "scroll_event",
G_CALLBACK(glarea_scroll_event), this);
g_signal_connect(G_OBJECT(glarea_), "focus_in_event",
G_CALLBACK(glarea_focus_event), this);
g_signal_connect(G_OBJECT(glarea_), "focus_out_event",
G_CALLBACK(glarea_focus_event), this);
gtk_container_add(GTK_CONTAINER(parentView), glarea_);
}
static int lglext_config_new_by_mode(lua_State* L)
{
luaL_checktype(L, 1, LUA_TNUMBER);
GdkGLConfig* ptr = gdk_gl_config_new_by_mode(lua_tointeger(L, 1));
object_new(L, ptr, TRUE);
return 1;
}
static void
darxen_splash_gl_init()
{
glSettings->glConfig = gdk_gl_config_new_by_mode(( GDK_GL_MODE_RGB |
GDK_GL_MODE_DEPTH |
GDK_GL_MODE_DOUBLE |
GDK_GL_MODE_STENCIL));
if (!glSettings->glConfig)
g_error("Error creating OpenGL configuration");
}
bool
GtkGlExtGlue::init(int argc, char** argv[])
{
// GNASH_REPORT_FUNCTION;
#ifdef FIX_I810_LOD_BIAS
int c = getopt (argc, *argv, "m:");
if (c == 'm') {
_tex_lod_bias = (float) strtof(optarg, NULL);
}
#endif
gtk_gl_init (&argc, argv);
gint major, minor;
gdk_gl_query_version (&major, &minor);
log_debug (_("OpenGL extension version - %d.%d"),
(int)major, (int)minor);
GdkGLConfigMode glcmode = (GdkGLConfigMode)(GDK_GL_MODE_RGB |
GDK_GL_MODE_STENCIL |
GDK_GL_MODE_DOUBLE |
GDK_GL_MODE_ACCUM);
_glconfig = gdk_gl_config_new_by_mode (glcmode);
if (!_glconfig) {
log_error (_("Cannot find the double-buffered visual.\n"
"Trying single-buffered visual."));
glcmode = (GdkGLConfigMode)(GDK_GL_MODE_RGB | GDK_GL_MODE_DEPTH);
_glconfig = gdk_gl_config_new_by_mode (glcmode);
if (!_glconfig) {
log_error (_("No appropriate OpenGL-capable visual found."));
gtk_main_quit(); // XXX
} else {
log_debug (_("Got single-buffered visual."));
}
} else {
log_debug (_("Got double-buffered visual."));
}
return true;
}
bool OSGGTKDrawingArea::createWidget(int width, int height) {
_glconfig = gdk_gl_config_new_by_mode(static_cast<GdkGLConfigMode>(
GDK_GL_MODE_RGBA |
GDK_GL_MODE_DEPTH |
GDK_GL_MODE_DOUBLE
));
if(not _glconfig) {
osg::notify(osg::FATAL) << "Fail!" << std::endl;
return false;
}
gtk_widget_set_size_request(_widget, width, height);
gtk_widget_set_gl_capability(
_widget,
_glconfig,
0,
true,
GDK_GL_RGBA_TYPE
);
gtk_widget_add_events(
_widget,
GDK_BUTTON1_MOTION_MASK |
GDK_BUTTON2_MOTION_MASK |
GDK_BUTTON3_MOTION_MASK |
GDK_POINTER_MOTION_MASK |
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
GDK_KEY_PRESS_MASK |
GDK_KEY_RELEASE_MASK |
GDK_VISIBILITY_NOTIFY_MASK
);
// We do this so that we don't have to suck up ALL the input to the
// window, but instead just when the drawing area is focused.
g_object_set(_widget, "can-focus", true, NULL);
_connect("realize", G_CALLBACK(&OSGGTKDrawingArea::_srealize));
_connect("unrealize", G_CALLBACK(&OSGGTKDrawingArea::_sunrealize));
_connect("expose_event", G_CALLBACK(&OSGGTKDrawingArea::_sexpose_event));
_connect("configure_event", G_CALLBACK(&OSGGTKDrawingArea::_sconfigure_event));
_connect("motion_notify_event", G_CALLBACK(&OSGGTKDrawingArea::_smotion_notify_event));
_connect("button_press_event", G_CALLBACK(&OSGGTKDrawingArea::_sbutton_press_event));
_connect("button_release_event", G_CALLBACK(&OSGGTKDrawingArea::_sbutton_press_event));
_connect("key_press_event", G_CALLBACK(&OSGGTKDrawingArea::_skey_press_event));
_gw = setUpViewerAsEmbeddedInWindow(0, 0, width, height);
return true;
}
int
init_opengl_gdk_3Demu( GdkDrawable * drawable) {
GdkGLConfig *glconfig;
/* create the off screen pixmap */
target_pixmap = gdk_pixmap_new ( drawable, 256, 192, -1);
if ( target_pixmap == NULL) {
g_print ("*** Failed to create pixmap.\n");
return 0;
}
glconfig = gdk_gl_config_new_by_mode ((GdkGLConfigMode)(GDK_GL_MODE_RGBA |
GDK_GL_MODE_DEPTH |
GDK_GL_MODE_STENCIL |
GDK_GL_MODE_SINGLE));
if (glconfig == NULL)
{
g_print ("*** No appropriate OpenGL-capable visual found.\n");
return 0;
}
/*
* Set OpenGL-capability to the pixmap
*/
gldrawable = GDK_GL_DRAWABLE (gdk_pixmap_set_gl_capability (target_pixmap,
glconfig,
NULL));
if ( gldrawable == NULL) {
g_print ("Failed to create the GdkGLPixmap\n");
return 0;
}
glcontext = gdk_gl_context_new (gldrawable,
NULL,
FALSE,
GDK_GL_RGBA_TYPE);
if (glcontext == NULL)
{
g_print ("Connot create the OpenGL rendering context\n");
return 0;
}
oglrender_init = _oglrender_init;
oglrender_beginOpenGL = _oglrender_beginOpenGL;
oglrender_endOpenGL = _oglrender_endOpenGL;
return 1;
}
GdkGLConfig *GLBase::MakeStandardConfig()
{
#ifdef _WINDOWS
HDC hDC = GetDC(NULL);
GdkGLConfig *ret = gdk_win32_gl_config_new_from_pixel_format(EnumPixelFormats(hDC));
DeleteDC(hDC);
return ret;
#else
GdkGLConfig *ret = gdk_gl_config_new_by_mode((GdkGLConfigMode)(GDK_GL_MODE_RGBA | GDK_GL_MODE_DOUBLE | GDK_GL_MODE_DEPTH | GDK_GL_MODE_STENCIL));
if (ret == NULL)
{
ret = gdk_gl_config_new_by_mode((GdkGLConfigMode)(GDK_GL_MODE_RGBA | GDK_GL_MODE_SINGLE | GDK_GL_MODE_DEPTH | GDK_GL_MODE_STENCIL));
if (ret == NULL)
{
printf("Cannot generate a suitable OpenGL Context Configuration, exiting.....");
exit(-1);
}
}
return ret;
#endif
}
int
main (int argc, char **argv)
{
RunAllTests();
GtkWidget *window;
GtkWidget *da;
GdkGLConfig *glconfig;
gtk_init (&argc, &argv);
gtk_gl_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (window), 800, 600);
da = gtk_drawing_area_new ();
gtk_container_add (GTK_CONTAINER (window), da);
g_signal_connect_swapped (window, "destroy",
G_CALLBACK (gtk_main_quit), NULL);
gtk_widget_set_events (da, GDK_EXPOSURE_MASK);
gtk_widget_show (window);
/* prepare GL */
glconfig = gdk_gl_config_new_by_mode ((GdkGLConfigMode)
(GDK_GL_MODE_RGB |
GDK_GL_MODE_DEPTH |
GDK_GL_MODE_DOUBLE));
if (!glconfig)
{
g_assert_not_reached ();
}
if (!gtk_widget_set_gl_capability (da, glconfig, NULL, TRUE,
GDK_GL_RGBA_TYPE))
{
g_assert_not_reached ();
}
g_signal_connect (da, "configure-event",
G_CALLBACK (configure), NULL);
g_signal_connect (da, "expose-event",
G_CALLBACK (expose), NULL);
gtk_widget_show_all (window);
g_timeout_add (1000 / 30, rotate, da);
t3dInit();
gtk_main ();
}
RenderArea::RenderArea(RenderAreaPtr theContext) : AbstractRenderWindow(jslib::JSApp::ShellErrorReporter),
_myContextRefCount(0),
_isFirstFrame(true)
{
GdkGLConfig * myGLConfig = gdk_gl_config_new_by_mode(
GdkGLConfigMode(GDK_GL_MODE_RGBA | GDK_GL_MODE_DEPTH | GDK_GL_MODE_DOUBLE | GDK_GL_MODE_ALPHA));
if (myGLConfig == 0) {
throw asl::Exception("can't init GL",PLUS_FILE_LINE);
}
// If another render area is supplied as constructor paramter, this render area is uses as
// source for a shared y60-gl-context and gdk-gl-context.
GdkGLContext * myGdkGLContext = 0;
if (theContext) {
myGdkGLContext = theContext->getGdkGlContext();
if (!myGdkGLContext) {
throw asl::Exception("RenderArea: Failed to get gdk GL context from shared render area.", PLUS_FILE_LINE);
}
setGLContext(theContext->getGLContext());
} else {
setGLContext(GLContextPtr(new GLContext()));
}
/* Set OpenGL-capability to the widget. */
DB(cerr << "RenderArea::RenderArea() sharing with " << myGdkGLContext << endl);
if (!gtk_widget_set_gl_capability (GTK_WIDGET(gobj()),
myGLConfig,
myGdkGLContext,
true,
GDK_GL_RGBA_TYPE))
{
throw asl::Exception("RenderArea: could not create GL context!", PLUS_FILE_LINE);
}
// enable mouse events
Gdk::EventMask flags = get_events();
flags |= Gdk::BUTTON_PRESS_MASK;
flags |= Gdk::POINTER_MOTION_MASK;
flags |= Gdk::BUTTON_RELEASE_MASK;
flags |= Gdk::SCROLL_MASK;
flags |= Gdk::ENTER_NOTIFY_MASK;
flags |= Gdk::LEAVE_NOTIFY_MASK;
set_events(flags);
y60::EventDispatcher::get().addSource(&_myEventAdapter);
y60::EventDispatcher::get().addSink(this);
// TODO: createRenderer(theOtherRenderer);
ShaderLibrary::setGLisReadyFlag(true);
}
GdkGLConfig* glconfig_new(){
GdkGLConfig* glconfig = NULL;
for ( configs_iterator i = configs, end = configs + 2; i != end && glconfig == NULL; ++i )
{
glconfig = gdk_gl_config_new( *i );
}
if ( glconfig == NULL ) {
return gdk_gl_config_new_by_mode( (GdkGLConfigMode)( GDK_GL_MODE_RGBA | GDK_GL_MODE_DOUBLE ) );
}
return glconfig;
}
GdkGLConfig *
pinte_create_gl_config ()
{
GdkGLConfig *glconfig;
glconfig = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGB |
GDK_GL_MODE_DEPTH /*|
GDK_GL_MODE_DOUBLE*/);
if (glconfig == NULL)
g_error ("Não foi possível criar configurações do OpenGL.\n");
return glconfig;
}
GdkGLConfig* glconfig_new(){
GdkGLConfig* glconfig = 0;
for ( configs_iterator i = configs, end = configs + 2; i != end; ++i )
{
glconfig = gdk_gl_config_new( ( *i ).attribs );
if ( glconfig != 0 ) {
globalOutputStream() << "OpenGL window configuration: " << ( *i ).name << "\n";
return glconfig;
}
}
globalOutputStream() << "OpenGL window configuration: colour-buffer = auto, depth-buffer = none\n";
return gdk_gl_config_new_by_mode( (GdkGLConfigMode)( GDK_GL_MODE_RGBA | GDK_GL_MODE_DOUBLE ) );
}
GdkGLConfig* GLWidget::createGLConfigWithDepth() {
for (configs_iterator i = configs_with_depth, end = configs_with_depth + 6; i
!= end; ++i) {
GdkGLConfig* glconfig = gdk_gl_config_new(i->attribs);
if (glconfig != NULL) {
globalOutputStream() << "OpenGL window configuration: " << i->name
<< "\n";
return glconfig;
}
}
globalOutputStream()
<< "OpenGL window configuration: colour-buffer = auto, depth-buffer = auto (fallback)\n";
return gdk_gl_config_new_by_mode((GdkGLConfigMode) (GDK_GL_MODE_RGBA
| GDK_GL_MODE_DOUBLE | GDK_GL_MODE_DEPTH));
}
int
main (int argc, char *argv[])
{
set_log_handlers();
wf_debug = 1;
gtk_init(&argc, &argv);
GdkGLConfig* glconfig;
if(!(glconfig = gdk_gl_config_new_by_mode(GDK_GL_MODE_RGBA | GDK_GL_MODE_DEPTH | GDK_GL_MODE_DOUBLE))){
gerr ("Cannot initialise gtkglext."); return EXIT_FAILURE;
}
GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
canvas = gtk_drawing_area_new();
gtk_widget_set_can_focus (canvas, true);
gtk_widget_set_size_request (canvas, GL_WIDTH + 2 * HBORDER, 128);
gtk_widget_set_gl_capability (canvas, glconfig, NULL, 1, GDK_GL_RGBA_TYPE);
gtk_widget_add_events (canvas, GDK_POINTER_MOTION_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
gtk_container_add((GtkContainer*)window, (GtkWidget*)canvas);
agl = agl_get_instance();
scene = (AGlRootActor*)agl_actor__new_root(canvas);
wfc = wf_canvas_new((AGlRootActor*)scene);
char* filename = find_wav(WAV);
w1 = waveform_load_new(filename);
g_free(filename);
g_signal_connect((gpointer)canvas, "realize", G_CALLBACK(on_canvas_realise), NULL);
g_signal_connect((gpointer)canvas, "size-allocate", G_CALLBACK(on_allocate), NULL);
g_signal_connect((gpointer)canvas, "expose-event", G_CALLBACK(agl_actor__on_expose), scene);
gtk_widget_show_all(window);
add_key_handlers((GtkWindow*)window, NULL, (Key*)&keys);
gboolean window_on_delete(GtkWidget* widget, GdkEvent* event, gpointer user_data){
gtk_main_quit();
return false;
}
static void grits_tester_init(GritsTester *tester)
{
g_debug("GritsTester: init");
tester->objects = NULL;
/* Set OpenGL before "realize" */
GdkGLConfig *glconfig = gdk_gl_config_new_by_mode(
GDK_GL_MODE_RGBA | GDK_GL_MODE_DEPTH |
GDK_GL_MODE_DOUBLE | GDK_GL_MODE_ALPHA);
if (!glconfig)
g_error("Failed to create glconfig");
if (!gtk_widget_set_gl_capability(GTK_WIDGET(tester),
glconfig, NULL, TRUE, GDK_GL_RGBA_TYPE))
g_error("GL lacks required capabilities");
g_object_unref(glconfig);
/* Finish OpenGL init after it's realized */
g_signal_connect(tester, "realize", G_CALLBACK(on_realize), NULL);
}
static gboolean
__init ()
{
dbg(2, "...");
if(!gl_context){
gtk_gl_init(NULL, NULL);
if(wf_debug){
gint major, minor;
gdk_gl_query_version (&major, &minor);
g_print ("GtkGLExt version %d.%d\n", major, minor);
}
}
glconfig = gdk_gl_config_new_by_mode( GDK_GL_MODE_RGBA | GDK_GL_MODE_DEPTH | GDK_GL_MODE_DOUBLE );
if (!glconfig) { gerr ("Cannot initialise gtkglext."); return false; }
return true;
}
/// Returns a "global" (to the document) gdkgl context that can be used to share display lists
GdkGLContext* gdkgl_share_list()
{
if(!m_gdkgl_share_list)
{
GdkGLConfig* const config = gdk_gl_config_new_by_mode(
static_cast<GdkGLConfigMode>(GDK_GL_MODE_RGBA | GDK_GL_MODE_DOUBLE | GDK_GL_MODE_DEPTH));
return_val_if_fail(config, 0);
Gtk::Window* const window = new Gtk::Window();
gtk_widget_set_gl_capability(GTK_WIDGET(window->gobj()), config, 0, true, GDK_GL_RGBA_TYPE);
window->show();
window->hide();
GdkGLContext* const context = gtk_widget_get_gl_context(GTK_WIDGET(window->gobj()));
return_val_if_fail(context, 0);
m_gdkgl_share_list = context;
}
return m_gdkgl_share_list;
}
/// Returns a "global" (to the document) gdkgl context that can be used to share display lists
GdkGLContext* gdkgl_share_list()
{
if(!m_gdkgl_share_list)
{
GdkGLConfig* const config = gdk_gl_config_new_by_mode(
static_cast<GdkGLConfigMode>(GDK_GL_MODE_RGBA | GDK_GL_MODE_DOUBLE | GDK_GL_MODE_DEPTH));
return_val_if_fail(config, 0);
GdkPixmap* const pixmap = gdk_pixmap_new(0, 8, 8, gdk_gl_config_get_depth(config));
return_val_if_fail(pixmap, 0);
GdkGLPixmap* const glpixmap = gdk_pixmap_set_gl_capability(pixmap, config, 0);
return_val_if_fail(glpixmap, 0);
GdkGLContext* const context = gdk_gl_context_new(
gdk_pixmap_get_gl_drawable(pixmap), 0, true, GDK_GL_RGBA_TYPE);
return_val_if_fail(context, 0);
m_gdkgl_share_list = context;
}
return m_gdkgl_share_list;
}
