orxDisplay.h

Go to the documentation of this file.

/* Orx - Portable Game Engine
 *
 * Copyright (c) 2008- 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 "math/orxOBox.h"
#include "memory/orxBank.h"
#include "utils/orxHashTable.h"
#include "utils/orxString.h"
#include "utils/orxLinkList.h"
 

typedef struct __orxRGBA_t
{
  union
  {
    struct
    {
      orxU8 u8R, u8G, u8B, u8A;
    };
 
    orxU32  u32RGBA;
  };
 
} orxRGBA;
 
#define orx2RGBA(R, G, B, A)        orxRGBA_Set((orxU8)(R), (orxU8)(G), (orxU8)(B), (orxU8)(A))
#define orxRGBA_R(RGBA)             RGBA.u8R
#define orxRGBA_G(RGBA)             RGBA.u8G
#define orxRGBA_B(RGBA)             RGBA.u8B
#define orxRGBA_A(RGBA)             RGBA.u8A
 
#define orxCOLOR_NORMALIZER         (orx2F(1.0f / 255.0f))
#define orxCOLOR_DENORMALIZER       (orx2F(255.0f))
 
typedef struct __orxBITMAP_t        orxBITMAP;
 

typedef enum __orxDISPLAY_ORIENTATION_t
{
  orxDISPLAY_ORIENTATION_UP = 0,
  orxDISPLAY_ORIENTATION_LEFT,
  orxDISPLAY_ORIENTATION_DOWN,
  orxDISPLAY_ORIENTATION_RIGHT,
 
  orxDISPLAY_ORIENTATION_NUMBER,
 
  orxDISPLAY_ORIENTATION_NONE = orxENUM_NONE
 
} orxDISPLAY_ORIENTATION;
 

typedef struct __orxDISPLAY_VERTEX_t
{
  orxFLOAT  fX, fY;
  orxFLOAT  fU, fV;
  orxRGBA   stRGBA;
 
} orxDISPLAY_VERTEX;

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

typedef enum __orxDISPLAY_PRIMITIVE_t
{
  orxDISPLAY_PRIMITIVE_POINTS = 0,
  orxDISPLAY_PRIMITIVE_LINES,
  orxDISPLAY_PRIMITIVE_LINE_LOOP,
  orxDISPLAY_PRIMITIVE_LINE_STRIP,
  orxDISPLAY_PRIMITIVE_TRIANGLES,
  orxDISPLAY_PRIMITIVE_TRIANGLE_STRIP,
  orxDISPLAY_PRIMITIVE_TRIANGLE_FAN,
 
  orxDISPLAY_PRIMITIVE_NUMBER,
 
  orxDISPLAY_PRIMITIVE_NONE = orxENUM_NONE
 
} orxDISPLAY_PRIMITIVE;

typedef struct __orxDISPLAY_MESH_t
{
  const orxDISPLAY_VERTEX * astVertexList;
  const orxU16 *            au16IndexList;
  orxU32                    u32VertexNumber;
  orxU32                    u32IndexNumber;
  orxDISPLAY_PRIMITIVE      ePrimitive;
 
} orxDISPLAY_MESH;

typedef struct __orxDISPLAY_VIDEO_MODE_t
{
  orxU32  u32Width, u32Height, u32Depth, u32RefreshRate;
  orxBOOL bFullScreen;
 
} orxDISPLAY_VIDEO_MODE;

typedef struct __orxCHARACTER_GLYPH_t
{
  orxFLOAT fX, fY, fWidth;
 
} orxCHARACTER_GLYPH;

typedef struct __orxCHARACTER_MAP_t
{
  orxBANK      *pstCharacterBank;
  orxHASHTABLE *pstCharacterTable;
 
  orxFLOAT      fCharacterHeight;
 
} 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_PREMUL,
 
  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_POSITION                       "ScreenPosition"
#define orxDISPLAY_KZ_CONFIG_REFRESH_RATE                   "RefreshRate"
#define orxDISPLAY_KZ_CONFIG_FULLSCREEN                     "FullScreen"
#define orxDISPLAY_KZ_CONFIG_ALLOW_RESIZE                   "AllowResize"
#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_CONFIG_SHADER_VERSION                 "ShaderVersion"
#define orxDISPLAY_KZ_CONFIG_SHADER_EXTENSION_LIST          "ShaderExtensionList"
#define orxDISPLAY_KZ_CONFIG_MONITOR                        "Monitor"
#define orxDISPLAY_KZ_CONFIG_CURSOR                         "Cursor"
#define orxDISPLAY_KZ_CONFIG_ICON_LIST                      "IconList"
#define orxDISPLAY_KZ_CONFIG_FRAMEBUFFER_SIZE               "FramebufferSize"
#define orxDISPLAY_KZ_CONFIG_CONTENT_SCALE                  "ContentScale"
#define orxDISPLAY_KZ_CONFIG_TEXTURE_UNIT_NUMBER            "TextureUnitNumber"
#define orxDISPLAY_KZ_CONFIG_DRAW_BUFFER_NUMBER             "DrawBufferNumber"
#define orxDISPLAY_KZ_CONFIG_MAX_TEXTURE_SIZE               "MaxTextureSize"
#define orxDISPLAY_KZ_CONFIG_DEBUG_OUTPUT                   "DebugOutput"
 
#define orxCOLOR_KZ_CONFIG_SECTION                          "Color"
 

#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"
 

#define orxDISPLAY_KC_SHADER_EXTENSION_ADD                  '+'
#define orxDISPLAY_KC_SHADER_EXTENSION_REMOVE               '-'
 

typedef enum __orxDISPLAY_EVENT_t
{
  orxDISPLAY_EVENT_SET_VIDEO_MODE = 0,
  orxDISPLAY_EVENT_LOAD_BITMAP,
 
  orxDISPLAY_EVENT_NUMBER,
 
  orxDISPLAY_EVENT_NONE = orxENUM_NONE
 
} orxDISPLAY_EVENT;

typedef struct __orxDISPLAY_EVENT_PAYLOAD_t
{
  union
  {
    struct
    {
      orxU32  u32Width;                                     
      orxU32  u32Height;                                    
      orxU32  u32Depth;                                     
      orxU32  u32RefreshRate;                               
      orxU32  u32PreviousWidth;                             
      orxU32  u32PreviousHeight;                            
      orxU32  u32PreviousDepth;                             
      orxU32  u32PreviousRefreshRate;                       
      orxBOOL bFullScreen;                                  
 
    } stVideoMode;
 
    struct
    {
      const orxSTRING zLocation;                            
      orxSTRINGID     stFilenameID;                         
      orxU32          u32ID;                                
 
    } stBitmap;
  };
 
} orxDISPLAY_EVENT_PAYLOAD;
 
 
/***************************************************************************
 * Functions directly implemented by orx core
 ***************************************************************************/
 
#if defined(__orxIOS__) && 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 orxViewController : UIViewController
{
@private
  UIInterfaceOrientation eOrientation;
}
 
@property                     UIInterfaceOrientation eOrientation;
 
@end

@interface orxView : UIView
{
@private
  EAGLContext  *poMainContext, *poThreadContext;
  GLuint        uiRenderBuffer, uiDepthBuffer, uiScreenFrameBuffer, uiTextureFrameBuffer;
  BOOL          bShaderSupport, bCompressedTextureSupport;
}
 
+ (orxView *) GetInstance;
 
- (void) QueueEvent:(orxENUM)_eID WithPayload:(orxSYSTEM_EVENT_PAYLOAD *)_pstPayload;
- (void) NotifyAcceleration:(UIAcceleration *)_poAcceleration;
 
@property (nonatomic, retain) EAGLContext  *poMainContext;
@property (nonatomic, retain) EAGLContext  *poThreadContext;
@property                     BOOL          bShaderSupport;
@property                     BOOL          bCompressedTextureSupport;
 
@end
 
#endif /* __orxIOS__ && __orxOBJC__ */
 

extern orxDLLAPI void orxFASTCALL orxDisplay_Setup();

static orxINLINE orxRGBA          orxRGBA_Set(orxU8 _u8R, orxU8 _u8G, orxU8 _u8B, orxU8 _u8A)
{
  orxRGBA stResult;
 
  /* Updates result */
  stResult.u8R = _u8R;
  stResult.u8G = _u8G;
  stResult.u8B = _u8B;
  stResult.u8A = _u8A;
 
  /* Done! */
  return stResult;
}
 

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_BLACK, &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(orxMath_Round(vColor.fR)), orxF2U(orxMath_Round(vColor.fG)), orxF2U(orxMath_Round(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;
}

extern orxDLLAPI orxDISPLAY_BLEND_MODE orxFASTCALL    orxDisplay_GetBlendModeFromString(const orxSTRING _zBlendMode);
 
 
/***************************************************************************
 * Functions extended by plugins
 ***************************************************************************/

extern orxDLLAPI orxSTATUS orxFASTCALL                orxDisplay_Init();

extern orxDLLAPI void orxFASTCALL                     orxDisplay_Exit();
 

extern orxDLLAPI orxSTATUS orxFASTCALL                orxDisplay_Swap();
 

extern orxDLLAPI orxBITMAP *orxFASTCALL               orxDisplay_GetScreenBitmap();

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

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

extern orxDLLAPI void orxFASTCALL                     orxDisplay_DeleteBitmap(orxBITMAP *_pstBitmap);
 

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

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

extern orxDLLAPI orxBITMAP *orxFASTCALL               orxDisplay_LoadFont(const orxSTRING _zFileName, const orxSTRING _zCharacterList, const orxVECTOR *_pvCharacterSize, const orxVECTOR *_pvCharacterSpacing, const orxVECTOR *_pvCharacterPadding, orxBOOL _bSDF, orxFLOAT *_afCharacterWidthList);
 

extern orxDLLAPI orxSTATUS orxFASTCALL                orxDisplay_SetTempBitmap(const orxBITMAP *_pstBitmap);

extern orxDLLAPI const orxBITMAP *orxFASTCALL         orxDisplay_GetTempBitmap();
 

extern orxDLLAPI orxSTATUS orxFASTCALL                orxDisplay_SetDestinationBitmaps(orxBITMAP **_apstBitmapList, orxU32 _u32Number);

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

extern orxDLLAPI orxSTATUS orxFASTCALL                orxDisplay_SetBlendMode(orxDISPLAY_BLEND_MODE _eBlendMode);

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

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

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

extern orxDLLAPI orxSTATUS orxFASTCALL                orxDisplay_SetPartialBitmapData(orxBITMAP *_pstBitmap, const orxU8 *_au8Data, orxU32 _u32X, orxU32 _u32Y, orxU32 _u32Width, orxU32 _u32Height);

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

extern orxDLLAPI orxU32 orxFASTCALL                   orxDisplay_GetBitmapID(const orxBITMAP *_pstBitmap);
 

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

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

extern orxDLLAPI orxSTATUS orxFASTCALL                orxDisplay_DrawLine(const orxVECTOR *_pvStart, const orxVECTOR *_pvEnd, orxRGBA _stColor);

extern orxDLLAPI orxSTATUS orxFASTCALL                orxDisplay_DrawPolyline(const orxVECTOR *_avVertexList, orxU32 _u32VertexNumber, orxRGBA _stColor);

extern orxDLLAPI orxSTATUS orxFASTCALL                orxDisplay_DrawPolygon(const orxVECTOR *_avVertexList, orxU32 _u32VertexNumber, orxRGBA _stColor, orxBOOL _bFill);

extern orxDLLAPI orxSTATUS orxFASTCALL                orxDisplay_DrawCircle(const orxVECTOR *_pvCenter, orxFLOAT _fRadius, orxRGBA _stColor, orxBOOL _bFill);

extern orxDLLAPI orxSTATUS orxFASTCALL                orxDisplay_DrawOBox(const orxOBOX *_pstBox, orxRGBA _stColor, orxBOOL _bFill);

extern orxDLLAPI orxSTATUS orxFASTCALL                orxDisplay_DrawMesh(const orxDISPLAY_MESH *_pstMesh, const orxBITMAP *_pstBitmap, orxDISPLAY_SMOOTHING _eSmoothing, orxDISPLAY_BLEND_MODE _eBlendMode);

extern orxDLLAPI orxBOOL orxFASTCALL                  orxDisplay_HasShaderSupport();

extern orxDLLAPI orxHANDLE orxFASTCALL                orxDisplay_CreateShader(const orxSTRING *_azCodeList, orxU32 _u32Size, const orxLINKLIST *_pstParamList, orxBOOL _bUseCustomParam);

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 orxU32 orxFASTCALL                   orxDisplay_GetShaderID(const orxHANDLE _hShader);
 

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

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