doc/api/_gx_sys_debug_communication_8h_source.html

//===========================================================================

//===========================================================================

#pragma once


GX_CORE_NAMESPACE_BEGIN()


#if GX_DEVELOP

//===========================================================================

//===========================================================================

class GxDebugCommunicationInitialInformation : public GxClassBase

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    // RTTI定義

    GX_RTTI_CLASS(GxDebugCommunicationInitialInformation, GxClassBase)

    // GxClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE(GxDebugCommunicationInitialInformation)


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    GxDebugCommunicationInitialInformation(void)

    : _reciveBufferSize(GxDebugCommunicationBase::RECEIVE_MAX_SIZE)

    , _useRuntimeShaderCompile(false)

#if defined(_NX64)

    , _useLastWriteTime(true)

#endif //_NX64

    {}


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    void loadJson(const GxJson::GxJsonNode& jsonNode);


#if GX_DEVELOP

    static GxGuiBase* createGui(GxProperty& property, GxTypedObject* pOwner, const GxRtti& rtti, u32 index);

#endif // GX_DEVELOP


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    u32                 _reciveBufferSize;

    b32                 _useRuntimeShaderCompile;

#if defined(_NX64)

    b32                 _useLastWriteTime;

#endif //_NX64

};


//===========================================================================

//===========================================================================

class GxSysDebugCommunication : public GxSysBase, public SingletonBase<GxSysDebugCommunication>

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    // RTTI定義

    GX_RTTI_ABSTRACT_CLASS(GxSysDebugCommunication, GxSysBase)

    // ClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE(GxSysDebugCommunication)


    // アプリケーションデータ受信オブザーバ基底クラス宣言

    class ApplicationDataReceiveObserverBase;


protected:

    static constexpr u32 FILE_COMMUNICATION_TIMEOUT_MSEC    = 5 * 1000;

    static constexpr u32 PACKET_MAX_SIZE                    = GxDebugCommunicationBase::PACKET_MAX_SIZE;

    static constexpr u32 KEEP_ALIVE_PACKET_SPAN_SEC         = 2 * 1000;


protected:

    struct GxApplicationDataReceiveCallbackInformation

    {

        u32                                                             _magic;

        GxSysDebugCommunication::ApplicationDataReceiveObserverBase*    _pObserver;

    };


protected:

    enum class COMMAND

    {

        HEALTH_CHECK                = 0x00010001,

        INPUT                       = 0x00100001,

        FILE_OPEN                   = 0x01000001,

        FILE_CLOSE                  = 0x01000002,

        FILE_READ                   = 0x01000003,

        FILE_WRITE                  = 0x01000004,

        FILE_SEEK                   = 0x01000005,

        FILE_MOVE                   = 0x01000006,

        FILE_COPY                   = 0x01000007,

        FILE_REMOVE                 = 0x01000008,

        FILE_FIND_FIRST             = 0x01000009,

        FILE_FIND_NEXT              = 0x0100000a,

        FILE_FIND_CLOSE             = 0x0100000b,

        FILE_SET_TIMESTAMP          = 0x0100000c,

        FILE_GET_SIZE               = 0x0100000d,

#if defined(_NX64)

        FILE_GET_TIMESTAMP_NX       = 0x0100000e,

        FILE_SET_TIMESTAMP_NX       = 0x0100000f,

#endif // _NX64

        DIRECTORY_CREATE            = 0x02000001,

        DIRECTORY_REMOVE            = 0x02000002,

#if ENABLE_SHADER_COMPILE

        COMPILE_SHADER              = 0x03000001,

#endif //ENABLE_SHADER_COMPILE

        SENDDATA_FROM_APPLICATION   = 0x10000001,

        SENDDATA_FROM_PLATFORM      = 0x10000002

    };


    struct GxPacketKeepAliveResponse

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxPacketKeepAliveResponse(void)

        {

            _header._command  = GxDebugCommunicationBase::getPlatformToNetwork(static_cast<u32>(COMMAND::HEALTH_CHECK));

            _header._bodySize = 0;

            _header._isReply  = true;

        }


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxDebugCommunicationBase::GxPacketHeader    _header;


    };


    struct GxPacketBodyInput

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------


        static constexpr u32 KEY_NUM = GxMath::VALUE_256;

        static constexpr u32 KEY_LBUTTON = 0x01;

        static constexpr u32 KEY_RBUTTON = 0x02;

        static constexpr u32 KEY_MBUTTON = 0x04;

        static constexpr u32 KEY_XBUTTON1 = 0x05;

        static constexpr u32 KEY_XBUTTON2 = 0x06;


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        s32                 _mousePointX;

        s32                 _mousePointY;

        u32                 _captureRectWidth;

        u32                 _captureRectHeight;

        s32                 _mouseOffsetZ;

        GX_CHAR             _keyboardState[KEY_NUM];


    };


    struct GxPacketBodyFileOpen

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------


        static constexpr u32 FILE_PATH_MAX = GxMath::VALUE_256;


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GX_CHAR             _path[FILE_PATH_MAX];

        u32                 _mode;


    };


    struct GxPacketBodyFileOpenResponse

    {

        u32                 _handle;

        u32                 _size;

    };


    struct GxPacketFileOpen

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxPacketFileOpen(void)

        {

            _header._command  = GxDebugCommunicationBase::getPlatformToNetwork(static_cast<u32>(COMMAND::FILE_OPEN));

            _header._bodySize = GxDebugCommunicationBase::getPlatformToNetwork(static_cast<u16>(sizeof(GxPacketBodyFileOpen)));

            _header._isReply  = false;

            GX_MEMSET(&_body, 0, sizeof(GxPacketBodyFileOpen));

        }


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxDebugCommunicationBase::GxPacketHeader    _header;

        GxPacketBodyFileOpen                        _body;


    };


    struct GxPacketBodyFileClose

    {

        u32 _handle;

    };


    struct GxPacketFileClose

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxPacketFileClose(void)

        {

            _header._command  = GxDebugCommunicationBase::getPlatformToNetwork(static_cast<u32>(COMMAND::FILE_CLOSE));

            _header._bodySize = GxDebugCommunicationBase::getPlatformToNetwork(static_cast<u16>(sizeof(GxPacketBodyFileClose)));

            _header._isReply  = false;

            _body._handle = 0;

        }


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxDebugCommunicationBase::GxPacketHeader    _header;

        GxPacketBodyFileClose                       _body;


    };


    struct GxPacketBodyFileRead

    {

        u32                 _handle;

        u32                 _size;

    };


    struct GxPacketBodyFileReadResponse

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------


        static constexpr u32 READ_SIZE_MAX = PACKET_MAX_SIZE - sizeof(GxDebugCommunicationBase::GxPacketHeader) - sizeof(u32);


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        u32                 _size;

        GX_CHAR             _data[READ_SIZE_MAX];


    };


    struct GxPacketFileRead

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxPacketFileRead(void)

        {

            _header._command  = GxDebugCommunicationBase::getPlatformToNetwork(static_cast<u32>(COMMAND::FILE_READ));

            _header._bodySize = GxDebugCommunicationBase::getPlatformToNetwork(static_cast<u16>(sizeof(GxPacketBodyFileRead)));

            _header._isReply  = false;

            GX_MEMSET(&_body, 0, sizeof(GxPacketBodyFileRead));

        }


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxDebugCommunicationBase::GxPacketHeader    _header;

        GxPacketBodyFileRead                        _body;


    };


    struct GxPacketBodyFileWrite

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------


        static constexpr u32 WRITE_SIZE_MAX = PACKET_MAX_SIZE - sizeof(GxDebugCommunicationBase::GxPacketHeader) - sizeof(u32) * 2;


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        u32                 _handle;

        u32                 _size;

        GX_CHAR             _data[WRITE_SIZE_MAX];


    };


    struct GxPacketBodyFileWriteResponse

    {

        u32                 _size;

    };


    struct GxPacketFileWrite

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxPacketFileWrite(void)

        {

            _header._command  = GxDebugCommunicationBase::getPlatformToNetwork(static_cast<u32>(COMMAND::FILE_WRITE));

            _header._bodySize = GxDebugCommunicationBase::getPlatformToNetwork(static_cast<u16>(sizeof(GxPacketBodyFileWrite)));

            _header._isReply  = false;

            GX_MEMSET(&_body, 0, sizeof(GxPacketBodyFileWrite));

        }


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxDebugCommunicationBase::GxPacketHeader    _header;

        GxPacketBodyFileWrite                       _body;


    };


    //---- ファイルシーク


    struct GxPacketBodyFileSeek

    {

        u32                 _handle;

        s32                 _position;

        u32                 _mode;

    };


    struct GxPacketBodyFileSeekResponse

    {

        u32                 _position;

    };


    struct GxPacketFileSeek

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxPacketFileSeek(void)

        {

            _header._command  = GxDebugCommunicationBase::getPlatformToNetwork(static_cast<u32>(COMMAND::FILE_SEEK));

            _header._bodySize = GxDebugCommunicationBase::getPlatformToNetwork(static_cast<u16>(sizeof(GxPacketBodyFileSeek)));

            _header._isReply  = false;

            GX_MEMSET(&_body, 0, sizeof(GxPacketBodyFileSeek));

        }


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxDebugCommunicationBase::GxPacketHeader    _header;

        GxPacketBodyFileSeek                        _body;


    };


    struct GxPacketBodyFileMove

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------


        static constexpr u32 FILE_PATH_MAX = GxMath::VALUE_256;


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GX_CHAR             _srcPath[FILE_PATH_MAX];

        GX_CHAR             _dstPath[FILE_PATH_MAX];


    };


    struct GxPacketFileMove

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxPacketFileMove(void)

        {

            _header._command  = GxDebugCommunicationBase::getPlatformToNetwork(static_cast<u32>(COMMAND::FILE_MOVE));

            _header._bodySize = GxDebugCommunicationBase::getPlatformToNetwork(static_cast<u16>(sizeof(GxPacketBodyFileMove)));

            _header._isReply  = false;

            GX_MEMSET(&_body, 0, sizeof(GxPacketBodyFileMove));

        }


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxDebugCommunicationBase::GxPacketHeader    _header;

        GxPacketBodyFileMove                        _body;


    };


    //--- ファイルコピー


    struct GxPacketBodyFileCopy

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------


        static constexpr u32 FILE_PATH_MAX = GxMath::VALUE_256;


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GX_CHAR             _srcPath[FILE_PATH_MAX];

        GX_CHAR             _dstPath[FILE_PATH_MAX];


    };


    struct GxPacketFileCopy

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxPacketFileCopy(void)

        {

            _header._command  = GxDebugCommunicationBase::getPlatformToNetwork(static_cast<u32>(COMMAND::FILE_COPY));

            _header._bodySize = GxDebugCommunicationBase::getPlatformToNetwork(static_cast<u16>(sizeof(GxPacketBodyFileCopy)));

            _header._isReply  = false;

            GX_MEMSET(&_body, 0, sizeof(GxPacketBodyFileCopy));

        }


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxDebugCommunicationBase::GxPacketHeader    _header;

        GxPacketBodyFileCopy                        _body;


    };


    struct GxPacketBodyFileRemove

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------


        static constexpr u32 FILE_PATH_MAX = GxMath::VALUE_256;


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GX_CHAR             _path[FILE_PATH_MAX];


    };


    struct GxPacketFileRemove

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxPacketFileRemove(void)

        {

            _header._command  = GxDebugCommunicationBase::getPlatformToNetwork(static_cast<u32>(COMMAND::FILE_REMOVE));

            _header._bodySize = GxDebugCommunicationBase::getPlatformToNetwork(static_cast<u16>(sizeof(GxPacketBodyFileRemove)));

            _header._isReply  = false;

            _body._path[0] = '\0';

        }


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxDebugCommunicationBase::GxPacketHeader    _header;

        GxPacketBodyFileRemove                      _body;


    };


    //---- ファイル初回探索


    struct GxPacketBodyFileFindFirst

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------


        static constexpr u32 FILE_PATH_MAX = GxMath::VALUE_256;


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GX_CHAR             _path[FILE_PATH_MAX];


    };


    struct GxPacketBodyFileFindFirstResponse

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------


        static constexpr u32 FILE_PATH_MAX = GxMath::VALUE_256;


        enum ATTRIBUTE

        {

            ATTRIBUTE_NOTHING       = 0,

            ATTRIBUTE_DIRECTORY     = (1<<0),

            ATTRIBUTE_ARCHIVE       = (1<<1),

            ATTRIBUTE_READONLY      = (1<<2),

            ATTRIBUTE_HIDDEN        = (1<<3),

            ATTRIBUTE_SYSTEM        = (1<<4),

            ATTRIBUTE_NORMAL        = (1<<5)

        };


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        u32                 _handle;

        u32                 _fileSizeLow;

        u32                 _fileSizeHigh;

        u32                 _lastWriteTimeLow;

        u32                 _lastWriteTimeHigh;

        u32                 _attribute;

        GX_CHAR             _filename[FILE_PATH_MAX];


    };


    struct GxPacketFileFindFirst

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxPacketFileFindFirst(void)

        {

            _header._command  = GxDebugCommunicationBase::getPlatformToNetwork(static_cast<u32>(COMMAND::FILE_FIND_FIRST));

            _header._bodySize = GxDebugCommunicationBase::getPlatformToNetwork(static_cast<u16>(sizeof(GxPacketBodyFileFindFirst)));

            _header._isReply  = false;

            _body._path[0] = '\0';

        }


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxDebugCommunicationBase::GxPacketHeader    _header;

        GxPacketBodyFileFindFirst                   _body;


    };


    struct GxPacketBodyFileFindNext

    {

        u32 _handle;

    };


    struct GxPacketBodyFileFindNextResponse

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------


        static constexpr u32 FILE_PATH_MAX = GxMath::VALUE_256;


        enum ATTRIBUTE

        {

            ATTRIBUTE_NOTHING       = 0,

            ATTRIBUTE_DIRECTORY     = (1<<0),

            ATTRIBUTE_ARCHIVE       = (1<<1),

            ATTRIBUTE_READONLY      = (1<<2),

            ATTRIBUTE_HIDDEN        = (1<<3),

            ATTRIBUTE_SYSTEM        = (1<<4),

            ATTRIBUTE_NORMAL        = (1<<5)

        };


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        u32                 _fileSizeLow;

        u32                 _fileSizeHigh;

        u32                 _lastWriteTimeLow;

        u32                 _lastWriteTimeHigh;

        u32                 _attribute;

        GX_CHAR             _filename[FILE_PATH_MAX];

        u8                  _result;

        u8                  _padding[3];


    };


    struct GxPacketFileFindNext

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxPacketFileFindNext(void)

        {

            _header._command  = GxDebugCommunicationBase::getPlatformToNetwork(static_cast<u32>(COMMAND::FILE_FIND_NEXT));

            _header._bodySize = GxDebugCommunicationBase::getPlatformToNetwork(static_cast<u16>(sizeof(GxPacketBodyFileFindNext)));

            _header._isReply  = false;

            _body._handle = 0;

        }


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxDebugCommunicationBase::GxPacketHeader    _header;

        GxPacketBodyFileFindNext                    _body;


    };


    struct GxPacketBodyFileFindClose

    {

        u32                 _handle;

    };


    struct GxPacketFileFindClose

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxPacketFileFindClose(void)

        {

            _header._command  = GxDebugCommunicationBase::getPlatformToNetwork(static_cast<u32>(COMMAND::FILE_FIND_CLOSE));

            _header._bodySize = GxDebugCommunicationBase::getPlatformToNetwork(static_cast<u16>(sizeof(GxPacketBodyFileFindClose)));

            _header._isReply  = false;

            _body._handle = 0;

        }


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxDebugCommunicationBase::GxPacketHeader    _header;

        GxPacketBodyFileFindClose                   _body;


    };


    struct GxPacketBodyFileTimestamp

    {

        u32                 _handle;

        u32                 _lowDateTime;

        u32                 _highDateTime;

    };


    struct GxPacketFileTimestamp

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxPacketFileTimestamp(void)

        {

            _header._command  = GxDebugCommunicationBase::getPlatformToNetwork(static_cast<u32>(COMMAND::FILE_SET_TIMESTAMP));

            _header._bodySize = GxDebugCommunicationBase::getPlatformToNetwork(static_cast<u16>(sizeof(GxPacketBodyFileTimestamp)));

            _header._isReply  = false;

            GX_MEMSET(&_body, 0, sizeof(GxPacketBodyFileTimestamp));

        }


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxDebugCommunicationBase::GxPacketHeader    _header;

        GxPacketBodyFileTimestamp                   _body;


    };


    struct GxPacketBodyFileGetSize

    {

        u32                 _handle;

    };


    struct GxPacketBodyFileGetSizeResponse

    {

        u32                 _size;

    };


    struct GxPacketFileGetSize

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxPacketFileGetSize(void)

        {

            _header._command  = GxDebugCommunicationBase::getPlatformToNetwork(static_cast<u32>(COMMAND::FILE_GET_SIZE));

            _header._bodySize = GxDebugCommunicationBase::getPlatformToNetwork(static_cast<u16>(sizeof(GxPacketBodyFileGetSize)));

            _header._isReply  = false;

            _body._handle = 0;

        }


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxDebugCommunicationBase::GxPacketHeader    _header;

        GxPacketBodyFileGetSize                     _body;


    };


#if defined(_NX64)

    struct GxPacketBodyFileGetTimestampNx

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------


        static constexpr u32 FILE_PATH_MAX = GxMath::VALUE_256;


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GX_CHAR             _path[FILE_PATH_MAX];


    };


    struct GxPacketBodyFileGetTimestampNxResponse

    {

        u32                 _size;

        u32                 _lowDateTime;

        u32                 _highDateTime;

    };


    struct GxPacketFileGetTimestampNx

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxPacketFileGetTimestampNx(void)

        {

            _header._command = GxDebugCommunicationBase::getPlatformToNetwork(static_cast<u32>(COMMAND::FILE_GET_TIMESTAMP_NX));

            _header._bodySize = GxDebugCommunicationBase::getPlatformToNetwork(static_cast<u16>(sizeof(GxPacketBodyFileGetTimestampNx)));

            _header._isReply = false;

            _body._path[0] = '\0';

        }


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxDebugCommunicationBase::GxPacketHeader    _header;

        GxPacketBodyFileGetTimestampNx              _body;


    };


    struct GxPacketBodyFileSetTimestampNx

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------


        static constexpr u32 FILE_PATH_MAX = GxMath::VALUE_256;


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GX_CHAR             _path[FILE_PATH_MAX];

        u32                 _lowDateTime;

        u32                 _highDateTime;


    };


    struct GxPacketFileSetTimestampNx

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxPacketFileSetTimestampNx(void)

        {

            _header._command = GxDebugCommunicationBase::getPlatformToNetwork(static_cast<u32>(COMMAND::FILE_SET_TIMESTAMP_NX));

            _header._bodySize = GxDebugCommunicationBase::getPlatformToNetwork(static_cast<u16>(sizeof(GxPacketBodyFileSetTimestampNx)));

            _header._isReply = false;

            GX_MEMSET(&_body, 0, sizeof(GxPacketBodyFileSetTimestampNx));

        }


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxDebugCommunicationBase::GxPacketHeader    _header;

        GxPacketBodyFileSetTimestampNx              _body;


    };

#endif // _NX64


    struct GxPacketBodyDirectoryCreate

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------


        static constexpr u32 FILE_PATH_MAX = GxMath::VALUE_256;


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GX_CHAR             _path[FILE_PATH_MAX];


    };


    struct GxPacketBodyDirectoryCreateResponse

    {

        u8                  _result;

        u8                  _padding[3];

    };


    struct GxPacketDirectoryCreate

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxPacketDirectoryCreate(void)

        {

            _header._command  = GxDebugCommunicationBase::getPlatformToNetwork(static_cast<u32>(COMMAND::DIRECTORY_CREATE));

            _header._bodySize = GxDebugCommunicationBase::getPlatformToNetwork(static_cast<u16>(sizeof(GxPacketBodyDirectoryCreate)));

            _header._isReply  = false;

            _body._path[0] = '\0';

        }


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxDebugCommunicationBase::GxPacketHeader    _header;

        GxPacketBodyDirectoryCreate                 _body;


    };


    struct GxPacketBodyDirectoryRemove

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------


        static constexpr u32 FILE_PATH_MAX = GxMath::VALUE_256;


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GX_CHAR             _path[FILE_PATH_MAX];


    };


    struct GxPacketBodyDirectoryRemoveResponse

    {

        u8                  _result;

        u8                  _padding[3];

    };


    struct GxPacketDirectoryRemove

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxPacketDirectoryRemove(void)

        {

            _header._command  = GxDebugCommunicationBase::getPlatformToNetwork(static_cast<u32>(COMMAND::DIRECTORY_REMOVE));

            _header._bodySize = GxDebugCommunicationBase::getPlatformToNetwork(static_cast<u16>(sizeof(GxPacketBodyDirectoryRemove)));

            _header._isReply  = false;

            _body._path[0] = '\0';

        }


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxDebugCommunicationBase::GxPacketHeader    _header;

        GxPacketBodyDirectoryRemove                 _body;


    };


#if ENABLE_SHADER_COMPILE

public:

    struct GxCompileOptions

    {

        //-----------------------------------------------------------

        //-----------------------------------------------------------


        enum class LOCALE

        {

            ENGLISH,

            JAPANESE,

        };


        //-----------------------------------------------------------

        //-----------------------------------------------------------


        GxCompileOptions(void) : _mainSourceFile(nullptr), _targetProfile(RENDER_SHADER::VERTEX), _entryFunctionName("main"),

                                _searchPathCount(0), _searchPaths(nullptr), _macroDefinitionCount(0), _macroDefinitions(nullptr),

                                _includeFileCount(0), _includeFiles(nullptr), _suppressedWarningsCount(0), _pSuppressedWarnings(nullptr),

                                _locale(LOCALE::ENGLISH),

                                _useFx(0), _noStdlib(0),

                                _optimizationLevel(3), _useFastMath(1), _useFastPrecision(0), _useFastInt(1), _positionInvariant(0),

                                _warningsAsErrors(0), _performanceWarnings(0), _warningLevel(1), _pedantic(0), _pedanticError(0),

                                _stripSymbols(0) {}


        //-----------------------------------------------------------

        //-----------------------------------------------------------


        GX_STR  _mainSourceFile;

        RENDER_SHADER _targetProfile;

        GX_CSTR _entryFunctionName;

        u32     _searchPathCount;

        GX_STR  _searchPaths;

        u32     _macroDefinitionCount;

        GX_STR  _macroDefinitions;

        u32     _includeFileCount;

        GX_STR  _includeFiles;

        u32     _suppressedWarningsCount;

        u32*    _pSuppressedWarnings;


        LOCALE _locale;


        s32 _useFx;

        s32 _noStdlib;


        s32 _optimizationLevel;

        s32 _useFastMath;

        s32 _useFastPrecision;

        s32 _useFastInt;

        s32 _positionInvariant;


        s32 _warningsAsErrors;

        s32 _performanceWarnings;

        s32 _warningLevel;

        s32 _pedantic;

        s32 _pedanticError;

        s32 _xmlCache;

        s32 _stripSymbols;


#if defined(_PS4) || defined(_PS5)

        s32 _outputTargets;

#endif //_PS4 || _PS5


    };


public:

    struct GxPacketBodyCompileShaderResult

    {

        //-----------------------------------------------------------

        //-----------------------------------------------------------


        enum class DATA_STRING

        {

            ENTRY_FUNCTION_NAME,

            SEARCH_PATHS,

            MACRO_DEFINITIONS,

            INCLUDE_FILES,

            SUPPRESSED_WARNINGS,

            MAIN_SOURCE_FILE,

            MAX,

        };


        static constexpr u32 DATA_SIZE_MAX = PACKET_MAX_SIZE - sizeof(GxDebugCommunicationBase::GxPacketHeader) - sizeof(GxCompileOptions) - sizeof(u32) * (static_cast<s32>(DATA_STRING::MAX) + 2);


        //-----------------------------------------------------------

        //-----------------------------------------------------------


        GxPacketBodyCompileShaderResult(void) : _packetCount(0), _shaderCount(0) { GX_MEMSET(_size, 0, sizeof(u32) * static_cast<s32>(DATA_STRING::MAX)); }


        //-----------------------------------------------------------

        //-----------------------------------------------------------


        GxCompileOptions    _options;

        u32                 _size[static_cast<s32>(DATA_STRING::MAX)];

        u32                 _packetCount;

        u32                 _shaderCount;

        GX_CHAR             _data[DATA_SIZE_MAX];


    };


    struct GxPacketCompileShaderResult

    {

        //-----------------------------------------------------------

        //-----------------------------------------------------------


        GxPacketCompileShaderResult(void)

        {

            _header._command  = GxDebugCommunicationBase::getPlatformToNetwork(static_cast<u32>(COMMAND::COMPILE_SHADER));

            _header._bodySize = GxDebugCommunicationBase::getPlatformToNetwork(static_cast<u16>(sizeof(GxPacketBodyCompileShaderResult)));

            _header._isReply  = false;

        }


        //-----------------------------------------------------------

        //-----------------------------------------------------------


        GxDebugCommunicationBase::GxPacketHeader _header;

        GxPacketBodyCompileShaderResult          _body;


    };

#endif //_PS4 || _NX64 || _PS5


    //---- アプリケーションデータ送信


    struct GxPacketApplicationHeader

    {

        u32                 _magic;

    };


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    GxSysDebugCommunication(void);

    ~GxSysDebugCommunication(void) override;


    b32 initialize(const GxClassBase* pInitialInformation) override;

    void terminate(void) override;


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    GX_FORCE_INLINE b32 isConnected(void) const { return (_pCommunication == nullptr) ? static_cast<b32>(false) : _pCommunication->isConnected(); }


    GX_FORCE_INLINE void getKeyboardState(GX_CHAR* pDst) const { GX_MEMCPY(pDst, _keyboardState, sizeof(_keyboardState)); }

    GX_FORCE_INLINE void getMouseState(GxMouse::GxInputData* pDst) const { GX_MEMCPY(pDst, &_mouseState, sizeof(_mouseState)); }

#if ENABLE_SHADER_COMPILE

    constexpr u32 getCompiledShaderSize(void) const { return _compiledShaderSize; }

    constexpr GX_CHAR* getCompiledShader(void){ return _compiledShader; }

#endif //ENABLE_SHADER_COMPILE

    GX_FORCE_INLINE b32 getUseRuntimeShaderCompile(void) const { return _useRuntimeShaderCompile; }


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    void update(void) override;


    GX_HANDLE openFile(GX_CSTR path, GxFile::MODE mode, u32* pSize = nullptr);

    void      closeFile(GX_HANDLE handle);

    u32       readFile(GX_HANDLE handle, void* pDst, u32 size);

    b32       writeFile(GX_HANDLE handle, const void* pSrc, u32 size);

    u32       seekFile(GX_HANDLE handle, s32 offset, GxFile::SEEK_TYPE seekType = GxFile::SEEK_TYPE::BEGIN);

    void      moveFile(GX_CSTR srcPath, GX_CSTR dstPath);

    void      copyFile(GX_CSTR srcPath, GX_CSTR dstPath);

    void      removeFile(GX_CSTR path);

    GX_HANDLE findFirstFile(GX_CSTR path, GxFileInformation& fileInformation);

    b32       findNextFile(GX_HANDLE handle, GxFileInformation& fileInformation);

    void      findCloseFile(GX_HANDLE handle);

    void      setLastWriteTime(GX_HANDLE handle, u64 lastWriteTime);

    u32       getFileSize(GX_HANDLE handle);

#if defined(_NX64)

    GX_FORCE_INLINE b32 getUseLastWriteTime(void) const { return _useLastWriteTime; }

    u64       getLastWriteTimeNX(GX_CSTR path);

    void      setLastWriteTimeNX(GX_CSTR path, u64 lastWriteTime);

#endif // _NX64

    b32       createDirectory(GX_CSTR directoryPath);

    b32       removeDirectory(GX_CSTR directoryPath);

#if ENABLE_SHADER_COMPILE

    b32       compileShader(const GxCompileOptions& options, void* pData, u32 size, b32 isOutputTrace);

    constexpr void startCompileShader(void) {_shaderCompiling = true;}

    u32       addCompileCounter(void);

    void      sendShaderCompileRequset(void);

    constexpr u32 getCompileCounter(void) const { return _shaderCompileCount; }

#endif //ENABLE_SHADER_COMPILE


public:

    b32  sendApplicationData(u32 magic, const void* pData, u32 size);

    b32  registerApplicationDataReceiveObserver(u32 magic, GxSysDebugCommunication::ApplicationDataReceiveObserverBase* pObserver);

    void unregisterApplicationDataReceiveObserver(u32 magic);


protected:

    GxSysDebugCommunication::ApplicationDataReceiveObserverBase* getApplicationDataReceiveObserver(u32 magic);


    b32  reserveFileCommunicationRights(void);

    void freeFileCommunicationRigths(void);

    b32  waitFileCommunicationResponse(void);

    void completeFileCommunicationResponse(void);


    static void callbackAnalyseMessage(const GxDebugCommunicationBase::GxPacketHeader& header, const void* pBody);


    //-----------------------------------------------------------

    //-----------------------------------------------------------

protected:

    GxDebugCommunicationBase*       _pCommunication;


    GX_CHAR                         _keyboardState[GxPacketBodyInput::KEY_NUM];

    GxMouse::GxInputData            _mouseState;


    GxTimer                         _fileCommunicationTimer;

    b32                             _isFileCommunicationRights;

    b32                             _isFileCommunicationResponseWaiting;

    GX_CHAR                         _fileCommunicationBuffer[PACKET_MAX_SIZE];


    GxTimer                         _keepAliveTimer;


    GxArray*                        _pApplicationDataReceiveCallbackList;

    b32                             _useRuntimeShaderCompile;

#if defined(_NX64)

    b32                             _useLastWriteTime;

#endif //_NX64

#if ENABLE_SHADER_COMPILE

    u32                             _shaderCompileCount;

    volatile bool                   _shaderCompiling;

    u32                             _compiledShaderSize;

    GX_CHAR                         _compiledShader[PACKET_MAX_SIZE];

#endif //ENABLE_SHADER_COMPILE


};


#if ENABLE_PARARELL_SHADER_COMPILE

//===========================================================================

//===========================================================================

class GxShaderCompileRequestSender: public GxThread

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP)


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    GxShaderCompileRequestSender(void) : _isFinish(0)

    {

        GX_ASSERT(_pEvent == nullptr, "singleton");

        _pEvent = &_event;

    }

    ~GxShaderCompileRequestSender(void){ _pEvent = nullptr; }


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GX_FORCE_INLINE void Stop(void) { GxThread::atomicExchangeU32(&_isFinish, 1); }

    GX_FORCE_INLINE void setEvent(void) { _event.setEvent(); }

    GX_FORCE_INLINE static void sendStart(void) { _pEvent->setEvent(); }

protected:

    void threadMain(void* pArgument) override;


    //-----------------------------------------------------------

    //-----------------------------------------------------------

protected:

    volatile u32    _isFinish;

    GxEvent         _event;

    static GxEvent* _pEvent;


};


//===========================================================================

//===========================================================================

class GxShaderCompileMessenger : public GxClassBaseReference

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    GX_OPERATOR_NEW_DELETE(gx::core::GxAllocatorList::ALLOCATOR_TYPE::DEVELOP)


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GxShaderCompileMessenger(void) : _shaderCompiling(0), _compiledShaderSize(0), _currentCompileCount(0xffffffff)

    {

        GX_MEMSET(_compiledShader, 0, GxDebugCommunicationBase::PACKET_MAX_SIZE);

    }


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    b32 compileShader(const GxSysDebugCommunication::GxCompileOptions& options, void* pData, u32 size, b32 isOutputTrace);

    constexpr u32 getCurrentCompileCount(void) { return _currentCompileCount; }


    constexpr void setCurrentCompileCounter(u32 count){ _currentCompileCount = count; }

    void copyCompiledShader(const void* pSrc, u32 size);

    constexpr GX_STR getCompileShader(void) { return _compiledShader; }

    constexpr u32 getCompiledShaderSize(void) { return _compiledShaderSize; }


    //-----------------------------------------------------------

    //-----------------------------------------------------------

private:

    volatile u32        _shaderCompiling;

    u32                 _compiledShaderSize;

    GX_CHAR             _compiledShader[GxDebugCommunicationBase::PACKET_MAX_SIZE];

    u32                 _currentCompileCount;

    GxCriticalSection   _criticalSection;


};


//===========================================================================

//===========================================================================

class GxCompileMessengerContainer

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    static void initialize(void);

    static void terminate(void);


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    static GxShaderCompileMessenger* createMessenger(void);

    static GxShaderCompileMessenger* getMessengerFrom(u32 requestCount);

    static void releaseMessengerFrom(u32 requestCount);

    static void requestShaderCompile(GxSysDebugCommunication::GxPacketCompileShaderResult& requestData);

    GX_FORCE_INLINE static GxArray* getRequestList(void) { return _pRequestList; }

    GX_FORCE_INLINE static void lock(void) { _pCriticalSection->lock(); }

    GX_FORCE_INLINE static void unlock(void) { _pCriticalSection->unlock(); }


    //-----------------------------------------------------------

    //-----------------------------------------------------------

private:

    static GxArray*             _pRequestList;

    static GxArray*             _pCompilerList;

    static GxCriticalSection*   _pCriticalSection;


};

#endif // ENABLE_PARARELL_SHADER_COMPILE


// アクセスインターフェース

GX_FORCE_INLINE GxSysDebugCommunication* getGxSysDebugCommunication(void) { return GxSysDebugCommunication::getSingletonPointer(); }


//===========================================================================

//===========================================================================

class GxSysDebugCommunication::ApplicationDataReceiveObserverBase

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    ApplicationDataReceiveObserverBase(void){}

    virtual ~ApplicationDataReceiveObserverBase(void){}


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    virtual b32 callbackReceiveData(const void* pData, u32 size) = 0;


};


#endif  // GX_DEVELOP


GX_CORE_NAMESPACE_END()

GX_PROHIBIT_CLASS_BASE
#define GX_PROHIBIT_CLASS_BASE(__CLASS__)
GxClassBase継承の禁止宣言
Definition GxBase.h:240

OUTPUT_TYPE::MAX
@ MAX
定義数

GxTypedObject
void GxTypedObject
その他
Definition GxDefine.h:213

GX_HANDLE
u32 GX_HANDLE
ハンドル
Definition GxDefine.h:214

RENDER_SHADER
RENDER_SHADER
Definition GxRender.h:75

RENDER_SHADER::VERTEX
@ VERTEX
頂点シェーダー

GxArray
配列クラス
Definition GxArray.h:18

GxClassBase
オブジェクト基底クラス
Definition GxBase.h:88

GxClassBaseReference
参照オブジェクト基底クラス
Definition GxBase.h:122

GxCriticalSection
クリティカルセクションクラス
Definition GxThread.h:20

GxEvent
イベントクラス
Definition GxThread.h:132

GxFile::SEEK_TYPE
SEEK_TYPE
シークタイプ
Definition GxFile.h:201

GxFile::SEEK_TYPE::BEGIN
@ BEGIN
先頭基準

GxFile::MODE
MODE
ファイルアクセスモード
Definition GxFile.h:185

GxFileInformation
ファイル情報クラス
Definition GxFile.h:19

GxJson::GxJsonNode
JSON解析用ノード
Definition GxJson.h:108

GxMath::VALUE_256
static constexpr u32 VALUE_256
256
Definition GxMath.h:127

GxProperty
プロパティクラス
Definition GxProperty.h:48

GxRtti
実行時型情報クラス
Definition GxRtti.h:154

GxSysBase
システム基底クラス
Definition GxSysBase.h:18

GxSysBase::update
virtual void update(void)
更新
Definition GxSysBase.cpp:79

GxSysBase::initialize
virtual b32 initialize(const GxClassBase *pInitialiInformation=nullptr)
初期化
Definition GxSysBase.cpp:29

GxSysBase::terminate
virtual void terminate(void)
終了処理
Definition GxSysBase.cpp:50

GxThread
スレッドクラス
Definition GxThread.h:177

GxThread::atomicExchangeU32
static void atomicExchangeU32(volatile u32 *pTarget, u32 newValue)
アトミックU32
Definition GxThread.cpp:78

GxThread::threadMain
virtual void threadMain(void *pArgument)=0
メインループ

GxTimer
タイマークラス
Definition GxTimer.h:110

SingletonBase
シングルトン基礎クラス
Definition GxSingleton.h:19

b32
32bitブーリアン
Definition GxDefine.h:173