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
///////////////////////////////////////////////////////////////////////////////

#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:
    typedef DisplayObject _BaseClass;
    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 */
    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 );

    GLSGEN_GLSNURBCURVE_EXPORT GlsNurbCurve( const GlsNurbCurve& that, const bool generateNames );

    /** Destructs a GlsNurbCurve object */
    virtual GLSGEN_GLSNURBCURVE_EXPORT ~GlsNurbCurve();

    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( void );

    /** 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 );
    virtual GLSGEN_GLSNURBCURVE_EXPORT DisplayObject* CloneObject( bool generateNames = false );
    virtual GLSGEN_GLSNURBCURVE_EXPORT void CopyGeometry( DisplayObject* src );

    virtual GLSGEN_GLSNURBCURVE_EXPORT InterfaceListType* GetCppInterfaceDescription( InterfaceListType* addToThisList = NULL );
    virtual GLSGEN_GLSNURBCURVE_EXPORT void GetCppInterfaceDescriptionFree( InterfaceListType* array );

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

    /** Calculates normals based on the vertices and the specified winding order */
    virtual GLSGEN_GLSNURBCURVE_EXPORT void CalcNormals( int windingOrder = 1 );

    /* See base class */
    virtual GLSGEN_GLSNURBCURVE_EXPORT void SetVertices( unsigned int nPoints, Vertex* vertices );

    /* See base class */
    virtual GLSGEN_GLSNURBCURVE_EXPORT void VaListSetVertices( unsigned int nPoints, va_list args );

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

    /* See base class */
    GLSGEN_GLSNURBCURVE_EXPORT void Scale( float px, float py, float pz, Vertex* a, int handleBar );

    /* See base class */
    virtual GLSGEN_GLSNURBCURVE_EXPORT void CalculateTextureCoordinates( void );

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

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

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

    /* See base class */
    virtual GLSGEN_GLSNURBCURVE_EXPORT void GetTransformedExtents( Vector& min, Vector& max, const GlsMatrixAffineD& matrix, bool resetMinMax = true );

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

    /** Remove the Vertex at the given index.  This causes tesselated vertices to be recalculated.
      * \param index The index to remove (1 based)   
      */
    virtual GLSGEN_GLSNURBCURVE_EXPORT void DeleteVertex( unsigned int index );

    /* See base class */
    virtual GLSGEN_GLSNURBCURVE_EXPORT void SetVertexColor( unsigned int index, unsigned char col[] );

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

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

    //
    //  Create a spline from a set of control points.  Return the vertices, so that the user
    //  can draw the spline as he/she wishes.
    //
    GLSGEN_GLSNURBCURVE_EXPORT void GenerateSpline(
        unsigned int  num_vertices, // Number of control points to make a spline out of
        Vertex*       vertices, // Control points
        unsigned int* curve_array_size, // Originally the size of the curve array
        // the actually used size is returned here
        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