/* -*-c++-*- */
/* osgEarth - Geospatial SDK for OpenSceneGraph
 * Copyright 2020 Pelican Mapping
 * http://osgearth.org
 *
 * osgEarth is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>
 */

#ifndef OSGEARTHSYMBOLOGY_LINE_SYMBOL_H
#define OSGEARTHSYMBOLOGY_LINE_SYMBOL_H 1

#include <osgEarth/Symbol>
#include <osgEarth/Stroke>

namespace osgEarth
{
    /** 
     * Symbol that describes how to draw linear geometry.
     */
    class OSGEARTH_EXPORT LineSymbol : public Symbol
    {
    public:
        META_Object(osgEarth, LineSymbol);

        LineSymbol(const LineSymbol& rhs,const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY);
        LineSymbol(const Config& conf =Config());

        /** dtor */
        virtual ~LineSymbol() { }

        /** Line stroking parameters */
        optional<Stroke>& stroke() { return _stroke; }
        const optional<Stroke>& stroke() const { return _stroke; }

        /** Tessellate the line geometry such that no segment is longer than this value */
        optional<Distance>& tessellationSize() { return _tessellationSize; }
        const optional<Distance>& tessellationSize() const { return _tessellationSize; }

        /** Tessellate the line geometry such that each source segment is divided into this many parts. */
        optional<unsigned>& tessellation() { return _tessellation; }
        const optional<unsigned>& tessellation() const { return _tessellation; }

        /** Minimum angle (deg) for which to create creases where applicable (like when outlining) */
        optional<float>& creaseAngle() { return _creaseAngle; }
        const optional<float>& creaseAngle() const { return _creaseAngle; }

        /** URI of an image to load and use to texture lines */
        optional<StringExpression>& imageURI() { return _imageURI; }
        const optional<StringExpression>& imageURI() const { return _imageURI; }

        //! Length of the image (y dimension) in meters
        optional<float>& imageLength() { return _imageLength; }
        const optional<float>& imageLength() const { return _imageLength; }

        //! Whether to force the use of legacy OpenGL lines (default=false)
        //! instead of the GPU-based lines that are required by GLCORE/GLES
        optional<bool>& useGLLines() { return _useGLLines; }
        const optional<bool>& useGLLines() const { return _useGLLines; }

        /** 3D line as a wire. */
        optional<bool>& useWireLines() { return _useWireLines; }
        const optional<bool>& useWireLines() const { return _useWireLines; }

    public:
        virtual Config getConfig() const;
        virtual void mergeConfig( const Config& conf );
        static void parseSLD(const Config& c, class Style& style);

    protected:
        optional<Stroke>           _stroke;
        optional<unsigned>         _tessellation;
        optional<float>            _creaseAngle;
        optional<Distance>         _tessellationSize;
        optional<StringExpression> _imageURI;
        optional<float>            _imageLength;
        optional<bool>             _useGLLines;
        optional<bool>             _useWireLines;
    };

} // namespace osgEarth

#endif // OSGEARTHSYMBOLOGY_LINE_SYMBOL_H