Plugin/Source/SenseGloveCore/Private/SGCore/SGHandProfile.cpp

/**
 * @file
 *
 * @author  Mamadou Babaei <mamadou@senseglove.com>
 *
 * @section LICENSE
 *
 * (The MIT License)
 *
 * Copyright (c) 2020 - 2022 SenseGlove
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * @section DESCRIPTION
 *
 *
 */


#include "SGCore/SGHandProfile.h"

#include "Runtime/Launch/Resources/Version.h"

#include "SGCore/SGNovaGloveHandProfile.h"
#include "SGCore/SGSenseGloveHandProfile.h"
#include "SGCoreImpl/SGExportedFunctions.h"
#include "SGCoreImpl/SGHandProfileImpl.h"
#include "SGInterop/SGIC_FSGHandProfileImpl.h"
#include "SGInterop/SGIC_FSGNovaGloveHandProfileImpl.h"
#include "SGInterop/SGIC_FSGSenseGloveHandProfileImpl.h"
#include "SGInterop/SGIC_FString.h"

struct USGHandProfile::FImpl
{
    /************************
     * Member variables
     ************************/

    FSGHandProfileImpl HandProfileImpl;

    /************************
     * Owner object
     ************************/

    USGHandProfile* Owner;

    /************************
     * Constructor / Destructor
     ************************/

    explicit FImpl(USGHandProfile* InOwner);
    ~FImpl();

    /************************
     * Default copy constructor & copy assignment operator
     ************************/

    FImpl(const FImpl& Rhs) = default;
    FImpl& operator=(const FImpl& Rhs) = default;

    /************************
     * Methods
     ************************/

    void SyncUProperties();
    void SyncImplObject();
};

USGHandProfile* USGHandProfile::NewHandProfile(UObject* Outer, const FSGHandProfileImpl& HandProfileImpl)
{
    USGHandProfile* Instance = NewObject<USGHandProfile>(Outer);
    Instance->SetHandProfileImpl(HandProfileImpl);
    return Instance;
}

USGHandProfile* USGHandProfile::NewHandProfile(UObject* Outer)
{
    FSGIC_FSGHandProfileImpl OutHandProfileImplContainer;
    SGCoreImpl_FSGHandProfileImpl_ctor(&OutHandProfileImplContainer);

    return NewHandProfile(Outer, MoveTemp(OutHandProfileImplContainer.HandProfileImpl));
}

USGHandProfile* USGHandProfile::NewHandProfile(UObject* Outer, const bool bRightHanded,
                                               const USGSenseGloveHandProfile* SenseGloveHandProfile,
                                               const USGNovaGloveHandProfile* NovaGloveHandProfile)
{
    FSGIC_FSGHandProfileImpl OutHandProfileImplContainer;
    FSGIC_FSGSenseGloveHandProfileImpl SenseGloveHandProfileContainer
        {SenseGloveHandProfile->ToSenseGloveHandProfileImpl()};
    FSGIC_FSGNovaGloveHandProfileImpl NovaGloveHandProfileContainer
        {NovaGloveHandProfile->ToNovaGloveHandProfileImpl()};
    SGCoreImpl_FSGHandProfileImpl_ctor_bRightHanded_SenseGloveHandProfile_NovaGloveHandProfile(
        &OutHandProfileImplContainer, bRightHanded, &SenseGloveHandProfileContainer, &NovaGloveHandProfileContainer);

    return NewHandProfile(Outer, MoveTemp(OutHandProfileImplContainer.HandProfileImpl));
}

USGHandProfile* USGHandProfile::Default(UObject* Outer, const bool bRightHanded)
{
    FSGIC_FSGHandProfileImpl OutHandProfileImplContainer;
    SGCoreImpl_FSGHandProfileImpl_Default(&OutHandProfileImplContainer, bRightHanded);

    return NewHandProfile(Outer, MoveTemp(OutHandProfileImplContainer.HandProfileImpl));
}

USGHandProfile* USGHandProfile::Deserialize(UObject* Outer, const FString& SerializedString)
{
    FSGIC_FSGHandProfileImpl OutHandProfileImplContainer;
    FSGIC_FString SerializedStringContainer{SerializedString};
    SGCoreImpl_FSGHandProfileImpl_Deserialize(&OutHandProfileImplContainer,
                                              &SerializedStringContainer);

    return NewHandProfile(Outer, MoveTemp(OutHandProfileImplContainer.HandProfileImpl));
}

FString USGHandProfile::GetProfileDirectory()
{
    FSGIC_FString OutDirectoryContainer;
    SGCoreImpl_FSGHandProfileImpl_GetProfileDirectory(&OutDirectoryContainer);
    return MoveTemp(OutDirectoryContainer.String);
}

FString USGHandProfile::GetLeftHandFileName()
{
    FSGIC_FString OutFileName;
    SGCoreImpl_FSGHandProfileImpl_GetLeftHandFileName(&OutFileName);
    return MoveTemp(OutFileName.String);
}

FString USGHandProfile::GetRightHandFileName()
{
    FSGIC_FString OutFileName;
    SGCoreImpl_FSGHandProfileImpl_GetRightHandFileName(&OutFileName);
    return MoveTemp(OutFileName.String);
}

FString USGHandProfile::GetProfileFileName(const bool bRightHanded)
{
    FSGIC_FString OutFileName;
    SGCoreImpl_FSGHandProfileImpl_GetProfileFileName(&OutFileName, bRightHanded);
    return MoveTemp(OutFileName.String);
}

bool USGHandProfile::GetLatestProfile(UObject* Outer, const bool bRightHanded, USGHandProfile*& OutLatestProfile)
{
    FSGIC_FSGHandProfileImpl OutLatestProfileContainer;
    const bool bResult = SGCoreImpl_FSGHandProfileImpl_GetLatestProfile(bRightHanded, &OutLatestProfileContainer);
    if (bResult)
    {
        OutLatestProfile = NewHandProfile(Outer, MoveTemp(OutLatestProfileContainer.HandProfileImpl));
    }
    return bResult;
}

bool USGHandProfile::StoreProfile(const USGHandProfile* ProfileToStore)
{
    FSGIC_FSGHandProfileImpl ProfileToStoreContainer{ProfileToStore->ToHandProfileImpl()};
    return SGCoreImpl_FSGHandProfileImpl_StoreProfile(&ProfileToStoreContainer);
}

bool USGHandProfile::ResetCalibration(const bool bRightHanded, const bool bOnDisk)
{
    return SGCoreImpl_FSGHandProfileImpl_ResetCalibration_bRightHanded_bOnDisk(bRightHanded, bOnDisk);
}

void USGHandProfile::ResetCalibration(const bool bOnDisk)
{
    return SGCoreImpl_FSGHandProfileImpl_ResetCalibration_bOnDisk(bOnDisk);
}

USGHandProfile::USGHandProfile()
    :
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
#else
    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
{
    FSGIC_FSGHandProfileImpl OutHandProfileImplContainer;
    SGCoreImpl_FSGHandProfileImpl_ctor(&OutHandProfileImplContainer);

    Pimpl->HandProfileImpl = MoveTemp(OutHandProfileImplContainer.HandProfileImpl);
    Pimpl->SyncUProperties();
}

USGHandProfile::USGHandProfile(const bool bRightHanded,
                               const USGSenseGloveHandProfile* SenseGloveHandProfile,
                               const USGNovaGloveHandProfile* NovaGloveHandProfile)
    :
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
#else
    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
{
    FSGIC_FSGHandProfileImpl OutHandProfileImplContainer;
    FSGIC_FSGSenseGloveHandProfileImpl SenseGloveHandProfileContainer
        {SenseGloveHandProfile->ToSenseGloveHandProfileImpl()};
    FSGIC_FSGNovaGloveHandProfileImpl NovaGloveHandProfileContainer
        {NovaGloveHandProfile->ToNovaGloveHandProfileImpl()};
    SGCoreImpl_FSGHandProfileImpl_ctor_bRightHanded_SenseGloveHandProfile_NovaGloveHandProfile(
        &OutHandProfileImplContainer, bRightHanded, &SenseGloveHandProfileContainer, &NovaGloveHandProfileContainer);

    Pimpl->HandProfileImpl = MoveTemp(OutHandProfileImplContainer.HandProfileImpl);
    Pimpl->SyncUProperties();
}

USGHandProfile::USGHandProfile(const FSGHandProfileImpl& HandProfileImpl)
    :
#if ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 )
    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
#else
    Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}))
#endif  /* ENGINE_MAJOR_VERSION == 5 || ( ENGINE_MAJOR_VERSION == 4 && ENGINE_MINOR_VERSION > 24 ) */
{
    SetHandProfileImpl(HandProfileImpl);
    Pimpl->SyncUProperties();
}

USGHandProfile::~USGHandProfile() = default;

void USGHandProfile::SetHandProfileImpl(const FSGHandProfileImpl& HandProfileImpl)
{
    FSGIC_FSGHandProfileImpl OutHandProfileContainer;
    FSGIC_FSGHandProfileImpl RhsContainer{HandProfileImpl};
    SGCoreImpl_FSGHandProfileImpl_ctor_copy(&OutHandProfileContainer, &RhsContainer);
    Pimpl->HandProfileImpl = MoveTemp(OutHandProfileContainer.HandProfileImpl);
}

const FSGHandProfileImpl& USGHandProfile::ToHandProfileImpl() const
{
    Pimpl->SyncImplObject();
    return Pimpl->HandProfileImpl;
}

bool USGHandProfile::IsRight() const
{
    FSGIC_FSGHandProfileImpl InstanceContainer{ToHandProfileImpl()};
    return SGCoreImpl_FSGHandProfileImpl_IsRight(&InstanceContainer);
}

USGSenseGloveHandProfile* USGHandProfile::GetSenseGloveHandProfile(UObject* Outer) const
{
    FSGIC_FSGHandProfileImpl InstanceContainer{ToHandProfileImpl()};
    FSGIC_FSGSenseGloveHandProfileImpl OutProfileContainer;
    SGCoreImpl_FSGHandProfileImpl_GetSenseGloveHandProfile(&InstanceContainer, &OutProfileContainer);

    return USGSenseGloveHandProfile::NewSenseGloveHandProfile(
        Outer, MoveTemp(OutProfileContainer.SenseGloveHandProfileImpl));
}

USGNovaGloveHandProfile* USGHandProfile::GetNovaGloveHandProfile(UObject* Outer) const
{
    FSGIC_FSGHandProfileImpl InstanceContainer{ToHandProfileImpl()};
    FSGIC_FSGNovaGloveHandProfileImpl OutProfileContainer;
    SGCoreImpl_FSGHandProfileImpl_GetNovaGloveHandProfile(&InstanceContainer, &OutProfileContainer);

    return USGNovaGloveHandProfile::NewNovaGloveHandProfile(
        Outer, MoveTemp(OutProfileContainer.NovaGloveHandProfileImpl));
}

bool USGHandProfile::Equals(const USGHandProfile* HandProfile) const
{
    Pimpl->SyncImplObject();

    FSGIC_FSGHandProfileImpl InstanceContainer{ToHandProfileImpl()};
    FSGIC_FSGHandProfileImpl HandProfileContainer{HandProfile->ToHandProfileImpl()};
    return SGCoreImpl_FSGHandProfileImpl_Equals(&InstanceContainer, &HandProfileContainer);
}

void USGHandProfile::Reset()
{
    Pimpl->SyncImplObject();

    FSGIC_FSGHandProfileImpl InstanceContainer{ToHandProfileImpl()};
    SGCoreImpl_FSGHandProfileImpl_Reset(&InstanceContainer);

    Pimpl->SyncUProperties();
}

FString USGHandProfile::SGSerialize() const
{
    Pimpl->SyncImplObject();

    FSGIC_FSGHandProfileImpl InstanceContainer{ToHandProfileImpl()};
    FSGIC_FString OutStringContainer;
    SGCoreImpl_FSGHandProfileImpl_Serialize(&InstanceContainer, &OutStringContainer);
    return MoveTemp(OutStringContainer.String);
}

USGHandProfile::FImpl::FImpl(USGHandProfile* InOwner)
    : Owner(InOwner)
{
}

USGHandProfile::FImpl::~FImpl() = default;

void USGHandProfile::FImplDeleter::operator()(const FImpl* P) const
{
    delete P;
}

void USGHandProfile::FImpl::SyncUProperties()
{
}

void USGHandProfile::FImpl::SyncImplObject()
{
}