GUIBitmapPlane.h

/*
* Copyright (C) TES Electronic Solutions GmbH,
* All Rights Reserved.
* Contact: info@guiliani.de
*
* This file is part of the Guiliani HMI framework
* for the development of graphical user interfaces on embedded systems.
*/
 
#if !defined GUIBASEBITMAP__H_
#define GUIBASEBITMAP__H_
 
#include "eC.h"
#include "GUITrace.h"
#include "GUICommonEnums.h"
 
class CGfxWrap;
 
typedef eC_UInt GUIBitmapPlaneID_t;
 
 
class CGUIBitmapPlane
{
    friend class CGfxWrap; 
 
public:
    // ---------------- 2D interface ----------------------------
 
    void SetPos2D(eC_Value vXPos, eC_Value vYPos);
 
    void SetXPos2D(eC_Value vXPos);
 
    void SetYPos2D(eC_Value vYPos);
 
    eC_Value GetXPos2D() const;
 
    eC_Value GetYPos2D() const;
 
    // ------------  3D interface  -----------------------
 
    void SetPos3D(eC_Value vXPos, eC_Value vYPos, eC_Value vZPos)
    {
        SetXPos3D(vXPos);
        SetYPos3D(vYPos);
        SetZPos3D(vZPos);
    }
 
    void SetXPos3D(const eC_Value vXPos)
    {
        m_vXPos = vXPos;
    }
 
    void SetYPos3D(const eC_Value vYPos)
    {
        m_vYPos = vYPos;
    }
 
    void SetZPos3D(const eC_Value vZPos)
    {
        m_vZPos = vZPos;
    }
 
    eC_Value GetXPos() const
    {
        return m_vXPos;
    }
 
    eC_Value GetYPos() const
    {
        return m_vYPos;
    }
 
    eC_Value GetZPos() const
    {
        return m_vZPos;
    }
 
    // ------------  Rotation interface  ---------------
    void RotateX(const eC_Value vXAngle)
    {
        m_vXAngle = vXAngle;
    }
 
    void RotateY(const eC_Value vYAngle)
    {
        m_vYAngle = vYAngle;
    }
 
    void RotateZ(const eC_Value vZAngle)
    {
        m_vZAngle = vZAngle;
    }
 
    eC_Value GetXAngle() const
    {
        return m_vXAngle;
    }
 
    eC_Value GetYAngle() const
    {
        return m_vYAngle;
    }
 
    eC_Value GetZAngle() const
    {
        return m_vZAngle;
    }
 
    void ResetRotation();
   
    GUIBitmapPlaneID_t GetID() const
    {
        return m_uiID;
    }
 
    virtual void SetWidth(eC_Value vWidth, eC_Bool bExpandCentered = false);
 
    eC_Value GetWidth() const
    {
        return m_vWidth;
    }
 
    eC_Value GetWidthCorrected() const;
 
    virtual void SetHeight(eC_Value vHeight, eC_Bool bExpandCentered = false);
 
    inline eC_Value GetHeight() const
    {
        return m_vHeight;
    }
 
    eC_Value GetHeightCorrected() const;
 
    void SetBytesPerPixel(const eC_UByte& ubBPP)
    {
        m_ubBPP = ubBPP;
    }
 
    eC_UByte GetBytesPerPixel() const
    {
        return m_ubBPP;
    }
 
    void SetFormat(const CGUICommonEnums::ImageType_t& eFormat)
    {
        m_eFormat = eFormat;
    }
 
    CGUICommonEnums::ImageType_t GetFormat() const
    {
        return m_eFormat;
    }
 
    void SetAutoScale(const eC_Bool bAutoScale)
    {
        m_bAutoScale = bAutoScale;
    }
 
 
 
    virtual void DoDraw();
 
    virtual void GetData(eC_TArray<eC_UByte>* pkData) {}
 
    virtual void Clear(
        const eC_UByte ubRed = 0,
        const eC_UByte ubGreen = 0,
        const eC_UByte ubBlue = 0,
        const eC_UByte ubAlpha = 0)
    {}
 
    const CGUIObject& GetParentGUIObject() const
    {
        return m_rkParentObject;
    }
 
    virtual void SetAlphaValues(
        const eC_UByte ubTopLeft, const eC_UByte ubBottomLeft,
        const eC_UByte ubBottomRight, const eC_UByte ubTopRight)
    {
    }
 
    void SetAlphaValue(const eC_UByte ubAlpha)
    {
        SetAlphaValues(ubAlpha, ubAlpha, ubAlpha, ubAlpha);
    }
 
    // -------------- UV interface --------------------------------
    //---- Top Left --
 
    virtual void SetTopLeftU(eC_Value vU);
 
    virtual eC_Value GetTopLeftU();
 
    virtual void SetTopLeftV(eC_Value vV);
 
    virtual eC_Value GetTopLeftV();
 
    void SetTopLeftUV(eC_Value vU, eC_Value vV)
    {
        SetTopLeftU(vU);
        SetTopLeftV(vV);
    }
 
    //---- Bottom Left --
 
    virtual void SetBottomLeftU(eC_Value vU);
 
    virtual eC_Value GetBottomLeftU();
 
    virtual void SetBottomLeftV(eC_Value vV);
 
    virtual eC_Value GetBottomLeftV();
 
    void SetBottomLeftUV(eC_Value vU, eC_Value vV)
    {
        SetBottomLeftU(vU);
        SetBottomLeftV(vV);
    }
 
    //--- Bottom Right
 
    virtual void SetBottomRightU(eC_Value vU);
 
    virtual eC_Value GetBottomRightU();
 
    virtual void SetBottomRightV(eC_Value vV);
 
    virtual eC_Value GetBottomRightV();
 
    void SetBottomRightUV(eC_Value vU, eC_Value vV)
    {
        SetBottomRightU(vU);
        SetBottomRightV(vV);
    }
 
    //---- Top Right ----
 
    virtual void SetTopRightU(eC_Value vU);
 
    virtual eC_Value GetTopRightU();
 
    virtual void SetTopRightV(eC_Value vV);
 
    virtual eC_Value GetTopRightV();
 
    void SetTopRightUV(eC_Value vU, eC_Value vV)
    {
        SetTopRightU(vU);
        SetTopRightV(vV);
    }
 
 
 
    void EnableDepthTest()
    {
        m_bDepthTest = true;
    }
 
    void DisableDepthTest()
    {
        m_bDepthTest = false;
    }
 
    eC_Bool IsDepthTestEnabled() const
    {
        return m_bDepthTest;
    }
 
    virtual eC_Value Get2DPlaneDistance();
 
    eC_Value GetFOV() const
    {
        return m_vFOV;
    }
 
    void SetFOV(const eC_Value vFOV)
    {
        m_vFOV = vFOV;
        //we need to recalculate the 2dplane distance and therefore the z pos
        eC_Value vZ = m_vZPos - m_v2DPlaneDistance;
        m_v2DPlaneDistance = eC_FromInt(0);
        m_uiScreenWidth = 0;
        m_uiScreenHeight = 0;
        m_vZPos = Get2DPlaneDistance() + vZ;
    }
 
    eC_Value GetNear() const
    {
        return ms_vNear;
    }
 
    eC_Value GetFar() const
    {
        return ms_vFar;
    }
 
    eC_Bool IsYFlipped() const
    {
        return m_bYFlipped;
    }
 
protected:
    CGUIBitmapPlane(GUIBitmapPlaneID_t uiNewBitmapID, const CGUIObject& rkParentObject, eC_Value vWidth = 0, eC_Value vHeight = 0);
 
    virtual ~CGUIBitmapPlane();
 
    virtual eC_Bool FinishDrawToBitmap() { return true; }
 
    virtual eC_Bool DrawToBitmap() { return true; }
 
    virtual eC_Bool DrawToScreen() { return true; }
 
    eC_Value GetCenterOfProjectionAbsX() const;
 
    eC_Value GetCenterOfProjectionAbsY() const;
 
    void SetTexUsed(eC_Value vNewTexUsedU, eC_Value vNewTexUsedV);
 
    eC_Value m_vGUIObjectInitWidth;
 
    eC_Value m_vGUIObjectInitHeight;
 
    eC_Bool m_bAutoScale; 
 
    eC_TArray<eC_Value> m_avUVValues; 
 
    eC_Value m_vTexUsedU;
    eC_Value m_vTexUsedV;
 
    eC_UInt m_uiScreenWidth; 
    eC_UInt m_uiScreenHeight; 
    eC_Value m_v2DPlaneDistance; 
 
    eC_Bool m_bYFlipped; 
 
private:
    CGUIBitmapPlane();
 
    GUIBitmapPlaneID_t  m_uiID; 
 
    const CGUIObject& m_rkParentObject; 
 
    eC_Value m_vXPos; 
    eC_Value m_vYPos; 
    eC_Value m_vZPos; 
 
    eC_Value m_vXAngle; 
    eC_Value m_vYAngle; 
    eC_Value m_vZAngle; 
 
    eC_Value m_vWidth;  
    eC_Value m_vHeight; 
    eC_UByte m_ubBPP;   
    CGUICommonEnums::ImageType_t m_eFormat; 
 
    eC_Bool m_bDepthTest; 
 
    eC_Value m_vFOV;  
    static eC_Value ms_vNear; 
    static eC_Value ms_vFar;  
};
 
#endif