sphere.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_SHAPES_SPHERE_1107121519_HPP
#define OGLPLUS_SHAPES_SPHERE_1107121519_HPP

#include <oglplus/shapes/draw.hpp>
#include <oglplus/face_mode.hpp>

#include <oglplus/shapes/vert_attr_info.hpp>

#include <oglplus/math/constants.hpp>
#include <oglplus/math/sphere.hpp>

namespace oglplus {
namespace shapes {

class Sphere
 : public DrawingInstructionWriter
 , public DrawMode
{
private:
    double _radius;
    unsigned _sections, _rings;
public:
    Sphere(void)
     : _radius(1.0)
     , _sections(18)
     , _rings(12)
    { }


    Sphere(double radius, unsigned sections, unsigned rings)
     : _radius(radius)
     , _sections(sections)
     , _rings(rings)
    {
        assert(_radius > 0);
        assert(_sections > 0);
        assert(_rings > 0);
    }

    double Radius(void) const
    {
        return _radius;
    }


    void Radius(double radius)
    {
        _radius = radius;
        assert(_radius > 0);
    }

    unsigned Sections(void) const
    {
        return _sections;
    }


    void Sections(unsigned sections)
    {
        _sections = sections;
        assert(_sections > 0);
    }

    unsigned Rings(void) const
    {
        return _rings;
    }


    void Rings(unsigned rings)
    {
        _rings = rings;
        assert(_rings > 0);
    }

    FaceOrientation FaceWinding(void) const
    {
        return FaceOrientation::CCW;
    }

    template <typename T>
    GLuint Normals(std::vector<T>& dest) const
    {
        dest.resize(((_rings + 2) * (_sections + 1)) * 3);
        unsigned k = 0;
        //
        double r_step = (1.0 * math::Pi()) / double(_rings + 1);
        double s_step = (2.0 * math::Pi()) / double(_sections);

        for(unsigned r=0; r!=(_rings+2);++r)
        {
            double r_lat = std::cos(r*r_step);
            double r_rad = std::sin(r*r_step);
            // the sections
            for(unsigned s=0; s!=(_sections+1);++s)
            {
                dest[k++] = T(r_rad *  std::cos(s*s_step));
                dest[k++] = T(r_lat);
                dest[k++] = T(r_rad * -std::sin(s*s_step));
            }
        }
        //
        assert(k == dest.size());
        // 3 values per vertex
        return 3;
    }

    template <typename T>
    GLuint Tangents(std::vector<T>& dest) const
    {
        dest.resize(((_rings + 2) * (_sections + 1)) * 3);
        unsigned k = 0;
        //
        double s_step = (2.0 * math::Pi()) / double(_sections);

        for(unsigned r=0; r!=(_rings+2);++r)
        {
            for(unsigned s=0; s!=(_sections+1);++s)
            {
                dest[k++] = T(-std::sin(s*s_step));
                dest[k++] = T(0);
                dest[k++] = T(-std::cos(s*s_step));
            }
        }
        //
        assert(k == dest.size());
        // 3 values per vertex
        return 3;
    }

    template <typename T>
    GLuint Bitangents(std::vector<T>& dest) const
    {
        dest.resize(((_rings + 2) * (_sections + 1)) * 3);
        unsigned k = 0;
        //
        double r_step = (1.0 * math::Pi()) / double(_rings + 1);
        double s_step = (2.0 * math::Pi()) / double(_sections);

        double ty = 0.0;
        for(unsigned r=0; r!=(_rings+2);++r)
        {
            double r_lat = std::cos(r*r_step);
            double r_rad = std::sin(r*r_step);
            double ny = r_lat;
            // the sections
            for(unsigned s=0; s!=(_sections+1);++s)
            {
                double tx = -std::sin(s*s_step);
                double tz = -std::cos(s*s_step);
                double nx = -r_rad * tz;
                double nz =  r_rad * tx;

                dest[k++] = T(ny*tz-nz*ty);
                dest[k++] = T(nz*tx-nx*tz);
                dest[k++] = T(nx*ty-ny*tx);
            }
        }
        //
        assert(k == dest.size());
        // 3 values per vertex
        return 3;
    }

    template <typename T>
    GLuint Positions(std::vector<T>& dest) const
    {
        GLuint n = Normals(dest);
        if(_radius != 1.0)
            for(auto i=dest.begin(),e=dest.end(); i!= e; ++i)
                *i *= _radius;
        return n;
    }

    template <typename T>
    GLuint TexCoordinates(std::vector<T>& dest) const
    {
        dest.resize(((_rings + 2) * (_sections + 1)) * 2);
        unsigned k = 0;
        //
        double r_step = 1.0 / double(_rings + 1);
        double s_step = 1.0 / double(_sections);
        for(unsigned r=0; r!=(_rings+2);++r)
        {
            double r_lat = 1.0 - r*r_step;
            // the sections
            for(unsigned s=0; s!=(_sections+1);++s)
            {
                dest[k++] = T(s * s_step);
                dest[k++] = T(r_lat);
            }
        }
        assert(k == dest.size());
        // 2 values per vertex
        return 2;
    }

#if OGLPLUS_DOCUMENTATION_ONLY

    typedef VertexAttribsInfo<Sphere> VertexAttribs;
#else
    typedef VertexAttribsInfo<
        Sphere,
        std::tuple<
            VertexPositionsTag,
            VertexNormalsTag,
            VertexTangentsTag,
            VertexBitangentsTag,
            VertexTexCoordinatesTag
        >
    > VertexAttribs;
#endif

    template <typename T>
    void BoundingSphere(oglplus::Sphere<T>& bounding_sphere) const
    {
        bounding_sphere = oglplus::Sphere<T>(
            T(0),
            T(0),
            T(0),
            T(_radius)
        );
    }

    typedef std::vector<GLushort> IndexArray;

    IndexArray Indices(Default = Default()) const;

    DrawingInstructions Instructions(Default = Default()) const;
};

} // shapes
} // oglplus

#if !OGLPLUS_LINK_LIBRARY || defined(OGLPLUS_IMPLEMENTING_LIBRARY)
#include <oglplus/shapes/sphere.ipp>
#endif // OGLPLUS_LINK_LIBRARY

#endif // include guard