gclwriter.h

Go to the documentation of this file.

#pragma once
 
#include <adtf_base.h>
#include <adtfdisplaytoolboxgraphics/dynamic_memoryblock.h>
 
namespace adtf
{
 
namespace disptb
{
 
namespace graphicslib
{
 
namespace dengar
{
 
//*************************************************************************************************
constexpr tInt g_nGCL_ItemSize = sizeof(tUInt32);
constexpr tInt g_nGCL_CommandSize = g_nGCL_ItemSize;
constexpr tInt g_nGCL_ParamSize = g_nGCL_ItemSize;
constexpr tInt g_nGCL_ExtraSize = g_nGCL_ItemSize;
 
//*****************************************************************************
class cGCLWriter
{
public:
    static tResult StoreCommand(tUInt32*& pCommandBlock, tUInt32 nCommandId)
    {
        ASSERT_IF_POINTER_NULL(pCommandBlock);
 
        *(pCommandBlock++) = nCommandId;
 
        RETURN_NOERROR;
    }

    static tResult StoreCommand(tUInt32*& pCommandBlock, tUInt32 nCommandId, tInt n)
    {
        ASSERT_IF_POINTER_NULL(pCommandBlock);
 
        *(pCommandBlock++) = nCommandId;
        *(pCommandBlock++) = n;
 
        RETURN_NOERROR;
    }

    static tResult StoreCommand(tUInt32*& pCommandBlock, tUInt32 nCommandId, tInt x, tInt y)
    {
        ASSERT_IF_POINTER_NULL(pCommandBlock);
 
        *(pCommandBlock++) = nCommandId;
        *(pCommandBlock++) = x;
        *(pCommandBlock++) = y;
 
        RETURN_NOERROR;
    }

    static tResult StoreCommand(tUInt32*& pCommandBlock, tUInt32 nCommandId, tFloat32 x, tFloat32 y)
    {
        ASSERT_IF_POINTER_NULL(pCommandBlock);
 
        *(pCommandBlock++) = nCommandId;
        tFloat32* pCmd = (tFloat32*) pCommandBlock;
        pCmd[0] = x;
        pCmd[1] = y;
 
        pCommandBlock += 2;
 
        RETURN_NOERROR;
    }

    static tResult StoreCommand(tUInt32*& pCommandBlock, tUInt32 nCommandId, tInt x, tInt y, tInt z)
    {
        ASSERT_IF_POINTER_NULL(pCommandBlock);
 
        *(pCommandBlock++) = nCommandId;
        *(pCommandBlock++) = x;
        *(pCommandBlock++) = y;
        *(pCommandBlock++) = z;
 
        RETURN_NOERROR;
    }

    static tResult StoreCommand(tUInt32*& pCommandBlock, tUInt32 nCommandId, tFloat32 x, tFloat32 y, tInt z)
    {
        ASSERT_IF_POINTER_NULL(pCommandBlock);
 
        *(pCommandBlock++) = nCommandId;
        tFloat32* pCmd = (tFloat32*) pCommandBlock;
        pCmd[0] = x;
        pCmd[1] = y;
        pCommandBlock[2] = z;
 
        pCommandBlock += 3;
 
        RETURN_NOERROR;
    }

    static tResult StoreCommand(tUInt32*& pCommandBlock, tUInt32 nCommandId, tFloat32 x, tFloat32 y, tFloat32 radius)
    {
        ASSERT_IF_POINTER_NULL(pCommandBlock);
 
        *(pCommandBlock++) = nCommandId;
        tFloat32* pCmd = (tFloat32*) pCommandBlock;
        pCmd[0] = x;
        pCmd[1] = y;
        pCmd[2] = radius;
        pCommandBlock += 3;
 
        RETURN_NOERROR;
    }

    static tResult StoreCommand(tUInt32*& pCommandBlock, tUInt32 nCommandId, tInt x1, tInt y1, tInt x2, tInt y2)
    {
        ASSERT_IF_POINTER_NULL(pCommandBlock);
 
        *(pCommandBlock++) = nCommandId;
        *(pCommandBlock++) = x1;
        *(pCommandBlock++) = y1;
        *(pCommandBlock++) = x2;
        *(pCommandBlock++) = y2;
 
        RETURN_NOERROR;
    }

    static tResult
        StoreCommand(tUInt32*& pCommandBlock, tUInt32 nCommandId, tFloat32 x1, tFloat32 y1, tFloat32 x2, tFloat32 y2)
    {
        ASSERT_IF_POINTER_NULL(pCommandBlock);
 
        *(pCommandBlock++) = nCommandId;
        tFloat32* pCmd = (tFloat32*) pCommandBlock;
        pCmd[0] = x1;
        pCmd[1] = y1;
        pCmd[2] = x2;
        pCmd[3] = y2;
        pCommandBlock += 4;
 
        RETURN_NOERROR;
    }

    static tResult StoreCommand(tUInt32*& pCommandBlock, tUInt32 nCommandId, tInt nParamCount, const tUInt32* pParams)
    {
        ASSERT_IF_POINTER_NULL(pCommandBlock);
        ASSERT_IF_POINTER_NULL(pParams);
 
        if (nParamCount < 0)
        {
            RETURN_ERROR(ERR_INVALID_ARG);
        }
 
        *(pCommandBlock++) = nCommandId;
 
        return StoreData(pCommandBlock, nParamCount, pParams);
    }

    static tResult StoreData(tUInt32*& pCommandBlock, tUInt32 nParam)
    {
        ASSERT_IF_POINTER_NULL(pCommandBlock);
 
        *(pCommandBlock++) = nParam;
 
        RETURN_NOERROR;
    }

    static tResult StoreData(tUInt32*& pCommandBlock, tInt nParamCount, const tUInt32* pParams)
    {
        ASSERT_IF_POINTER_NULL(pCommandBlock);
        ASSERT_IF_POINTER_NULL(pParams);
 
        if (nParamCount < 0)
        {
            RETURN_ERROR(ERR_INVALID_ARG);
        }
 
        for (tInt nIdx = 0; nIdx < nParamCount; nIdx++)
        {
            *(pCommandBlock++) = *(pParams++);
        }
 
        RETURN_NOERROR;
    }

    static tResult StoreData(tUInt32*& pCommandBlock, tInt nByteCount, const tUInt8* pData)
    {
        ASSERT_IF_POINTER_NULL(pCommandBlock);
        ASSERT_IF_POINTER_NULL(pData);
 
        if (nByteCount < 0)
        {
            RETURN_ERROR(ERR_INVALID_ARG);
        }
 
        tInt nParamCount = (nByteCount + sizeof(tUInt32) - 1) / sizeof(tUInt32);
 
        tInt nCompleteParams = nByteCount / sizeof(tUInt32);
        tUInt32* pParams = (tUInt32*) pData;
 
        for (tInt nIdx = 0; nIdx < nCompleteParams; nIdx++)
        {
            *(pCommandBlock++) = *(pParams++);
        }
 
        if (nParamCount > nCompleteParams)
        {
            tInt nRemainingBytes = nByteCount % sizeof(tUInt32);
 
            tUInt8* pSrcBytePtr = (tUInt8*) pParams;
            tUInt8* pDestBytePtr = (tUInt8*) pCommandBlock;
 
            for (tUInt nIdx = 0; nIdx < sizeof(tUInt32); nIdx++)
            {
                if (nRemainingBytes > 0)
                {
                    *(pDestBytePtr++) = *(pSrcBytePtr++);
                    nRemainingBytes--;
                }
                else
                {
                    *(pDestBytePtr++) = 0; // fill up with zeros
                }
            }
 
            pCommandBlock++;
        }
 
        RETURN_NOERROR;
    }

    static tResult StoreData(tUInt32*& pCommandBlock, tInt nByteCount, const tChar* pData)
    {
        if (nByteCount < 0)
        {
            RETURN_ERROR(ERR_INVALID_ARG);
        }
 
        return StoreData(pCommandBlock, nByteCount, (const tUInt8*) pData);
    }

    static tResult StoreCommand(tUInt32*& pCommandBlock, tUInt32 nCommandId, tUInt16 nPattern, tInt nFactor)
    {
        ASSERT_IF_POINTER_NULL(pCommandBlock);
 
        *(pCommandBlock++) = nCommandId;
        *(pCommandBlock++) = nPattern;
        *(pCommandBlock++) = nFactor;
 
        RETURN_NOERROR;
    }

    static tResult GetDynamicMemoryBlock(IDynamicMemoryBlock*& pCommandBlock)
    {
        pCommandBlock = (IDynamicMemoryBlock*) (new cDynamicMemoryBlock());
        RETURN_IF_POINTER_NULL(pCommandBlock);
        RETURN_NOERROR;
    }

    static tResult FreeDynamicMemoryBlock(IDynamicMemoryBlock*& pCommandBlock)
    {
        RETURN_IF_POINTER_NULL(pCommandBlock);
        auto pCDynamicMemoryBlock = dynamic_cast<cDynamicMemoryBlock*>(pCommandBlock);
        if (pCDynamicMemoryBlock)
        {
            delete pCDynamicMemoryBlock;
            pCommandBlock = nullptr;
            RETURN_NOERROR;
        }
        RETURN_ERROR_DESC(ERR_INVALID_ARG, "IDynamicMemoryBlock instance was not allocated by GetDynamicMemoryBlock");
    }

    static tResult StoreCommand(IDynamicMemoryBlock*& pCommandBlock, tUInt32 nCommandId)
    {
        ASSERT_IF_POINTER_NULL(pCommandBlock);
 
        tUInt32 aCommand[] = {nCommandId};
 
        pCommandBlock->Append((tVoid*) aCommand, sizeof(aCommand));
 
        RETURN_NOERROR;
    }

    static tResult StoreCommand(IDynamicMemoryBlock*& pCommandBlock, tUInt32 nCommandId, tInt n)
    {
        ASSERT_IF_POINTER_NULL(pCommandBlock);
 
        tInt aCommand[] = {static_cast<tInt>(nCommandId), n};
 
        pCommandBlock->Append((tVoid*) aCommand, sizeof(aCommand));
 
        RETURN_NOERROR;
    }

    static tResult StoreCommand(IDynamicMemoryBlock*& pCommandBlock, tUInt32 nCommandId, tInt x, tInt y)
    {
        ASSERT_IF_POINTER_NULL(pCommandBlock);
 
        tInt aCommand[] = {static_cast<tInt>(nCommandId), x, y};
 
        pCommandBlock->Append((tVoid*) aCommand, sizeof(aCommand));
 
        RETURN_NOERROR;
    }

    static tResult StoreCommand(IDynamicMemoryBlock*& pCommandBlock, tUInt32 nCommandId, tFloat32 x, tFloat32 y)
    {
        ASSERT_IF_POINTER_NULL(pCommandBlock);
 
        tUInt32 aCommand[3];
        tFloat32* pCommand = (tFloat32*) aCommand;
        aCommand[0] = nCommandId;
        pCommand[1] = x;
        pCommand[2] = y;
 
        pCommandBlock->Append((tVoid*) aCommand, sizeof(aCommand));
 
        RETURN_NOERROR;
    }

    static tResult StoreCommand(IDynamicMemoryBlock*& pCommandBlock, tUInt32 nCommandId, tInt x, tInt y, tInt z)
    {
        ASSERT_IF_POINTER_NULL(pCommandBlock);
 
        tUInt32 aCommand[] = {nCommandId, static_cast<tUInt32>(x), static_cast<tUInt32>(y), static_cast<tUInt32>(z)};
 
        pCommandBlock->Append((tVoid*) aCommand, sizeof(aCommand));
 
        RETURN_NOERROR;
    }

    static tResult StoreCommand(IDynamicMemoryBlock*& pCommandBlock, tUInt32 nCommandId, tFloat32 x, tFloat32 y, tInt z)
    {
        ASSERT_IF_POINTER_NULL(pCommandBlock);
 
        tUInt32 aCommand[4];
        tFloat32* pCommand = (tFloat32*) aCommand;
        aCommand[0] = nCommandId;
        pCommand[1] = x;
        pCommand[2] = y;
        aCommand[3] = z;
 
        pCommandBlock->Append((tVoid*) aCommand, sizeof(aCommand));
 
        RETURN_NOERROR;
    }

    static tResult
        StoreCommand(IDynamicMemoryBlock*& pCommandBlock, tUInt32 nCommandId, tFloat32 x, tFloat32 y, tFloat32 radius)
    {
        ASSERT_IF_POINTER_NULL(pCommandBlock);
 
        tUInt32 aCommand[4];
        tFloat32* pCommand = (tFloat32*) aCommand;
        aCommand[0] = nCommandId;
        pCommand[1] = x;
        pCommand[2] = y;
        pCommand[3] = radius;
 
        pCommandBlock->Append((tVoid*) aCommand, sizeof(aCommand));
 
        RETURN_NOERROR;
    }

    static tResult
        StoreCommand(IDynamicMemoryBlock*& pCommandBlock, tUInt32 nCommandId, tInt x1, tInt y1, tInt x2, tInt y2)
    {
        ASSERT_IF_POINTER_NULL(pCommandBlock);
 
        tInt aCommand[] = {static_cast<tInt>(nCommandId), x1, y1, x2, y2};
 
        pCommandBlock->Append((tVoid*) aCommand, sizeof(aCommand));
 
        RETURN_NOERROR;
    }

    static tResult StoreCommand(IDynamicMemoryBlock*& pCommandBlock, tUInt32 nCommandId, tUInt16 nPattern, tInt nFactor)
    {
        ASSERT_IF_POINTER_NULL(pCommandBlock);
 
        tInt aCommand[] = {static_cast<tInt>(nCommandId), nPattern, nFactor};
 
        pCommandBlock->Append((tVoid*) aCommand, sizeof(aCommand));
 
        RETURN_NOERROR;
    }

    static tResult StoreCommand(
        IDynamicMemoryBlock*& pCommandBlock, tUInt32 nCommandId, tFloat32 x1, tFloat32 y1, tFloat32 x2, tFloat32 y2)
    {
        ASSERT_IF_POINTER_NULL(pCommandBlock);
 
        tUInt32 aCommand[5];
        tFloat32* pCommand = (tFloat32*) aCommand;
        aCommand[0] = nCommandId;
        pCommand[1] = x1;
        pCommand[2] = y1;
        pCommand[3] = x2;
        pCommand[4] = y2;
 
        pCommandBlock->Append((tVoid*) aCommand, sizeof(aCommand));
 
        RETURN_NOERROR;
    }

    static tResult
        StoreCommand(IDynamicMemoryBlock*& pCommandBlock, tUInt32 nCommandId, tInt nParamCount, const tUInt32* pParams)
    {
        ASSERT_IF_POINTER_NULL(pCommandBlock);
        ASSERT_IF_POINTER_NULL(pParams);
 
        if (nParamCount < 0)
        {
            RETURN_ERROR(ERR_INVALID_ARG);
        }
 
        pCommandBlock->Append((tVoid*) &nCommandId, sizeof(nCommandId));
 
        return StoreData(pCommandBlock, nParamCount, pParams);
    }

    static tResult StoreData(IDynamicMemoryBlock*& pCommandBlock, tUInt32 nParam)
    {
        ASSERT_IF_POINTER_NULL(pCommandBlock);
 
        pCommandBlock->Append((tVoid*) &nParam, sizeof(nParam));
 
        RETURN_NOERROR;
    }

    static tResult StoreData(IDynamicMemoryBlock*& pCommandBlock, tInt nParamCount, const tUInt32* pParams)
    {
        ASSERT_IF_POINTER_NULL(pCommandBlock);
        ASSERT_IF_POINTER_NULL(pParams);
 
        if (nParamCount < 0)
        {
            RETURN_ERROR(ERR_INVALID_ARG);
        }
 
        pCommandBlock->Append((tVoid*) pParams, nParamCount * sizeof(*pParams));
 
        RETURN_NOERROR;
    }

    static tResult StoreData(IDynamicMemoryBlock*& pCommandBlock, tInt nByteCount, const tUInt8* pData)
    {
        ASSERT_IF_POINTER_NULL(pCommandBlock);
        ASSERT_IF_POINTER_NULL(pData);
 
        if (nByteCount < 0)
        {
            RETURN_ERROR(ERR_INVALID_ARG);
        }
 
        tInt nParamCount = nByteCount / sizeof(tUInt32);
        if (nByteCount % sizeof(tUInt32))
        {
            nParamCount++;
        }
 
        tInt nCompleteParams = nByteCount / sizeof(tUInt32);
        tUInt32* pParams = (tUInt32*) pData;
 
        pCommandBlock->Append((tVoid*) pParams, nCompleteParams * sizeof(tUInt32));
        pParams += nCompleteParams;
 
        if (nParamCount > nCompleteParams)
        {
            tInt nRemainingBytes = nByteCount % sizeof(tUInt32);
            tUInt8* pSrcBytePtr = (tUInt8*) pParams;
 
            for (tUInt nIdx = 0; nIdx < sizeof(tUInt32); nIdx++)
            {
                if (nRemainingBytes > 0)
                {
                    pCommandBlock->Append((tVoid*) pSrcBytePtr++, sizeof(tUInt8));
                    nRemainingBytes--;
                }
                else
                {
                    tUInt8 nFillVal = 0;
                    pCommandBlock->Append((tVoid*) &nFillVal, sizeof(tUInt8));
                }
            }
        }
 
        RETURN_NOERROR;
    }

    static tResult StoreData(IDynamicMemoryBlock*& pCommandBlock, tInt nByteCount, const tChar* pData)
    {
        ASSERT_IF_POINTER_NULL(pCommandBlock);
        ASSERT_IF_POINTER_NULL(pData);
 
        if (nByteCount < 0)
        {
            RETURN_ERROR(ERR_INVALID_ARG);
        }
 
        return StoreData(pCommandBlock, nByteCount, (const tUInt8*) pData);
    }
};
 
} // namespace dengar
 
using dengar::cGCLWriter;
} // namespace graphicslib
 
} // namespace disptb
 
} // namespace adtf
 
//******************************************************************************