analyzer.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_SHAPES_ANALYZER_1308151449_HPP
#define OGLPLUS_SHAPES_ANALYZER_1308151449_HPP

#include <oglplus/config/basic.hpp>
#include <oglplus/math/vector.hpp>

#include <oglplus/shapes/analyzer_data.hpp>

#include <cstddef>

namespace oglplus {
namespace shapes {

class ShapeAnalyzerVert;
class ShapeAnalyzerEdge;
class ShapeAnalyzerFace;


class ShapeAnalyzerVert
{
private:
    const ShapeAnalyzerGraphData& _data;
    GLuint _face_index;
    GLuint _vert_index;

    friend class ShapeAnalyzer;
    friend class ShapeAnalyzerEdge;
    friend class ShapeAnalyzerFace;

    ShapeAnalyzerVert(
        const ShapeAnalyzerGraphData& data,
        GLuint face_index,
        GLuint vert_index
    ): _data(data)
     , _face_index(face_index)
     , _vert_index(vert_index)
    {
        assert(_face_index < data._face_index.size());
        assert(_vert_index < data._face_arity(_face_index));
    }
public:

    GLuint Index(void) const
    {
        return _vert_index;
    }

    ShapeAnalyzerFace Face(void) const;


    Vec4d MainAttrib(void) const;


    Vec4d SmoothAttrib(void) const;
};


class ShapeAnalyzerEdge
{
private:
    const ShapeAnalyzerGraphData& _data;
    GLuint _face_index;
    GLuint _edge_index;

    friend class ShapeAnalyzer;
    friend class ShapeAnalyzerFace;

    ShapeAnalyzerEdge(
        const ShapeAnalyzerGraphData& data,
        GLuint face_index,
        GLuint edge_index
    ): _data(data)
     , _face_index(face_index)
     , _edge_index(edge_index)
    {
        assert(_face_index < data._face_index.size());
        assert(_edge_index < data._face_arity(_face_index));
    }
public:

    GLuint Index(void) const
    {
        return _edge_index;
    }

    ShapeAnalyzerFace Face(void) const;

    bool HasAdjacentEdge(void) const;


    ShapeAnalyzerEdge AdjacentEdge(void) const;

    bool HasOppositeVert(void) const;


    ShapeAnalyzerVert OppositeVert(void) const;

    bool HasFlag(GLuint flag) const;

    bool IsContinuousEdge(void) const
    {
        return HasFlag(ShapeAnalyzerGraphData::_flg_contin_edge);
    }

    bool IsSmoothEdge(void) const
    {
        return HasFlag(ShapeAnalyzerGraphData::_flg_smooth_edge);
    }

    bool IsStripEdge(void) const
    {
        return HasFlag(ShapeAnalyzerGraphData::_flg_strip_edge);
    }

    bool IsFanEdge(void) const
    {
        return HasFlag(ShapeAnalyzerGraphData::_flg_fan_edge);
    }
};



class ShapeAnalyzerFace
{
private:
    const ShapeAnalyzerGraphData& _data;
    GLuint _index;

    friend class ShapeAnalyzer;
    friend class ShapeAnalyzerVert;
    friend class ShapeAnalyzerEdge;

    ShapeAnalyzerFace(const ShapeAnalyzerGraphData& data, GLuint index)
     : _data(data)
     , _index(index)
    {
        assert(_index < data._face_index.size());
    }
public:
    GLuint Index(void) const
    {
        return _index;
    }


    GLuint Arity(void) const
    {
        return _data._face_arity(_index);
    }


    ShapeAnalyzerVert Vert(GLuint vert_index) const;


    ShapeAnalyzerEdge Edge(GLuint edge_index) const;


    bool HasAdjacentFace(GLuint edge_index) const;


    ShapeAnalyzerFace AdjacentFace(GLuint edge_index) const;
};


class ShapeAnalyzer
{
private:
    ShapeAnalyzerGraphData _data;
public:
    template <typename ShapeBuilder>
    ShapeAnalyzer(const ShapeBuilder& builder)
     : _data(builder)
    { }

    typedef ShapeAnalyzerVert ShapeVert;

    typedef ShapeAnalyzerEdge ShapeEdge;

    typedef ShapeAnalyzerFace ShapeFace;


    GLuint FaceCount(void) const
    {
        assert(!_data._face_index.empty());
        return _data._face_index.size();
    }


    ShapeFace Face(GLuint face_index)
    {
        assert(face_index<_data._face_index.size());
        return ShapeFace(_data, face_index);
    }
};

} // shapes
} // oglplus

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

#endif // include guard