Plugin/Source/SenseGloveCoreKismet/Private/SGCoreKismet/SGHapticGloveCommandBufferKismetLibrary.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 "SGCoreKismet/SGHapticGloveCommandBufferKismetLibrary.h"

#include "SGCore/SGForceFeedbackCommand.h"
#include "SGCore/SGHapticGloveCommandBuffer.h"
#include "SGCore/SGTimedBuzzCommand.h"
#include "SGCore/SGTimedThumpCommand.h"

USGHapticGloveCommandBuffer* USGHapticGloveCommandBufferKismetLibrary::MakeHapticGloveCommandBuffer(
    UObject* WorldContextObject)
{
    return USGHapticGloveCommandBuffer::NewHapticGloveCommandBuffer(WorldContextObject);
}

int32 USGHapticGloveCommandBufferKismetLibrary::GetMaxForceFeedbackCommands()
{
    return USGHapticGloveCommandBuffer::GetMaxForceFeedbackCommands();
}

int32 USGHapticGloveCommandBufferKismetLibrary::GetMaxBuzzCommands()
{
    return USGHapticGloveCommandBuffer::GetMaxBuzzCommands();
}

int32 USGHapticGloveCommandBufferKismetLibrary::GetMaxThumpCommands()
{
    return USGHapticGloveCommandBuffer::GetMaxThumpCommands();
}

TArray<USGForceFeedbackCommand*> USGHapticGloveCommandBufferKismetLibrary::GetForceFeedbackCommandsQueue(
    UObject* WorldContextObject,
    const USGHapticGloveCommandBuffer* HapticGloveCommandBuffer)
{
    return HapticGloveCommandBuffer->GetForceFeedbackCommandsQueue(WorldContextObject);
}

TArray<USGTimedBuzzCommand*> USGHapticGloveCommandBufferKismetLibrary::GetBuzzCommandsQueue(
    UObject* WorldContextObject,
    const USGHapticGloveCommandBuffer* HapticGloveCommandBuffer)
{
    return HapticGloveCommandBuffer->GetBuzzCommandsQueue(WorldContextObject);
}

TArray<USGTimedThumpCommand*> USGHapticGloveCommandBufferKismetLibrary::GetThumperCommandsQueue(
    UObject* WorldContextObject,
    const USGHapticGloveCommandBuffer* HapticGloveCommandBuffer)
{
    return HapticGloveCommandBuffer->GetThumperCommandsQueue(WorldContextObject);
}

void USGHapticGloveCommandBufferKismetLibrary::ClearForceFeedbackCommandsQueue(
    USGHapticGloveCommandBuffer* HapticGloveCommandBuffer)
{
    HapticGloveCommandBuffer->ClearForceFeedbackCommandsQueue();
}

void USGHapticGloveCommandBufferKismetLibrary::ClearVibrations(
    USGHapticGloveCommandBuffer* HapticGloveCommandBuffer)
{
    HapticGloveCommandBuffer->ClearVibrations();
}

void USGHapticGloveCommandBufferKismetLibrary::Clear(USGHapticGloveCommandBuffer* HapticGloveCommandBuffer)
{
    HapticGloveCommandBuffer->Clear();
}

void USGHapticGloveCommandBufferKismetLibrary::AddCommand_ForceFeedbackCommand(
    USGHapticGloveCommandBuffer* HapticGloveCommandBuffer,
    const USGForceFeedbackCommand* ForceFeedbackCommand)
{
    HapticGloveCommandBuffer->AddCommand(ForceFeedbackCommand);
}

void USGHapticGloveCommandBufferKismetLibrary::AddCommand_BuzzCommand(
    USGHapticGloveCommandBuffer* HapticGloveCommandBuffer,
    const USGTimedBuzzCommand* BuzzCommand)
{
    HapticGloveCommandBuffer->AddCommand(BuzzCommand);
}

void USGHapticGloveCommandBufferKismetLibrary::AddCommand_ThumpCommand(
    USGHapticGloveCommandBuffer* HapticGloveCommandBuffer,
    const USGTimedThumpCommand* ThumpCommand)
{
    HapticGloveCommandBuffer->AddCommand(ThumpCommand);
}

void USGHapticGloveCommandBufferKismetLibrary::UpdateTimedCommands(
    USGHapticGloveCommandBuffer* HapticGloveCommandBuffer, const float DeltaSeconds)
{
    HapticGloveCommandBuffer->UpdateTimedCommands(DeltaSeconds);
}

USGForceFeedbackCommand* USGHapticGloveCommandBufferKismetLibrary::GetTotalForceFeedbackLevels_LastForceFeedbackCommand(
    UObject* WorldContextObject,
    const USGHapticGloveCommandBuffer* HapticGloveCommandBuffer,
    const USGForceFeedbackCommand* LastForceFeedbackCommand)
{
    return HapticGloveCommandBuffer->GetTotalForceFeedbackLevels(WorldContextObject, LastForceFeedbackCommand);
}

USGForceFeedbackCommand* USGHapticGloveCommandBufferKismetLibrary::GetTotalForceFeedbackLevels(
    UObject* WorldContextObject,
    const USGHapticGloveCommandBuffer* HapticGloveCommandBuffer)
{
    return HapticGloveCommandBuffer->GetTotalForceFeedbackLevels(WorldContextObject);
}

USGBuzzCommand* USGHapticGloveCommandBufferKismetLibrary::GetTotalBuzzLevels(
    UObject* WorldContextObject,
    const USGHapticGloveCommandBuffer* HapticGloveCommandBuffer)
{
    return HapticGloveCommandBuffer->GetTotalBuzzLevels(WorldContextObject);
}

USGThumperCommand* USGHapticGloveCommandBufferKismetLibrary::GetTotalThumperLevels(
    UObject* WorldContextObject,
    const USGHapticGloveCommandBuffer* HapticGloveCommandBuffer)
{
    return HapticGloveCommandBuffer->GetTotalThumperLevels(WorldContextObject);
}

void USGHapticGloveCommandBufferKismetLibrary::FlushHaptics_LBL_OutFFC_OutBC_OutTC_bCFFQ(
    UObject* WorldContextObject,
    USGHapticGloveCommandBuffer* HapticGloveCommandBuffer,
    const USGForceFeedbackCommand* LastBrakeLevel,
    USGForceFeedbackCommand*& OutForceFeedbackCommand,
    USGBuzzCommand*& OutBuzzCommand,
    USGThumperCommand*& OutThumperCommand,
    const bool bClearForceFeedbackQueue)
{
    HapticGloveCommandBuffer->FlushHaptics(WorldContextObject,
                                           LastBrakeLevel,
                                           OutForceFeedbackCommand, OutBuzzCommand, OutThumperCommand,
                                           bClearForceFeedbackQueue);
}

void USGHapticGloveCommandBufferKismetLibrary::FlushHaptics_DS_LBL_OutFFC_OutBuzzCommand_OutTC(
    UObject* WorldContextObject,
    USGHapticGloveCommandBuffer* HapticGloveCommandBuffer,
    const float DeltaSeconds,
    const USGForceFeedbackCommand* LastBrakeLevel,
    USGForceFeedbackCommand*& OutForceFeedbackCommand,
    USGBuzzCommand*& OutBuzzCommand,
    USGThumperCommand*& OutThumperCommand)
{
    HapticGloveCommandBuffer->FlushHaptics(WorldContextObject,
                                           DeltaSeconds, LastBrakeLevel,
                                           OutForceFeedbackCommand, OutBuzzCommand, OutThumperCommand);
}