oc_colormap.c

Go to the documentation of this file.

#include <oc_colormap.h>
#include <stddef.h>
#include <oc_stdlib.h>
#include <oc_errors.h>

#define _________________________________________INTERFACE_FUNCTIONS_SECTION________________________________________________________________

//==========================================================================================================================================
//==========================================================================================================================================
oC_ColorMap_t * oC_ColorMap_New( Allocator_t Allocator , AllocationFlags_t AllocationFlags , oC_Pixel_ResolutionUInt_t Width , oC_Pixel_ResolutionUInt_t Height , oC_ColorFormat_t ColorFormat )
{
    oC_ColorMap_t * colorMap = NULL;

    if(Width > 0 && Height > 0 && ColorFormat != oC_ColorFormat_Unknown)
    {

        colorMap = kmalloc(sizeof(oC_ColorMap_t) , Allocator , AllocationFlags);

        if(colorMap != NULL)
        {
            colorMap->Map = kmalloc(oC_Color_GetFormatSize(ColorFormat) * Width * Height , Allocator , AllocationFlags);

            if(colorMap->Map != NULL)
            {
                colorMap->ColorFormat = ColorFormat;
                colorMap->Height      = Height;
                colorMap->Width       = Width;
                colorMap->MagicNumber = oC_ColorMap_MagicNumber;
                colorMap->FormatSize  = oC_Color_GetFormatSize(ColorFormat);

            }
            else
            {
                oC_SaveIfFalse("ColorMap::New: cannot release memory" , kfree(colorMap,AllocationFlags), oC_ErrorCode_ReleaseError);

                colorMap = NULL;
            }
        }
    }



    return colorMap;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_ColorMap_Delete( oC_ColorMap_t * ColorMap , AllocationFlags_t AllocationFlags )
{
    bool deleted = false;

    if(oC_ColorMap_IsCorrect(ColorMap))
    {
        if(isram(ColorMap))
        {
            ColorMap->MagicNumber = 0;

            if(kfree(ColorMap->WriteMap,AllocationFlags) && kfree(ColorMap,AllocationFlags))
            {
                deleted = true;
            }
        }
    }

    return deleted;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_ColorMap_IsCorrect( const oC_ColorMap_t * ColorMap )
{
    return isaddresscorrect(ColorMap) && ColorMap->MagicNumber == oC_ColorMap_MagicNumber && isaddresscorrect(ColorMap->Map);
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_Color_t oC_ColorMap_GetColor( const oC_ColorMap_t * ColorMap , oC_Pixel_Position_t Position , oC_ColorFormat_t ColorFormat )
{
    oC_Color_t color = 0;

    if(oC_ColorMap_IsCorrect(ColorMap) && oC_ColorMap_IsPositionCorrect(ColorMap,Position))
    {
        oC_UInt_t        formatSize = oC_Color_GetFormatSize(ColorMap->ColorFormat);
        const uint8_t *  colorRef   = &ColorMap->ReadMap[(Position.X + ColorMap->Width * Position.Y)* formatSize ];

        for(uint8_t byteIndex = 0; byteIndex < formatSize ; byteIndex++)
        {
            color |= (*colorRef) << byteIndex * 8;
            colorRef++;
        }

        color = oC_Color_ConvertToFormat(color,ColorMap->ColorFormat,ColorFormat);
    }

    return color;
}

//==========================================================================================================================================
//==========================================================================================================================================
static inline void SetColor(oC_Pixel_Position_t Position , oC_Pixel_ResolutionUInt_t Width , oC_Pixel_ResolutionUInt_t Height , uint32_t FormatSize ,  uint8_t ColorMap[Height][Width][FormatSize] , oC_Color_t Color )
{
    static const uint8_t  bitOffset[4] = {
        0 ,
        8 ,
        16 ,
        32
    };

    for(uint8_t byteIndex = 0 ; byteIndex < FormatSize ; byteIndex++)
    {
        ColorMap[Position.Y][Position.X][byteIndex] = (uint8_t)((Color >> bitOffset[byteIndex]) & 0xFF);
    }
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_ColorMap_SetColor ( oC_ColorMap_t * ColorMap , oC_Pixel_Position_t Position , oC_Color_t Color , oC_ColorFormat_t ColorFormat )
{
    bool colorSet = false;

    /* To speed up this operation it is not checked if the color map is correct, but only if it is not NULL  */
    if(ColorMap != NULL && Position.X < ColorMap->Width && Position.Y < ColorMap->Height)
    {
        oC_Color_t color = oC_Color_ConvertToFormat(Color,ColorFormat,ColorMap->ColorFormat);
        SetColor(Position,ColorMap->Width,ColorMap->Height,ColorMap->FormatSize,ColorMap->GenericWriteMap,color);
        colorSet = true;
    }

    return colorSet;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_ColorMap_IsPositionCorrect( const oC_ColorMap_t * ColorMap , oC_Pixel_Position_t Position )
{
    return oC_ColorMap_IsCorrect(ColorMap) && Position.X < ColorMap->Width && Position.Y < ColorMap->Height;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_ColorMap_DrawChar( oC_ColorMap_t * ColorMap , oC_Pixel_Position_t Position , oC_Color_t Color , oC_ColorFormat_t ColorFormat , uint16_t C , oC_Font_t Font )
{
    bool drawed = false;

    if(oC_ColorMap_IsCorrect(ColorMap) && isram(ColorMap->Map) && isaddresscorrect(Font) && ColorFormat != oC_ColorFormat_Unknown  && oC_ColorMap_IsPositionCorrect(ColorMap,Position))
    {
        oC_Font_CharacterMap_t characterMap = {0};

        if(oC_Font_ReadCharacterMap(Font,C,&characterMap))
        {
            oC_Pixel_ResolutionUInt_t x                    = 0;
            oC_Pixel_ResolutionUInt_t y                    = 0;
            uint8_t                   characterMapBitIndex = 0;
            uint8_t                   characterMapByteIndex= 0;
            uint8_t                   characterMapByte     = characterMap.Data[characterMapByteIndex];
            oC_Pixel_Position_t       drawPosition         = {0};
            drawed = true;

            for( y = 0 ; y < characterMap.Height && drawed; y++ )
            {
                drawPosition.Y = Position.Y + y;

                for( x = 0 ; x < characterMap.Width && drawed; x++ )
                {
                    drawPosition.X = Position.X + x;

                    // Check if this pixel should be drawed
                    if(characterMapByte & (1<<characterMapBitIndex))
                    {
                        // If draw position is not correct (it is outside of the screen)
                        // then just do not draw it.
                        if(oC_ColorMap_IsPositionCorrect(ColorMap,drawPosition))
                        {
                            drawed = oC_ColorMap_SetColor(ColorMap,drawPosition,Color,ColorFormat);
                        }
                    }
                    // /////////////////////////////////////////////////////
                    // counting next character map byte
                    characterMapBitIndex++;

                    if(characterMapBitIndex == 8)
                    {
                        characterMapBitIndex = 0;
                        characterMapByte     = characterMap.Data[++characterMapByteIndex];
                    }
                    // counting next character map byte
                    // /////////////////////////////////////////////////////

                }

                characterMapBitIndex = 0;
                characterMapByte     = characterMap.Data[++characterMapByteIndex];
            }
        }
    }

    return drawed;
}



#undef  _________________________________________INTERFACE_FUNCTIONS_SECTION________________________________________________________________