main.c

   1 /*******************************************************************************
   2 **3456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789
   3 **      10        20        30        40        50        60        70        80
   4 **
   5 ** program:
   6 **    gl-cairo-cube
   7 **
   8 ** author:
   9 **    Mirco "MacSlow" Mueller <macslow@bangang.de>
  10 **
  11 ** copyright (C) Mirco Mueller, July 2006
  12 **
  13 ** notes:
  14 **    Simple example demonstrating how one could use cairo for generating
  15 **    dynamic texture-mapping with OpenGL. Intended to be run on a composited
  16 **    desktop (e.g. compiz, xcompmgr) with proper a OpenGL-implementation. I put
  17 **    this program under the terms of the "GNU General Public License". If you
  18 **    don't know what that means take a look a here...
  19 **
  20 **        http://www.gnu.org/licenses/licenses.html#GPL
  21 **
  22 *******************************************************************************/
  23
  24 #include <gtk/gtk.h>
  25 #include <gtk/gtkgl.h>
  26 #include <GL/glut.h>
  27
  28 #include "geometry.h"
  29 #include "events.h"
  30 #include "cairo-rendering.h"
  31
  32 GTimer*         g_pTimerId = NULL;
  33 gint            g_iWidth = 1;
  34 gint            g_iHeight = 1;
  35 cairo_t*        g_pCairoContext[3];
  36 guchar*         g_pucSurfaceData[3];
  37 gulong          g_ulMilliSeconds = 0L;
  38 Line            g_lineOne;
  39 Line            g_lineTwo;
  40
  41 int main (int argc, char** argv)
  42 {
  43         GtkWidget* pWindow = NULL;
  44         GdkGLConfig* pGlConfig = NULL;
  45         GtkWidget* pDrawingArea = NULL;
  46         guint uiDrawHandlerId = 0;
  47         cairo_surface_t* pCairoSurface[2];
  48
  49         g_lineOne.start.fX = 0.1f;
  50         g_lineOne.start.fY = 0.2f;
  51         g_lineOne.start.bGrowX = TRUE;
  52         g_lineOne.start.bGrowY = TRUE;
  53         g_lineOne.start.fStepX = 0.025f;
  54         g_lineOne.start.fStepY = 0.02f;
  55         g_lineOne.start.fLowerLimitX = 0.1f;
  56         g_lineOne.start.fUpperLimitX = 0.9f;
  57         g_lineOne.start.fLowerLimitY = 0.1f;
  58         g_lineOne.start.fUpperLimitY = 0.9f;
  59
  60         g_lineOne.end.fX = 0.5f;
  61         g_lineOne.end.fY = 0.7f;
  62         g_lineOne.end.bGrowX = TRUE;
  63         g_lineOne.end.bGrowY = FALSE;
  64         g_lineOne.end.fStepX = 0.025f;
  65         g_lineOne.end.fStepY = 0.01f;
  66         g_lineOne.end.fLowerLimitX = 0.1f;
  67         g_lineOne.end.fUpperLimitX = 0.9f;
  68         g_lineOne.end.fLowerLimitY = 0.1f;
  69         g_lineOne.end.fUpperLimitY = 0.9f;
  70
  71         g_lineTwo.start.fX = 0.75f;
  72         g_lineTwo.start.fY = 0.1f;
  73         g_lineTwo.start.bGrowX = FALSE;
  74         g_lineTwo.start.bGrowY = TRUE;
  75         g_lineTwo.start.fStepX = 0.01f;
  76         g_lineTwo.start.fStepY = 0.025f;
  77         g_lineTwo.start.fLowerLimitX = 0.1f;
  78         g_lineTwo.start.fUpperLimitX = 0.9f;
  79         g_lineTwo.start.fLowerLimitY = 0.1f;
  80         g_lineTwo.start.fUpperLimitY = 0.9f;
  81
  82         g_lineTwo.end.fX = 0.8f;
  83         g_lineTwo.end.fY = 0.8f;
  84         g_lineTwo.end.bGrowX = FALSE;
  85         g_lineTwo.end.bGrowY = FALSE;
  86         g_lineTwo.end.fStepX = 0.01f;
  87         g_lineTwo.end.fStepY = 0.01f;
  88         g_lineTwo.end.fLowerLimitX = 0.1f;
  89         g_lineTwo.end.fUpperLimitX = 0.9f;
  90         g_lineTwo.end.fLowerLimitY = 0.1f;
  91         g_lineTwo.end.fUpperLimitY = 0.9f;
  92
  93         /* init gtk+, GL and glut */
  94         gtk_init (&argc,&argv);
  95         gtk_gl_init (&argc,&argv);
  96         glutInit (&argc, argv);
  97
  98         /* setup GL-context */
  99         pGlConfig = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGB  |
 100                                                                                          GDK_GL_MODE_ALPHA      |
 101                                                                                          GDK_GL_MODE_DEPTH      |
 102                                                                                          GDK_GL_MODE_DOUBLE);
 103
 104         if (!pGlConfig)
 105         {
 106                 g_print ("Could not setup GL-context!\n");
 107                 return 1;
 108         }
 109
 110         /* create window and hook up event-handlers */
 111         pWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 112         if (!pWindow)
 113         {
 114                 g_print ("Could not create gtk+-window!\n");
 115                 return 2;
 116         }
 117
 118         gtk_widget_add_events (pWindow,
 119                                                    GDK_POINTER_MOTION_MASK |
 120                                                    GDK_BUTTON_PRESS_MASK |
 121                                                    GDK_BUTTON_RELEASE_MASK);
 122
 123         g_signal_connect (G_OBJECT (pWindow),
 124                                           "delete-event",
 125                                           G_CALLBACK (delete_handler),
 126                                           NULL);
 127         g_signal_connect (G_OBJECT (pWindow),
 128                                           "button-press-event",
 129                                           G_CALLBACK (button_handler),
 130                                           NULL);
 131         g_signal_connect (G_OBJECT (pWindow),
 132                                           "button-release-event",
 133                                           G_CALLBACK (button_handler),
 134                                           NULL);
 135         g_signal_connect (G_OBJECT (pWindow),
 136                                           "screen-changed",
 137                                           G_CALLBACK (screen_changed_handler),
 138                                           NULL);
 139         g_signal_connect (G_OBJECT (pWindow),
 140                                           "scroll-event",
 141                                           G_CALLBACK (scroll_handler),
 142                                           NULL);
 143         g_signal_connect (G_OBJECT (pWindow),
 144                                           "key-press-event",
 145                                           G_CALLBACK (key_press_handler),
 146                                           NULL);
 147
 148         pDrawingArea = gtk_drawing_area_new ();
 149         if (!pDrawingArea)
 150         {
 151                 g_print ("Could not create drawing-area!\n");
 152                 return 3;
 153         }
 154
 155         g_iWidth = 512;
 156         g_iHeight = 512;
 157         gtk_widget_set_size_request (pDrawingArea, g_iWidth, g_iHeight);
 158         gtk_widget_set_gl_capability (pDrawingArea,
 159                                                                   pGlConfig,
 160                                                                   NULL,
 161                                                                   TRUE,
 162                                                                   GDK_GL_RGBA_TYPE);
 163
 164         g_signal_connect_after (G_OBJECT (pDrawingArea),
 165                                                         "realize",
 166                                                         G_CALLBACK (realize_handler),
 167                                                         NULL);
 168         g_signal_connect (G_OBJECT (pDrawingArea),
 169                                           "configure-event",
 170                                           G_CALLBACK (configure_handler),
 171                                           NULL);
 172         g_signal_connect (G_OBJECT (pDrawingArea),
 173                                           "expose-event",
 174                                           G_CALLBACK (expose_handler),
 175                                           NULL);
 176         g_signal_connect (G_OBJECT (pWindow),
 177                                           "motion-notify-event",
 178                                           G_CALLBACK (motion_notify_handler),
 179                                           (gpointer) pDrawingArea);
 180
 181         gtk_container_add (GTK_CONTAINER (pWindow), pDrawingArea);
 182         gtk_widget_show (pDrawingArea);
 183         gtk_window_set_resizable (GTK_WINDOW (pWindow), FALSE);
 184         gtk_widget_set_app_paintable (pWindow, TRUE);
 185         gtk_window_set_decorated (GTK_WINDOW (pWindow), FALSE);
 186         screen_changed_handler (pWindow, NULL, NULL);
 187         gtk_widget_show (pWindow);
 188
 189         /* create cairo-surface/context to act as OpenGL-texture */
 190         g_pucSurfaceData[0] = g_malloc0 (4 * g_iWidth * g_iHeight);
 191         g_pucSurfaceData[1] = g_malloc0 (4 * g_iWidth * g_iHeight);
 192         g_pucSurfaceData[2] = g_malloc0 (4 * g_iWidth * g_iHeight);
 193         if (g_pucSurfaceData[0] && g_pucSurfaceData[1] && g_pucSurfaceData[2])
 194         {
 195                 pCairoSurface[0] = cairo_image_surface_create_for_data (g_pucSurfaceData[0],
 196                                                                                                                                 CAIRO_FORMAT_ARGB32,
 197                                                                                                                                 g_iWidth,
 198                                                                                                                                 g_iHeight,
 199                                                                                                                                 4 * g_iWidth);
 200                 pCairoSurface[1] = cairo_image_surface_create_for_data (g_pucSurfaceData[1],
 201                                                                                                                                 CAIRO_FORMAT_ARGB32,
 202                                                                                                                                 g_iWidth,
 203                                                                                                                                 g_iHeight,
 204                                                                                                                                 4 * g_iWidth);
 205                 pCairoSurface[2] = cairo_image_surface_create_for_data (g_pucSurfaceData[2],
 206                                                                                                                                 CAIRO_FORMAT_ARGB32,
 207                                                                                                                                 g_iWidth,
 208                                                                                                                                 g_iHeight,
 209                                                                                                                                 4 * g_iWidth);
 210
 211                 g_pCairoContext[0] = cairo_create (pCairoSurface[0]);
 212                 g_pCairoContext[1] = cairo_create (pCairoSurface[1]);
 213                 g_pCairoContext[2] = cairo_create (pCairoSurface[2]);
 214         }
 215
 216         /* force a refresh-rate of 20 Hz */
 217         uiDrawHandlerId = g_timeout_add (50,
 218                                                                          (GSourceFunc) draw_handler,
 219                                                                          pDrawingArea);
 220
 221         /* register timer used by fps-counter */
 222         g_pTimerId = g_timer_new ();
 223
 224         /* enter event-loop */
 225         gtk_main ();
 226
 227         /* clear resources before exit */
 228         if (g_pucSurfaceData[0])
 229                 g_free (g_pucSurfaceData[0]);
 230         if (g_pucSurfaceData[1])
 231                 g_free (g_pucSurfaceData[1]);
 232         if (g_pucSurfaceData[2])
 233                 g_free (g_pucSurfaceData[2]);
 234
 235         return 0;
 236 }