gls_sphere.h

Go to the documentation of this file.

/*! \file
  \brief  The disti::GlsSphere class.
 
  \par Copyright Information
 
  Copyright (c) 2017 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_SPHERE_H
#define _GLS_SPHERE_H
 
#include "display.h"
#include "dynamic_array.h"
#include "gls_color.h"
#include "gls_cpp_lang_support.h"
#include "gls_include.h"
 
#define DEF_SPHERE_STACKS 10        ///< The default number of stacks for a new GlsSphere.
#define DEF_SPHERE_SLICES 10        ///< The default number of slices for a new GlsSphere.
#define DEF_SPHERE_SLICE_START 0.0f ///< The default slice start angle in degrees for a new GlsSphere.
#define DEF_SPHERE_SLICE_END 360.0f ///< The default slice end angle in degrees for a new GlsSphere.
#define DEF_SPHERE_STACK_START 0.0f ///< The default stack start angle in degrees for a new GlsSphere.
#define DEF_SPHERE_STACK_END 180.0f ///< The default stack end angle in degrees for a new GlsSphere.
 
namespace disti
{
/** gls Sphere Mapping */
typedef enum
{
    GLS_SPHERE_SPHERICAL_MAP, /**< Spherical texture map */
    GLS_SPHERE_CYLINDER_MAP   /**< Cylindrical texture map */
} glsSphereMapping_e;
 
/**
    Sphere Initializers
*/
typedef enum
{
    GLS_SPHERE_MAPPING = GLS_LAST_INITIALIZER + 1,
    GLS_SPHERE_COLOR,
    GLS_SPHERE_STACKS,
    GLS_SPHERE_SLICES,
    GLS_SPHERE_SLICE_START,
    GLS_SPHERE_SLICE_END,
    GLS_SPHERE_STACK_START,
    GLS_SPHERE_STACK_END,
    GLS_SPHERE_RADII
} GLS_Sphere_Initializers;
 
/** The Sphere class.  Implements Sphere primitive */
class GlsSphere : public DisplayObject
{
private:
    /** Factors out common code shared by the various glsSphere constructors */
    void CommonConstructorInit();
    /** Assignment operator not implemented. Use CloneObject() or the copy constructor instead. */
    GlsSphere& operator=( const GlsSphere& ) DISTI_SPECIAL_MEM_FUN_DELETE;
    GlsSphere( const GlsSphere& ) DISTI_SPECIAL_MEM_FUN_DELETE;
 
protected:
    Vector _radii[ 3 ]; ///< Sphere radii
 
    GlsColor _objectColor; ///< Fill color of object.
 
    float _sliceStartDeg; ///< 0-180, where 0 is the bottom and 180 the top of the sphere.
    float _sliceEndDeg;   ///< 0-180, where 0 is the bottom and 180 the top of the sphere.
    float _stackStartDeg; ///< 0-360, where 0 is the positive x-axis of the sphere.
    float _stackEndDeg;   ///< 0-360, where 0 is the positive x-axis of the sphere.
 
    unsigned int _stacks; ///< Number of stacks used to draw the sphere.
    unsigned int _slices; ///< Number of slices used to draw the sphere.
 
    bool _needsRecalculate; ///< True when the sphere vertices need to be recalculated.
    bool _needsResize;      ///< True when the sphere needs to be resized.
 
    glsSphereMapping_e _textureMappingType; ///< Texture mapping method.
 
    /** Sets the resize and recalculate flags, causing the sphere to be resized and recalculated
      * the next time the sphere draws
      */
    GLS_EXPORT void SetResizeRecalculate();
 
    /** Recalculates the sphere vertices values */
    GLS_EXPORT void Recalculate();
 
    /** Reallocates the vertices of the sphere */
    GLS_EXPORT void Resize();
 
    virtual GLS_EXPORT void SetValue( int spec, va_list& args ) DISTI_METHOD_OVERRIDE;
 
#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 ) DISTI_METHOD_OVERRIDE;
#endif
 
private:
    /* 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 );
 
public:
    DISTI_DEPRECATED( "This identifier is forbidden by the C++ standard. Use BaseClass instead." )
    typedef DisplayObject _BaseClass; ///< Deprecated typedef for the base class.
    typedef DisplayObject BaseClass;  ///< Typedef for the base class.
 
    friend class GlsSphereEditor;
 
    /** Constructor.  Creates a new GlsSphere object at given coordinates.
      * \param x    x-coordinate of new GlsSphere
      * \param y    y-coordinate of new GlsSphere
      * \param z    z-coordinate of new GlsSphere
      */
    GLS_EXPORT GlsSphere( float x, float y, float z );
 
    /// Allocate a (blank) GlsSphere object.
    /// \param newGlsSphere Unused, kept for backward compatibility.
    GLS_EXPORT GlsSphere( bool newGlsSphere = true );
 
    /// Copy constructor
    /// \param that The object to copy from.
    /// \param generateNames Whether or not to generate an instance name for this object.
    GLS_EXPORT GlsSphere( const GlsSphere& that, const bool generateNames );
 
    /** Destroy a GlsSphere object */
    virtual GLS_EXPORT ~GlsSphere();
 
    virtual GLS_EXPORT void SetAvailableAttributes( unsigned int value ) DISTI_METHOD_OVERRIDE;
 
    /** Gets the texture mapping method.
      * \return  Enumerative representation of texture mapping method
      */
    GLS_EXPORT glsSphereMapping_e TextureMappingType();
 
    /* Unhides base class implementation. */
    using BaseClass::TextureIndex;
    virtual GLS_EXPORT void TextureIndex( int index ) DISTI_METHOD_OVERRIDE;
 
    /** Sets the texture mapping type 
      * \param value  The texture mapping value (e.g. cylindrical or spherical)
     */
    GLS_EXPORT void TextureMappingType( glsSphereMapping_e 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 ) DISTI_METHOD_OVERRIDE;
 
    virtual GLS_EXPORT void CalculateTextureCoordinates() DISTI_METHOD_OVERRIDE;
    virtual GLS_EXPORT void GetExtents( float& x, float& y, float& z, float& x1, float& y1, float& z1 ) DISTI_METHOD_OVERRIDE;
    virtual GLS_EXPORT void Draw() DISTI_METHOD_OVERRIDE;
    virtual GLS_EXPORT bool Hit( float x, float y, float z, float scale, const Vector& directionVector, Vector* collisionPoint ) DISTI_METHOD_OVERRIDE;
 
    /* Unhides base class implementation. */
    using BaseClass::Scale;
    virtual GLS_EXPORT void Scale( float px, float py, float pz, Vertex* anchor, int handleBar ) DISTI_METHOD_OVERRIDE;
 
    /* Usually copies the attributes except for geometry attributes from one object to another. 
      * However, since the GlsSphere'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 ) DISTI_METHOD_OVERRIDE;
 
    virtual GLS_EXPORT void CopyGeometry( DisplayObject* src ) DISTI_METHOD_OVERRIDE;
    virtual GLS_EXPORT DisplayObject* CloneObject( bool generateNames = false ) DISTI_METHOD_OVERRIDE;
 
    /* Unhides base class implementation. */
    using BaseClass::Rotate;
    virtual GLS_EXPORT void Rotate( const Vector& orig, float angle, const Vector& axis ) DISTI_METHOD_OVERRIDE;
 
    /* Unhides base class implementation. */
    using BaseClass::SetFillColor;
 
    virtual GLS_EXPORT void SetFillColor( const GlsColor& color ) DISTI_METHOD_OVERRIDE;
 
    /* Unhides base class implementation. */
    using BaseClass::GetFillColor;
 
    virtual GLS_EXPORT GlsColor GetFillColor() DISTI_METHOD_OVERRIDE;
 
    /** Sets the starting degree value for the stacks
      * \param deg  Degree value to which to set _stackStartDeg
      */
    virtual GLS_EXPORT void StackStartAngle( float deg );
 
    /** Gets the starting degree value for the stacks
      * \return  Returns the value of _stackStartDeg
      */
    virtual GLS_EXPORT float StackStartAngle();
 
    /** Sets the ending degree value for the stacks
      * \param deg  Degree value to which to set _stackEndDeg
      */
    virtual GLS_EXPORT void StackEndAngle( float deg );
 
    /** Gets the ending degree value for the stacks
      * \return  Returns the value of _stackEndDeg
      */
    virtual GLS_EXPORT float StackEndAngle();
 
    /** Sets the starting degree value for the slices
      * \param deg  Degree value to which to set _sliceStartDeg
      */
    virtual GLS_EXPORT void SliceStartAngle( float deg );
 
    /** Gets the starting degree value for the slices
      * \return  Returns the value of _sliceStartDeg
      */
    virtual GLS_EXPORT float SliceStartAngle();
 
    /** Sets the ending degree value for the slices
      * \param deg  Degree value to which to set _sliceEndDeg
      */
    virtual GLS_EXPORT void SliceEndAngle( float deg );
 
    /** Gets the ending degree value for the slices
      * \return  Returns the value of _sliceEndDeg
      */
    virtual GLS_EXPORT float SliceEndAngle();
 
    /** Sets the number of horizontal slices
      * \param slices  Desired number of slices to which to set _slices
      */
    virtual GLS_EXPORT void Slices( unsigned int slices );
 
    /** Gets the number of horizontal slices
      * \return  Returns the value of _slices
      */
    virtual GLS_EXPORT unsigned int Slices();
 
    /** Sets the number of vertical stacks
      * \param stacks Desired number of stacks to which to set _stacks
      */
    virtual GLS_EXPORT void Stacks( unsigned int stacks );
 
    /** Gets the number of vertical stacks
      * \return  Returns the value of _stacks
      */
    virtual GLS_EXPORT unsigned int Stacks();
 
    /** Gets the radii vectors for the sphere
      * \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 sphere
      * \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
    virtual GLS_EXPORT InterfaceListType* GetCppInterfaceDescription( InterfaceListType* addToThisList = NULL ) DISTI_METHOD_OVERRIDE;
    virtual GLS_EXPORT void               GetCppInterfaceDescriptionFree( InterfaceListType* array ) DISTI_METHOD_OVERRIDE;
#endif
};
 
#define DEF_SPHERE_MAPPING GLS_SPHERE_SPHERICAL_MAP ///< The default texture mapping behavior for a new GlsSphere.
 
/** Defines metadata for glsSphereMapping_e */
class DistiAttributeSphereMappingTypeEnum : public DistiAttributeEnum<GlsSphere, glsSphereMapping_e, glsSphereMapping_e>
{
public:
    /// Constructor
    /// \param frame The object containing the property.
    /// \param setMethod The set method function pointer.
    /// \param getMethod The get method function pointer.
    /// \param name The name of the associated property.
    GLS_EXPORT DistiAttributeSphereMappingTypeEnum( GlsSphere* frame, SetMethodType setMethod, GetMethodType getMethod, const AttributeName& name );
 
    virtual GLS_EXPORT ~DistiAttributeSphereMappingTypeEnum();
};
 
} // namespace disti
 
#endif