gls_nurb_curve.h

Go to the documentation of this file.

/*! \file
  \brief  The disti::GlsNurbCurve class.
 
  \par Copyright Information
 
  Copyright (c) 2016 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 _GLSNURBCURVE_H
#define _GLSNURBCURVE_H
 
#include "display.h"
#include "glpolygon.h"
#include "gls_cpp_lang_support.h"
 
/// Provides support for creating DLLs.
#if( defined( GLSGEN_EXPORT_GLSNURBCURVE ) || defined( GLSGEN_IMPORT_GLSNURBCURVE ) || defined( GLS_EXPORT_GENERATED ) || defined( GLS_IMPORT_GENERATED ) ) \
    && defined( _MSC_VER )
#    if defined( GLSGEN_EXPORT_GLSNURBCURVE ) || defined( GLS_EXPORT_GENERATED )
#        define GLSGEN_GLSNURBCURVE_EXPORT __declspec( dllexport )
#    else
#        define GLSGEN_GLSNURBCURVE_EXPORT __declspec( dllimport )
#    endif
#else
#    define GLSGEN_GLSNURBCURVE_EXPORT
#endif
///////////////////////////////////////////////////////////////////////////////
 
/// Automatically link the runtime library plugin (on Windows).
#define LIB_BASE_NAME "gls_nurb_curve"
#include "gls_auto_lib.h"
#undef LIB_BASE_NAME
 
namespace disti
{
/** Maximum number of tesselated vertices in a spline */
const int MAX_SPLINE_VERTICES = 2000;
 
/** smallest number of control points in a spline */
const int MIN_NUMBER_POINTS = 2;
 
/**  When calculating the current vertices, how many control
  *  points should we consider */
const int NUMBER_POINTS_TO_CONSIDER = 3;
 
// SetValue enumerations
enum
{
    GLS_GLSNURBCURVE_FIRST_VALUE = GLS_LAST_INITIALIZER + 1,
    GLS_GLSNURBCURVE_EMITEVENT // example
};
 
/** Runtime implementation of a GlsNurbCurve */
class GlsNurbCurve : public DisplayObject
{
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 GlsNurbCurveEditor;
 
private:
    // We capture the tesselated vertices from the NURB render function
    // and store them here, to be used by the draw routine.
    // This is not to be confused with the editor Tesselator functions.
    // These are the points that the NURB render function generates to
    // draw the curve.
    Vertex*      _tesselated_vertices;       /** The tesselated vertices, computed from the control points */
    unsigned int _tesselated_vertices_count; /** The number of tesselated vertices */
 
    // disabling default implicit assignment and copy constructor
    GlsNurbCurve& operator=( const GlsNurbCurve& ) DISTI_SPECIAL_MEM_FUN_DELETE;
    GlsNurbCurve( const GlsNurbCurve& ) DISTI_SPECIAL_MEM_FUN_DELETE;
 
public:
    /** Creates a NURB Curve with the vertices specified 
      * \param nPoints Number of control points in the NURB
      * \param vertices An array of allocated vertices
      * \pre vertices is not NULL
      */
    GLSGEN_GLSNURBCURVE_EXPORT GlsNurbCurve( unsigned int nPoints, Vertex* vertices );
 
    /// Allocate a (blank) NURB Curve object.
    /// \param generateInstanceName Whether or not to generate an instance name for this object.
    GLSGEN_GLSNURBCURVE_EXPORT GlsNurbCurve( bool generateInstanceName = false );
 
    /** NurbCurve Constructor.  Creates a new NURBCurve object with 
      * the number of vertices and vertex data specified.
      * \param n_points Number of control points in the NURB
      * \param vertices An array of allocated vertices
      * \param location Initial location of the NURB
      */
    GLSGEN_GLSNURBCURVE_EXPORT GlsNurbCurve( unsigned int n_points, Vertex* vertices, Vertex& location );
 
    /// Copy constructor
    /// \param that The object to copy from.
    /// \param generateNames Whether or not to generate an instance name for this object.
    GLSGEN_GLSNURBCURVE_EXPORT GlsNurbCurve( const GlsNurbCurve& that, const bool generateNames );
 
    /** Destructs a GlsNurbCurve object */
    virtual GLSGEN_GLSNURBCURVE_EXPORT ~GlsNurbCurve();
 
    /// \return A pointer to a new GlsNurbCurve object.
    static GLSGEN_GLSNURBCURVE_EXPORT DisplayObject* CreateInstance();
 
    /** Generate a list of vertices describing the NURB curve, save those
      * vertices in the NURBCurve object for use in drawing.
      */
    void GLSGEN_GLSNURBCURVE_EXPORT GenerateTessellatedVertices();
 
    /** Gets the object's number of Tesselated vertices.
      * These tesselated vertices are generated by the NURB render function.
      * \return  The number of vertices in the object
      */
    unsigned int NumberOfTessVertices() const { return _tesselated_vertices_count; }
 
    /** Gets the object's tesselated vertices.
      * \return  Pointer the the object's tesselated vertices
      */
    Vertex* TessVertices() { return _tesselated_vertices; }
 
    //////////////////////////////////////////////////
    // Overridden base class methods
    //////////////////////////////////////////////////
 
    virtual GLSGEN_GLSNURBCURVE_EXPORT void SetAvailableAttributes( unsigned int availableAttributes ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSNURBCURVE_EXPORT DisplayObject* CloneObject( bool generateNames = false ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSNURBCURVE_EXPORT void           CopyGeometry( DisplayObject* src ) DISTI_METHOD_OVERRIDE;
 
#ifndef GLES
    virtual GLSGEN_GLSNURBCURVE_EXPORT InterfaceListType* GetCppInterfaceDescription( InterfaceListType* addToThisList = NULL ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSNURBCURVE_EXPORT void               GetCppInterfaceDescriptionFree( InterfaceListType* array ) DISTI_METHOD_OVERRIDE;
#endif
 
    virtual GLSGEN_GLSNURBCURVE_EXPORT void PreDraw( const OpenGLMatrices& parentMatrices, Culler& culler ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSNURBCURVE_EXPORT void Draw() DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSNURBCURVE_EXPORT void SetVertices( unsigned int nPoints, Vertex* vertices ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSNURBCURVE_EXPORT void VaListSetVertices( unsigned int nPoints, va_list args ) DISTI_METHOD_OVERRIDE;
 
    /* Unhides base class implementation. */
    using BaseClass::Scale;
    GLSGEN_GLSNURBCURVE_EXPORT void Scale( float px, float py, float pz, Vertex* a, int handleBar ) DISTI_METHOD_OVERRIDE;
 
    virtual GLSGEN_GLSNURBCURVE_EXPORT void CalculateTextureCoordinates() DISTI_METHOD_OVERRIDE;
 
    /* Unhides base class implementation. */
    using BaseClass::Rotate;
    virtual GLSGEN_GLSNURBCURVE_EXPORT void Rotate( const Vector& orig, float angle, const Vector& axis ) DISTI_METHOD_OVERRIDE;
 
    virtual GLSGEN_GLSNURBCURVE_EXPORT void GetExtents( float& x, float& y, float& z, float& x1, float& y1, float& z1 ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSNURBCURVE_EXPORT void GetTransformedExtents( Vector& min, Vector& max, const GlsMatrixType& matrix, bool resetMinMax = true ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSNURBCURVE_EXPORT bool Hit( float x, float y, float z, float scale, const Vector& directionVector, Vector* collisionPoint ) DISTI_METHOD_OVERRIDE;
 
    GLSGEN_GLSNURBCURVE_EXPORT void         DeleteVertexAt( unsigned int index ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSNURBCURVE_EXPORT void SetVertexColor( unsigned int index, unsigned char col[] ) DISTI_METHOD_OVERRIDE;
 
    /* Unhides base class implementation. */
    using BaseClass::SetFillColor;
    virtual GLSGEN_GLSNURBCURVE_EXPORT void SetFillColor( const GlsColor& color ) DISTI_METHOD_OVERRIDE;
 
    /// Calculates normals based on the vertices and the specified winding order.
    /// \param windingOrder If less than zero, all normals will be mirrored (*= -1.0f).
    virtual GLSGEN_GLSNURBCURVE_EXPORT void CalcNormals( int windingOrder = 1 );
 
    /// Create a spline from a set of control points. Return the vertices, so that the user can draw the spline as they wish.
    /// \param num_vertices The number of control points to make a spline out of.
    /// \param vertices The control points.
    /// \param curve_array_size Originally the size of the curve array.
    /// \param curve_array The actually used size is returned here.
    GLSGEN_GLSNURBCURVE_EXPORT void GenerateSpline( unsigned int num_vertices, Vertex* vertices, unsigned int* curve_array_size, Vertex* curve_array );
 
protected:
#ifdef GLES
    // BakeVBO is a helper function only used for GLES drawing and should not be considered missing external api
    void           BakeVBO();
    GlsVertexArray _curve;
    GlsVertexArray _fill;
#endif
};
 
} // namespace disti
 
#endif