gls_ellipse.h

Go to the documentation of this file.

/*! \file
  \brief  The disti::GlsEllipse class.

  \par Copyright Information

  Copyright (c) 2015 by The DiSTI Corporation.<br>
  11301 Corporate Blvd; Suite 100<br>
  Orlando, Florida 32817<br>
  USA<br>
  <br>
  All rights reserved.<br>

  This Software contains proprietary trade secrets of DiSTI and may not be
reproduced, in whole or part, in any form, or by any means of electronic,
mechanical, or otherwise, without the written permission of DiSTI.  Said
permission may be derived through the purchase of applicable DiSTI product
licenses which detail the distribution rights of this content and any
Derivative Works based on this or other copyrighted DiSTI Software.

  NO WARRANTY. THE SOFTWARE IS PROVIDED "AS-IS," WITHOUT WARRANTY OF ANY KIND,
AND ANY USE OF THIS SOFTWARE PRODUCT IS AT YOUR OWN RISK. TO THE MAXIMUM EXTENT
PERMITTED BY APPLICABLE LAW, DISTI AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES
AND CONDITIONS, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
IMPLIED WARRANTIES AND CONDITIONS OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE, TITLE, AND NON-INFRINGEMENT, WITH REGARD TO THE SOFTWARE.

  LIMITATION OF LIABILITY. TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW,
IN NO EVENT SHALL DISTI OR ITS SUPPLIERS BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
INDIRECT, OR CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION,
DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS
INFORMATION, OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE USE OF OR
INABILITY TO USE THE SOFTWARE, EVEN IF DISTI HAS BEEN ADVISED OF THE POSSIBILITY
OF SUCH DAMAGES.  DISTI'S ENTIRE LIABILITY AND YOUR EXCLUSIVE REMEDY SHALL NOT
EXCEED FIVE DOLLARS (US$5.00).

  The aforementioned terms and restrictions are governed by the laws of the
State of Florida and the United States of America.

*/
#ifndef _GLSELLIPSE_H
#define _GLSELLIPSE_H
#include "glpolygon.h"
#include "gls_cpp_lang_support.h"

#ifdef GLES
#include "gls_vertex_array.h"
#include "gls_index_array.h"
#else
#include "gls_display_list.h"
#endif
//////////////////// Provides support for creating DLLs ////////////////////////
#if (defined(GLSGEN_EXPORT_GLSELLIPSE) || \
     defined(GLSGEN_IMPORT_GLSELLIPSE) || \
     defined(GLS_EXPORT_GENERATED) || \
     defined(GLS_IMPORT_GENERATED)) \
     && defined(_MSC_VER) 
#  if defined(GLSGEN_EXPORT_GLSELLIPSE) || defined(GLS_EXPORT_GENERATED)
#    define GLSGEN_GLSELLIPSE_EXPORT    __declspec(dllexport)
#  else
#    define GLSGEN_GLSELLIPSE_EXPORT    __declspec(dllimport)
#  endif
#else
#  define GLSGEN_GLSELLIPSE_EXPORT
#endif
///////////////////////////////////////////////////////////////////////////////

#define LIB_BASE_NAME "gls_ellipse"
#include "gls_auto_lib.h"
#undef LIB_BASE_NAME

namespace disti
{

// SetValue enumerations
enum {
    GLS_ELLIPSE_FIRST_VALUE = GLS_LAST_INITIALIZER+1,
    GLS_ELLIPSE_RADII,
    GLS_ELLIPSE_THICKNESS,
    GLS_ELLIPSE_SOLID,
    GLS_ELLIPSE_INTERVAL,
    GLS_ELLIPSE_START_ANGLE,
    GLS_ELLIPSE_END_ANGLE,
    GLS_ELLIPSE_COLOR
 };

/** Runtime implementation of a GlsEllipse */
class GlsEllipse : public GLPolygon
{
    friend class GlsEllipseEditor;
public:   
    typedef GLPolygon _BaseClass;

    /** Create a new GlsEllipse.
      * \param generateInstance  Whether or not to generate an instance name
      * for this inputdevice */
    GLSGEN_GLSELLIPSE_EXPORT GlsEllipse(bool generateInstance=false);

    // Copy Constructor
    GLSGEN_GLSELLIPSE_EXPORT GlsEllipse( const GlsEllipse& that, const bool generateNames );

    /** Destructs a GlsEllipse object */
    virtual GLSGEN_GLSELLIPSE_EXPORT ~GlsEllipse();

    static GLSGEN_GLSELLIPSE_EXPORT DisplayObject* CreateInstance();

    virtual GLSGEN_GLSELLIPSE_EXPORT void SetAvailableAttributes(unsigned int value);

    virtual GLSGEN_GLSELLIPSE_EXPORT DisplayObject* CloneObject(bool generateNames = false);

    virtual GLSGEN_GLSELLIPSE_EXPORT void CopyProperties(DisplayObject *src);
    virtual GLSGEN_GLSELLIPSE_EXPORT void CopyGeometry(DisplayObject *srcArg);

#ifndef GLES
    virtual GLSGEN_GLSELLIPSE_EXPORT InterfaceListType* GetCppInterfaceDescription(InterfaceListType* addToThisList= NULL );
    virtual GLSGEN_GLSELLIPSE_EXPORT void GetCppInterfaceDescriptionFree(InterfaceListType* array);
#endif

    virtual GLSGEN_GLSELLIPSE_EXPORT void PreDraw( const OpenGLMatrices& parentMatrices,Culler &culler );
    virtual GLSGEN_GLSELLIPSE_EXPORT void Draw(void);

    virtual GLSGEN_GLSELLIPSE_EXPORT void Scale(float px, float py, float pz, Vertex *anchor, int handleBar);
    virtual GLSGEN_GLSELLIPSE_EXPORT void Rotate(const Vector &orig,float angle,const Vector &axis);
    virtual GLSGEN_GLSELLIPSE_EXPORT bool Hit(float x,float y,float z,float scale, const Vector& directionVector,Vector *collisionPoint);
    virtual GLSGEN_GLSELLIPSE_EXPORT void CalculateTextureCoordinates();

    virtual GLSGEN_GLSELLIPSE_EXPORT Vertex* Vertices();
    virtual GLSGEN_GLSELLIPSE_EXPORT void GetExtents(float &minx,float &miny,float &minz, float &maxx,float &maxy,float &maxz);
    virtual GLSGEN_GLSELLIPSE_EXPORT void GetTransformedExtents(Vector& min, Vector& max, const GlsMatrixType& matrix, bool resetMinMax);
    virtual GLSGEN_GLSELLIPSE_EXPORT void UpdateBoundingVolume(void);

    /* Unhides base class implementation. */
    using _BaseClass::SetFillColor;
    
    /* Unhides base class implementation. */
    using _BaseClass::GetFillColor;

    /** Sets the color for filling the object
      * \param color  The new color for the object
      */
    virtual GLSGEN_GLSELLIPSE_EXPORT void SetFillColor(const glsColor &color);

    /** Gets the color for filling the object
      * \return  The fill color for the object
      */
    virtual GLSGEN_GLSELLIPSE_EXPORT glsColor GetFillColor(void);

    DisplayObject* handle(DisplayEvent *ev);

    virtual GLSGEN_GLSELLIPSE_EXPORT void SetValue(int spec,va_list &args);

    /* GlsEllipse does not use texture inheritance */
    virtual GLSGEN_GLSELLIPSE_EXPORT bool SetupTexture(void);

    //////////////////////////////////////////////////
    // GlsEllipse specific operations
    //////////////////////////////////////////////////

    /** Sets the radius vectors
      * \param r1
      * \param r2
      */
    virtual GLSGEN_GLSELLIPSE_EXPORT void RadiusVectors( const Vector& r1, const Vector& r2 );

    /** Gets the radius vector
      * \param index
      */
    virtual GLSGEN_GLSELLIPSE_EXPORT Vector RadiusVector( unsigned int index );
    
    /** Gets the unit vector
      * \param index
      */
    virtual GLSGEN_GLSELLIPSE_EXPORT Vector UnitVector( unsigned int index );

    /** Sets the angular interval between vertices
      * \param value the interval in degrees.
      */
    virtual GLSGEN_GLSELLIPSE_EXPORT void Interval( const unsigned int& value );
    /** Gets the angular interval between vertices.
      * \return the interval.
      */
    virtual GLSGEN_GLSELLIPSE_EXPORT unsigned int Interval();

    /** Sets the thickness of the ellipse in logical units.
      * \param value The thickness in logical units.
      */
    virtual GLSGEN_GLSELLIPSE_EXPORT void Thickness( const float& value );
    /** Gets the thickness of the ellipse.
      * \return The current thickness of the ellipse in logical units.
      */
    virtual GLSGEN_GLSELLIPSE_EXPORT float Thickness();

    /** Sets the Start Angle in degrees 
      * \param value The start angle
      */
    virtual GLSGEN_GLSELLIPSE_EXPORT void StartAngle( const float& value );
    /** Gets the Start Angle in degrees
      * \return The start angle in degrees
      */
    virtual GLSGEN_GLSELLIPSE_EXPORT float StartAngle();

    /** Sets the end angle in degrees
      * \param value The end angle in degrees
      */
    virtual GLSGEN_GLSELLIPSE_EXPORT void EndAngle( const float& value );
    /** Gets the end angle in degrees
      * \return The end angle in degrees
      */
    virtual GLSGEN_GLSELLIPSE_EXPORT float EndAngle();

    /** Sets the magnitude
      */
    virtual GLSGEN_GLSELLIPSE_EXPORT void Magnitude( const float& value,unsigned int index );
    /** Gets the magnitude
      */
    virtual GLSGEN_GLSELLIPSE_EXPORT float Magnitude(unsigned int index);

    /** Sets the solid flag
      * \param value When true the elipse is drawn solid
      */
    virtual GLSGEN_GLSELLIPSE_EXPORT void Solid( const bool& value );
    /** Gets the solid flag
      * \return The current solid flag value
      */
    virtual GLSGEN_GLSELLIPSE_EXPORT bool Solid();

#ifdef GLES
    /** Causes the display list for this object to be recomputed */
    GLSGEN_GLSELLIPSE_EXPORT void InvalidateGeometry(void) { _geometryRefresh = true; }
#else
    /** Causes the display list for this object to be recomputed */
    GLSGEN_GLSELLIPSE_EXPORT void InvalidateGeometry(void) { _displayList.Invalidate(); }

    /** Returns a reference to this object's display list */
    GLSGEN_GLSELLIPSE_EXPORT GlsDisplayList &DisplayList(void) { return _displayList; }
#endif
protected:

    /** Calculates _radiiUnit and _magnitude based on _radii */
    void CalculateRadiiUnit(void);

    /** callback called when the ellipse needs to be recalculated because an attribute has changed 
      */
    void SetNeedsRecalculate( void );

#ifdef GLES
    /** Draws the arc segment mode 
      * \param textureObject TRUE if object should be drawn textured
      */
    void ComputeArcSegment(bool textureObject);

    /** Draws the solid circle mode
      * \param textureObject TRUE if object should be drawn textured
      */
    void ComputeSolidCircle(bool textureObject);
    
    /** Set a single attribute from the GLO file.
     * \param data The attribute to set and its associated data.
     */
    virtual GLS_EXPORT void SetFromGloData(GlsGloFileAttribute &data);
#else
    /** Draws the arc segment mode 
      * \param textureObject TRUE if object should be drawn textured
      */
    void DrawArcSegment(bool textureObject);

    /** Draws the solid circle mode
      * \param textureObject TRUE if object should be drawn textured
      */
    void DrawSolidCircle(bool textureObject);
    
    /** Performs OpenGL drawing commands */
    void DrawGeometry(void);
#endif
    /** Recomputes the object's vertices from its radii */
    void RecomputeVertices(void);

    /** Calculates the start vertices */
    void CalculateStartVertices(void);

    /** Calculates the end vertices */
    void CalculateEndVertices(void);

    /** Gets starting and ending indices for vertices */
    void GetSegmentIndices(const float startAngle,unsigned int &startIndex,const float endAngle,unsigned int &endIndex);
    unsigned int InnerIndex(const unsigned int index);
    unsigned int OuterIndex(const unsigned int index);
    
#ifndef GLES
    /** Stores the scale in a display list for faster drawing */
    GlsDisplayList _displayList;
#else
    GlsVertexArray _outlineVertexArray;
#endif
    /** Stores the scale in a display list for faster drawing */
    Vector       _radii[2],       /**  Two radii defining the ellipse size and orientation 
                                    *  Only used to read/write file.  _radiiNormal is in control
                                    */

                 _normal,         /**< Normal to surface defined by radii */
                 _radiiUnit[2],   /**< Unit vector of radii */
                 _start[2],       /**< Two points defining the starting edge of a partial ellipse. */
                 _startTex[2],    /**< Texture coordinates of starting points */
                 _end[2],         /**< Two points defining the ending edge of a partial ellipse. */
                 _endTex[2],      /**< Texture coordinates of starting points */
                 _centerTex;      /**< Texture coordinate of center point */

    glsColor     _objectColor;    /**< Fill color of object */

    float        _thickness,      /**< Thickness of the outer edge of the ellipse in logical units */
                 _startAngle,     /**< Starting angle of ellipse segment in degrees */
                 _endAngle,       /**< Ending angle of ellipse segment in degrees */
                 _magnitude[2];   /**< Magnitude of radii */

    unsigned int _interval;       /**< Interval between subdivisions, in degrees */
    bool         _solid;          /**< If true, ellipse drawn as solid not as "donut" */
    bool         _needsRecalculate;

    GlsMatrixType  _world2tex; /**< Matrix used to calculate texture coordinates for the object */

private:
    // disallow implicit assignments and copy constructor
    GlsEllipse& operator=( const GlsEllipse& ) DISTI_SPECIAL_MEM_FUN_DELETE ;
    GlsEllipse( const GlsEllipse& ) DISTI_SPECIAL_MEM_FUN_DELETE ;
};

} // namespace disti

#endif