// EMERGENT GAME TECHNOLOGIES PROPRIETARY INFORMATION
//
// This software is supplied under the terms of a license agreement or
// nondisclosure agreement with Emergent Game Technologies and may not 
// be copied or disclosed except in accordance with the terms of that 
// agreement.
//
//      Copyright (c) 1996-2007 Emergent Game Technologies.
//      All Rights Reserved.
//
// Emergent Game Technologies, Chapel Hill, North Carolina 27517
// http://www.emergent.net

// Precompiled Header
#include "NiD3DRendererPCH.h"

#include "NiD3DUtility.h"

#include <NiSystem.h>

#include <NiGeometry.h>
#include <NiTriShape.h>
#include <NiTriShapeData.h>
#include <NiTriStrips.h>
#include <NiTriStripsData.h>

bool NiD3DUtility::ms_bLogEnabled = true;

//---------------------------------------------------------------------------
NiD3DUtility::NiD3DUtility()
{
}
//---------------------------------------------------------------------------
NiD3DUtility::~NiD3DUtility()
{
}
//---------------------------------------------------------------------------
void NiD3DUtility::Log(char* pcFmt, ...)
{
    if (!ms_bLogEnabled)
        return;

    char acMessage[1024];

    va_list args;
    va_start(args, pcFmt);
    NiVsprintf(acMessage, 1024, pcFmt, args);
    va_end(args);

    NiOutputDebugString(acMessage);
}
//---------------------------------------------------------------------------
bool NiD3DUtility::GetLogEnabled()
{
    return ms_bLogEnabled;
}
//---------------------------------------------------------------------------
void NiD3DUtility::SetLogEnabled(bool bEnabled)
{
    ms_bLogEnabled = bEnabled;
}
//---------------------------------------------------------------------------
// THIS FUNCTION ASSUMES THE FOLLOWING:
//  pcDrive can hold _MAX_DRIVE
//  pcDir   can hold _MAX_PATH
//  pcFname can hold _MAX_PATH
//  pcExt   can hold _MAX_EXT
bool NiD3DUtility::GetSplitPath(const char* pcFilename, char* pcDrive, 
    char* pcDir, char* pcFname, char* pcExt)
{
#if _MSC_VER >= 1400
    _splitpath_s(pcFilename, pcDrive, _MAX_DRIVE, pcDir, _MAX_PATH,
        pcFname, _MAX_PATH, pcExt, _MAX_EXT);
#else //#if _MSC_VER >= 1400
    _splitpath(pcFilename, pcDrive, pcDir, pcFname, pcExt);
#endif //#if _MSC_VER >= 1400
    return true;
}
//---------------------------------------------------------------------------
bool NiD3DUtility::GetFilePath(const char* pcFilename, char* pcPath,
    unsigned int uiMaxLen)
{
    char acDrive[_MAX_DRIVE];
    char acDir[_MAX_PATH];
    char acFileName[_MAX_FNAME];
    char acFileExt[_MAX_EXT];

#if _MSC_VER >= 1400
    _splitpath_s(pcFilename, acDrive, _MAX_DRIVE, acDir, _MAX_PATH,
        acFileName, _MAX_FNAME, acFileExt, _MAX_EXT);
#else //#if _MSC_VER >= 1400
    _splitpath(pcFilename, acDrive, acDir, acFileName, acFileExt);
#endif //#if _MSC_VER >= 1400

    if ((strlen(acDrive) + strlen(acDir) + 1) > uiMaxLen)
        return false;

    NiSprintf(pcPath, uiMaxLen, "%s%s", acDrive, acDir);

    return true;
}
//---------------------------------------------------------------------------
bool NiD3DUtility::GetFileName(const char* pcFilename, char* pcName,
    unsigned int uiMaxLen)
{
    char acDrive[_MAX_DRIVE];
    char acDir[_MAX_PATH];
    char acFileName[_MAX_FNAME];
    char acFileExt[_MAX_EXT];

#if _MSC_VER >= 1400
    _splitpath_s(pcFilename, acDrive, _MAX_DRIVE, acDir, _MAX_PATH,
        acFileName, _MAX_FNAME, acFileExt, _MAX_EXT);
#else //#if _MSC_VER >= 1400
    _splitpath(pcFilename, acDrive, acDir, acFileName, acFileExt);
#endif //#if _MSC_VER >= 1400

    if ((strlen(acFileName) + 1) > uiMaxLen)
        return false;

    NiSprintf(pcName, uiMaxLen, "%s", acFileName);

    return true;
}
//---------------------------------------------------------------------------
bool NiD3DUtility::GetFileExtension(const char* pcFilename, char* pcExt, 
    unsigned int uiMaxLen)
{
    char acDrive[_MAX_DRIVE];
    char acDir[_MAX_PATH];
    char acFileName[_MAX_FNAME];
    char acFileExt[_MAX_EXT];

#if _MSC_VER >= 1400
    _splitpath_s(pcFilename, acDrive, _MAX_DRIVE, acDir, _MAX_PATH,
        acFileName, _MAX_FNAME, acFileExt, _MAX_EXT);
#else //#if _MSC_VER >= 1400
    _splitpath(pcFilename, acDrive, acDir, acFileName, acFileExt);
#endif //#if _MSC_VER >= 1400

    size_t stExtLen = strlen(acFileExt);
    NIASSERT(stExtLen < uiMaxLen);
    NiStrncpy(pcExt, uiMaxLen, acFileExt, stExtLen);

    return true;
}
//---------------------------------------------------------------------------
unsigned int NiD3DUtility::SetString(char*& pcDest, unsigned int uiDestSize, 
    const char* pcSrc)
{
    if (pcSrc && pcSrc[0] != '\0')
    {
        unsigned int uiSrcSize = strlen(pcSrc) + 1;
        if (pcDest)
        {
            // See if the length is ok
            if (uiDestSize <= uiSrcSize)
            {
                NiFree(pcDest);
                pcDest = 0;
            }
        }

        if (!pcDest)
        {
            pcDest = NiAlloc(char, uiSrcSize);
            uiDestSize = uiSrcSize;
        }

        NiStrcpy(pcDest, uiDestSize, pcSrc);
        return uiDestSize;
    }
    else
    {
        NiFree(pcDest);
        pcDest = 0;
        return 0;
    }
}
//---------------------------------------------------------------------------
bool NiD3DUtility::WriteString(NiBinaryStream& kStream, const char* pcString)
{
    unsigned int uiLen = (pcString ? strlen(pcString) : 0);
    NiStreamSaveBinary(kStream, uiLen);

    if (uiLen)
    {
        NiStreamSaveBinary(kStream, pcString, uiLen);
    }
    return true;
}
//---------------------------------------------------------------------------
bool NiD3DUtility::WriteData(NiBinaryStream& kStream, void* pvData, 
    unsigned int uiSize)
{
    NiStreamSaveBinary(kStream, uiSize);

    if (uiSize)
    {
        unsigned int uiWrote = kStream.Write(pvData, uiSize);
        if (uiWrote != uiSize)
            return false;
    }

    return true;
}
//---------------------------------------------------------------------------
bool NiD3DUtility::ReadString(NiBinaryStream& kStream, char* pcString,
    unsigned int& uiBufferSize)
{
    unsigned int uiLen;
    NiStreamLoadBinary(kStream, uiLen);
    
    if (uiLen >= uiBufferSize)
    {
        uiBufferSize = uiLen + 1;
        return false;
    }

    if (uiLen)
        NiStreamLoadBinary(kStream, pcString, uiLen);
    pcString[uiLen] = '\0';

    return true;
}
//---------------------------------------------------------------------------
bool NiD3DUtility::AllocateAndReadString(NiBinaryStream& kStream, 
    char*& pcString, unsigned int& uiStringSize)
{
    unsigned int uiLen;
    NiStreamLoadBinary(kStream, uiLen);

    if (uiLen)
    {
        NiFree(pcString);
        uiStringSize = uiLen + 1;
        pcString = NiAlloc(char, uiStringSize);
        NIASSERT(pcString);

        NiStreamLoadBinary(kStream, pcString, uiLen);
        pcString[uiLen] = '\0';
    }
    else
    {
        pcString = NULL;
    }

    return true;
}
//---------------------------------------------------------------------------
bool NiD3DUtility::ReadData(NiBinaryStream& kStream, void*& pvData,
    unsigned int& uiSize)
{
    unsigned int uiReadSize;
    NiStreamLoadBinary(kStream, uiReadSize);

    if (uiReadSize > uiSize)
    {
        uiSize = uiReadSize;
        return false;
    }

    if (uiSize)
    {
        unsigned int uiRead = kStream.Read(pvData, uiSize);
        if (uiRead != uiSize)
            return false;
    }

    return true;
}
//---------------------------------------------------------------------------
bool NiD3DUtility::AllocateAndReadData(NiBinaryStream& kStream, void*& pvData,
    unsigned int& uiDataSize)
{
    NiStreamLoadBinary(kStream, uiDataSize);

    if (uiDataSize)
    {
        pvData = NiAlloc(unsigned char, uiDataSize);
        NIASSERT(pvData);

        unsigned int uiRead = kStream.Read(pvData, uiDataSize);
        if (uiRead != uiDataSize)
            return false;
    }
    else
    {
        pvData = NULL;
    }

    return true;
}
//---------------------------------------------------------------------------
bool NiD3DUtility::ConvertCHARToWCHAR(WCHAR* pwDestination, 
    const char* pcSource, unsigned int uiDestChar)
{
    if (pwDestination == NULL || pcSource == NULL || uiDestChar == 0)
        return false;

    int iResult = MultiByteToWideChar(CP_ACP, 0, pcSource, -1, pwDestination, 
        uiDestChar);
    pwDestination[uiDestChar - 1] = 0;
    
    return (iResult != 0);
}
//---------------------------------------------------------------------------
bool NiD3DUtility::ConvertWCHARToCHAR(char* pcDestination, 
    const WCHAR* pwSource, unsigned int uiDestChar)
{
    if (pcDestination == NULL || pwSource == NULL || uiDestChar == 0)
        return false;

    int iResult = WideCharToMultiByte(CP_ACP, 0, pwSource, -1, pcDestination, 
        uiDestChar*sizeof(char), NULL, NULL);
    pcDestination[uiDestChar - 1] = 0;
    
    return (iResult != 0);
}
//---------------------------------------------------------------------------
bool NiD3DUtility::ConvertTCHARToCHAR(char* pcDestination, 
    const TCHAR* ptSource, unsigned int uiDestChar)
{
    if (pcDestination == NULL || ptSource == NULL || uiDestChar == 0)
        return false;

#ifdef _UNICODE
    return ConvertWCHARToCHAR(pcDestination, ptSource, uiDestChar);
#else
    NiStrncpy(pcDestination, uiDestChar, ptSource, uiDestChar - 1);
    return true;
#endif   
}
//---------------------------------------------------------------------------
bool NiD3DUtility::ConvertTCHARToWCHAR(WCHAR* pwDestination, 
    const TCHAR* ptSource, unsigned int uiDestChar)
{
    if ( pwDestination == NULL || ptSource == NULL || uiDestChar == 0)
        return false;

#ifdef _UNICODE
    wcsncpy(pwDestination, ptSource, uiDestChar);
    pwDestination[uiDestChar - 1] = '\0';
    return true;
#else
    return ConvertCHARToWCHAR(pwDestination, ptSource, uiDestChar);
#endif    
}
//---------------------------------------------------------------------------
bool NiD3DUtility::ConvertCHARToTCHAR(TCHAR* ptDestination, 
    const char* pcSource, unsigned int uiDestChar)
{
    if ( ptDestination == NULL || pcSource==NULL || uiDestChar == 0)
        return false;
        
#ifdef _UNICODE
    return ConvertCHARToWCHAR(ptDestination, pcSource, uiDestChar);
#else
    NiStrncpy(ptDestination, uiDestChar, pcSource, uiDestChar - 1);
    ptDestination[uiDestChar - 1] = L'\0';
    return true;
#endif    
}
//---------------------------------------------------------------------------
bool NiD3DUtility::ConvertWCHARToTCHAR(TCHAR* ptDestination, 
    const WCHAR* pwSource, unsigned int uiDestChar)
{
    if (ptDestination == NULL || pwSource == NULL || uiDestChar == 0)
        return false;

#ifdef _UNICODE
    wcsncpy(ptDestination, pwSource, uiDestChar);
    ptDestination[uiDestChar - 1] = L'\0';    
    return S_OK;
#else
    return ConvertWCHARToCHAR(ptDestination, pwSource, uiDestChar);
#endif
}
//---------------------------------------------------------------------------