glpolygon.h

Go to the documentation of this file.

/*! \file
  \brief  The disti::GLPolygon class.  Implements Polygons.
 
  \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 _GLPOLYGON_H
#define _GLPOLYGON_H
 
#include "gls_include.h"
#ifdef GLES
#    include "gls_vertex_array.h"
#endif
#include "display.h"
#include "gls_cpp_lang_support.h"
 
namespace disti
{
/**
  \brief  The Polygon class.  Implements Polygons
*/
class GLPolygon : public DisplayObject
{
private:
    /** Assignment operator not implemented. Use CloneObject() or the copy constructor instead. */
    GLPolygon& operator=( const GLPolygon& that ) DISTI_SPECIAL_MEM_FUN_DELETE;
    GLPolygon( const GLPolygon& that ) DISTI_SPECIAL_MEM_FUN_DELETE;
 
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 GLPolygonEditor;
 
    /// \return A new GLPolygon instance.
    static GLS_EXPORT DisplayObject* CreateInstance();
 
    /** Creates a polygon with the vertices specified
      * \param nPoints   The number of vertices in the new polygon
      * \param vertices  The array of vertices for the polygon
      */
    GLS_EXPORT GLPolygon( unsigned int nPoints, const Vertex* vertices );
 
    /** Creates a polygon with the vertices specified
      * \param nPoints   The number of vertices in the new polygon
      * \param vertices  The array of vertices for the polygon
      * \param location  The location point of the object
      */
    GLS_EXPORT GLPolygon( unsigned int nPoints, const Vertex* vertices, const Vertex& location );
 
    /** Allocate a (blank) polygon object */
    GLS_EXPORT GLPolygon();
 
    /** Copy construct a new GLPolygon object
      * \param polygon          The polygon to be cloned
      * \param generateNames    Whether or not to generate a new instance name
      */
    GLS_EXPORT GLPolygon( const GLPolygon& polygon, const bool generateNames );
 
    /** Destroy a polygon object */
    virtual GLS_EXPORT ~GLPolygon();
 
    /** Configures MetaData */
    GLS_EXPORT void ConfigureMetaData();
 
    /* Copy+Create operation in one method. In derived classes, this
      * method will create a new instance of the derived class and then
      * copy the object into the new instance. The cut,copy,paste and undo
      * operations use this method.
      * \param generateNames  Whether or not to generate new names for cloned objects
      * \return A new object, identical to the original, except for the instance name
      */
    virtual GLS_EXPORT DisplayObject* CloneObject( bool generateNames = false );
 
#ifdef GLES
    /// \copydoc DisplayObject::PreDraw
    virtual GLS_EXPORT void PreDraw( const OpenGLMatrices& current, Culler& culler ) DISTI_METHOD_OVERRIDE;
#endif
 
    /** Draws this object on the current display frame (_parent member). */
    virtual GLS_EXPORT void Draw() DISTI_METHOD_OVERRIDE;
 
    /** Recalculates the texture coordinates for the object based on the TexturePoints.
      */
    virtual GLS_EXPORT void CalculateTextureCoordinates();
 
    /// Calculates normals based on the vertices and the specified winding order.
    /// \param windingOrder Multiply calculated normals by -1 if less than 0.
    virtual GLS_EXPORT void CalcNormals( int windingOrder = 1 );
 
#ifdef GLES
    /** Sets the RGBA color for filling the object
      * \param r  The new Red fill color (0-255 range) for the object
      * \param g  The new Green fill color (0-255 range) for the object
      * \param b  The new Blue fill color (0-255 range) for the object
      * \param a  The new Alpha fill color (0-255 range) for the object
      */
    virtual GLS_EXPORT void SetFillColor( unsigned char r, unsigned char g, unsigned char b, unsigned char a );
 
    /** Sets the RGBA color for filling the object
      * \param color  The new RGBA fill color (0-255 range) for the object
      */
    virtual GLS_EXPORT void SetFillColor( const GlsColor& color );
#endif
 
    /// DeleteVertexAt is overloaded in polygon to prevent having a poly with less than 2 verts. This
    /// prevents incorrect GL calls when polygon is set to POLY_MODE_FILLED
    /// \param index The index of the vertex to delete.
    virtual GLS_EXPORT void DeleteVertexAt( unsigned int index );
 
    /// \copydoc DisplayObject::Pick3D
    virtual GLS_EXPORT DisplayObject* Pick3D( const Vector& winLoc,
        const Vector&                                       logicalCoords,
        float                                               scale,
        const Vector&                                       directionVector,
        Vector&                                             collisionWinLoc, /*Returned*/
        const OpenGLMatrices&                               drawnMatrices ) DISTI_METHOD_OVERRIDE;
 
#ifdef GLES
protected:
    /// Renders the vertex array as a triangle fan.
    /// \param textureObject If true, then this will texture the mesh surface.
    /// \param gouraudShading If true, then it'll apply gouraudShading. Otherwise, it'll use flat shading.
    /// \param normal If true, then allow per vertex normals.
    void DrawSolidGeometry( bool textureObject, bool gouraudShading, bool normal );
 
    /// Draws lines that form this polygon's outline.
    void DrawOutlineGeometry();
 
    /// Draws a point for each vertex of this polygon.
    void DrawPoints();
 
    /// Bakes the vertex array to a Vertext Buffer Object.
    /// \param hasT If true, then the vertex array's texture coordinates will be updated.
    /// \param hasN If true, then the vertex array's normals will be updated.
    /// \param hasC If true, then the vertex array's colors will be updated.
    void BakeVBO( bool hasT, bool hasC, bool hasN );
 
    GlsVertexArray _vertArray;        ///< A vertex array that makes up this mesh. Each vertex contains data such as position, normal, texture coordinates, and color.
    bool           _pendingFillColor; ///< If true and gouraudShading is true during a paint cycle, then it'll bake the VBO.
#endif
};
 
} // namespace disti
 
#endif