omni::visual::Sphere Class Reference

Draw Handler for visualizing a centered sphere. More...

#include <Sphere.h>

Inheritance diagram for omni::visual::Sphere:

Collaboration diagram for omni::visual::Sphere:

Public Types
enum	TexCoordsMode { EQUIRECTANGULAR, FISHEYE }

Public Member Functions
	Sphere (qreal _radius=1.0)
	~Sphere ()
qreal	radius () const
	Return radius of sphere. More...
void	setRadius (qreal)
	Set new sphere radius. More...
int	stacks () const
	Return number of stacks (in Z direction) More...
void	setStacks (int _stacks)
	Set number of stacks. More...
int	slices () const
	Return slices of sphere. More...
void	setSlices (int _slices)
	Set number of slices and update mesh. More...
float	top () const
	Return top position where to cut off sphere. More...
void	setTop (float)
	Set new top position where to cut off sphere. More...
float	bottom () const
	Return bottom position where to cut off sphere. More...
void	setBottom (float)
	Set new bottom position where to cut off sphere. More...
TexCoordsMode	texCoordsMode () const
	Return tex coords mode; fisheye or equirectangular. More...
void	setTexCoordsMode (TexCoordsMode)
	Set tex coords mode, fisheye or equirectangular. More...
void	draw () const
	Draws sphere from vertex buffer object. More...
void	update ()
	Regenerates the mesh and updates the vertex buffer objects. More...
Public Member Functions inherited from omni::visual::Interface
virtual	~Interface ()

Private Member Functions
void	generateStack (float _top, float _bottom, float _topRadius, float _bottomRadius)

Private Attributes
int	stacks_ = 64
int	slices_ = 128
float	top_ = 1.0
float	bottom_ = -1.0
qreal	radius_ = 1.0
VertexVBO	vbo_
VertexVBO::vertex_buffer_type	vertices_
VertexVBO::index_buffer_type	indices_
TexCoordsMode	texCoordsMode_ = EQUIRECTANGULAR

Additional Inherited Members
Static Protected Member Functions inherited from omni::visual::Interface
static void	vertex3 (QVector3D const &)
	glVertex3f from QVector3D More...
static void	visualLine (QVector3D const &_from, QVector3D const &_to)
	Draws a line. More...
static void	color (QColor _color, float _alpha=1.0)
	glColor4f from QColor More...

Detailed Description

Draw Handler for visualizing a centered sphere.

Member Enumeration Documentation

enum omni::visual::Sphere::TexCoordsMode

Enumerator
EQUIRECTANGULAR
FISHEYE

                         {
            EQUIRECTANGULAR,
            FISHEYE
      };

Constructor & Destructor Documentation

omni::visual::Sphere::Sphere

(

qreal

_radius = 1.0

)

                                :
      radius_(_radius)
    {
      update();
    }

omni::visual::Sphere::~Sphere

(

)

    {}

Member Function Documentation

float omni::visual::Sphere::bottom

(

)

const

Return bottom position where to cut off sphere.

    {
      return bottom_;
    }

void omni::visual::Sphere::draw ( ) const

virtual

Draws sphere from vertex buffer object.

Implements omni::visual::Interface.

    {
      glPushMatrix();
      withCurrentContext([this](QOpenGLFunctions& _)
      {
        // Scale offset
        glScalef(radius_, radius_, radius_);
        vbo_.bindAndDraw();
      });
      glPopMatrix();
    }

void omni::visual::Sphere::generateStack ( float  _top, float  _bottom, float  _topRadius, float  _bottomRadius  )

private

Generate vertices

Top triangle

Bottom triangle

    {
      size_t _startIndex = vertices_.size();

      for (size_t i = 0; i <= slices_; ++i)
      {
        /// Generate vertices
        float _m   = 2.0 * M_PI * float(i) / slices_;
        float _cos = cos(_m), _sin = sin(_m);
        QVector3D _topPoint(_cos * _topRadius, _sin * _topRadius, _top);
        QVector3D _bottomPoint(_cos * _bottomRadius, _sin * _bottomRadius,
                               _bottom);
        QVector3D _normalTop(_topPoint.normalized());
        QVector3D _normalBottom(_bottomPoint.normalized());

        auto getTexCoord = [this, &i](QVector3D const& _v) -> QVector2D {
                             QVector2D texCoords;
                             QVector3D uvw = _v.normalized();

                             switch (this->texCoordsMode_) {
                             default:
                             case EQUIRECTANGULAR:
                               texCoords.setX(i / float(slices_));
                               texCoords.setY(1.0 - acos(uvw.z()) / M_PI);
                               break;

                             case FISHEYE: {
                               float _phi = i / float(slices_) * M_PI * 2.0;
                               float _r   = atan2(QVector2D(uvw.x(),
                                                            uvw.y()).length(),
                                                  uvw.z()) / M_PI;
                               texCoords.setX(_r * cos(_phi) + 0.5);
                               texCoords.setY(_r * sin(_phi) + 0.5);
                               break;
                             }
                             }

                             return texCoords;
                           };

        QVector2D _texCoordTop(getTexCoord(_topPoint));
        QVector2D _texCoordBottom(getTexCoord(_bottomPoint));

        vertices_.emplace_back(_topPoint, _normalTop, _texCoordTop);          //
                                                                              // QVector2D(float(i)/slices_,1.0
                                                                              // -
                                                                              // acos(_normalTop.z())
                                                                              // /
                                                                              // M_PI));
        vertices_.emplace_back(_bottomPoint, _normalBottom, _texCoordBottom); //
                                                                              // QVector2D(float(i)/slices_,1.0
                                                                              // -
                                                                              // acos(_normalBottom.z())
                                                                              // /
                                                                              // M_PI));

        /// Top triangle
        indices_.push_back(_startIndex + 2 * i);
        indices_.push_back(_startIndex + 2 * i + 1);
        indices_.push_back(_startIndex + 2 * (i + 1));

        /// Bottom triangle
        indices_.push_back(_startIndex + 2 * i + 1);
        indices_.push_back(_startIndex + 2 * (i + 1) + 1);
        indices_.push_back(_startIndex + 2 * (i + 1));
      }
    }

qreal omni::visual::Sphere::radius

(

)

const

Return radius of sphere.

    {
      return radius_;
    }

void omni::visual::Sphere::setBottom

(

float

_bottom

)

Set new bottom position where to cut off sphere.

    {
      bottom_ = _bottom;
      update();
    }

void omni::visual::Sphere::setRadius

(

qreal

_radius

)

Set new sphere radius.

    {
      radius_ = _radius;
    }

void omni::visual::Sphere::setSlices

(

int

_slices

)

Set number of slices and update mesh.

    {
      slices_ = _slices;
      update();
    }

void omni::visual::Sphere::setStacks

(

int

_stacks

)

Set number of stacks.

    {
      stacks_ = _stacks;
      update();
    }

void omni::visual::Sphere::setTexCoordsMode

(

TexCoordsMode

_texCoordsMode

)

Set tex coords mode, fisheye or equirectangular.

                                                              {
      texCoordsMode_ = _texCoordsMode;
    }

void omni::visual::Sphere::setTop

(

float

_top

)

Set new top position where to cut off sphere.

    {
      top_ = _top;
      update();
    }

int omni::visual::Sphere::slices

(

)

const

Return slices of sphere.

    {
      return slices_;
    }

int omni::visual::Sphere::stacks

(

)

const

Return number of stacks (in Z direction)

    {
      return stacks_;
    }

Sphere::TexCoordsMode omni::visual::Sphere::texCoordsMode

(

)

const

Return tex coords mode; fisheye or equirectangular.

                                                    {
      return texCoordsMode_;
    }

float omni::visual::Sphere::top

(

)

const

Return top position where to cut off sphere.

    {
      return top_;
    }

void omni::visual::Sphere::update ( )

virtual

Regenerates the mesh and updates the vertex buffer objects.

Reimplemented from omni::visual::Interface.

    {
      primaryContextSwitch([&](QOpenGLFunctions& _) {
        vertices_.clear();
        indices_.clear();
        vertices_.reserve(2 * slices_ * stacks_);
        indices_.reserve(6 * slices_ * stacks_);

        // If there are M lines of latitude (horizontal) and
        // N lines of longitude (vertical), then put dots at
        // (x, y, z) = (sin(Pi * m/M) cos(2Pi * n/N), sin(Pi * m/M) sin(2Pi *
        // n/N), cos(Pi * m/M))
        auto stackRadius = [this](size_t index)
                           {
                             return sin(M_PI * float(index) / stacks_);
                           };
        auto stackPos = [this](size_t index)
                        {
                          return cos(M_PI * float(index) / stacks_);
                        };

        for (size_t i = 0; i < stacks_; ++i)
        {
          if ((stackPos(i) > top_) || (stackPos(i + 1) < bottom_)) continue;

          generateStack(stackPos(i), stackPos(i + 1),
                        stackRadius(i), stackRadius(i + 1));
        }

        vbo_.buffer(vertices_, indices_);
        vertices_.clear();
        indices_.clear();
      });
    }

Field Documentation

float omni::visual::Sphere::bottom_ = -1.0

private

VertexVBO::index_buffer_type omni::visual::Sphere::indices_

private

qreal omni::visual::Sphere::radius_ = 1.0

private

int omni::visual::Sphere::slices_ = 128

private

int omni::visual::Sphere::stacks_ = 64

private

TexCoordsMode omni::visual::Sphere::texCoordsMode_ = EQUIRECTANGULAR

private

float omni::visual::Sphere::top_ = 1.0

private

VertexVBO omni::visual::Sphere::vbo_

private

VertexVBO::vertex_buffer_type omni::visual::Sphere::vertices_

private

---

The documentation for this class was generated from the following files:

• include/omni/visual/Sphere.h
• src/lib/visual/Sphere.cpp