BasicShape.h

Go to the documentation of this file.

// This is OPEN SOURCE software developed by James R. Miller (jrmiller@ku.edu)

#ifndef BASICSHAPE_H
#define BASICSHAPE_H

#ifdef __APPLE__
#include "GLFW/glfw3.h"
#else
#include <GL/gl.h>
#endif

#include "AffPoint.h"
#include "AffVector.h"

class BasicShape
{
public:
    virtual ~BasicShape();

    enum Caps { CAP_AT_NEITHER, CAP_AT_BOTTOM, CAP_AT_TOP, CAP_AT_BOTH };

    static BasicShape* makeBlock(
        const cryph::AffPoint& llCorner,
        const cryph::AffVector& uEdge, double uLength,
        const cryph::AffVector& vEdge, double vLength,
        const cryph::AffVector& wEdge, double wLength);

    static BasicShape* makeBoundedCone(
        const cryph::AffPoint& Pbottom, const cryph::AffPoint& Ptop,
        double radiusAtBottom, double radiusAtTop,
        int nPointsAroundSide=10, int nPointsAlongAxis=2,
        Caps capSpec=CAP_AT_BOTH,
        double sMin=0, double sMax=0, double tMin=0, double tMax=0,
        const cryph::AffVector& sZero=cryph::AffVector::xu);

    static BasicShape* makeBoundedCylinder(
        const cryph::AffPoint& Pbottom, const cryph::AffPoint& Ptop,
        double radius,
        int nPointsAroundSide=10, int nPointsAlongAxis=2,
        Caps capSpec=CAP_AT_BOTH,
        double sMin=0, double sMax=0, double tMin=0, double tMax=0,
        const cryph::AffVector& sZero=cryph::AffVector::xu);

    static BasicShape* makeSphere(
        const cryph::AffPoint& center, double radius,
        int nPointsAroundSide=15, int nPointsAlongAxis=15,
        double sMin=0, double sMax=0, double tMin=0, double tMax=0,
        const cryph::AffVector& upAxis=cryph::AffVector::yu,
        const cryph::AffVector& sZero=cryph::AffVector::xu);

    static BasicShape* makeTorus(
        const cryph::AffPoint& center, const cryph::AffVector& u, const cryph::AffVector& v,
        double rMajor, double rMinor,
        double thetaMinDegrees=0.0, double thetaMaxDegrees=360.0,
        double phiMinDegrees=0, double phiMaxDegrees=360.0,
        int nPointsInThetaDirection=60, int nPointsInPhiDirection=40,
        double sMin=0, double sMax=0, double tMin=0, double tMax=0);

    void getMCBoundingBox(double* xyzLimits) const;

    int getNumPoints() const { return nPoints; }

    const float* getPointCoords() const { return pointCoords; }

    const float* getNormals() const { return normals; }

    const float* getTextureCoords() const { return textureCoords; }

    int getNumDrawArraysCalls() const { return nDrawArraysCalls; }

    int getDrawArraysData(int i, GLenum& mode, int& thisStartsFace, int& offset,
            bool& canUsePerVertexTexCoords, bool& canUseNormalArray,
            cryph::AffVector& fixedN) const;

    int getNumIndexLists() const { return nIndexLists; }

    const void* getIndexList(int i, GLenum& mode, int& thisStartsFace, int& nInList,
            GLenum& type,
            bool& canUsePerVertexTexCoords, bool& canUsePerVertexNormals,
            cryph::AffVector& fixedNormal) const;

    static bool getAlwaysGeneratePerVertexNormals()
        { return alwaysGeneratePerVertexNormals; }

    static void setAlwaysGeneratePerVertexNormals(bool b);

private:
    BasicShape(); // use public factory methods instead
    BasicShape(const BasicShape& s) {} // don't make copies

    // common "worker" routines for cones and cylinders:
    void addCapsFixedNormal(Caps capSpec, int nPointsInCap,
            const cryph::AffVector& axis, int nPointsAlongAxis);
    void addCapsPerVertexNormals(Caps capSpec, int nPointsAlongAxis,
            int firstAtBottom, int firstAtTop, int nPointsInOneCap);
    void addDrawArraysDataForConeCylCaps(int nextIndex,
            int firstAtBottom, int firstAtTop, int nPointsInOneCap);
    void allocateIndexListsForConeCyl(int nPointsAlongAxis, Caps capSpec);
    void allocateIndexListsForSphere(int nPointsAlongAxis);
    void makeBlockData(
        const cryph::AffPoint& llCorner,
        const cryph::AffVector& uEdge, double uLength,
        const cryph::AffVector& vEdge, double vLength,
        const cryph::AffVector& wEdge, double wLength);
    void finishBlockDataUsingFixedNormals(
        const cryph::AffVector& uvNormal, const cryph::AffVector& uwNormal,
        const cryph::AffVector& vwNormal, const cryph::AffPoint* vertices);
    void finishBlockDataUsingPerVertexNormals(
        const cryph::AffVector& uvNormal, const cryph::AffVector& uwNormal,
        const cryph::AffVector& vwNormal, const cryph::AffPoint* vertices);
    void makeDrawArraysDataForConeCyl(int nPointsWithoutCaps,
        int firstAtBottom, int firstAtTop); // if nPointsAlongAxis == 2
    void makeEightBlockVertices(
        const cryph::AffPoint& llCorner,
        const cryph::AffVector& u, double uLength,
        const cryph::AffVector& v, double vLength,
        const cryph::AffVector& w, double wLength,
        cryph::AffPoint* vertices);
    void makeIndexLists(int nPointsAroundSide, int nPointsAlongAxis);
    void makeRuledSurfaceBetweenCircles(
        const cryph::AffPoint& Pbottom, cryph::AffVector& axis,
        double height, double radiusAtBottom, double radiusAtTop,
        int nPointsAroundSide, int nPointsAlongAxis,
        Caps capSpec, double sMin, double sMax, double tMin, double tMax,
        const cryph::AffVector& sZero);
    void makeSphere(const cryph::AffPoint& center,
                    const cryph::AffVector& u, const cryph::AffVector& v, const cryph::AffVector& w,
                    double radius,
                    int nPointsAroundSide, int nPointsAlongAxis,
                    double sMin, double sMax, double tMin, double tMax);
    static void updateOneCoordLimit(double c, double minMax[2]);
    void updateXYZMinMaxLimits(const cryph::AffPoint& p);

    // geometry and per-vertex attributes
    float* pointCoords;
    float* normals;
    float* textureCoords;
    int nPoints;
    // always generate per-vertex normals, even for flat faces?
    static bool alwaysGeneratePerVertexNormals;
    // for bounding box
    double xyzMinMax[6];

    struct DrawArraysCallData
    {
        GLenum mode;
        int thisStartsFace; // >= 0 ==> this starts a new face on the original shape
        int offset;
        int nPointsInCall;
        bool usePerVertexTexCoords, usePerVertexNormals;
        cryph::AffVector useFixedNormal; // if !usePerVertexNormals
        DrawArraysCallData() : thisStartsFace(-1) {}
    };
    DrawArraysCallData* drawArraysCallData;
    int nDrawArraysCalls;

    struct IndexListData
    {
        GLenum mode;
        int thisStartsFace; // >= 0 ==> this starts a new face on the original shape
        int* indices;
        int nIndices;
        bool usePerVertexTexCoords, usePerVertexNormals;
        cryph::AffVector useFixedNormal; // if !usePerVertexNormals
        IndexListData(): thisStartsFace(-1) {}
    };
    IndexListData* indexLists;
    int nIndexLists, nIndexListsConstructed;
};

#endif