Torus.cpp

#include "Torus.h"
#include "Geometry.h"
#include "Textures.h"

Torus::Torus (double i_r, double o_r, int n_s, int n_r)
{
        inner_radius = i_r;
        outer_radius = o_r;
        n_sides = n_s;
        n_rings = n_r;
}

Torus::~Torus ()
{
        // nothing to do
}

void Torus::Draw ()
{
        // use spherical texture mapping (which does not look very good).
        glEnable (GL_TEXTURE_2D);

        glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP); 
        glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);  

        glEnable(GL_TEXTURE_GEN_S);                          
        glEnable(GL_TEXTURE_GEN_T); 

        glBindTexture (GL_TEXTURE_2D, Textures::GetId (T_PERLIN));

        glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, emission);

        glColor4fv (color);
        glutSolidTorus (inner_radius, outer_radius, n_sides, n_rings);

        glDisable(GL_TEXTURE_GEN_S);
        glDisable(GL_TEXTURE_GEN_T);

        glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR); 
        glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);  

        glDisable (GL_TEXTURE_2D);
}

double Torus::GetBoundingRadius ()
{
        return inner_radius + outer_radius;
}

BoundingBox Torus::GetBoundingBox ()
{
        BoundingBox result;

        result.xmin = - inner_radius - outer_radius;
        result.xmax = inner_radius + outer_radius;
        result.ymin = - inner_radius - outer_radius;
        result.ymax = inner_radius + outer_radius;
        result.zmin = - inner_radius;
        result.zmax = inner_radius;

        return result;
}

Torus2::Torus2 (double radius_t, double radius_p, int n_sides_, int n_rings_)
{
        r_t = radius_t;
        r_p = radius_p;
        n_sides = n_sides_;
        n_rings = n_rings_;

        data = NULL;
        indices = NULL;

        Construct ();
}

Torus2::~Torus2 ()
{
        // nothing to do.
}

void Torus2::SetTexture (GLuint texture_id)
{
        ComputeSphericalTextureCoordinates (texture_id);
}

double Torus2::GetBoundingRadius ()
{
        return r_t + r_p;
}

BoundingBox Torus2::GetBoundingBox ()
{
        BoundingBox result;

        result.xmax = r_t + r_p;
        result.xmin = -r_t - r_p;
        result.ymax = r_t + r_p;
        result.ymin = -r_t - r_p;
        result.zmax = r_p;
        result.zmin = -r_p;

        return result;
}

void Torus2::Construct ()
{
        int index;
        double t, p;

        // allocate memory
        data = new float[n_sides * n_rings * 3];
        indices = new GLuint[n_sides * n_rings * 6];

        // fill data
        index = 0;
        for (int ring_index = 0; ring_index < n_rings; ring_index++)
        {
                for (int side_index = 0; side_index < n_sides; side_index++)
                {
                        t = 2.0 * MY_PI * ring_index / n_rings;
                        p = 2.0 * MY_PI * side_index / n_sides;

                        data[index++] = (r_t + r_p * cos (p)) * cos (t);
                        data[index++] = (r_t + r_p * cos (p)) * sin (t);
                        data[index++] =  r_p * sin (p);
                }
        }

        // fill indices
        index = 0;
        for (int ring_index = 0; ring_index < n_rings; ring_index++)
        {
                for (int side_index = 0; side_index < n_sides; side_index++)
                {
                        // first_triangle
                        indices[index++] = (ring_index * n_sides) + side_index;
                        indices[index++] = (ring_index * n_sides) + (side_index + 1)%n_sides;
                        indices[index++] = (((ring_index+1)%n_rings) * n_sides) + side_index;

                        // second triangle
                        indices[index++] = (ring_index * n_sides) + (side_index + 1)%n_sides;
                        indices[index++] = (((ring_index+1)%n_rings) * n_sides) + (side_index + 1)%n_sides;
                        indices[index++] = (((ring_index+1)%n_rings) * n_sides) + side_index;
                }
        }
        // set pointers
        SetVertexData (data, n_sides * n_rings);
        SetVertexIndices (indices, n_sides * n_rings * 2);

        // compute normals
        ComputeNormals (true);
}

---