aux.C

Go to the documentation of this file.

/*
 * This file is part of the "Archon" framework.
 * (http://files3d.sourceforge.net)
 *
 * Copyright © 2002 by Kristian Spangsege and Brian Kristiansen.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation under the terms of the GNU General Public License is
 * hereby granted. No representations are made about the suitability of
 * this software for any purpose. It is provided "as is" without express
 * or implied warranty. See the GNU General Public License
 * (http://www.gnu.org/copyleft/gpl.html) for more details.
 *
 * The characters in this file are ISO8859-1 encoded.
 *
 * The documentation in this file is in "Doxygen" style
 * (http://www.doxygen.org).
 */

#include <GL/gl.h>

#include <archon/x3d/server/field_type.H>
#include <archon/x3d/server/field.H>
#include <archon/x3d/server/aux.H>

namespace Archon
{
  namespace X3D
  {
    const NodeType *Torus::type = 0;  // Not a part of X3D

    void initializeAuxComponent()
    {
      vector<const FieldBase *> fields;

      // Torus

      fields.push_back(newPrivateField("majorRadius", SFFloat::type,
                                       &Torus::majorRadius));
      fields.push_back(newPrivateField("minorRadius", SFFloat::type,
                                       &Torus::minorRadius));
      Torus::type =
        NodeType::newConcrete("Torus", "geometry", Torus::instantiate, &fields,
                              Geometry3DNode::type);
      fields.clear();
    }

    int Torus::intersect(const Math::Ray3 &ray, double &dist) const
    {
      return Math::intersectTorus(ray, majorRadius, minorRadius, dist) ? 1 : 0;
    }

    void Torus::getNormalAndTexCoord(Vector3 hitPoint, int where,
                                     const Shape *,
                                     Vector3 *hitNormal,
                                     Vector2 *hitTexCoord) const
    {
      double a = sqrt(hitPoint[0]*hitPoint[0] + hitPoint[2]*hitPoint[2]);
      double b = a - majorRadius;

      if(hitTexCoord)
      {
        hitTexCoord->set(hitPoint[0] == 0 ? hitPoint[2] < 0 ? 0 : 0.5 :
                         (hitPoint[0] < 0 ? 0.25 : 0.75) -
                         atan(hitPoint[2]/hitPoint[0]) / (2 * M_PI),
                         hitPoint[1] == 0 ? b < 0 ? 0 : 0.5 :
                         (hitPoint[1] < 0 ? 0.25 : 0.75) -
                         atan(b/hitPoint[1]) / (2 * M_PI));
      }

      if(hitNormal)
      {
        b /= a;
        hitNormal->set(hitPoint[0]*b, hitPoint[1], hitPoint[2]*b);
      }
    }

    void renderNormals(const vector<Vector3> &, const RenderConfig *);

    void Torus::render(bool texture,
                       const Shape *shape,
                       const RenderConfig *config)
    {
      glFrontFace(GL_CW);
      glDisable(GL_COLOR_MATERIAL);
      glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, 0);
      glEnable(GL_CULL_FACE);

      vector<Vector3> normals;
      const bool showNormals = config->showNormals;

      const int phiSteps = config->subdivision2;  // Around a section of the torus tube
      const int thetaSteps = config->subdivision1; // Around the hole

      vector<Vector3> nl(thetaSteps);
      vector<Vector3> vl(thetaSteps);
      vector<Vector3> fnl(thetaSteps);
      vector<Vector3> fvl(thetaSteps);

      for(int i=0; i<thetaSteps; ++i)
      {
        double texS = 1.0 / thetaSteps * i;
        double theta = 2 * M_PI * texS;

        double cos_theta = cos(theta);
        double sin_theta = sin(theta);

        fnl[i] = nl[i] = Vector3(sin_theta, 0, cos_theta);
        fvl[i] = vl[i] = nl[i] * (minorRadius - majorRadius);
      }

      double prevTexT = 0;
      Vector3 v;

      for(int i=1; i<phiSteps; ++i)
      {
        glBegin(GL_QUAD_STRIP);

        const Vector3 pvl0 = vl[0];
        const Vector3 pnl0 = nl[0];

        double texT = 1.0 / phiSteps * i;
        double phi = 2 * M_PI * texT;

        double cos_phi = cos(phi);
        double sin_phi = sin(phi);

        double a = majorRadius - minorRadius * cos_phi;
        double b = -minorRadius * sin_phi;

        for(int j=0; j<thetaSteps; ++j)
        {
          double texS = 1.0 / thetaSteps * j;
          double theta = 2 * M_PI * texS;

          double cos_theta = cos(theta);
          double sin_theta = sin(theta);

          if(texture) glTexCoord2d(texS, prevTexT);
          v = nl[j];
          glNormal3d(v[0], v[1], v[2]);
          v = vl[j];
          glVertex3d(v[0], v[1], v[2]);
          if(showNormals)
          {
            normals.push_back(v);
            normals.push_back(nl[j]);
          }

          if(texture) glTexCoord2d(texS, texT);
          v = nl[j] = Vector3(cos_phi*sin_theta, -sin_phi, cos_phi*cos_theta);
          glNormal3d(v[0], v[1], v[2]);
          v = vl[j] = Vector3(-sin_theta * a, b, -cos_theta * a);
          glVertex3d(v[0], v[1], v[2]);
        }

        if(texture) glTexCoord2d(1, prevTexT);
        glNormal3d(pnl0[0], pnl0[1], pnl0[2]);
        glVertex3d(pvl0[0], pvl0[1], pvl0[2]);

        if(texture) glTexCoord2d(1, texT);
        v = nl[0];
        glNormal3d(v[0], v[1], v[2]);
        v = vl[0];
        glVertex3d(v[0], v[1], v[2]);

        prevTexT = texT;

        glEnd();
      }

      glBegin(GL_QUAD_STRIP);

      for(int i=0; i<thetaSteps; ++i)
      {
        double texS = 1.0 / thetaSteps * i;

        if(texture) glTexCoord2d(texS, prevTexT);
        v = nl[i];
        glNormal3d(v[0], v[1], v[2]);
        v = vl[i];
        glVertex3d(v[0], v[1], v[2]);
        if(showNormals)
        {
          normals.push_back(v);
          normals.push_back(nl[i]);
        }

        if(texture) glTexCoord2d(texS, 1);
        v = fnl[i];
        glNormal3d(v[0], v[1], v[2]);
        v = fvl[i];
        glVertex3d(v[0], v[1], v[2]);
      }

      if(texture) glTexCoord2d(1, prevTexT);
      v = nl[0];
      glNormal3d(v[0], v[1], v[2]);
      v = vl[0];
      glVertex3d(v[0], v[1], v[2]);

      if(texture) glTexCoord2d(1, 1);
      v = fnl[0];
      glNormal3d(v[0], v[1], v[2]);
      v = fvl[0];
      glVertex3d(v[0], v[1], v[2]);

      glEnd();

      if(showNormals) renderNormals(normals, config);
    }
  }
}

---