include/display/orxDisplay.h

Go to the documentation of this file.

/* Orx - Portable Game Engine
 *
 * Copyright (c) 2008-2011 Orx-Project
 *
 * This software is provided 'as-is', without any express or implied
 * warranty. In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 *    1. The origin of this software must not be misrepresented; you must not
 *    claim that you wrote the original software. If you use this software
 *    in a product, an acknowledgment in the product documentation would be
 *    appreciated but is not required.
 *
 *    2. Altered source versions must be plainly marked as such, and must not be
 *    misrepresented as being the original software.
 *
 *    3. This notice may not be removed or altered from any source
 *    distribution.
 */

#ifndef _orxDISPLAY_H_
#define _orxDISPLAY_H_

#include "orxInclude.h"
#include "plugin/orxPluginCore.h"

#include "math/orxVector.h"
#include "memory/orxBank.h"
#include "utils/orxHashTable.h"
#include "utils/orxString.h"
#include "utils/orxLinkList.h"


typedef orxU32                      orxRGBA;

#ifdef __orxBIG_ENDIAN__

  #define orx2RGBA(R, G, B, A)      ((((R) & 0xFF) << 24) | (((G) & 0xFF) << 16) | (((B) & 0xFF) << 8) | ((A) & 0xFF))
  #define orxRGBA_R(RGBA)           (orxU8)(((RGBA) >> 24) & 0xFF)
  #define orxRGBA_G(RGBA)           (orxU8)(((RGBA) >> 16) & 0xFF)
  #define orxRGBA_B(RGBA)           (orxU8)(((RGBA) >> 8) & 0xFF)
  #define orxRGBA_A(RGBA)           (orxU8)((RGBA) & 0xFF)

#else /* __orxBIG_ENDIAN__ */

  #define orx2RGBA(R, G, B, A)      ((((A) & 0xFF) << 24) | (((B) & 0xFF) << 16) | (((G) & 0xFF) << 8) | ((R) & 0xFF))
  #define orxRGBA_R(RGBA)           (orxU8)((RGBA) & 0xFF)
  #define orxRGBA_G(RGBA)           (orxU8)(((RGBA) >> 8) & 0xFF)
  #define orxRGBA_B(RGBA)           (orxU8)(((RGBA) >> 16) & 0xFF)
  #define orxRGBA_A(RGBA)           (orxU8)(((RGBA) >> 24) & 0xFF)

#endif /* __orxBIG_ENDIAN__ */

#define orxCOLOR_NORMALIZER         (orx2F(1.0f / 255.0f))
#define orxCOLOR_DENORMALIZER       (orx2F(255.0f))


typedef struct __orxBITMAP_t        orxBITMAP;

typedef struct __orxDISPLAY_TRANSFORM_t
{
  orxFLOAT  fSrcX, fSrcY, fDstX, fDstY;
  orxFLOAT  fRepeatX, fRepeatY;
  orxFLOAT  fScaleX;
  orxFLOAT  fScaleY;
  orxFLOAT  fRotation;

} orxDISPLAY_TRANSFORM;

typedef struct __orxDISPLAY_VIDEO_MODE_t
{
  orxU32  u32Width, u32Height, u32Depth;

} orxDISPLAY_VIDEO_MODE;

typedef struct __orxCHARACTER_GLYPH_t
{
  orxFLOAT fX, fY, fWidth;

} orxCHARACTER_GLYPH;

typedef struct __orxCHARACTER_MAP_t
{
  orxFLOAT      fCharacterHeight;

  orxBANK      *pstCharacterBank;
  orxHASHTABLE *pstCharacterTable;

} orxCHARACTER_MAP;

typedef enum __orxDISPLAY_SMOOTHING_t
{
  orxDISPLAY_SMOOTHING_DEFAULT = 0,
  orxDISPLAY_SMOOTHING_ON,
  orxDISPLAY_SMOOTHING_OFF,

  orxDISPLAY_SMOOTHING_NUMBER,

  orxDISPLAY_SMOOTHING_NONE = orxENUM_NONE

} orxDISPLAY_SMOOTHING;

typedef enum __orxDISPLAY_BLEND_MODE_t
{
  orxDISPLAY_BLEND_MODE_ALPHA = 0,
  orxDISPLAY_BLEND_MODE_MULTIPLY,
  orxDISPLAY_BLEND_MODE_ADD,

  orxDISPLAY_BLEND_MODE_NUMBER,

  orxDISPLAY_BLEND_MODE_NONE = orxENUM_NONE

} orxDISPLAY_BLEND_MODE;

typedef struct __orxCOLOR_t
{
  union
  {
    orxVECTOR vRGB;                     
    orxVECTOR vHSL;                     
    orxVECTOR vHSV;                     
  };
  orxFLOAT  fAlpha;                     
} orxCOLOR;


#define orxDISPLAY_KZ_CONFIG_SECTION        "Display"
#define orxDISPLAY_KZ_CONFIG_WIDTH          "ScreenWidth"
#define orxDISPLAY_KZ_CONFIG_HEIGHT         "ScreenHeight"
#define orxDISPLAY_KZ_CONFIG_DEPTH          "ScreenDepth"
#define orxDISPLAY_KZ_CONFIG_FULLSCREEN     "FullScreen"
#define orxDISPLAY_KZ_CONFIG_DECORATION     "Decoration"
#define orxDISPLAY_KZ_CONFIG_TITLE          "Title"
#define orxDISPLAY_KZ_CONFIG_SMOOTH         "Smoothing"
#define orxDISPLAY_KZ_CONFIG_VSYNC          "VSync"
#define orxDISPLAY_KZ_CONFIG_DEPTHBUFFER    "DepthBuffer"


#define orxDISPLAY_KZ_SHADER_SUFFIX_TOP     "_top"
#define orxDISPLAY_KZ_SHADER_SUFFIX_LEFT    "_left"
#define orxDISPLAY_KZ_SHADER_SUFFIX_BOTTOM  "_bottom"
#define orxDISPLAY_KZ_SHADER_SUFFIX_RIGHT   "_right"


typedef enum __orxDISPLAY_EVENT_t
{
  orxDISPLAY_EVENT_SET_VIDEO_MODE = 0,

#ifdef __orxANDROID_NATIVE__

  orxDISPLAY_EVENT_SAVE_CONTEXT,
  orxDISPLAY_EVENT_RESTORE_CONTEXT,

#endif /* __orxANDROID_NATIVE__ */

  orxDISPLAY_EVENT_NUMBER,

  orxDISPLAY_EVENT_NONE = orxENUM_NONE

} orxDISPLAY_EVENT;

typedef struct __orxDISPLAY_EVENT_PAYLOAD_t
{
  orxU32  u32Width;                                     
  orxU32  u32Height;                                    
  orxU32  u32Depth;                                     
  orxBOOL bFullScreen;                                  
} orxDISPLAY_EVENT_PAYLOAD;


/***************************************************************************
 * Functions directly implemented by orx core
 ***************************************************************************/

#if defined(__orxIPHONE__) && defined(__orxOBJC__)

#import <UIKit/UIKit.h>
#import <OpenGLES/EAGL.h>
#import <OpenGLES/ES1/gl.h>
#import <OpenGLES/ES1/glext.h>
#import <OpenGLES/ES2/gl.h>
#import <OpenGLES/ES2/glext.h>

@interface orxView : UIView
{
@private
  EAGLContext  *poMainContext, *poThreadContext;
  GLuint        uiRenderBuffer, uiFrameBuffer, uiDepthBuffer;
  BOOL          bShaderSupport;
}

@property (nonatomic, retain) EAGLContext  *poMainContext;
@property (nonatomic, retain) EAGLContext  *poThreadContext;
@property                     BOOL          bShaderSupport;

@end

#endif /* __orxIPHONE__ && __orxOBJC__ */


extern orxDLLAPI void orxFASTCALL orxDisplay_Setup();

static orxINLINE orxCOLOR *       orxColor_SetRGBA(orxCOLOR *_pstColor, orxRGBA _stRGBA)
{
  orxCOLOR *pstResult = _pstColor;

  /* Checks */
  orxASSERT(_pstColor != orxNULL);

  /* Stores RGB */
  orxVector_Set(&(_pstColor->vRGB), orxCOLOR_NORMALIZER * orxU2F(orxRGBA_R(_stRGBA)), orxCOLOR_NORMALIZER * orxU2F(orxRGBA_G(_stRGBA)), orxCOLOR_NORMALIZER * orxU2F(orxRGBA_B(_stRGBA)));

  /* Stores alpha */
  _pstColor->fAlpha = orxCOLOR_NORMALIZER * orxRGBA_A(_stRGBA);

  /* Done! */
  return pstResult;
}

static orxINLINE orxCOLOR *       orxColor_Set(orxCOLOR *_pstColor, const orxVECTOR *_pvRGB, orxFLOAT _fAlpha)
{
  orxCOLOR *pstResult = _pstColor;

  /* Checks */
  orxASSERT(_pstColor != orxNULL);

  /* Stores RGB */
  orxVector_Copy(&(_pstColor->vRGB), _pvRGB);

  /* Stores alpha */
  _pstColor->fAlpha = _fAlpha;

  /* Done! */
  return pstResult;
}

static orxINLINE orxCOLOR *       orxColor_SetRGB(orxCOLOR *_pstColor, const orxVECTOR *_pvRGB)
{
  orxCOLOR *pstResult = _pstColor;

  /* Checks */
  orxASSERT(_pstColor != orxNULL);
  orxASSERT(_pvRGB != orxNULL);

  /* Stores components */
  orxVector_Copy(&(_pstColor->vRGB), _pvRGB);

  /* Done! */
  return pstResult;
}

static orxINLINE orxCOLOR *       orxColor_SetAlpha(orxCOLOR *_pstColor, orxFLOAT _fAlpha)
{
  orxCOLOR *pstResult = _pstColor;

  /* Checks */
  orxASSERT(_pstColor != orxNULL);

  /* Stores it */
  _pstColor->fAlpha = _fAlpha;

  /* Done! */
  return pstResult;
}

static orxINLINE orxRGBA          orxColor_ToRGBA(const orxCOLOR *_pstColor)
{
  orxRGBA   stResult;
  orxVECTOR vColor;
  orxFLOAT  fAlpha;

  /* Checks */
  orxASSERT(_pstColor != orxNULL);

  /* Clamps RGB components */
  orxVector_Clamp(&vColor, &(_pstColor->vRGB), &orxVECTOR_0, &orxVECTOR_WHITE);

  /* De-normalizes vector */
  orxVector_Mulf(&vColor, &vColor, orxCOLOR_DENORMALIZER);

  /* Clamps alpha */
  fAlpha = orxCLAMP(_pstColor->fAlpha, orxFLOAT_0, orxFLOAT_1);

  /* Updates result */
  stResult = orx2RGBA(orxF2U(vColor.fR), orxF2U(vColor.fG), orxF2U(vColor.fB), orxF2U(orxCOLOR_DENORMALIZER * fAlpha));

  /* Done! */
  return stResult;
}

static orxINLINE orxCOLOR *       orxColor_Copy(orxCOLOR *_pstDst, const orxCOLOR *_pstSrc)
{
  /* Checks */
  orxASSERT(_pstDst != orxNULL);
  orxASSERT(_pstSrc != orxNULL);

  /* Copies it */
  orxMemory_Copy(_pstDst, _pstSrc, sizeof(orxCOLOR));

  /* Done! */
  return _pstDst;
}

static orxCOLOR *orxFASTCALL      orxColor_FromRGBToHSL(orxCOLOR *_pstDst, const orxCOLOR *_pstSrc)
{
  orxCOLOR *pstResult = _pstDst;
  orxFLOAT  fMin, fMax, fDelta, fR, fG, fB;

  /* Checks */
  orxASSERT(_pstDst != orxNULL);
  orxASSERT(_pstSrc != orxNULL);

  /* Gets source red, blue and green components */
  fR = _pstSrc->vRGB.fR;
  fG = _pstSrc->vRGB.fG;
  fB = _pstSrc->vRGB.fB;

  /* Gets min, max & delta values */
  fMin    = orxMIN(fR, orxMIN(fG, fB));
  fMax    = orxMAX(fR, orxMAX(fG, fB));
  fDelta  = fMax - fMin;

  /* Stores lightness */
  pstResult->vHSL.fL = orx2F(0.5f) * (fMax + fMin);

  /* Gray? */
  if(fDelta == orxFLOAT_0)
  {
    /* Gets hue & saturation */
    pstResult->vHSL.fH = pstResult->vHSL.fS = orxFLOAT_0;
  }
  else
  {
    /* Updates saturation */
    pstResult->vHSL.fS = (pstResult->vHSL.fL < orx2F(0.5f))
                       ? fDelta / (fMax + fMin)
                       : fDelta / (orx2F(2.0f) - fMax - fMin);

    /* Red tone? */
    if(fR == fMax)
    {
      /* Updates hue */
      pstResult->vHSL.fH = orx2F(1.0f / 6.0f) * (fG - fB) / fDelta;
    }
    /* Green tone? */
    else if(fG == fMax)
    {
      /* Updates hue */
      pstResult->vHSL.fH = orx2F(1.0f / 3.0f) + (orx2F(1.0f / 6.0f) * (fB - fR) / fDelta);
    }
    /* Blue tone */
    else
    {
      /* Updates hue */
      pstResult->vHSL.fH = orx2F(2.0f / 3.0f) + (orx2F(1.0f / 6.0f) * (fR - fG) / fDelta);
    }

    /* Clamps hue */
    if(pstResult->vHSL.fH < orxFLOAT_0)
    {
      pstResult->vHSL.fH += orxFLOAT_1;
    }
    else if(pstResult->vHSL.fH > orxFLOAT_1)
    {
      pstResult->vHSL.fH -= orxFLOAT_1;
    }
  }

  /* Updates alpha */
  pstResult->fAlpha = _pstSrc->fAlpha;

  /* Done! */
  return pstResult;
}

static orxCOLOR *orxFASTCALL      orxColor_FromHSLToRGB(orxCOLOR *_pstDst, const orxCOLOR *_pstSrc)
{
  orxCOLOR *pstResult = _pstDst;
  orxFLOAT  fH, fS, fL;

#define orxCOLOR_GET_RGB_COMPONENT(RESULT, ALT, CHROMA, HUE)                      \
do                                                                                \
{                                                                                 \
  if(HUE < orx2F(1.0f / 6.0f))                                                    \
  {                                                                               \
    RESULT = ALT + (orx2F(6.0f) * HUE * (CHROMA - ALT));                          \
  }                                                                               \
  else if(HUE < orx2F(1.0f / 2.0f))                                               \
  {                                                                               \
    RESULT = CHROMA;                                                              \
  }                                                                               \
  else if(HUE < orx2F(2.0f / 3.0f))                                               \
  {                                                                               \
    RESULT = ALT + (orx2F(6.0f) * (CHROMA - ALT) * (orx2F(2.0f / 3.0f) - HUE));   \
  }                                                                               \
  else                                                                            \
  {                                                                               \
    RESULT = ALT;                                                                 \
  }                                                                               \
  if(RESULT < orxMATH_KF_EPSILON)                                                 \
  {                                                                               \
    RESULT = orxFLOAT_0;                                                          \
  }                                                                               \
  else if(RESULT > orxFLOAT_1 - orxMATH_KF_EPSILON)                               \
  {                                                                               \
    RESULT = orxFLOAT_1;                                                          \
  }                                                                               \
}                                                                                 \
while(orxFALSE)

  /* Checks */
  orxASSERT(_pstDst != orxNULL);
  orxASSERT(_pstSrc != orxNULL);

  /* Gets source hue, saturation and lightness components */
  fH = _pstSrc->vRGB.fH;
  fS = _pstSrc->vRGB.fS;
  fL = _pstSrc->vRGB.fL;

  /* Gray? */
  if(fS == orxFLOAT_0)
  {
    /* Updates result */
    orxVector_SetAll(&(pstResult->vRGB), fL);
  }
  else
  {
    orxFLOAT fChroma, fIntermediate;

    /* Gets chroma */
    fChroma = (fL < orx2F(0.5f))
            ? fL + (fL * fS)
            : fL + fS - (fL * fS);

    /* Gets intermediate value */
    fIntermediate = (orx2F(2.0f) * fL) - fChroma;

    /* Gets RGB components */
    if(fH > orx2F(2.0f / 3.0f))
    {
      orxCOLOR_GET_RGB_COMPONENT(pstResult->vRGB.fR, fIntermediate, fChroma, (fH - orx2F(2.0f / 3.0f)));
    }
    else
    {
      orxCOLOR_GET_RGB_COMPONENT(pstResult->vRGB.fR, fIntermediate, fChroma, (fH + orx2F(1.0f / 3.0f)));
    }
    orxCOLOR_GET_RGB_COMPONENT(pstResult->vRGB.fG, fIntermediate, fChroma, fH);
    if(fH < orx2F(1.0f / 3.0f))
    {
      orxCOLOR_GET_RGB_COMPONENT(pstResult->vRGB.fB, fIntermediate, fChroma, (fH + orx2F(2.0f / 3.0f)));
    }
    else
    {
      orxCOLOR_GET_RGB_COMPONENT(pstResult->vRGB.fB, fIntermediate, fChroma, (fH - orx2F(1.0f / 3.0f)));
    }
  }

  /* Updates alpha */
  pstResult->fAlpha = _pstSrc->fAlpha;

  /* Done! */
  return pstResult;
}

static orxCOLOR *orxFASTCALL      orxColor_FromRGBToHSV(orxCOLOR *_pstDst, const orxCOLOR *_pstSrc)
{
  orxCOLOR *pstResult = _pstDst;
  orxFLOAT  fMin, fMax, fDelta, fR, fG, fB;

  /* Checks */
  orxASSERT(_pstDst != orxNULL);
  orxASSERT(_pstSrc != orxNULL);

  /* Gets source red, blue and green components */
  fR = _pstSrc->vRGB.fR;
  fG = _pstSrc->vRGB.fG;
  fB = _pstSrc->vRGB.fB;

  /* Gets min, max & delta values */
  fMin    = orxMIN(fR, orxMIN(fG, fB));
  fMax    = orxMAX(fR, orxMAX(fG, fB));
  fDelta  = fMax - fMin;

  /* Stores value */
  pstResult->vHSL.fV = fMax;

  /* Gray? */
  if(fDelta == orxFLOAT_0)
  {
    /* Gets hue & saturation */
    pstResult->vHSL.fH = pstResult->vHSL.fS = orxFLOAT_0;
  }
  else
  {
    /* Updates saturation */
    pstResult->vHSL.fS = fDelta / fMax;

    /* Red tone? */
    if(fR == fMax)
    {
      /* Updates hue */
      pstResult->vHSL.fH = orx2F(1.0f / 6.0f) * (fG - fB) / fDelta;
    }
    /* Green tone? */
    else if(fG == fMax)
    {
      /* Updates hue */
      pstResult->vHSL.fH = orx2F(1.0f / 3.0f) + (orx2F(1.0f / 6.0f) * (fB - fR) / fDelta);
    }
    /* Blue tone */
    else
    {
      /* Updates hue */
      pstResult->vHSL.fH = orx2F(2.0f / 3.0f) + (orx2F(1.0f / 6.0f) * (fR - fG) / fDelta);
    }

    /* Clamps hue */
    if(pstResult->vHSL.fH < orxFLOAT_0)
    {
      pstResult->vHSL.fH += orxFLOAT_1;
    }
    else if(pstResult->vHSL.fH > orxFLOAT_1)
    {
      pstResult->vHSL.fH -= orxFLOAT_1;
    }
  }

  /* Updates alpha */
  pstResult->fAlpha = _pstSrc->fAlpha;

  /* Done! */
  return pstResult;
}

static orxCOLOR *orxFASTCALL      orxColor_FromHSVToRGB(orxCOLOR *_pstDst, const orxCOLOR *_pstSrc)
{
  orxCOLOR *pstResult = _pstDst;
  orxFLOAT  fH, fS, fV;

  /* Checks */
  orxASSERT(_pstDst != orxNULL);
  orxASSERT(_pstSrc != orxNULL);

  /* Gets source hue, saturation and value components */
  fH = _pstSrc->vRGB.fH;
  fS = _pstSrc->vRGB.fS;
  fV = _pstSrc->vRGB.fV;

  /* Gray? */
  if(fS == orxFLOAT_0)
  {
    /* Updates result */
    orxVector_SetAll(&(pstResult->vRGB), fV);
  }
  else
  {
    orxFLOAT fFullHue, fSector, fIntermediate;

    /* Gets intermediate value */
    fIntermediate = fV * fS;

    /* Gets full hue & sector */
    fFullHue  = orx2F(6.0f) * fH;
    fSector   = orxMath_Floor(fFullHue);

    /* Depending on sector */
    switch(orxF2U(fSector))
    {
      default:
      case 0:
      {
        /* Updates RGB components */
        pstResult->vRGB.fR = fV;
        pstResult->vRGB.fG = fV - (fIntermediate - (fIntermediate * (fFullHue - fSector)));
        pstResult->vRGB.fB = fV - fIntermediate;

        break;
      }

      case 1:
      {
        /* Updates RGB components */
        pstResult->vRGB.fR = fV - (fIntermediate * (fFullHue - fSector));
        pstResult->vRGB.fG = fV;
        pstResult->vRGB.fB = fV - fIntermediate;

        break;
      }

      case 2:
      {
        /* Updates RGB components */
        pstResult->vRGB.fR = fV - fIntermediate;
        pstResult->vRGB.fG = fV;
        pstResult->vRGB.fB = fV - (fIntermediate - (fIntermediate * (fFullHue - fSector)));

        break;
      }

      case 3:
      {
        /* Updates RGB components */
        pstResult->vRGB.fR = fV - fIntermediate;
        pstResult->vRGB.fG = fV - (fIntermediate * (fFullHue - fSector));
        pstResult->vRGB.fB = fV;

        break;
      }

      case 4:
      {
        /* Updates RGB components */
        pstResult->vRGB.fR = fV - (fIntermediate - (fIntermediate * (fFullHue - fSector)));
        pstResult->vRGB.fG = fV - fIntermediate;
        pstResult->vRGB.fB = fV;

        break;
      }

      case 5:
      {
        /* Updates RGB components */
        pstResult->vRGB.fR = fV;
        pstResult->vRGB.fG = fV - fIntermediate;
        pstResult->vRGB.fB = fV - (fIntermediate * (fFullHue - fSector));

        break;
      }
    }
  }

  /* Updates alpha */
  pstResult->fAlpha = _pstSrc->fAlpha;

  /* Done! */
  return pstResult;
}


/***************************************************************************
 * Functions extended by plugins
 ***************************************************************************/

extern orxDLLAPI orxSTATUS orxFASTCALL                orxDisplay_Init();

extern orxDLLAPI void orxFASTCALL                     orxDisplay_Exit();


extern orxDLLAPI orxSTATUS orxFASTCALL                orxDisplay_Swap();

extern orxDLLAPI orxSTATUS orxFASTCALL                orxDisplay_TransformText(const orxSTRING _zString, const orxBITMAP *_pstFont, const orxCHARACTER_MAP *_pstMap, const orxDISPLAY_TRANSFORM *_pstTransform, orxDISPLAY_SMOOTHING _eSmoothing, orxDISPLAY_BLEND_MODE _eBlendMode);


extern orxDLLAPI orxBITMAP *orxFASTCALL               orxDisplay_CreateBitmap(orxU32 _u32Width, orxU32 _u32Height);

extern orxDLLAPI void orxFASTCALL                     orxDisplay_DeleteBitmap(orxBITMAP *_pstBitmap);


extern orxDLLAPI orxBITMAP *orxFASTCALL               orxDisplay_GetScreenBitmap();

extern orxDLLAPI orxSTATUS orxFASTCALL                orxDisplay_GetScreenSize(orxFLOAT *_pfWidth, orxFLOAT *_pfHeight);


extern orxDLLAPI orxSTATUS orxFASTCALL                orxDisplay_ClearBitmap(orxBITMAP *_pstBitmap, orxRGBA _stColor);

extern orxDLLAPI orxSTATUS orxFASTCALL                orxDisplay_SetDestinationBitmap(orxBITMAP *_pstDst);

extern orxDLLAPI orxSTATUS orxFASTCALL                orxDisplay_TransformBitmap(const orxBITMAP *_pstSrc, const orxDISPLAY_TRANSFORM *_pstTransform, orxDISPLAY_SMOOTHING _eSmoothing, orxDISPLAY_BLEND_MODE _eBlendMode);


extern orxDLLAPI orxSTATUS orxFASTCALL                orxDisplay_SetBitmapData(orxBITMAP *_pstBitmap, const orxU8 *_au8Data, orxU32 _u32ByteNumber);

extern orxDLLAPI orxSTATUS orxFASTCALL                orxDisplay_SetBitmapColorKey(orxBITMAP *_pstBitmap, orxRGBA _stColor, orxBOOL _bEnable);

extern orxDLLAPI orxSTATUS orxFASTCALL                orxDisplay_SetBitmapColor(orxBITMAP *_pstBitmap, orxRGBA _stColor);

extern orxDLLAPI orxSTATUS orxFASTCALL                orxDisplay_SetBitmapClipping(orxBITMAP *_pstBitmap, orxU32 _u32TLX, orxU32 _u32TLY, orxU32 _u32BRX, orxU32 _u32BRY);


extern orxDLLAPI orxSTATUS orxFASTCALL                orxDisplay_BlitBitmap(const orxBITMAP *_pstSrc, orxFLOAT _fPosX, orxFLOAT _fPosY, orxDISPLAY_SMOOTHING _eSmoothing, orxDISPLAY_BLEND_MODE _eBlendMode);


extern orxDLLAPI orxSTATUS orxFASTCALL                orxDisplay_SaveBitmap(const orxBITMAP *_pstBitmap, const orxSTRING _zFileName);

extern orxDLLAPI orxBITMAP *orxFASTCALL               orxDisplay_LoadBitmap(const orxSTRING _zFileName);


extern orxDLLAPI orxSTATUS orxFASTCALL                orxDisplay_GetBitmapData(orxBITMAP *_pstBitmap, orxU8 *_au8Data, orxU32 _u32ByteNumber);

extern orxDLLAPI orxRGBA orxFASTCALL                  orxDisplay_GetBitmapColor(const orxBITMAP *_pstBitmap);

extern orxDLLAPI orxSTATUS orxFASTCALL                orxDisplay_GetBitmapSize(const orxBITMAP *_pstBitmap, orxFLOAT *_pfWidth, orxFLOAT *_pfHeight);


extern orxDLLAPI orxHANDLE orxFASTCALL                orxDisplay_CreateShader(const orxSTRING _zCode, const orxLINKLIST *_pstParamList);

extern orxDLLAPI void orxFASTCALL                     orxDisplay_DeleteShader(orxHANDLE _hShader);

extern orxDLLAPI orxSTATUS orxFASTCALL                orxDisplay_StartShader(const orxHANDLE _hShader);

extern orxDLLAPI orxSTATUS orxFASTCALL                orxDisplay_StopShader(const orxHANDLE _hShader);

extern orxDLLAPI orxS32 orxFASTCALL                   orxDisplay_GetParameterID(orxHANDLE _hShader, const orxSTRING _zParam, orxS32 _s32Index, orxBOOL _bIsTexture);

extern orxDLLAPI orxSTATUS orxFASTCALL                orxDisplay_SetShaderBitmap(orxHANDLE _hShader, orxS32 _s32ID, const orxBITMAP *_pstValue);

extern orxDLLAPI orxSTATUS orxFASTCALL                orxDisplay_SetShaderFloat(orxHANDLE _hShader, orxS32 _s32ID, orxFLOAT _fValue);

extern orxDLLAPI orxSTATUS orxFASTCALL                orxDisplay_SetShaderVector(orxHANDLE _hShader, orxS32 _s32ID, const orxVECTOR *_pvValue);


extern orxDLLAPI orxSTATUS orxFASTCALL                orxDisplay_EnableVSync(orxBOOL _bEnable);

extern orxDLLAPI orxBOOL orxFASTCALL                  orxDisplay_IsVSyncEnabled();


extern orxDLLAPI orxSTATUS orxFASTCALL                orxDisplay_SetFullScreen(orxBOOL _bFullScreen);

extern orxDLLAPI orxBOOL orxFASTCALL                  orxDisplay_IsFullScreen();


extern orxDLLAPI orxU32 orxFASTCALL                   orxDisplay_GetVideoModeCounter();

extern orxDLLAPI orxDISPLAY_VIDEO_MODE *orxFASTCALL   orxDisplay_GetVideoMode(orxU32 _u32Index, orxDISPLAY_VIDEO_MODE *_pstVideoMode);

extern orxDLLAPI orxSTATUS orxFASTCALL                orxDisplay_SetVideoMode(const orxDISPLAY_VIDEO_MODE *_pstVideoMode);

extern orxDLLAPI orxBOOL orxFASTCALL                  orxDisplay_IsVideoModeAvailable(const orxDISPLAY_VIDEO_MODE *_pstVideoMode);


#endif /* _orxDISPLAY_H_ */