gls_cylinder.h

Go to the documentation of this file.

/*! \file
  \brief  The disti::GlsCylinder 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 _GLS_CYLINDER_H
#define _GLS_CYLINDER_H

#include "display.h"
#include "gls_color.h"
#include "gls_include.h"
#include "dynamic_array.h"
#include "timer.h"
#include "glpolygon.h"
#include "group.h"
#include "gls_cpp_lang_support.h"

#define DEF_CYLINDER_SEGMENTS       1
#define DEF_CYLINDER_FACES          30
#define DEF_CYLINDER_FACE_START     0.0f
#define DEF_CYLINDER_FACE_END       360.0f
#define DEF_CYLINDER_TOP_SIZE       1.0f
#define DEF_CYLINDER_BOTTOM_SIZE    1.0f
#define DEF_CYLINDER_TOP_FACE       false
#define DEF_CYLINDER_BOTTOM_FACE    false

namespace disti
{

/**
    Cylinder Initializers
*/
typedef enum 
{
    GLS_CYLINDER_COLOR=GLS_LAST_INITIALIZER+1,
    GLS_CYLINDER_SEGMENTS,
    GLS_CYLINDER_FACES,
    GLS_CYLINDER_FACE_START,
    GLS_CYLINDER_FACE_END,
    GLS_CYLINDER_TOP_SIZE,
    GLS_CYLINDER_BOTTOM_SIZE,
    GLS_CYLINDER_TOP_FACE,
    GLS_CYLINDER_BOTTOM_FACE,
    GLS_CYLINDER_RADII
} GLS_Cylinder_Initializers;

/**
    The Cylinder class.  Implements Cylinder primitive
*/

class GlsCylinder : public DisplayObject
{
public:
    typedef DisplayObject _BaseClass;
    friend class GlsCylinderEditor; 

private:

    /** Initialize data to default values */
    void CommonConstructorInit(void);
    /** Disabling default implicit assignment and copy constructors */
    GlsCylinder& operator=( const GlsCylinder& that ) DISTI_SPECIAL_MEM_FUN_DELETE;
    GlsCylinder( const GlsCylinder& ) DISTI_SPECIAL_MEM_FUN_DELETE;

    void CopyGeometryInternal( GlsCylinder* src );
    void CopyPropertiesInternal( GlsCylinder* src );

    /* Utility routine used by Hit.  Performs a "FirstHit" test, which performs a hit test on the object
      * but does not guarantee that the collision point returned by Hit is the closest collision point
      * to the observer
      * \param point            The logical coordinate of the click, relative to the object
      * \param directionVector  The direction of the pick vector
      * \param collisionPoint   Set to the point on the object hit by directionVector
      * \return boolean indicating if the object was hit by the mouse
      */
    bool FirstHit(const Vector &point,const Vector& directionVector,Vector *collisionPoint);

    /* Utility routine used by Hit.  Performs a "BestHit" test, which performs a hit test on the object
      * and guarantees that the collision point returned by Hit is the closest collision point to the observer.
      * \param point            The logical coordinate of the click, relative to the object
      * \param directionVector  The direction of the pick vector
      * \param collisionPoint   Set to the point on the object hit by directionVector
      * \return boolean indicating if the object was hit by the mouse
      */
    bool BestHit(const Vector &point,const Vector& directionVector,Vector *collisionPoint);

    bool EndCapFirstPick(unsigned int startIndex,const Vector &point,const Vector& directionVector,Vector *collisionPoint);

    void UpdateBestPickStatus(const Vector &point,const Vector &directionVector, Vector &tempCollisionPoint,Vector &closestPoint,float &pickDistance);

protected:

    Vector _radii[3];                           /** Cylinder radii.  3 vectors */

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

    float  _faceStartDeg,_faceEndDeg;           /** 0-360, where 0 is positive x-axis of cylinder */
    float  _topSize, _bottomSize;               /** 0 - 1, scale of top and bottom ends */

    unsigned int    _segments,                  /** Number of segments used to draw the cylinder */
                    _faces;                     /** Number of faces used to draw the cylinder */

    bool   _needsRecalculate;                   /** True when the cylinder vertices need to be recalculated */
    bool   _needsResize;                        /** True when the cylinder needs to be resized */
    bool   _topFace;                            /** True when there is a circle on top of the cylinder */
    bool   _bottomFace;                         /** True when there is a circle on bottom of the cylinder */


    /** Sets the resize and recalculate flags, causing the cylinder to be resized and recalculated
      * the next time the cylinder draws
      */
    GLS_EXPORT void SetResizeRecalculate();

    /** Recalculates the cylinder vertices values */
    GLS_EXPORT void Recalculate(void);

    /** Reallocates the vertices of the cylinder */
    GLS_EXPORT void Resize(void);

    /* See base class */
    virtual GLS_EXPORT void SetValue(int spec,va_list &args);

#ifdef GLES
    /** 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);
#endif

public:

    /** Constructor.  Creates a new GlsCylinder object at given coordinates.
      * \param x    x-coordinate of new GlsCylinder
      * \param y    y-coordinate of new GlsCylinder
      * \param z    z-coordinate of new GlsCylinder
      */
    GLS_EXPORT GlsCylinder(float x,float y,float z);

    /** Allocate a (blank) GlsCylinder object */
    GLS_EXPORT GlsCylinder(bool newGlsCylinder = true);

    /** The copy constructor for GlsCylinder
      * 
      * \param that          The GlsCylinder object that is being copied
      * \param generateName  Whether or not to generate a new instance name
      */
    GLS_EXPORT GlsCylinder( const GlsCylinder& that, const bool generateName );

    /** Destroy a GlsCylinder object */
    virtual GLS_EXPORT ~GlsCylinder(void);

    virtual GLS_EXPORT void SetAvailableAttributes(unsigned int value);

    /** Finds three coplanar points and the surface normal, if possible.  This calculation is performed using the
      * Vertices() of this object.  Used in the editor to determine how to map a texture onto an object.
      * \param p1  Returns a point on the plane
      * \param p2  Returns a point on the plane
      * \param p3  Returns a point on the plane
      * \param planeVector Returns the surface normal of the plane
      * \return  True if 3 coplanar points were found
      */
    virtual GLS_EXPORT bool GetPlaneVectorPoints(Vertex &p1,Vertex &p2,Vertex &p3,Vertex &planeVector);

    /* See base class. */
    virtual GLS_EXPORT void CalculateTextureCoordinates(void);

    /* See base class */
    virtual GLS_EXPORT void GetExtents(float &x,float &y,float &z,float &x1,float &y1,float &z1);

    /* See base class */
    virtual GLS_EXPORT void Draw(void);

    /* See base class */
    virtual GLS_EXPORT bool Hit(float x,float y,float z,float scale, const Vector& directionVector,Vector *collisionPoint);

    /* Unhides base class implementation. */
    using _BaseClass::Scale;

    /* See base class */
    virtual GLS_EXPORT void Scale(float px, float py, float pz, Vertex *anchor, int handleBar = 0);

    /* Unhides base class implementation. */
    using _BaseClass::TextureIndex;

    /** See base class */
    virtual GLS_EXPORT void TextureIndex(int index);

    /* Usually copies the attributes except for geometry attributes from one object to another. 
      * However, since the GlsCylinder's geometry defines its properties, its geometry is copied.
      * Used by the undo mechanism to undo most attribute change operations.
      * \param src   The object to copy properties from
      */
    virtual GLS_EXPORT void CopyProperties(DisplayObject *src);

    /* See base class */
    virtual GLS_EXPORT void CopyGeometry(DisplayObject *src);

    /* See base class */
    virtual GLS_EXPORT DisplayObject* CloneObject(bool generateNames = false);

    /* Unhides base class implementation. */
    using _BaseClass::Rotate;

    /* See base class */
    virtual GLS_EXPORT void Rotate(const Vector &orig,float angle, const Vector &axis);

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

    /* See base class */
    virtual GLS_EXPORT void SetFillColor(const glsColor &color);

    using _BaseClass::GetFillColor;

    /* See base class */
    virtual GLS_EXPORT glsColor GetFillColor(void);

    /** Sets the starting degree value for the cylinder
      * \param deg  Degree value to which to set _faceStartDeg
      */
    virtual GLS_EXPORT void FaceStartAngle(float deg);

    /** Gets the starting degree value for the cylinder
      * \return  Returns the value of _faceStartDeg
      */
    virtual GLS_EXPORT float FaceStartAngle();

    /** Sets the ending degree value for the cylinder
      * \param deg  Degree value to which to set _faceEndDeg
      */
    virtual GLS_EXPORT void FaceEndAngle(float deg);

    /** Gets the ending degree value for the cylinder
      * \return  Returns the value of _faceEndDeg
      */
    virtual GLS_EXPORT float FaceEndAngle();

    /** Sets the size factor for the top of the cylinder
      * \param size  Factor to which to set _topSize
      */
    virtual GLS_EXPORT void TopSizeFactor(float size);

    /** Gets the size factor for the top of the cylinder
      * \return  Returns the value of _topSize
      */
    virtual GLS_EXPORT float TopSizeFactor();

    /** Sets the size factor for the bottom of the cylinder
      * \param size  Factor to which to set _bottomSize
      */
    virtual GLS_EXPORT void BottomSizeFactor(float size);

    /** Gets the size factor for the bottom of the cylinder
      * \return  Returns the value of _bottomSize
      */
    virtual GLS_EXPORT float BottomSizeFactor();

    /** Sets the number of vertical segments per face
      * \param segments  Desired number of segments to which to set _segments
      */
    virtual GLS_EXPORT void Segments(unsigned int segments);

    /** Gets the number of vertical segments per face
      * \return  Returns the value of _segments
      */
    virtual GLS_EXPORT unsigned int Segments();

    /** Sets the number of faces around the cylinder
      * \param faces  Desired number of faces to which to set _faces
      */
    virtual GLS_EXPORT void Faces(unsigned int faces);

    /** Gets the number of faces around the cylinder
      * \return  Returns the value of _faces
      */
    virtual GLS_EXPORT unsigned int Faces();

    /** Sets whether or not to draw a top face on the cylinder
      * \param top  Presences of a top face, value assigned to _topFace
      */
    virtual GLS_EXPORT void TopFace(bool top);

    /** Gets whether or not to draw a top face on the cylinder
      * \return  Presences of a top face, returns the value of to _topFace
      */
    virtual GLS_EXPORT bool TopFace();

    /** Sets whether or not to draw a bottom face on the cylinder
      * \param bottom  Presences of a bottom face, value assigned to _bottomFace
      */
    virtual GLS_EXPORT void BottomFace(bool bottom);

    /** Gets whether or not to draw a bottom face on the cylinder
      * \return  Presences of a bottom face, returns the value of to _bottomFace
      */
    virtual GLS_EXPORT bool BottomFace();

    /** Gets the radii vectors for the cylinder
      * \param r1  First radius vector (width)
      * \param r2  First radius vector (height)
      * \param r3  First radius vector (depth)
      */
    virtual GLS_EXPORT void GetRadii(Vector &r1,Vector &r2,Vector &r3);

    /** Sets the radii vectors for the cylinder
      * \param r1  First radius vector (width)
      * \param r2  First radius vector (height)
      * \param r3  First radius vector (depth)
      */
    virtual GLS_EXPORT void SetRadii(const Vector &r1,const Vector &r2,const Vector &r3);

#ifndef GLES
    /* See base class */
    virtual GLS_EXPORT InterfaceListType* GetCppInterfaceDescription(InterfaceListType* addToThisList= NULL );

    /* See base class */
    virtual GLS_EXPORT void GetCppInterfaceDescriptionFree(InterfaceListType* array);
#endif
};

} // namespace disti

#endif