gls_texture_vertex_array.h

Go to the documentation of this file.

#ifndef _GLS_TEXTURE_VERTEX_ARRAY_H
#define _GLS_TEXTURE_VERTEX_ARRAY_H
 
/*! \file gls_texture_vertex_array.h
 
\brief  This header defines GlsTextureVertexArray which encapsulates an array of 
        GlsTextureVertex 's
        in the GL Studio DO-178B Runtime Library.
 
\par Copyright Information
Copyright (C) 1999-2012 The DiSTI Corporation<br>
Orlando, FL USA<br>
All rights reserved.<br>
 
  This file is copyrighted software and contains proprietary trade secrets of
DiSTI, and embodies substantial creative efforts as well as confidential
information, ideas, and expressions.
 
  Permission to use, and copy this software and its documentation for any
purpose is hereby granted per the Distribution Agreement and/or the Licensing
Agreement signed with DiSTI. This permission is granted provided that:
    1.  The above copyright notice appears in all copies.
    2.  That both the copyright notice and this permission notice appear in
        the supporting documentation.
    3.  That the names DiSTI and GL Studio not be used in advertising or
        publicity pertaining to distribution of the software without specific,
        written prior permission of DiSTI.
 
  Permission to modify the software is granted, but not the right to
distribute the source code whether modified, or non-modified.  Modifying the
software might invalidate the DO-178B certification package.
 
  Permission to distribute binaries produced by compiling source code, or
modified source code is granted, provided you:
    1.  Provide your name and address as the primary contact for the support
        of your modified version.
    2.  Retain our contact information in regard to use of the base software. 
 
   DiSTI does not provide warranty for this software or guarantee that it
satisfies any specification or requirement unless otherwise stated in a
specific contractual arrangement between the customer and DiSTI.
 
*/
 
#include "gls_include.h"
#include "gls_vertex.h"
#include "gls_class_invariant.h"
 
class GlsStateManager;
 
/** This class encapsulates an array of one or more GlsTextureVertex 's.
  * \invariant  _numVertices > 0, _vertices != GLS_NULL,
  *             every vertex in the array is valid
  */
class GlsTextureVertexArray
{
public:
    GLS_CLASS_INVARIANT_DECLARATION( GlsTextureVertexArray )
 
    /** initialization parameters for GlsTextureVertexArray */
    struct InitParameters
    {
        const GlsUInt32                numVertices; /**< number of vertices in vertices array ( >0 ) */
        const GlsTextureVertex* const  vertices;    /**< initial vertices */
 
        #if defined( GLS_DEBUG )
            /** Determine if the initialization parameters are valid ( GLS_DEBUG only )
              * \return GLS_TRUE if valid else GLS_FALSE
              * \pre none
              * \post none
              */
            GlsBool IsValid( void ) const;
        #endif // GLS_DEBUG
    };
 
    /** Constructor - create an instance
      * \param initParameters initialization parameters
      * \pre initParameters.IsValid()
      * \post instance is created
      */
    GlsTextureVertexArray( const InitParameters &initParameters );
 
    /** Destructor - shall never be called
      * \pre none
      * \post none
      */
    virtual ~GlsTextureVertexArray();
 
    /** Set a vertex in the array
      * \param index index to desired vertex to set
      * \param v new value for vertex
      * \pre index < number of elements in array, v.IsValid()
      * \post vertex at given index is set to v
      */
    void SetVertex( const GlsUInt32 index, const GlsTextureVertex &v );
 
    #if defined( GLS_DEBUG )
        /** Get a const ref to the vertex at the given index ( GLS_DEBUG only )
          * \param index index of desired vertex
          * \return const ref to vertex at given index
          * \pre index < number of elements in array
          * \post none
          */
        const GlsTextureVertex& GetVertex( const GlsUInt32 index ) const;
    #endif // GLS_DEBUG
 
    #if defined( GLS_DEBUG )
        /** Get the number of texture vertices in the array ( >0 ) ( GLS_DEBUG only )
          * \pre none
          * \post none
          * \return number of texture vertices in the array ( >0 )
          */
        GlsUInt32 GetSize( void ) const;
    #endif // GLS_DEBUG
 
    /** Output the vertices in the array to GL
      * \param gl GL state manager to receive verts
      * \param doTextureCoordinates GLS_TRUE to send texture coordinates with each vert else GLS_FALSE
      * \param doVertexColors GLS_TRUE to send vertex colors with each vert else GLS_FALSE
      * \pre called inside a GL begin/end pair
      * \post vertices are output to GL
      */
    void OutputVertices( GlsStateManager &gl, const GlsBool doTextureCoordinates, const GlsBool doVertexColors ) const;
 
    /** Output three vertices in the array to GL
      * \param gl GL state manager to receive verts
      * \param v1Index index of first vertex to send
      * \param v2Index index of second vertex to send
      * \param v3Index index of third vertex to send
      * \param doTextureCoordinates GLS_TRUE to send texture coordinates with each vert else GLS_FALSE
      * \param doVertexColors GLS_TRUE to send vertex colors with each vert else GLS_FALSE
      * \pre called inside a GL begin/end pair,
      *       v1Index < _numVertices, v2Index < _numVertices, v3Index < _numVertices
      * \post vertices are output to GL 
      */
    void OutputTriangle( GlsStateManager &gl,
                         const GlsUInt32 v1Index, const GlsUInt32 v2Index, const GlsUInt32 v3Index,
                         const GlsBool doTextureCoordinates, const GlsBool doVertexColors ) const;
 
    /** Offset all of texture coordinates in the array by a given 2D vector
      * \param offset 2D offset vector
      * \pre offset.IsValid()
      * \post texture coordinates in the array are offset by the vector
      */
    void OffsetTextureCoordinates( const GlsVector2D &offset );
 
protected:
    const GlsUInt32         _numVertices; /**< number of vertices in vertices array */
    GlsTextureVertex* const _vertices;    /**< array of vertices */
 
private:
    // Disable implicit generated Members
    GlsTextureVertexArray& operator=( const GlsTextureVertexArray &rhs );
    GlsTextureVertexArray( const GlsTextureVertexArray &src );
};
 
#endif // _GLS_TEXTURE_VERTEX_ARRAY_H