MarkerArtist.hpp

Go to the documentation of this file.

/***********************************
   Copyright 2018 Ravishankar Mathur

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
***********************************/

#ifndef _OF_MARKERARTIST_
#define _OF_MARKERARTIST_

#include <OpenFrames/Export.h>
#include <OpenFrames/TrajectoryArtist.hpp>

namespace OpenFrames
{
  class OF_EXPORT MarkerArtist : public TrajectoryArtist
  {
  public:

    enum DrawnMarkers
    {
      START = 1,        // Draw marker at start point.
      INTERMEDIATE = 2, // Draw markers at intermediate points, excluding
                        // the start & end points.
      END = 4           // Draw marker at end point.
    };

    enum IntermediateType
    {
      TIME = 1, // Draw markers at equally spaced time increments.
      DISTANCE, // Draw markers at equally spaced distances, with distance
                // being measured using DataSource as a point.
      DATA      // Draw markers at equally spaced data points.
    };

    MarkerArtist( const Trajectory *traj = NULL );

    // Copy constructor
    MarkerArtist( const MarkerArtist &ca,
                  const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY );

    virtual Object* cloneType() const { return new MarkerArtist(); }
    virtual Object* clone(const osg::CopyOp& copyop) const { return new MarkerArtist(*this,copyop); }
    virtual bool isSameKindAs(const osg::Object* obj) const { return dynamic_cast<const MarkerArtist*>(obj)!=NULL; }
    virtual const char* libraryName() const { return "OpenFrames"; }
    virtual const char* className() const { return "MarkerArtist"; }

    virtual void setTrajectory(const Trajectory *traj);

    bool setXData(const Trajectory::DataSource &src);
    bool setYData(const Trajectory::DataSource &src);
    bool setZData(const Trajectory::DataSource &src);

    void setMarkers( unsigned int markers );
    void setMarkerColor( unsigned int markers, float r, float g, float b);
    void setMarkerSize(unsigned int size); // Size in pixels
    bool setMarkerImage( const std::string &fname );
    bool setMarkerShader( const std::string &fname );

    void setAutoAttenuate(bool attenuate);
    bool getAutoAttenuate() const;

    void setIntermediateType(IntermediateType type);

    void setIntermediateSpacing(double spacing);

    void setIntermediateDirection(DrawnMarkers direction);

    virtual void drawImplementation(osg::RenderInfo& renderInfo) const;

    virtual void dataCleared(Trajectory* traj);

    virtual void dataAdded(Trajectory* traj);

    void computeAttenuation();

  protected:
    virtual ~MarkerArtist();

    virtual osg::BoundingBox computeBoundingBox() const;

    void verifyData() const;

        void resetMarkerShader();

        // Data sources for x, y, and z components
    Trajectory::DataSource _dataSource[3];

    unsigned int _markers; // Which points to draw as markers

    IntermediateType _intermediateType; // Type of intermediate markers
    double _intermediateSpacing; // Spacing for intermediate markers
    DrawnMarkers _intermediateDirection; // Intermediate marker direction

    float _startColor[3]; // Starting marker color
    float _endColor[3];   // Ending marker color
    float _intermediateColor[3]; // Intermediate markers color

    mutable bool _dataValid; // If trajectory supports required data
    mutable bool _dataZero; // If we're just drawing at the origin
    mutable bool _shouldAttenuate; // Attenuation needs to be recomputed

        osg::ref_ptr<osg::Shader> _fragShader; // Marker fragment shader
  };

}

#endif