File: gears_8cc-example.html

package info (click to toggle)
gtkglextmm 1.0.1-2
links: PTS
area: main
in suites: sarge
size: 4,556 kB
ctags: 1,882
sloc: sh: 8,380; cpp: 4,443; xml: 1,605; ansic: 832; makefile: 407; perl: 179
file content (745 lines) | stat: -rw-r--r-- 32,458 bytes
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1">
<title>gtkglextmm: Example Documentation</title>
<link href="doxygen.css" rel="stylesheet" type="text/css">
</head><body>
<!-- Generated by Doxygen 1.3.4 -->
<div class="qindex"><a class="qindex" href="index.html">Main&nbsp;Page</a> | <a class="qindex" href="modules.html">Modules</a> | <a class="qindex" href="namespaces.html">Namespace List</a> | <a class="qindex" href="hierarchy.html">Class&nbsp;Hierarchy</a> | <a class="qindex" href="classes.html">Alphabetical&nbsp;List</a> | <a class="qindex" href="annotated.html">Class&nbsp;List</a> | <a class="qindex" href="files.html">File&nbsp;List</a> | <a class="qindex" href="namespacemembers.html">Namespace&nbsp;Members</a> | <a class="qindex" href="functions.html">Class&nbsp;Members</a> | <a class="qindex" href="globals.html">File&nbsp;Members</a> | <a class="qindex" href="examples.html">Examples</a></div>
<h1>gears.cc</h1>3-D gear wheels demo. <div class="fragment"><pre><span class="comment">// -*- C++ -*-</span>
<span class="comment">/*</span>
<span class="comment"> * 3-D gear wheels.  This program is in the public domain.</span>
<span class="comment"> *</span>
<span class="comment"> * Brian Paul</span>
<span class="comment"> */</span>

<span class="comment">/* Conversion to gtkglextmm by Naofumi Yasufuku */</span>

<span class="preprocessor">#include &lt;iostream&gt;</span>
<span class="preprocessor">#include &lt;cstdlib&gt;</span>
<span class="preprocessor">#include &lt;cmath&gt;</span>

<span class="preprocessor">#include &lt;gtkmm.h&gt;</span>

<span class="preprocessor">#include &lt;<a class="code" href="gtkglmm_8h.html">gtkglmm.h</a>&gt;</span>

<span class="preprocessor">#ifdef G_OS_WIN32</span>
<span class="preprocessor"></span><span class="preprocessor">#define WIN32_LEAN_AND_MEAN 1</span>
<span class="preprocessor"></span><span class="preprocessor">#include &lt;windows.h&gt;</span>
<span class="preprocessor">#endif</span>
<span class="preprocessor"></span>
<span class="preprocessor">#include &lt;GL/gl.h&gt;</span>
<span class="preprocessor">#include &lt;GL/glu.h&gt;</span>


<span class="comment">//</span>
<span class="comment">// OpenGL frame buffer configuration utilities.</span>
<span class="comment">//</span>
<span class="comment"></span>
<span class="keyword">struct </span><a name="_a6"></a><a class="code" href="classGLConfigUtil.html">GLConfigUtil</a>
{
  <span class="keyword">static</span> <span class="keywordtype">void</span> print_gl_attrib(<span class="keyword">const</span> Glib::RefPtr&lt;const Gdk::GL::Config&gt;&amp; glconfig,
                              <span class="keyword">const</span> <span class="keywordtype">char</span>* attrib_str,
                              <span class="keywordtype">int</span> attrib,
                              <span class="keywordtype">bool</span> is_boolean);

  <span class="keyword">static</span> <span class="keywordtype">void</span> examine_gl_attrib(<span class="keyword">const</span> Glib::RefPtr&lt;const Gdk::GL::Config&gt;&amp; glconfig);
};

<span class="comment">//</span>
<span class="comment">// Print a configuration attribute.</span>
<span class="comment">//</span>
<span class="keywordtype">void</span> GLConfigUtil::print_gl_attrib(<span class="keyword">const</span> Glib::RefPtr&lt;const Gdk::GL::Config&gt;&amp; glconfig,
                                   <span class="keyword">const</span> <span class="keywordtype">char</span>* attrib_str,
                                   <span class="keywordtype">int</span> attrib,
                                   <span class="keywordtype">bool</span> is_boolean)
{
  <span class="keywordtype">int</span> value;

  <span class="keywordflow">if</span> (glconfig-&gt;get_attrib(attrib, value))
    {
      std::cout &lt;&lt; attrib_str &lt;&lt; <span class="stringliteral">" = "</span>;
      <span class="keywordflow">if</span> (is_boolean)
        std::cout &lt;&lt; (value == <span class="keyword">true</span> ? <span class="stringliteral">"true"</span> : <span class="stringliteral">"false"</span>) &lt;&lt; std::endl;
      <span class="keywordflow">else</span>
        std::cout &lt;&lt; value &lt;&lt; std::endl;
    }
  <span class="keywordflow">else</span>
    {
      std::cout &lt;&lt; <span class="stringliteral">"*** Cannot get "</span>
                &lt;&lt; attrib_str
                &lt;&lt; <span class="stringliteral">" attribute value\n"</span>;
    }
}

<span class="comment">//</span>
<span class="comment">// Print configuration attributes.</span>
<span class="comment">//</span>
<span class="keywordtype">void</span> GLConfigUtil::examine_gl_attrib(<span class="keyword">const</span> Glib::RefPtr&lt;const Gdk::GL::Config&gt;&amp; glconfig)
{
  std::cout &lt;&lt; <span class="stringliteral">"\nOpenGL visual configurations :\n\n"</span>;

  std::cout &lt;&lt; <span class="stringliteral">"glconfig-&gt;is_rgba() = "</span>
            &lt;&lt; (glconfig-&gt;is_rgba() ? <span class="stringliteral">"true"</span> : <span class="stringliteral">"false"</span>)
            &lt;&lt; std::endl;
  std::cout &lt;&lt; <span class="stringliteral">"glconfig-&gt;is_double_buffered() = "</span>
            &lt;&lt; (glconfig-&gt;is_double_buffered() ? <span class="stringliteral">"true"</span> : <span class="stringliteral">"false"</span>)
            &lt;&lt; std::endl;
  std::cout &lt;&lt; <span class="stringliteral">"glconfig-&gt;is_stereo() = "</span>
            &lt;&lt; (glconfig-&gt;is_stereo() ? <span class="stringliteral">"true"</span> : <span class="stringliteral">"false"</span>)
            &lt;&lt; std::endl;
  std::cout &lt;&lt; <span class="stringliteral">"glconfig-&gt;has_alpha() = "</span>
            &lt;&lt; (glconfig-&gt;has_alpha() ? <span class="stringliteral">"true"</span> : <span class="stringliteral">"false"</span>)
            &lt;&lt; std::endl;
  std::cout &lt;&lt; <span class="stringliteral">"glconfig-&gt;has_depth_buffer() = "</span>
            &lt;&lt; (glconfig-&gt;has_depth_buffer() ? <span class="stringliteral">"true"</span> : <span class="stringliteral">"false"</span>)
            &lt;&lt; std::endl;
  std::cout &lt;&lt; <span class="stringliteral">"glconfig-&gt;has_stencil_buffer() = "</span>
            &lt;&lt; (glconfig-&gt;has_stencil_buffer() ? <span class="stringliteral">"true"</span> : <span class="stringliteral">"false"</span>)
            &lt;&lt; std::endl;
  std::cout &lt;&lt; <span class="stringliteral">"glconfig-&gt;has_accum_buffer() = "</span>
            &lt;&lt; (glconfig-&gt;has_accum_buffer() ? <span class="stringliteral">"true"</span> : <span class="stringliteral">"false"</span>)
            &lt;&lt; std::endl;

  std::cout &lt;&lt; std::endl;

  print_gl_attrib(glconfig, <span class="stringliteral">"Gdk::GL::USE_GL"</span>,           Gdk::GL::USE_GL,           <span class="keyword">true</span>);
  print_gl_attrib(glconfig, <span class="stringliteral">"Gdk::GL::BUFFER_SIZE"</span>,      Gdk::GL::BUFFER_SIZE,      <span class="keyword">false</span>);
  print_gl_attrib(glconfig, <span class="stringliteral">"Gdk::GL::LEVEL"</span>,            Gdk::GL::LEVEL,            <span class="keyword">false</span>);
  print_gl_attrib(glconfig, <span class="stringliteral">"Gdk::GL::RGBA"</span>,             Gdk::GL::RGBA,             <span class="keyword">true</span>);
  print_gl_attrib(glconfig, <span class="stringliteral">"Gdk::GL::DOUBLEBUFFER"</span>,     Gdk::GL::DOUBLEBUFFER,     <span class="keyword">true</span>);
  print_gl_attrib(glconfig, <span class="stringliteral">"Gdk::GL::STEREO"</span>,           Gdk::GL::STEREO,           <span class="keyword">true</span>);
  print_gl_attrib(glconfig, <span class="stringliteral">"Gdk::GL::AUX_BUFFERS"</span>,      Gdk::GL::AUX_BUFFERS,      <span class="keyword">false</span>);
  print_gl_attrib(glconfig, <span class="stringliteral">"Gdk::GL::RED_SIZE"</span>,         Gdk::GL::RED_SIZE,         <span class="keyword">false</span>);
  print_gl_attrib(glconfig, <span class="stringliteral">"Gdk::GL::GREEN_SIZE"</span>,       Gdk::GL::GREEN_SIZE,       <span class="keyword">false</span>);
  print_gl_attrib(glconfig, <span class="stringliteral">"Gdk::GL::BLUE_SIZE"</span>,        Gdk::GL::BLUE_SIZE,        <span class="keyword">false</span>);
  print_gl_attrib(glconfig, <span class="stringliteral">"Gdk::GL::ALPHA_SIZE"</span>,       Gdk::GL::ALPHA_SIZE,       <span class="keyword">false</span>);
  print_gl_attrib(glconfig, <span class="stringliteral">"Gdk::GL::DEPTH_SIZE"</span>,       Gdk::GL::DEPTH_SIZE,       <span class="keyword">false</span>);
  print_gl_attrib(glconfig, <span class="stringliteral">"Gdk::GL::STENCIL_SIZE"</span>,     Gdk::GL::STENCIL_SIZE,     <span class="keyword">false</span>);
  print_gl_attrib(glconfig, <span class="stringliteral">"Gdk::GL::ACCUM_RED_SIZE"</span>,   Gdk::GL::ACCUM_RED_SIZE,   <span class="keyword">false</span>);
  print_gl_attrib(glconfig, <span class="stringliteral">"Gdk::GL::ACCUM_GREEN_SIZE"</span>, Gdk::GL::ACCUM_GREEN_SIZE, <span class="keyword">false</span>);
  print_gl_attrib(glconfig, <span class="stringliteral">"Gdk::GL::ACCUM_BLUE_SIZE"</span>,  Gdk::GL::ACCUM_BLUE_SIZE,  <span class="keyword">false</span>);
  print_gl_attrib(glconfig, <span class="stringliteral">"Gdk::GL::ACCUM_ALPHA_SIZE"</span>, Gdk::GL::ACCUM_ALPHA_SIZE, <span class="keyword">false</span>);

  std::cout &lt;&lt; std::endl;
}


<span class="comment">//</span>
<span class="comment">// Gears scene.</span>
<span class="comment">//</span>
<span class="comment"></span>
<span class="keyword">class </span>GearsScene : <span class="keyword">public</span> Gtk::GL::DrawingArea
{
<span class="keyword">public</span>:
  <span class="keyword">explicit</span> <a name="_a7"></a><a class="code" href="classGearsScene.html">GearsScene</a>(<span class="keywordtype">bool</span> is_sync = <span class="keyword">true</span>);
  <span class="keyword">virtual</span> ~<a class="code" href="classGearsScene.html">GearsScene</a>();

<span class="keyword">protected</span>:
  <span class="keywordtype">void</span> gear(GLfloat inner_radius,
            GLfloat outer_radius,
            GLfloat width,
            GLint   teeth,
            GLfloat tooth_depth);

<span class="keyword">protected</span>:
  <span class="comment">// signal handlers:</span>
  <span class="keyword">virtual</span> <span class="keywordtype">void</span> on_realize();
  <span class="keyword">virtual</span> <span class="keywordtype">bool</span> on_configure_event(GdkEventConfigure* event);
  <span class="keyword">virtual</span> <span class="keywordtype">bool</span> on_expose_event(GdkEventExpose* event);
  <span class="keyword">virtual</span> <span class="keywordtype">bool</span> on_map_event(GdkEventAny* event);
  <span class="keyword">virtual</span> <span class="keywordtype">bool</span> on_unmap_event(GdkEventAny* event);
  <span class="keyword">virtual</span> <span class="keywordtype">bool</span> on_visibility_notify_event(GdkEventVisibility* event);
  <span class="keyword">virtual</span> <span class="keywordtype">bool</span> on_idle();

<span class="keyword">public</span>:
  <span class="comment">// Invalidate whole window.</span>
  <span class="keywordtype">void</span> invalidate() {
    GtkAllocation allocation = get_allocation();
    get_window()-&gt;invalidate_rect(Gdk::Rectangle(&amp;allocation), <span class="keyword">false</span>);
  }

  <span class="comment">// Update window synchronously (fast).</span>
  <span class="keywordtype">void</span> update()
  { get_window()-&gt;process_updates(<span class="keyword">false</span>); }

<span class="keyword">protected</span>:
  <span class="comment">// idle signal connection:</span>
  SigC::Connection m_ConnectionIdle;

<span class="keyword">public</span>:
  <span class="comment">// get &amp; set view rotation values.</span>
  <span class="keywordtype">void</span> get_view_rot(GLfloat&amp; x, GLfloat&amp; y, GLfloat&amp; z)
  { x = m_ViewRotX; y = m_ViewRotY; z = m_ViewRotZ; }

  <span class="keywordtype">void</span> set_view_rot(GLfloat x, GLfloat y, GLfloat z)
  { m_ViewRotX = x; m_ViewRotY = y; m_ViewRotZ = z; }

<span class="keyword">protected</span>:
  <span class="comment">// OpenGL scene related variables:</span>
  GLint m_Gear1;
  GLint m_Gear2;
  GLint m_Gear3;

  GLfloat m_ViewRotX;
  GLfloat m_ViewRotY;
  GLfloat m_ViewRotZ;

  GLfloat m_Angle;

  <span class="keywordtype">bool</span> m_IsSync;

<span class="keyword">protected</span>:
  <span class="comment">// frame rate evaluation stuff:</span>
  Glib::Timer m_Timer;
  <span class="keywordtype">int</span> m_Frames;
};

GearsScene::GearsScene(<span class="keywordtype">bool</span> is_sync)
  : m_Gear1(0), m_Gear2(0), m_Gear3(0),
    m_ViewRotX(20.0), m_ViewRotY(30.0), m_ViewRotZ(0.0),
    m_Angle(0.0), m_IsSync(is_sync),
    m_Frames(0)
{
  <span class="comment">//</span>
  <span class="comment">// Configure OpenGL-capable visual.</span>
  <span class="comment">//</span>

  Glib::RefPtr&lt;Gdk::GL::Config&gt; glconfig;

  <span class="comment">// Try double-buffered visual</span>
  glconfig = <a name="a8"></a><a class="code" href="classGdk_1_1GL_1_1Config.html#e0">Gdk::GL::Config::create</a>(Gdk::GL::MODE_RGB    |
                                     Gdk::GL::MODE_DEPTH  |
                                     Gdk::GL::MODE_DOUBLE);
  <span class="keywordflow">if</span> (glconfig.is_null())
    {
      std::cerr &lt;&lt; <span class="stringliteral">"*** Cannot find the double-buffered visual.\n"</span>
                &lt;&lt; <span class="stringliteral">"*** Trying single-buffered visual.\n"</span>;

      <span class="comment">// Try single-buffered visual</span>
      glconfig = <a class="code" href="classGdk_1_1GL_1_1Config.html#e0">Gdk::GL::Config::create</a>(Gdk::GL::MODE_RGB   |
                                         Gdk::GL::MODE_DEPTH);
      <span class="keywordflow">if</span> (glconfig.is_null())
        {
          std::cerr &lt;&lt; <span class="stringliteral">"*** Cannot find any OpenGL-capable visual.\n"</span>;
          std::exit(1);
        }
    }

  <span class="comment">// print frame buffer attributes.</span>
  GLConfigUtil::examine_gl_attrib(glconfig);

  <span class="comment">//</span>
  <span class="comment">// Set OpenGL-capability to the widget.</span>
  <span class="comment">//</span>

  set_gl_capability(glconfig);

  <span class="comment">// Add events.</span>
  add_events(Gdk::VISIBILITY_NOTIFY_MASK);
}

GearsScene::~GearsScene()
{
}

<span class="comment">/*</span>
<span class="comment"> * Draw a gear wheel.  You'll probably want to call this function when</span>
<span class="comment"> * building a display list since we do a lot of trig here.</span>
<span class="comment"> *</span>
<span class="comment"> * Input:  inner_radius - radius of hole at center</span>
<span class="comment"> * outer_radius - radius at center of teeth</span>
<span class="comment"> * width - width of gear</span>
<span class="comment"> * teeth - number of teeth</span>
<span class="comment"> * tooth_depth - depth of tooth</span>
<span class="comment"> */</span>

<span class="keywordtype">void</span> GearsScene::gear(GLfloat inner_radius,
                      GLfloat outer_radius,
                      GLfloat width,
                      GLint   teeth,
                      GLfloat tooth_depth)
{
  GLint i;
  GLfloat r0, r1, r2;
  GLfloat angle, da;
  GLfloat u, v, len;

  r0 = inner_radius;
  r1 = outer_radius - tooth_depth / 2.0;
  r2 = outer_radius + tooth_depth / 2.0;

  da = 2.0 * G_PI / teeth / 4.0;

  glShadeModel(GL_FLAT);

  glNormal3f(0.0, 0.0, 1.0);

  <span class="comment">/* draw front face */</span>
  glBegin(GL_QUAD_STRIP);
  <span class="keywordflow">for</span> (i = 0; i &lt;= teeth; i++) {
    angle = i * 2.0 * G_PI / teeth;
    glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
    glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
    <span class="keywordflow">if</span> (i &lt; teeth) {
      glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
      glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), width * 0.5);
    }
  }
  glEnd();

  <span class="comment">/* draw front sides of teeth */</span>
  glBegin(GL_QUADS);
  da = 2.0 * G_PI / teeth / 4.0;
  <span class="keywordflow">for</span> (i = 0; i &lt; teeth; i++) {
    angle = i * 2.0 * G_PI / teeth;

    glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
    glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5);
    glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), width * 0.5);
    glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), width * 0.5);
  }
  glEnd();

  glNormal3f(0.0, 0.0, -1.0);

  <span class="comment">/* draw back face */</span>
  glBegin(GL_QUAD_STRIP);
  <span class="keywordflow">for</span> (i = 0; i &lt;= teeth; i++) {
    angle = i * 2.0 * G_PI / teeth;
    glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
    glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
    <span class="keywordflow">if</span> (i &lt; teeth) {
      glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), -width * 0.5);
      glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
    }
  }
  glEnd();

  <span class="comment">/* draw back sides of teeth */</span>
  glBegin(GL_QUADS);
  da = 2.0 * G_PI / teeth / 4.0;
  <span class="keywordflow">for</span> (i = 0; i &lt; teeth; i++) {
    angle = i * 2.0 * G_PI / teeth;

    glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), -width * 0.5);
    glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), -width * 0.5);
    glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -width * 0.5);
    glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
  }
  glEnd();

  <span class="comment">/* draw outward faces of teeth */</span>
  glBegin(GL_QUAD_STRIP);
  <span class="keywordflow">for</span> (i = 0; i &lt; teeth; i++) {
    angle = i * 2.0 * G_PI / teeth;

    glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
    glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
    u = r2 * cos(angle + da) - r1 * cos(angle);
    v = r2 * sin(angle + da) - r1 * sin(angle);
    len = sqrt(u * u + v * v);
    u /= len;
    v /= len;
    glNormal3f(v, -u, 0.0);
    glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5);
    glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -width * 0.5);
    glNormal3f(cos(angle), sin(angle), 0.0);
    glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), width * 0.5);
    glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), -width * 0.5);
    u = r1 * cos(angle + 3 * da) - r2 * cos(angle + 2 * da);
    v = r1 * sin(angle + 3 * da) - r2 * sin(angle + 2 * da);
    glNormal3f(v, -u, 0.0);
    glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), width * 0.5);
    glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), -width * 0.5);
    glNormal3f(cos(angle), sin(angle), 0.0);
  }

  glVertex3f(r1 * cos(0), r1 * sin(0), width * 0.5);
  glVertex3f(r1 * cos(0), r1 * sin(0), -width * 0.5);

  glEnd();

  glShadeModel(GL_SMOOTH);

  <span class="comment">/* draw inside radius cylinder */</span>
  glBegin(GL_QUAD_STRIP);
  <span class="keywordflow">for</span> (i = 0; i &lt;= teeth; i++) {
    angle = i * 2.0 * G_PI / teeth;
    glNormal3f(-cos(angle), -sin(angle), 0.0);
    glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
    glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
  }
  glEnd();

}

<span class="keywordtype">void</span> GearsScene::on_realize()
{
  <span class="comment">// We need to call the base on_realize()</span>
  Gtk::DrawingArea::on_realize();

  <span class="comment">//</span>
  <span class="comment">// Get GL::Drawable.</span>
  <span class="comment">//</span>

  Glib::RefPtr&lt;Gdk::GL::Drawable&gt; gldrawable = get_gl_drawable();

  <span class="comment">//</span>
  <span class="comment">// GL calls.</span>
  <span class="comment">//</span>

  <span class="comment">// *** OpenGL BEGIN ***</span>
  <span class="keywordflow">if</span> (!gldrawable-&gt;gl_begin(get_gl_context()))
    <span class="keywordflow">return</span>;

  <span class="keyword">static</span> GLfloat pos[4] = {5.0, 5.0, 10.0, 0.0};
  <span class="keyword">static</span> GLfloat red[4] = {0.8, 0.1, 0.0, 1.0};
  <span class="keyword">static</span> GLfloat green[4] = {0.0, 0.8, 0.2, 1.0};
  <span class="keyword">static</span> GLfloat blue[4] = {0.2, 0.2, 1.0, 1.0};

  glLightfv(GL_LIGHT0, GL_POSITION, pos);
  glEnable(GL_CULL_FACE);
  glEnable(GL_LIGHTING);
  glEnable(GL_LIGHT0);
  glEnable(GL_DEPTH_TEST);

  <span class="comment">// Make the gears.</span>
  m_Gear1 = glGenLists(1);
  glNewList(m_Gear1, GL_COMPILE);
  glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, red);
  gear(1.0, 4.0, 1.0, 20, 0.7);
  glEndList();

  m_Gear2 = glGenLists(1);
  glNewList(m_Gear2, GL_COMPILE);
  glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, green);
  gear(0.5, 2.0, 2.0, 10, 0.7);
  glEndList();

  m_Gear3 = glGenLists(1);
  glNewList(m_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);

  std::cout &lt;&lt; <span class="stringliteral">"GL_RENDERER   = "</span> &lt;&lt; glGetString(GL_RENDERER)   &lt;&lt; std::endl;
  std::cout &lt;&lt; <span class="stringliteral">"GL_VERSION    = "</span> &lt;&lt; glGetString(GL_VERSION)    &lt;&lt; std::endl;
  std::cout &lt;&lt; <span class="stringliteral">"GL_VENDOR     = "</span> &lt;&lt; glGetString(GL_VENDOR)     &lt;&lt; std::endl;
  std::cout &lt;&lt; <span class="stringliteral">"GL_EXTENSIONS = "</span> &lt;&lt; glGetString(GL_EXTENSIONS) &lt;&lt; std::endl;
  std::cout &lt;&lt; std::endl;

  gldrawable-&gt;gl_end();
  <span class="comment">// *** OpenGL END ***</span>

  <span class="comment">// Start timer.</span>
  m_Timer.start();
}

<span class="keywordtype">bool</span> GearsScene::on_configure_event(GdkEventConfigure* event)
{
  <span class="comment">//</span>
  <span class="comment">// Get GL::Drawable.</span>
  <span class="comment">//</span>

  Glib::RefPtr&lt;Gdk::GL::Drawable&gt; gldrawable = get_gl_drawable();

  <span class="comment">//</span>
  <span class="comment">// GL calls.</span>
  <span class="comment">//</span>

  <span class="comment">// *** OpenGL BEGIN ***</span>
  <span class="keywordflow">if</span> (!gldrawable-&gt;gl_begin(get_gl_context()))
    <span class="keywordflow">return</span> <span class="keyword">false</span>;

  GLfloat h = (GLfloat)(get_height()) / (GLfloat)(get_width());

  glViewport(0, 0, get_width(), get_height());
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  glFrustum(-1.0, 1.0, -h, h, 5.0, 60.0);
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
  glTranslatef(0.0, 0.0, -40.0);

  gldrawable-&gt;gl_end();
  <span class="comment">// *** OpenGL END ***</span>

  <span class="keywordflow">return</span> <span class="keyword">true</span>;
}

<span class="keywordtype">bool</span> GearsScene::on_expose_event(GdkEventExpose* event)
{
  <span class="comment">//</span>
  <span class="comment">// Get GL::Drawable.</span>
  <span class="comment">//</span>

  Glib::RefPtr&lt;Gdk::GL::Drawable&gt; gldrawable = get_gl_drawable();

  <span class="comment">//</span>
  <span class="comment">// GL calls.</span>
  <span class="comment">//</span>

  <span class="comment">// *** OpenGL BEGIN ***</span>
  <span class="keywordflow">if</span> (!gldrawable-&gt;gl_begin(get_gl_context()))
    <span class="keywordflow">return</span> <span class="keyword">false</span>;

  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  glPushMatrix();
    glRotatef(m_ViewRotX, 1.0, 0.0, 0.0);
    glRotatef(m_ViewRotY, 0.0, 1.0, 0.0);
    glRotatef(m_ViewRotZ, 0.0, 0.0, 1.0);

    glPushMatrix();
      glTranslatef(-3.0, -2.0, 0.0);
      glRotatef(m_Angle, 0.0, 0.0, 1.0);
      glCallList(m_Gear1);
    glPopMatrix();

    glPushMatrix();
      glTranslatef(3.1, -2.0, 0.0);
      glRotatef(-2.0 * m_Angle - 9.0, 0.0, 0.0, 1.0);
      glCallList(m_Gear2);
    glPopMatrix();

    glPushMatrix();
      glTranslatef(-3.1, 4.2, 0.0);
      glRotatef(-2.0 * m_Angle - 25.0, 0.0, 0.0, 1.0);
      glCallList(m_Gear3);
    glPopMatrix();

  glPopMatrix();

  <span class="comment">// Swap buffers.</span>
  <span class="keywordflow">if</span> (gldrawable-&gt;is_double_buffered())
    gldrawable-&gt;swap_buffers();
  <span class="keywordflow">else</span>
    glFlush();

  gldrawable-&gt;gl_end();
  <span class="comment">// *** OpenGL END ***</span>

  <span class="comment">//</span>
  <span class="comment">// Print frame rate.</span>
  <span class="comment">//</span>

  ++m_Frames;

  <span class="keywordtype">double</span> seconds = m_Timer.elapsed();
  <span class="keywordflow">if</span> (seconds &gt;= 5.0)
    {
      <span class="comment">// std::cout.setf(std::ios_base::fixed, std::ios_base::floatfield);</span>
      std::cout.setf(std::ios::fixed, std::ios::floatfield);
      std::cout.precision(3);
      std::cout &lt;&lt; m_Frames &lt;&lt; <span class="stringliteral">" frames in "</span>
                &lt;&lt; seconds &lt;&lt; <span class="stringliteral">" seconds = "</span>
                &lt;&lt; (m_Frames / seconds) &lt;&lt; <span class="stringliteral">" FPS\n"</span>;
      m_Timer.reset();
      m_Frames = 0;
    }

  <span class="keywordflow">return</span> <span class="keyword">true</span>;
}

<span class="keywordtype">bool</span> GearsScene::on_map_event(GdkEventAny* event)
{
  <span class="keywordflow">if</span> (!m_ConnectionIdle.connected())
    m_ConnectionIdle = Glib::signal_idle().connect(
      SigC::slot(*<span class="keyword">this</span>, &amp;GearsScene::on_idle), GDK_PRIORITY_REDRAW);

  <span class="keywordflow">return</span> <span class="keyword">true</span>;
}

<span class="keywordtype">bool</span> GearsScene::on_unmap_event(GdkEventAny* event)
{
  <span class="keywordflow">if</span> (m_ConnectionIdle.connected())
    m_ConnectionIdle.disconnect();

  <span class="keywordflow">return</span> <span class="keyword">true</span>;
}

<span class="keywordtype">bool</span> GearsScene::on_visibility_notify_event(GdkEventVisibility* event)
{
  <span class="keywordflow">if</span> (event-&gt;state == GDK_VISIBILITY_FULLY_OBSCURED)
    {
      <span class="keywordflow">if</span> (m_ConnectionIdle.connected())
        m_ConnectionIdle.disconnect();
    }
  <span class="keywordflow">else</span>
    {
      <span class="keywordflow">if</span> (!m_ConnectionIdle.connected())
        m_ConnectionIdle = Glib::signal_idle().connect(
          SigC::slot(*<span class="keyword">this</span>, &amp;GearsScene::on_idle), GDK_PRIORITY_REDRAW);
    }

  <span class="keywordflow">return</span> <span class="keyword">true</span>;
}

<span class="keywordtype">bool</span> GearsScene::on_idle()
{
  m_Angle += 2.0;

  <span class="comment">// Invalidate the whole window.</span>
  invalidate();

  <span class="comment">// Update window synchronously (fast).</span>
  <span class="keywordflow">if</span> (m_IsSync)
    update();

  <span class="keywordflow">return</span> <span class="keyword">true</span>;
}


<span class="comment">//</span>
<span class="comment">// The application class.</span>
<span class="comment">//</span>
<span class="comment"></span>
<span class="keyword">class </span>Gears : <span class="keyword">public</span> Gtk::Window
{
<span class="keyword">public</span>:
  <span class="keyword">explicit</span> <a name="_a9"></a><a class="code" href="classGears.html">Gears</a>(<span class="keywordtype">bool</span> is_sync = <span class="keyword">true</span>);
  <span class="keyword">virtual</span> ~<a class="code" href="classGears.html">Gears</a>();

<span class="keyword">protected</span>:
  <span class="comment">// signal handlers:</span>
  <span class="keywordtype">void</span> on_button_quit_clicked();
  <span class="keyword">virtual</span> <span class="keywordtype">bool</span> on_key_press_event(GdkEventKey* event);

<span class="keyword">protected</span>:
  <span class="comment">// member widgets:</span>
  Gtk::VBox m_VBox;
  <a class="code" href="classGearsScene.html">GearsScene</a> m_GearsScene;
  Gtk::Button m_ButtonQuit;
};

Gears::Gears(<span class="keywordtype">bool</span> is_sync)
  : m_VBox(false, 0), m_GearsScene(is_sync), m_ButtonQuit("Quit")
{
  <span class="comment">//</span>
  <span class="comment">// Top-level window.</span>
  <span class="comment">//</span>

  set_title(<span class="stringliteral">"Gears"</span>);

  <span class="comment">// Get automatically redrawn if any of their children changed allocation.</span>
  set_reallocate_redraws(<span class="keyword">true</span>);

  add(m_VBox);

  <span class="comment">//</span>
  <span class="comment">// Gears scene.</span>
  <span class="comment">//</span>

  m_GearsScene.set_size_request(300, 300);

  m_VBox.pack_start(m_GearsScene);

  <span class="comment">//</span>
  <span class="comment">// Simple quit button.</span>
  <span class="comment">//</span>

  m_ButtonQuit.signal_clicked().connect(
    SigC::slot(*<span class="keyword">this</span>, &amp;Gears::on_button_quit_clicked));

  m_VBox.pack_start(m_ButtonQuit, Gtk::PACK_SHRINK, 0);

  <span class="comment">//</span>
  <span class="comment">// Show window.</span>
  <span class="comment">//</span>

  show_all();
}

Gears::~Gears()
{
}

<span class="keywordtype">void</span> Gears::on_button_quit_clicked()
{
  Gtk::Main::quit();
}

<span class="keywordtype">bool</span> Gears::on_key_press_event(GdkEventKey* event)
{
  GLfloat x, y, z;

  m_GearsScene.get_view_rot(x, y, z);

  <span class="keywordflow">switch</span> (event-&gt;keyval)
    {
    <span class="keywordflow">case</span> GDK_z:
      z += 5.0;
      <span class="keywordflow">break</span>;
    <span class="keywordflow">case</span> GDK_Z:
      z -= 5.0;
      <span class="keywordflow">break</span>;
    <span class="keywordflow">case</span> GDK_Up:
      x += 5.0;
      <span class="keywordflow">break</span>;
    <span class="keywordflow">case</span> GDK_Down:
      x -= 5.0;
      <span class="keywordflow">break</span>;
    <span class="keywordflow">case</span> GDK_Left:
      y += 5.0;
      <span class="keywordflow">break</span>;
    <span class="keywordflow">case</span> GDK_Right:
      y -= 5.0;
      <span class="keywordflow">break</span>;
    <span class="keywordflow">case</span> GDK_Escape:
      Gtk::Main::quit();
      <span class="keywordflow">break</span>;
    <span class="keywordflow">default</span>:
      <span class="keywordflow">return</span> <span class="keyword">true</span>;
    }

  m_GearsScene.set_view_rot(x, y, z);

  m_GearsScene.invalidate();

  <span class="keywordflow">return</span> <span class="keyword">true</span>;
}


<span class="comment">//</span>
<span class="comment">// Main.</span>
<span class="comment">//</span>
<span class="comment"></span>
<span class="keywordtype">int</span> main(<span class="keywordtype">int</span> argc, <span class="keywordtype">char</span>** argv)
{
  Gtk::Main kit(argc, argv);

  <span class="comment">//</span>
  <span class="comment">// Init gtkglextmm.</span>
  <span class="comment">//</span>

  <a name="a10"></a><a class="code" href="namespaceGtk_1_1GL.html#a2">Gtk::GL::init</a>(argc, argv);

  <span class="comment">//</span>
  <span class="comment">// Parse arguments.</span>
  <span class="comment">//</span>

  <span class="keywordtype">bool</span> is_sync = <span class="keyword">true</span>;

  <span class="keywordflow">for</span> (<span class="keywordtype">int</span> i = 1; i &lt; argc; ++i) {
    <span class="keywordflow">if</span> (std::strcmp(argv[i], <span class="stringliteral">"--async"</span>) == 0)
      is_sync = <span class="keyword">false</span>;
  }

  <span class="comment">//</span>
  <span class="comment">// Instantiate and run the application.</span>
  <span class="comment">//</span>

  <a class="code" href="classGears.html">Gears</a> gears(is_sync);

  kit.run(gears);

  <span class="keywordflow">return</span> 0;
}
</pre></div> <hr size="1"><address style="align: right;"><small>Generated on Thu Nov 20 22:46:30 2003 for gtkglextmm by
<a href="http://www.doxygen.org/index.html">
<img src="doxygen.png" alt="doxygen" align="middle" border=0 > 
</a>1.3.4 </small></address>
</body>
</html>