Sophie

Sophie

distrib > Mageia > 7 > armv7hl > media > core-release > by-pkgid > 4385fe4d2beb794f6ab11a7801f18ad5 > files > 201

gtkglextmm-doc-1.2.0-11.mga7.noarch.rpm

<!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: logo.cc</title>
<link href="doxygen.css" rel="stylesheet" type="text/css">
</head><body>
<!-- Generated by Doxygen 1.4.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="dirs.html">Directories</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>logo.cc</h1>GtkGLExt logo demo.<p>
<div class="fragment"><pre class="fragment"><span class="comment">// -*- C++ -*-</span>
<span class="comment">/*</span>
<span class="comment"> * logo.cc:</span>
<span class="comment"> * GtkGLExt logo demo.</span>
<span class="comment"> *</span>
<span class="comment"> * written by Naofumi Yasufuku  &lt;naofumi@users.sourceforge.net&gt;</span>
<span class="comment"> */</span>

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

<span class="preprocessor">#include &lt;GL/gl.h&gt;</span>
<span class="preprocessor">#include &lt;GL/glu.h&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 "logo.h"</span>

<span class="comment">//</span>
<span class="comment">// logo_draw_*() functions.</span>
<span class="comment">//</span>
<span class="keyword">namespace </span>LogoModel {
<span class="preprocessor">  #include "logo-model.h"</span>
}

<span class="comment">//</span>
<span class="comment">// Trackball utilities.</span>
<span class="comment">//</span>
<span class="keyword">namespace </span>Trackball {
  <span class="keyword">extern</span> <span class="stringliteral">"C"</span> {
<span class="preprocessor">    #include "trackball.h"</span>
  }
}

<span class="preprocessor">#define DIG_2_RAD (G_PI / 180.0)</span>
<span class="preprocessor"></span><span class="preprocessor">#define RAD_2_DIG (180.0 / G_PI)</span>
<span class="preprocessor"></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>GLConfigUtil
{
  <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>,           <a name="a46"></a><a class="code" href="group__gdkmm__glEnums.html#gga36a15">Gdk::GL::USE_GL</a>,           <span class="keyword">true</span>);
  print_gl_attrib(glconfig, <span class="stringliteral">"Gdk::GL::BUFFER_SIZE"</span>,      <a name="a47"></a><a class="code" href="group__gdkmm__glEnums.html#gga36a16">Gdk::GL::BUFFER_SIZE</a>,      <span class="keyword">false</span>);
  print_gl_attrib(glconfig, <span class="stringliteral">"Gdk::GL::LEVEL"</span>,            <a name="a48"></a><a class="code" href="group__gdkmm__glEnums.html#gga36a17">Gdk::GL::LEVEL</a>,            <span class="keyword">false</span>);
  print_gl_attrib(glconfig, <span class="stringliteral">"Gdk::GL::RGBA"</span>,             <a name="a49"></a><a class="code" href="group__gdkmm__glEnums.html#gga36a18">Gdk::GL::RGBA</a>,             <span class="keyword">true</span>);
  print_gl_attrib(glconfig, <span class="stringliteral">"Gdk::GL::DOUBLEBUFFER"</span>,     <a name="a50"></a><a class="code" href="group__gdkmm__glEnums.html#gga36a19">Gdk::GL::DOUBLEBUFFER</a>,     <span class="keyword">true</span>);
  print_gl_attrib(glconfig, <span class="stringliteral">"Gdk::GL::STEREO"</span>,           <a name="a51"></a><a class="code" href="group__gdkmm__glEnums.html#gga36a20">Gdk::GL::STEREO</a>,           <span class="keyword">true</span>);
  print_gl_attrib(glconfig, <span class="stringliteral">"Gdk::GL::AUX_BUFFERS"</span>,      <a name="a52"></a><a class="code" href="group__gdkmm__glEnums.html#gga36a21">Gdk::GL::AUX_BUFFERS</a>,      <span class="keyword">false</span>);
  print_gl_attrib(glconfig, <span class="stringliteral">"Gdk::GL::RED_SIZE"</span>,         <a name="a53"></a><a class="code" href="group__gdkmm__glEnums.html#gga36a22">Gdk::GL::RED_SIZE</a>,         <span class="keyword">false</span>);
  print_gl_attrib(glconfig, <span class="stringliteral">"Gdk::GL::GREEN_SIZE"</span>,       <a name="a54"></a><a class="code" href="group__gdkmm__glEnums.html#gga36a23">Gdk::GL::GREEN_SIZE</a>,       <span class="keyword">false</span>);
  print_gl_attrib(glconfig, <span class="stringliteral">"Gdk::GL::BLUE_SIZE"</span>,        <a name="a55"></a><a class="code" href="group__gdkmm__glEnums.html#gga36a24">Gdk::GL::BLUE_SIZE</a>,        <span class="keyword">false</span>);
  print_gl_attrib(glconfig, <span class="stringliteral">"Gdk::GL::ALPHA_SIZE"</span>,       <a name="a56"></a><a class="code" href="group__gdkmm__glEnums.html#gga36a25">Gdk::GL::ALPHA_SIZE</a>,       <span class="keyword">false</span>);
  print_gl_attrib(glconfig, <span class="stringliteral">"Gdk::GL::DEPTH_SIZE"</span>,       <a name="a57"></a><a class="code" href="group__gdkmm__glEnums.html#gga36a26">Gdk::GL::DEPTH_SIZE</a>,       <span class="keyword">false</span>);
  print_gl_attrib(glconfig, <span class="stringliteral">"Gdk::GL::STENCIL_SIZE"</span>,     <a name="a58"></a><a class="code" href="group__gdkmm__glEnums.html#gga36a27">Gdk::GL::STENCIL_SIZE</a>,     <span class="keyword">false</span>);
  print_gl_attrib(glconfig, <span class="stringliteral">"Gdk::GL::ACCUM_RED_SIZE"</span>,   <a name="a59"></a><a class="code" href="group__gdkmm__glEnums.html#gga36a28">Gdk::GL::ACCUM_RED_SIZE</a>,   <span class="keyword">false</span>);
  print_gl_attrib(glconfig, <span class="stringliteral">"Gdk::GL::ACCUM_GREEN_SIZE"</span>, <a name="a60"></a><a class="code" href="group__gdkmm__glEnums.html#gga36a29">Gdk::GL::ACCUM_GREEN_SIZE</a>, <span class="keyword">false</span>);
  print_gl_attrib(glconfig, <span class="stringliteral">"Gdk::GL::ACCUM_BLUE_SIZE"</span>,  <a name="a61"></a><a class="code" href="group__gdkmm__glEnums.html#gga36a30">Gdk::GL::ACCUM_BLUE_SIZE</a>,  <span class="keyword">false</span>);
  print_gl_attrib(glconfig, <span class="stringliteral">"Gdk::GL::ACCUM_ALPHA_SIZE"</span>, <a name="a62"></a><a class="code" href="group__gdkmm__glEnums.html#gga36a31">Gdk::GL::ACCUM_ALPHA_SIZE</a>, <span class="keyword">false</span>);

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


<span class="comment">//</span>
<span class="comment">// Logo classes.</span>
<span class="comment">//</span>
<span class="comment"></span>
<span class="keyword">namespace </span>Logo
{

  <span class="comment">//</span>
  <span class="comment">// View class implementation.</span>
  <span class="comment">//</span>

  <span class="keyword">const</span> <span class="keywordtype">float</span> View::NEAR_CLIP   = 2.0;
  <span class="keyword">const</span> <span class="keywordtype">float</span> View::FAR_CLIP    = 60.0;

  <span class="keyword">const</span> <span class="keywordtype">float</span> View::INIT_POS_X  = 0.0;
  <span class="keyword">const</span> <span class="keywordtype">float</span> View::INIT_POS_Y  = 0.0;
  <span class="keyword">const</span> <span class="keywordtype">float</span> View::INIT_POS_Z  = -30.0;

  <span class="keyword">const</span> <span class="keywordtype">float</span> View::INIT_AXIS_X = 1.0;
  <span class="keyword">const</span> <span class="keywordtype">float</span> View::INIT_AXIS_Y = 0.0;
  <span class="keyword">const</span> <span class="keywordtype">float</span> View::INIT_AXIS_Z = 0.0;
  <span class="keyword">const</span> <span class="keywordtype">float</span> View::INIT_ANGLE  = 20.0;

  <span class="keyword">const</span> <span class="keywordtype">float</span> View::INIT_SCALE  = 1.0;

  <span class="keyword">const</span> <span class="keywordtype">float</span> View::SCALE_MAX   = 2.0;
  <span class="keyword">const</span> <span class="keywordtype">float</span> View::SCALE_MIN   = 0.5;

  View::View()
    : m_Scale(INIT_SCALE), m_BeginX(0.0), m_BeginY(0.0)
  {
    reset();
  }

  View::~View()
  {
  }

  <span class="keywordtype">void</span> View::frustum(<span class="keywordtype">int</span> w, <span class="keywordtype">int</span> h)
  {
    glViewport(0, 0, w, h);

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();

    <span class="keywordflow">if</span> (w &gt; h) {
      <span class="keywordtype">float</span> aspect = static_cast&lt;float&gt;(w) / static_cast&lt;float&gt;(h);
      glFrustum(-aspect, aspect, -1.0, 1.0, NEAR_CLIP, FAR_CLIP);
    } <span class="keywordflow">else</span> {
      <span class="keywordtype">float</span> aspect = static_cast&lt;float&gt;(h) / static_cast&lt;float&gt;(w);
      glFrustum(-1.0, 1.0, -aspect, aspect, NEAR_CLIP, FAR_CLIP);
    }

    glMatrixMode(GL_MODELVIEW);
  }

  <span class="keywordtype">void</span> View::xform()
  {
    glTranslatef(m_Pos[0], m_Pos[1], m_Pos[2]);

    glScalef(m_Scale, m_Scale, m_Scale);

    <span class="keywordtype">float</span> m[4][4];
    Trackball::build_rotmatrix(m, m_Quat);
    glMultMatrixf(&amp;m[0][0]);
  }

  <span class="keywordtype">void</span> View::reset()
  {
    m_Pos[0] = INIT_POS_X;
    m_Pos[1] = INIT_POS_Y;
    m_Pos[2] = INIT_POS_Z;

    <span class="keywordtype">float</span> sine = sin(0.5 * INIT_ANGLE * DIG_2_RAD);
    m_Quat[0] = INIT_AXIS_X * sine;
    m_Quat[1] = INIT_AXIS_Y * sine;
    m_Quat[2] = INIT_AXIS_Z * sine;
    m_Quat[3] = cos(0.5 * INIT_ANGLE * DIG_2_RAD);

    m_Scale = INIT_SCALE;
  }

  <span class="keywordtype">bool</span> View::on_button_press_event(GdkEventButton* event,
                                   Scene* scene)
  {
    m_BeginX = event-&gt;x;
    m_BeginY = event-&gt;y;

    <span class="comment">// don't block</span>
    <span class="keywordflow">return</span> <span class="keyword">false</span>;
  }

  <span class="keywordtype">bool</span> View::on_motion_notify_event(GdkEventMotion* event,
                                    Scene* scene)
  {
    <span class="keywordflow">if</span> (scene == 0)
      <span class="keywordflow">return</span> <span class="keyword">false</span>;

    <span class="keywordtype">float</span> w = scene-&gt;get_width();
    <span class="keywordtype">float</span> h = scene-&gt;get_height();
    <span class="keywordtype">float</span> x = event-&gt;x;
    <span class="keywordtype">float</span> y = event-&gt;y;
    <span class="keywordtype">float</span> d_quat[4];
    <span class="keywordtype">bool</span> redraw = <span class="keyword">false</span>;

    <span class="comment">// Rotation.</span>
    <span class="keywordflow">if</span> (event-&gt;state &amp; GDK_BUTTON1_MASK) {
      Trackball::trackball(d_quat,
                           (2.0 * m_BeginX - w) / w,
                           (h - 2.0 * m_BeginY) / h,
                           (2.0 * x - w) / w,
                           (h - 2.0 * y) / h);
      Trackball::add_quats(d_quat, m_Quat, m_Quat);
      redraw = <span class="keyword">true</span>;
    }

    <span class="comment">// Scaling.</span>
    <span class="keywordflow">if</span> (event-&gt;state &amp; GDK_BUTTON2_MASK) {
      m_Scale = m_Scale * (1.0 + (y - m_BeginY) / h);
      <span class="keywordflow">if</span> (m_Scale &gt; SCALE_MAX)
        m_Scale = SCALE_MAX;
      <span class="keywordflow">else</span> <span class="keywordflow">if</span> (m_Scale &lt; SCALE_MIN)
        m_Scale = SCALE_MIN;
      redraw = <span class="keyword">true</span>;
    }

    m_BeginX = x;
    m_BeginY = y;

    <span class="keywordflow">if</span> (redraw &amp;&amp; !scene-&gt;anim_is_enabled())
      scene-&gt;invalidate();

    <span class="comment">// don't block</span>
    <span class="keywordflow">return</span> <span class="keyword">false</span>;
  }


  <span class="comment">//</span>
  <span class="comment">// Model class implementation.</span>
  <span class="comment">//</span>

  <span class="keyword">const</span> <span class="keywordtype">float</span> Model::MAT_SPECULAR[4]  = { 0.5, 0.5, 0.5, 1.0 };
  <span class="keyword">const</span> <span class="keywordtype">float</span> Model::MAT_SHININESS[1] = { 10.0 };
  <span class="keyword">const</span> <span class="keywordtype">float</span> Model::MAT_BLACK[4]     = { 0.0, 0.0, 0.0, 1.0 };
  <span class="keyword">const</span> <span class="keywordtype">float</span> Model::MAT_RED[4]       = { 1.0, 0.0, 0.0, 1.0 };
  <span class="keyword">const</span> <span class="keywordtype">float</span> Model::MAT_GREEN[4]     = { 0.0, 1.0, 0.0, 1.0 };
  <span class="keyword">const</span> <span class="keywordtype">float</span> Model::MAT_BLUE[4]      = { 0.0, 0.0, 1.0, 1.0 };

  <span class="keyword">const</span> <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> Model::DEFAULT_ROT_COUNT = 100;

  <span class="keyword">static</span> <span class="keywordtype">float</span> AXIS_X[3] = { 1.0, 0.0, 0.0 };
  <span class="keyword">static</span> <span class="keywordtype">float</span> AXIS_Y[3] = { 0.0, 1.0, 0.0 };
  <span class="keyword">static</span> <span class="keywordtype">float</span> AXIS_Z[3] = { 0.0, 0.0, 1.0 };

  <span class="keyword">const</span> Model::RotMode Model::ROT_MODE[] = {
    { AXIS_X,  1.0 },
    { AXIS_Y,  1.0 },
    { AXIS_X,  1.0 },
    { AXIS_Z,  1.0 },
    { AXIS_X,  1.0 },
    { AXIS_Y, -1.0 },
    { AXIS_X,  1.0 },
    { AXIS_Z, -1.0 },
    { 0,       0.0 }  <span class="comment">// terminator</span>
  };

  Model::Model(<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> rot_count,
               <span class="keywordtype">bool</span> enable_anim)
    : m_RotCount(rot_count),
      m_EnableAnim(enable_anim), m_Mode(0), m_Counter(0)
  {
    reset_anim();
  }

  Model::~Model()
  {
  }

  <span class="keywordtype">void</span> Model::init_gl()
  {
    glEnable(GL_CULL_FACE);

    glPushMatrix();

    glMaterialfv(GL_FRONT, GL_SPECULAR, MAT_SPECULAR);
    glMaterialfv(GL_FRONT, GL_SHININESS, MAT_SHININESS);

    <span class="comment">/* Center black cube. */</span>
    glNewList(CUBE, GL_COMPILE);
      glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, MAT_BLACK);
      LogoModel::logo_draw_cube();
    glEndList();

    <span class="comment">/* Forward "G". */</span>
    glNewList(G_FORWARD, GL_COMPILE);
      glDisable(GL_CULL_FACE);
      glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, MAT_BLUE);
      LogoModel::logo_draw_g_plane();
    glEnable(GL_CULL_FACE);

    glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, MAT_BLACK);
      LogoModel::logo_draw_g();
    glEndList();

    <span class="comment">/* Backward "G". */</span>
    glNewList(G_BACKWARD, GL_COMPILE);
      glPushMatrix();
        glRotatef(180.0, 1.0, 0.0, 0.0);

        glDisable(GL_CULL_FACE);
        glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, MAT_BLUE);
        LogoModel::logo_draw_g_plane();
        glEnable(GL_CULL_FACE);

        glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, MAT_BLACK);
        LogoModel::logo_draw_g();

      glPopMatrix();
    glEndList();

    <span class="comment">/* Forward "T". */</span>
    glNewList(T_FORWARD, GL_COMPILE);
      glDisable(GL_CULL_FACE);
      glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, MAT_RED);
      LogoModel::logo_draw_t_plane();
      glEnable(GL_CULL_FACE);

      glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, MAT_BLACK);
      LogoModel::logo_draw_t();
    glEndList();

    <span class="comment">/* Backward "T". */</span>
    glNewList(T_BACKWARD, GL_COMPILE);
      glPushMatrix();
        glRotatef(180.0, 1.0, 0.0, 0.0);

        glDisable(GL_CULL_FACE);
        glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, MAT_RED);
        LogoModel::logo_draw_t_plane();
        glEnable(GL_CULL_FACE);

        glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, MAT_BLACK);
        LogoModel::logo_draw_t();

      glPopMatrix();
    glEndList();

    <span class="comment">/* Forward "K". */</span>
    glNewList(K_FORWARD, GL_COMPILE);
      glDisable(GL_CULL_FACE);
      glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, MAT_GREEN);
      LogoModel::logo_draw_k_plane();
      glEnable(GL_CULL_FACE);

      glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, MAT_BLACK);
      LogoModel::logo_draw_k();
    glEndList();

    <span class="comment">/* Backward "K". */</span>
    glNewList(K_BACKWARD, GL_COMPILE);
      glPushMatrix();
        glRotatef(180.0, 0.0, 0.0, 1.0);

        glDisable(GL_CULL_FACE);
        glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, MAT_GREEN);
        LogoModel::logo_draw_k_plane();
        glEnable(GL_CULL_FACE);

        glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, MAT_BLACK);
        LogoModel::logo_draw_k();
      glPopMatrix();
    glEndList();

    glPopMatrix();

    glEnable(GL_NORMALIZE);
  }

  <span class="keywordtype">void</span> Model::draw()
  {
    <span class="comment">// Init GL context.</span>
    <span class="keyword">static</span> <span class="keywordtype">bool</span> initialized = <span class="keyword">false</span>;
    <span class="keywordflow">if</span> (!initialized) {
      init_gl();
      initialized = <span class="keyword">true</span>;
    }

    <span class="comment">// Animation.</span>
    <span class="keywordflow">if</span> (m_EnableAnim) {
      <span class="keywordflow">if</span> (m_Counter == m_RotCount) {
        <span class="keywordflow">if</span> (ROT_MODE[++m_Mode].axis == 0)
          m_Mode = 0;
        m_Counter = 0;
      }

      <span class="keywordtype">float</span> d_quat[4];
      Trackball::axis_to_quat(ROT_MODE[m_Mode].axis,
                              ROT_MODE[m_Mode].sign * G_PI_2 / m_RotCount,
                              d_quat);
      Trackball::add_quats(d_quat, m_Quat, m_Quat);

      ++m_Counter;
    }

    <span class="comment">// Draw logo model.</span>
    glPushMatrix();
      glTranslatef(m_Pos[0], m_Pos[1], m_Pos[2]);

      <span class="keywordtype">float</span> m[4][4];
      Trackball::build_rotmatrix(m, m_Quat);
      glMultMatrixf(&amp;m[0][0]);

      glRotatef(90.0, 1.0, 0.0, 0.0);
      glCallList(CUBE);
      glCallList(G_FORWARD);
      glCallList(G_BACKWARD);
      glCallList(T_FORWARD);
      glCallList(T_BACKWARD);
      glCallList(K_FORWARD);
      glCallList(K_BACKWARD);
    glPopMatrix();
  }

  <span class="keywordtype">void</span> Model::reset_anim()
  {
    m_Pos[0] = 0.0;
    m_Pos[1] = 0.0;
    m_Pos[2] = 0.0;

    m_Quat[0] = 0.0;
    m_Quat[1] = 0.0;
    m_Quat[2] = 0.0;
    m_Quat[3] = 1.0;

    m_Mode = 0;
    m_Counter = 0;
  }


  <span class="comment">//</span>
  <span class="comment">// Scene class implementation.</span>
  <span class="comment">//</span>

  <span class="keyword">const</span> <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> Scene::TIMEOUT_INTERVAL = 10;

  <span class="keyword">const</span> <span class="keywordtype">float</span> Scene::CLEAR_COLOR[4] = { 0.5, 0.5, 0.8, 1.0 };
  <span class="keyword">const</span> <span class="keywordtype">float</span> Scene::CLEAR_DEPTH    = 1.0;

  <span class="keyword">const</span> <span class="keywordtype">float</span> Scene::LIGHT0_POSITION[4] = { 0.0, 0.0, 30.0, 0.0 };
  <span class="keyword">const</span> <span class="keywordtype">float</span> Scene::LIGHT0_DIFFUSE[4]  = { 1.0, 1.0, 1.0, 1.0 };
  <span class="keyword">const</span> <span class="keywordtype">float</span> Scene::LIGHT0_SPECULAR[4] = { 1.0, 1.0, 1.0, 1.0 };

  Scene::Scene(<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> rot_count,
               <span class="keywordtype">bool</span> enable_anim)
    : m_Menu(0), m_Model(rot_count, enable_anim)
  {
    <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="a63"></a><a class="code" href="classGdk_1_1GL_1_1Config.html#e0">Gdk::GL::Config::create</a>(<a name="a64"></a><a class="code" href="group__gdkmm__glEnums.html#gga35a0">Gdk::GL::MODE_RGB</a>    |
                                       <a name="a65"></a><a class="code" href="group__gdkmm__glEnums.html#gga35a7">Gdk::GL::MODE_DEPTH</a>  |
                                       <a name="a66"></a><a class="code" href="group__gdkmm__glEnums.html#gga35a4">Gdk::GL::MODE_DOUBLE</a>);
    <span class="keywordflow">if</span> (!glconfig) {
      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>(<a class="code" href="group__gdkmm__glEnums.html#gga35a0">Gdk::GL::MODE_RGB</a>   |
                                         <a class="code" href="group__gdkmm__glEnums.html#gga35a7">Gdk::GL::MODE_DEPTH</a>);
      <span class="keywordflow">if</span> (!glconfig) {
        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">//</span>
    <span class="comment">// Add events.</span>
    <span class="comment">//</span>
    add_events(Gdk::BUTTON1_MOTION_MASK    |
               Gdk::BUTTON2_MOTION_MASK    |
               Gdk::BUTTON_PRESS_MASK      |
               Gdk::VISIBILITY_NOTIFY_MASK);

    <span class="comment">// View transformation signals.</span>
    signal_button_press_event().connect(
      sigc::bind(sigc::mem_fun(m_View, &amp;View::on_button_press_event), <span class="keyword">this</span>));
    signal_motion_notify_event().connect(
      sigc::bind(sigc::mem_fun(m_View, &amp;View::on_motion_notify_event), <span class="keyword">this</span>));

    <span class="comment">//</span>
    <span class="comment">// Popup menu.</span>
    <span class="comment">//</span>

    m_Menu = create_popup_menu();
  }

  Scene::~Scene()
  {
  }

  <span class="keywordtype">void</span> Scene::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>;

    glClearColor(CLEAR_COLOR[0], CLEAR_COLOR[1], CLEAR_COLOR[2], CLEAR_COLOR[3]);
    glClearDepth(CLEAR_DEPTH);

    glLightfv(GL_LIGHT0, GL_POSITION, LIGHT0_POSITION);
    glLightfv(GL_LIGHT0, GL_DIFFUSE,  LIGHT0_DIFFUSE);
    glLightfv(GL_LIGHT0, GL_SPECULAR, LIGHT0_SPECULAR);

    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);

    glEnable(GL_DEPTH_TEST);

    glShadeModel(GL_SMOOTH);

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

  <span class="keywordtype">bool</span> Scene::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>;

    m_View.frustum(get_width(), get_height());

    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> Scene::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);

    glLoadIdentity();

    <span class="comment">// View transformation.</span>
    m_View.xform();

    <span class="comment">// Logo model.</span>
    m_Model.draw();

    <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="keywordflow">return</span> <span class="keyword">true</span>;
  }

  <span class="keywordtype">bool</span> Scene::on_button_press_event(GdkEventButton* event)
  {
    <span class="keywordflow">if</span> (event-&gt;button == 3) {
      m_Menu-&gt;popup(event-&gt;button, event-&gt;time);
      <span class="keywordflow">return</span> <span class="keyword">true</span>;
    }

    <span class="comment">// don't block</span>
    <span class="keywordflow">return</span> <span class="keyword">false</span>;
  }

  <span class="keywordtype">bool</span> Scene::on_map_event(GdkEventAny* event)
  {
    <span class="keywordflow">if</span> (m_Model.anim_is_enabled())
      timeout_add();

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

  <span class="keywordtype">bool</span> Scene::on_unmap_event(GdkEventAny* event)
  {
    timeout_remove();

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

  <span class="keywordtype">bool</span> Scene::on_visibility_notify_event(GdkEventVisibility* event)
  {
    <span class="keywordflow">if</span> (m_Model.anim_is_enabled()) {
      <span class="keywordflow">if</span> (event-&gt;state == GDK_VISIBILITY_FULLY_OBSCURED)
        timeout_remove();
      <span class="keywordflow">else</span>
        timeout_add();
    }

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

  <span class="keywordtype">bool</span> Scene::on_timeout()
  {
    <span class="comment">// Invalidate whole window.</span>
    invalidate();
    <span class="comment">// Update window synchronously (fast).</span>
    update();

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

  <span class="keywordtype">void</span> Scene::timeout_add()
  {
    <span class="keywordflow">if</span> (!m_ConnectionTimeout.connected())
      m_ConnectionTimeout = Glib::signal_timeout().connect(
        sigc::mem_fun(*<span class="keyword">this</span>, &amp;Scene::on_timeout), TIMEOUT_INTERVAL);
  }

  <span class="keywordtype">void</span> Scene::timeout_remove()
  {
    <span class="keywordflow">if</span> (m_ConnectionTimeout.connected())
      m_ConnectionTimeout.disconnect();
  }

  <span class="keywordtype">void</span> Scene::toggle_anim()
  {
    <span class="keywordflow">if</span> (m_Model.anim_is_enabled()) {
      m_Model.disable_anim();
      timeout_remove();
    } <span class="keywordflow">else</span> {
      m_Model.enable_anim();
      timeout_add();
    }
  }

  <span class="keywordtype">void</span> Scene::init_anim()
  {
    m_View.reset();
    m_Model.reset_anim();

    invalidate();
  }

  Gtk::Menu* Scene::create_popup_menu()
  {
    Gtk::Menu* menu = Gtk::manage(<span class="keyword">new</span> Gtk::Menu());

    Gtk::Menu::MenuList&amp; menu_list = menu-&gt;items();

    <span class="comment">// Toggle animation</span>
    menu_list.push_back(Gtk::Menu_Helpers::MenuElem(<span class="stringliteral">"Toggle Animation"</span>,
      sigc::mem_fun(*<span class="keyword">this</span>, &amp;Scene::toggle_anim)));

    <span class="comment">// Init orientation</span>
    menu_list.push_back(Gtk::Menu_Helpers::MenuElem(<span class="stringliteral">"Initialize"</span>,
      sigc::mem_fun(*<span class="keyword">this</span>, &amp;Scene::init_anim)));

    <span class="comment">// Quit</span>
    menu_list.push_back(Gtk::Menu_Helpers::MenuElem(<span class="stringliteral">"Quit"</span>,
      sigc::ptr_fun(&amp;Gtk::Main::quit)));    

    <span class="keywordflow">return</span> menu;
  }


  <span class="comment">//</span>
  <span class="comment">// Application class implementation.</span>
  <span class="comment">//</span>

  <span class="keyword">const</span> Glib::ustring Application::APP_NAME = <span class="stringliteral">"Logo"</span>;

  Application::Application(<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> rot_count,
                           <span class="keywordtype">bool</span> enable_anim)
    : m_VBox(false, 0), m_Scene(rot_count, enable_anim), m_ButtonQuit(<span class="stringliteral">"Quit"</span>)
  {
    <span class="comment">//</span>
    <span class="comment">// Top-level window.</span>
    <span class="comment">//</span>

    set_title(APP_NAME);

    <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">// Application scene.</span>
    <span class="comment">//</span>

    m_Scene.set_size_request(300, 300);

    m_VBox.pack_start(m_Scene);

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

    m_ButtonQuit.signal_clicked().connect(
      sigc::mem_fun(*<span class="keyword">this</span>, &amp;Application::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();
  }

  Application::~Application()
  {
  }

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

  <span class="keywordtype">bool</span> Application::on_key_press_event(GdkEventKey* event)
  {
    <span class="keywordflow">switch</span> (event-&gt;keyval) {
    <span class="keywordflow">case</span> GDK_a:
      m_Scene.toggle_anim();
      <span class="keywordflow">break</span>;
    <span class="keywordflow">case</span> GDK_i:
      m_Scene.init_anim();
      <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_Scene.invalidate();

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


} <span class="comment">// namespace Logo</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="a67"></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">unsigned</span> <span class="keywordtype">int</span> rot_count = Logo::Model::DEFAULT_ROT_COUNT;
  <span class="keywordtype">bool</span> enable_anim = <span class="keyword">true</span>;

  <span class="keywordtype">bool</span> arg_count = <span class="keyword">false</span>;
  <span class="keywordflow">for</span> (<span class="keywordtype">int</span> i = 1; i &lt; argc; ++i) {
    <span class="keywordflow">if</span> (arg_count)
      rot_count = std::atoi(argv[i]);

    <span class="keywordflow">if</span> (std::strcmp(argv[i], <span class="stringliteral">"--help"</span>) == 0 ||
        std::strcmp(argv[i], <span class="stringliteral">"-h"</span>) == 0) {
      std::cerr &lt;&lt; <span class="stringliteral">"Usage: "</span>
                &lt;&lt; argv[0]
                &lt;&lt; <span class="stringliteral">" [-count num] [-noanim] [--help]\n"</span>;
      std::exit(0);
    }

    <span class="keywordflow">if</span> (std::strcmp(argv[i], <span class="stringliteral">"-count"</span>) == 0)
      arg_count = <span class="keyword">true</span>;

    <span class="keywordflow">if</span> (std::strcmp(argv[i], <span class="stringliteral">"-noanim"</span>) == 0)
      enable_anim = <span class="keyword">false</span>;
  }

  <span class="comment">//</span>
  <span class="comment">// Query OpenGL extension version.</span>
  <span class="comment">//</span>

  <span class="keywordtype">int</span> major, minor;
  <a name="a68"></a><a class="code" href="namespaceGdk_1_1GL.html#a116">Gdk::GL::query_version</a>(major, minor);
  std::cout &lt;&lt; <span class="stringliteral">"OpenGL extension version - "</span>
            &lt;&lt; major &lt;&lt; <span class="stringliteral">"."</span> &lt;&lt; minor &lt;&lt; std::endl;

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

  Logo::Application application(rot_count, enable_anim);

  kit.run(application);

  <span class="keywordflow">return</span> 0;
}
</pre></div> <hr size="1"><address style="align: right;"><small>Generated on Mon Feb 27 18:46:52 2006 for gtkglextmm by&nbsp;
<a href="http://www.doxygen.org/index.html">
<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.4 </small></address>
</body>
</html>

Perl :: Catalyst :: PostgreSQL :: RPM Valid HTML 4.01 Transitional