---

PolyLib.cc

Go to the documentation of this file.

/*
    File:           PolyLib.cc

    Function:       See header file

    Author(s):      Andrew Willmott

    Copyright:      (c) 1995-2000, Andrew Willmott

    Notes:          

*/

#include "gcl/PolyLib.h"
#include "gcl/SceneLang.h"

Int PolyLib::numTesselations = 32;

Void AddPolyObjects()
{
    slAddToLibrary(slBeginObject("tetrahedron"));
    CreateSolidTetrahedron();
    slEndObject();

    slAddToLibrary(slBeginObject("cylinder"));
    CreateSolidCylinder();
    slEndObject();

    slAddToLibrary(slBeginObject("sphere"));
    CreateSolidSphere();
    slEndObject();

    slAddToLibrary(slBeginObject("cone"));
    CreateSolidCone();
    slEndObject();
    
    slAddToLibrary(slBeginObject("cube"));
    CreateSolidCube();
    slEndObject();

    slAddToLibrary(slBeginObject("square"));
    CreateSquare();
    slEndObject();
}

Void CreateSquare()
{
    slPointList();
    slPoint(Point(-1, 0, -1));
    slPoint(Point(-1, 0,  1));
    slPoint(Point( 1, 0,  1));
    slPoint(Point( 1, 0, -1));
    slPointIndexes(Indexes(0, 1, 2, 3, IDX_END));
    slPoly();
}

Void CreateSolidCube()
{
    slPointList();
    slPoint(Point(-1, -1, -1));
    slPoint(Point( 1, -1, -1));
    slPoint(Point( 1, -1,  1));
    slPoint(Point(-1, -1,  1));
    slPoint(Point(-1,  1, -1));
    slPoint(Point( 1,  1, -1));
    slPoint(Point( 1,  1,  1));
    slPoint(Point(-1,  1,  1));

    slApply(Scalef(0.5));
    slPointIndexes(Indexes(0, 1, 2, 3, IDX_END));
    slPoly();

    slPointIndexes(Indexes(7, 6, 5, 4, IDX_END));
    slPoly();
    
    slPointIndexes(Indexes(1, 5, 6, 2, IDX_END));
    slPoly();
    
    slPointIndexes(Indexes(6, 7, 3, 2, IDX_END));
    slPoly();
    
    slPointIndexes(Indexes(4, 0, 3, 7, IDX_END));
    slPoly();
    
    slPointIndexes(Indexes(1, 0, 4, 5, IDX_END));
    slPoly();
}

// --- Tetrahedron creation ---------------------------------------------------

Void TetrahedronPoints()
// Creates a tetrahedron lying on the x-z plane, and centred on the y-axis.
{
    GCLReal     RecipRoot3;
    GCLReal     hmax;

    RecipRoot3 = 1 / sqrt(3);
    hmax = sqrt(2.0 / 3.0);         // Height of tetrahedron 

    slPointList();
    slPoint(Point(0, 0, RecipRoot3));
    slPoint(Point(0.5, 0, -RecipRoot3 / 2));
    slPoint(Point(-0.5, 0, -RecipRoot3 / 2));
    slPoint(Point(0, hmax, 0));
}

Void CreateSolidTetrahedron()
// Creates a tetrahedron lying on the x-z plane, and centred on the y-axis.
{
    TetrahedronPoints();

    slPointIndexes(Indexes(0, 2, 1, IDX_END));      // base         
    slPoly();
    slPointIndexes(Indexes(0, 1, 3, IDX_END));      // right side 
    slPoly();
    slPointIndexes(Indexes(3, 1, 2, IDX_END));      // back 
    slPoly();
    slPointIndexes(Indexes(0, 3, 2, IDX_END));      // left side
    slPoly();
}


// --- Cylinder ---------------------------------------------------------------


Void CylinderPoints()
{
    Int i;
    GCLReal theta, dTheta, cosTheta, sinTheta;

    theta = 0;
    dTheta = 2 * vl_pi / PolyLib::numTesselations;
    slPointList();
    for (i = 0; i < PolyLib::numTesselations; i++)
    {
        cosTheta = cos(theta) / 2.0;
        sinTheta = sin(theta) / 2.0;
        slPoint(Point(cosTheta, 0.5, sinTheta));
        slPoint(Point(cosTheta, -0.5, sinTheta));
        theta = theta + dTheta;
    }
}

Void SolidCylinderEnds()
{
    Int         i;
    IndexList   topFace, bottomFace;
    
    for (i = 0; i < PolyLib::numTesselations; i++)
    {
        topFace.Append(2 * (PolyLib::numTesselations - 1 - i));
        bottomFace.Append(2 * i + 1);
    }

    slPointIndexes(topFace);
    slPoly();
    slPointIndexes(bottomFace);
    slPoly();
}

Void SolidCylinderSides()
{
    Int         topLHS;
    IndexList   tesselation(4);
    Int         i;

    for (i = 0; i < PolyLib::numTesselations; i++)
    {
        // Vertex num of top LHS of face 
        topLHS = 2 * i;
        // Do LHS   
        tesselation[0] = (topLHS + 1);          
        tesselation[1] = topLHS;                
        // Last face has to close back to first 2 vertices 
        if (i == PolyLib::numTesselations - 1)
            topLHS = -2;                        
        tesselation[2] = (topLHS + 2);
        tesselation[3] = (topLHS + 3);
        slPointIndexes(tesselation);
        slPoly();
    }
}

Void CreateSolidCylinder()
{
    CylinderPoints();
    SolidCylinderEnds();
    SolidCylinderSides();
}


// --- Cone -------------------------------------------------------------------


Void ConePoints()
{
    Int         i;
    GCLReal     theta, dTheta, cosTheta, sinTheta;

    theta = 0;
    dTheta = 2 * vl_pi / PolyLib::numTesselations;
    slPointList();
    slPoint(Point(0, 1, 0));
    
    for (i = 0; i < PolyLib::numTesselations; i++)
    {
        cosTheta = cos(theta) / 2;
        sinTheta = sin(theta) / 2;
        slPoint(Point(cosTheta, 0, sinTheta));
        theta = theta + dTheta;
    }
}

Void SolidConeEnd()
{
    Int i;
    
    slPointIndexList();
    for (i = 1; i <= PolyLib::numTesselations; i++)
        slPointIndex(i);

    slPoly();
}

Void SolidConeSides()
{
    IndexList   tesselation(3);
    Int         i;

    tesselation[0] = 0;

    for (i = 1; i <= PolyLib::numTesselations; i++)
    {
        if (i == PolyLib::numTesselations)
            // Last face has to close back to first 2 vertices 
            tesselation[1] = 1;   
        else
            tesselation[1] = i + 1;
        tesselation[2] = i; 

        slPointIndexes(tesselation);
        slPoly();
    }
}

Void CreateSolidCone()
{
    ConePoints();
    SolidConeEnd();
    SolidConeSides();
}


// --- Sphere -----------------------------------------------------------------

Void SpherePoints()
{
    Int     i, j;
    GCLReal theta, dtheta, phi, dphi, z;

    slPointList();
    slPoint(Point(0.0, 0.0, 0.5));

    phi = 2.0 * vl_pi / PolyLib::numTesselations;
    dphi = phi;
    dtheta = dphi;

    for (j = 0; j < (PolyLib::numTesselations / 2) - 1; j++)
    {
        z = cos(phi) / 2.0;
        theta = 0.0;
        for (i = 0; i < PolyLib::numTesselations; i++)
        {
            slPoint(Point(sin(phi) * cos(theta) / 2.0,
                          sin(phi) * sin(theta) / 2.0,
                          z));
            theta += dtheta;
        }
        phi += dphi;
    }   
    
    slPoint(Point(0.0, 0.0, -0.5));
}

Void AddSphereFaces()
{
    Int         i, j, p, offset;
    IndexList   triangle1(3), triangle2(3), square(4);

    p = PolyLib::numTesselations;

    for (i = 1; i <= PolyLib::numTesselations; i++)
        // Step around the sphere... 
    {
        // Make a face on the top of the sphere 
        triangle1[0] = 0;
        triangle1[1] = p;
        triangle1[2] = i;
        slPointIndexes(triangle1);
        slPoly();

        // Make the faces between rings of vertices... 
        offset = 0;
        for (j = 0; j < (PolyLib::numTesselations / 2) - 2; j++)
        {
            // Make one such face 
            square[0] = i + offset;
            square[1] = p + offset;
            offset += PolyLib::numTesselations;
            square[2] = p + offset;
            square[3] = i + offset;
            slPointIndexes(square);
            slPoly();
        }

        // Make a face on the bottom of the sphere 
        triangle2[0] = offset + PolyLib::numTesselations + 1; // last vertex
        triangle2[1] = offset + i;
        triangle2[2] = offset + p;
        slPointIndexes(triangle2);
        slPoly();

        p = i;
    }
}

Void CreateSolidSphere()
{
    SpherePoints();
    AddSphereFaces();
}

---