gls_render_settings.h

Go to the documentation of this file.

#ifndef _GLS_RENDER_SETTINGS_H
#define _GLS_RENDER_SETTINGS_H
 
/*! \file gls_render_settings.h
\brief  This header defines the basic render setting types used 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_types.h"
 
/** Enumeration for texture mapping mode of the object */
enum GlsTextureMapMode
{
    GLS_TEXTURE_MAP_MODE_MODULATE, /**< Texture color and alpha is modulated with polygon color and alpha */
    GLS_TEXTURE_MAP_MODE_DECAL,    /**< Texture color is blended with polygon color */
    GLS_TEXTURE_MAP_MODE_REPLACE,  /**< Texture color and alpha replace polygon color and alpha */
 
    #if defined( GLS_DEBUG )
        GLS_TEXTURE_MAP_MODE_INVALID    /**< Invalid texture map mode ( GLS_DEBUG ) only */
    #endif
};
 
#if defined( GLS_DEBUG )
#pragma BullseyeCoverage save off
/**
 * Determine if the given texture map mode is valid ( GLS_DEBUG only )
 * \param mode texture map mode in question
 * \return GLS_TRUE if mode is valid else GLS_FALSE
 * \pre none
 * \post none
 */
inline GlsBool GlsTextureMapModeIsValid( const GlsTextureMapMode mode )
{
    return( ( GLS_TEXTURE_MAP_MODE_MODULATE == mode ) ||
            ( GLS_TEXTURE_MAP_MODE_DECAL    == mode ) ||
            ( GLS_TEXTURE_MAP_MODE_REPLACE  == mode ) );
}
#pragma BullseyeCoverage restore
#endif // GLS_DEBUG
 
/** Enumeration for texture filtering mode of the object */
enum GlsTextureFilterMode
{
    GLS_TEXTURE_FILTER_MODE_NEAREST,                /**< Nearest pixel filtering */
    GLS_TEXTURE_FILTER_MODE_LINEAR,                 /**< Bilinear interpolation filtering */
 
    #if defined( GLS_DEBUG )
        GLS_TEXTURE_FILTER_MODE_INVALID             /**< Invalid texture filter mode ( GLS_DEBUG only )*/
    #endif
};
 
#if defined( GLS_DEBUG )
#pragma BullseyeCoverage save off
/** Determine if the given texture filter mode is valid
  * \param mode texture filter mode in question
  * \return GLS_TRUE if valid else GLS_FALSE
  * \pre none
  * \post none
  */
inline GlsBool GlsTextureFilterModeIsValid( const GlsTextureFilterMode mode )
{
    return( ( GLS_TEXTURE_FILTER_MODE_NEAREST == mode ) ||
            ( GLS_TEXTURE_FILTER_MODE_LINEAR  == mode ) );
}
#pragma BullseyeCoverage restore
#endif // GLS_DEBUG
 
/** Enumeration for the Depth Testing and Writting mode */
enum GlsDepthBufferMode
{
    GLS_DEPTH_BUFFER_MODE_TEST,     /**< test against depth buffer */ 
    GLS_DEPTH_BUFFER_MODE_NO_TEST,  /**< do not test against depth buffer */
 
    #if defined( GLS_DEBUG )
        GLS_DEPTH_BUFFER_MODE_INVALID           /**< Invalid depth buffer mode ( GLS_DEBUG only ) */
    #endif
};
 
#if defined( GLS_DEBUG )
#pragma BullseyeCoverage save off
/** Determine if the given depth buffer mode is valid ( GLS_DEBUG only )
  * \param mode depth buffer mode in nquestion
  * \return GLS_TRUE if valid else GLS_FALSE
  * \pre none
  * \post none
  */
inline GlsBool GlsDepthBufferModeIsValid( const GlsDepthBufferMode mode )
{
    return( ( GLS_DEPTH_BUFFER_MODE_TEST    == mode ) ||
            ( GLS_DEPTH_BUFFER_MODE_NO_TEST == mode ) );
}
#pragma BullseyeCoverage restore
#endif // GLS_DEBUG
 
/** Enumeration for polygon drawing mode of the object */
enum GlsPolygonMode
{
    GLS_POLYGON_MODE_POINTS,            /**< Polygon will be rendered with a point at each vertex */
    GLS_POLYGON_MODE_OUTLINE,           /**< Polygon will be rendered as an outline */
    GLS_POLYGON_MODE_FILLED,            /**< Polygon will be rendered filled-in */
    GLS_POLYGON_MODE_FILL_AND_OUTLINE,  /**< Polygon will be rendered filled-in and with an outline */
 
    #if defined( GLS_DEBUG )
        GLS_POLYGON_MODE_INVALID        /**< Invalid polygon mode ( GLS_DEBUG only ) */
    #endif
};
 
#if defined( GLS_DEBUG )
#pragma BullseyeCoverage save off
/** Determine if the given polygon mode is valid
  * \param mode polygon mode in question
  * \return GLS_TRUE if valid else GLS_FALSE
  * \pre none
  * \post none
  */
inline GlsBool GlsPolygonModeIsValid( const GlsPolygonMode mode )
{
    return( ( GLS_POLYGON_MODE_POINTS           == mode ) ||
            ( GLS_POLYGON_MODE_OUTLINE          == mode ) ||
            ( GLS_POLYGON_MODE_FILLED           == mode ) ||
            ( GLS_POLYGON_MODE_FILL_AND_OUTLINE == mode ) );
}
#pragma BullseyeCoverage restore
#endif // GLS_DEBUG
 
/** Enumeration for Alpha Blending/Testing mode */
enum GlsAlphaMode
{
    GLS_ALPHA_MODE_OPAQUE,     /**< Alpha testing and blending are disabled */
    GLS_ALPHA_MODE_2_LEVEL,    /**< Alpha testing with a threshold of 0.5 is enabled, alpha blending is enabled. */
    GLS_ALPHA_MODE_256_LEVEL,  /**< Alpha blending is enabled, alpha testing is disabled. */
 
    #if defined( GLS_DEBUG )
        GLS_ALPHA_MODE_INVALID /**< Invalid alpha mode ( GLS_DEBUG only ) */
    #endif
};
 
#if defined( GLS_DEBUG )
#pragma BullseyeCoverage save off
/** Determine if the given alpha mode is valid
  * \param mode alpha mode in question
  * \return GLS_TRUE if valid else GLS_FALSE
  * \pre none
  * \post none
  */
inline GlsBool GlsAlphaModeIsValid( const GlsAlphaMode mode )
{
    return( ( GLS_ALPHA_MODE_OPAQUE    == mode ) ||
            ( GLS_ALPHA_MODE_2_LEVEL   == mode ) ||
            ( GLS_ALPHA_MODE_256_LEVEL == mode ) );
}
#pragma BullseyeCoverage restore
#endif // GLS_DEBUG
 
/** Enumeration for whether or not polygon is closed or open */
enum GlsPolygonEndMode
{
    GLS_POLYGON_END_MODE_OPEN,        /**< Polygon will be drawn open */
    GLS_POLYGON_END_MODE_CLOSED,      /**< Polygon will be drawn close */
 
    #if defined( GLS_DEBUG )
        GLS_POLYGON_END_MODE_INVALID  /**< Invalid polygon close mode ( GLS_DEBUG only ) */
    #endif 
};
 
#if defined( GLS_DEBUG )
#pragma BullseyeCoverage save off
/** Determine if the given polygon end mode is valid
  * \param mode polygon end mode in question
  * \return GLS_TRUE if valid else GLS_FALSE
  */
inline GlsBool GlsPolygonEndModeIsValid( const GlsPolygonEndMode mode )
{
    return( ( GLS_POLYGON_END_MODE_OPEN   == mode ) ||
            ( GLS_POLYGON_END_MODE_CLOSED == mode ) );
}
#pragma BullseyeCoverage restore
#endif // GLS_DEBUG
 
/** Enumeration for the type of shading used when drawing */
enum GlsShadingMode
{
    GLS_SHADING_MODE_FLAT,          /**< The object will be drawn with flat shading (monochromatic) */ 
    GLS_SHADING_MODE_GOURAUD,       /**< The object will be drawn with gouraud shading (linear color interpolation) */
 
    #if defined( GLS_DEBUG )
        GLS_SHADING_MODE_INVALID    /**< Invalid shading mode ( GLS_DEBUG only ) */
    #endif
};
 
#if defined( GLS_DEBUG )
#pragma BullseyeCoverage save off
/** Determine if the given shading mode is valid
  * \param mode shading mode in question
  * \return GLS_TRUE if valid else GLS_FALSE
  */
inline GlsBool GlsShadingModeIsValid( const GlsShadingMode mode )
{
    return( ( GLS_SHADING_MODE_FLAT    == mode ) ||
            ( GLS_SHADING_MODE_GOURAUD == mode ) );
}
#pragma BullseyeCoverage restore
#endif // GLS_DEBUG
 
#endif // _GLS_RENDER_SETTINGS_H