CoherentUIGTBaseComponent.h

/*
This file is part of Coherent UI GT, modern user interface library for
games. Release $RELEASE$. Build $VERSION$ for $LICENSEE$.

Copyright (c) 2012-2018 Coherent Labs AD and/or its licensors. All
rights reserved in all media.

The coded instructions, statements, computer programs, and/or related
material (collectively the "Data") in these files contain confidential
and unpublished information proprietary Coherent Labs and/or its
licensors, which is protected by United States of America federal
copyright law and by international treaties.

This software or source code is supplied under the terms of a license
agreement and nondisclosure agreement with Coherent Labs Limited and may
not be copied, disclosed, or exploited except in accordance with the
terms of that agreement. The Data may not be disclosed or distributed to
third parties, in whole or in part, without the prior written consent of
Coherent Labs Limited.

COHERENT LABS MAKES NO REPRESENTATION ABOUT THE SUITABILITY OF THIS
SOURCE CODE FOR ANY PURPOSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT
HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER, ITS AFFILIATES,
PARENT COMPANIES, LICENSORS, SUPPLIERS, OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY OUT OF THE USE OR PERFORMANCE OF THIS SOFTWARE OR SOURCE CODE,
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#pragma once

#include "Coherent/UIGT/View.h"

#include "CoherentUIGTMeshData.h"
#include "CoherentUIGTSystem.h"
#include "CoherentUIGTEventHelpers.h"
#include "CoherentUIGTViewListener.h"
#include "CoherentUIGTRenderWrapper.h"
#include "CoherentUIGTAudioWrapper.h"
#include "CoherentUIGTDataBinding.h"

#if !defined(COHERENT_UI_GT_UE4_413_SUPPORT)
#include "Runtime/Core/Public/HAL/ThreadSafeBool.h"
#endif

#include "CoherentUIGTBaseComponent.generated.h"

namespace Coherent
{
namespace UIGT
{
class UISystemRenderer;
}
}
struct FCohComponentViewState;

UCLASS(BlueprintType)
class COHERENTUIGTPLUGIN_API UCoherentUIGTBaseComponent : public UActorComponent
{
    GENERATED_UCLASS_BODY()

public:
    typedef TSharedPtr<TCoherentUIGTViewListener<UCoherentUIGTBaseComponent>> ListenerPtr;
    typedef TSharedPtr<FCoherentUIGTRenderWrapper> RenderWrapperPtr;

    UPROPERTY(BlueprintAssignable)
    FUIGTReadyForBindingsSignature ReadyForBindings;

    UPROPERTY(BlueprintAssignable)
    FUIGTBindingsReleasedSignature BindingsReleased;

    UPROPERTY(BlueprintAssignable)
    FUIGTFinishLoadSignature FinishLoad;

    UPROPERTY(BlueprintAssignable)
    FUIGTFailLoadSignature FailLoad;

    UPROPERTY(BlueprintAssignable)
    FUIGTStartLoadingSignature StartLoading;

    UPROPERTY(BlueprintAssignable)
    FUIGTNavigateToSignature NavigateTo;

    UPROPERTY(BlueprintAssignable)
    FUIGTOnJavaScriptEvent JavaScriptEvent;

    UPROPERTY(BlueprintAssignable)
    FUIGTScriptingReady UIGTScriptingReady;

    UPROPERTY()
    FUIGTOnLiveViewSizeRequest LiveViewSizeRequested;

    FUIGTOnPerformanceAuditSignature OnPerformanceAudit;

    UFUNCTION(BlueprintCallable, Category = "View")
    virtual void Resize(/*uint32*/ int32 width, /*uint32*/ int32 height);

    UFUNCTION(BlueprintCallable, Category = "View")
    bool IsReadyToCreateView() const;

    UFUNCTION(BlueprintCallable, Category = "View")
    bool IsReadyForBindings() const;

    UFUNCTION(BlueprintCallable, Category = "View")
    bool HasRequestedView() const;

    UFUNCTION(BlueprintCallable, Category = "View")
    bool IsTransparent() const;

    UFUNCTION(BlueprintCallable, Category = "View")
    void ShowPaintRects(bool show);

    UFUNCTION(BlueprintCallable, Category = "View")
    void Redraw() const;

    UFUNCTION(BlueprintCallable, Category = "View")
    void Load(const FString& path);

    UFUNCTION(BlueprintCallable, Category = "View")
    void Reload();

    UFUNCTION(BlueprintCallable, Category = "View")
    bool IsDocumentReady() const;

    UFUNCTION(BlueprintCallable, Category = "View")
    void DebugSaveNextFrame();

    UFUNCTION(BlueprintCallable, Category = "View")
    void BeginDebugFrameSave();

    UFUNCTION(BlueprintCallable, Category = "View")
    void EndDebugFrameSave();

    UPROPERTY(BlueprintReadOnly, Category = "View")
    UTextureRenderTarget2D* Texture;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "View", AdvancedDisplay)
    TEnumAsByte<enum TextureFilter> Filter;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "View")
    bool bReceiveInput;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "View")
    bool bReceiveInputWhenTransparent;

    UFUNCTION(BlueprintCallable, Category = "View")
    void SetClickThroughAlphaThreshold(float threshold);

    UFUNCTION(BlueprintCallable, Category = "View")
    float GetClickThroughAlphaThreshold() const;

    UFUNCTION(BlueprintCallable, Category = "View")
    void EnableDelayedUpdate(bool bEnabled);

    UFUNCTION(BlueprintCallable, Category = "ViewScripting")
    UCoherentUIGTJSEvent* CreateJSEvent();

    UFUNCTION(BlueprintCallable, Category = "ViewScripting")
    void TriggerJSEvent(const FString& name, UCoherentUIGTJSEvent* eventData) const;

    UFUNCTION(BlueprintCallable, Category = "ViewScripting")
    void CreateDataModelFromObject(const FString& Name, UObject* Model);

    // COH_BACKWARD_COMPATIBLE_BLOCK_START
    UFUNCTION(BlueprintCallable, CustomThunk, meta = (CustomStructureParam = "Arg"), Category = "ViewScripting")
    void CreateDataModelFromStruct(const FString& Name, const TFieldPath<FStructProperty> Arg);

    UFUNCTION(BlueprintCallable, CustomThunk, meta = (CustomStructureParam = "Arg"), Category = "ViewScripting")
    void UpdateWholeDataModelFromStruct(const TFieldPath<FStructProperty> Arg) const;
    // COH_BACKWARD_COMPATIBLE_BLOCK_END

    UFUNCTION(BlueprintCallable, Category = "ViewScripting")
    void UpdateWholeDataModelFromObject(UObject* Model) const;

    UFUNCTION(BlueprintCallable, Category = "ViewScripting")
    void SynchronizeModels() const;

    //UFUNCTION(BlueprintCallable, Category = "Audio") TODO: FIXME!
    void SetSoundAttenuation(const FAttenuationSettingsClass& settings);

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "ViewWarnings")
    bool AllowPerformanceWarnings;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "ViewWarnings", meta = (ClampMin = "0", UIMin = "0", UIMax = "100"))
    float ExecuteJSTimersThresholdMs;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "ViewWarnings", meta = (ClampMin = "0", UIMin = "0", UIMax = "100"))
    float UpdateStylesAndLayoutThresholdMs;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "ViewWarnings", meta = (ClampMin = "0", UIMin = "0", UIMax = "100"))
    float RecordRenderingCommandsThresholdMs;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "ViewWarnings", meta = (ClampMin = "0", UIMin = "0", UIMax = "100"))
    float PaintWarningThresholdMs;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "ViewWarnings", meta = (ClampMin = "0", UIMin = "0", UIMax = "200"))
    int32 LayersCountThreshold;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "ViewWarnings", meta = (ClampMin = "0", UIMin = "128", UIMax = "8192"))
    int32 LayerWidthThreshold;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "ViewWarnings", meta = (ClampMin = "0", UIMin = "128", UIMax = "8192"))
    int32 LayerHeightThreshold;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "View")
    bool bEnableAdditionalDefaultStyles;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "View")
    bool bDelayedUpdate;

    DECLARE_DELEGATE_RetVal(TUniquePtr<FCohComponentViewState>, FOnViewStateAdoption);
    FOnViewStateAdoption OnViewStateAdoption;

    DECLARE_DELEGATE_OneParam(FOnViewStatePostAdoption, const TUniquePtr<FCohComponentViewState>&);
    FOnViewStatePostAdoption OnViewStatePostAdoption;

    DECLARE_DELEGATE_OneParam(FOnViewStatePutForAdoption, TUniquePtr<FCohComponentViewState>&);
    FOnViewStatePutForAdoption OnViewStatePutForAdoption;

    EMouseCursor::Type CurrentMouseCursor;

    Coherent::UIGT::View* GetView() const;
    static void CreateSystemIfNecessary(UWorld* World);
    static class ACoherentUIGTSystem* GetSystemActor(UWorld* World);

    virtual ~UCoherentUIGTBaseComponent();
    virtual void InitializeComponent() override;
    virtual void BeginDestroy() override;
    virtual bool IsReadyForFinishDestroy() override;
    virtual void FinishDestroy() override;

    virtual void TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction *ThisTickFunction) override;
    void IssueMouseOnUIQuery(float normX, float normY);

    bool EnsureMeshData();
    TArray<FCoherentUIGTMeshData> MeshData;

    const FCaretRect& GetCaretRect() const;
    void SetCaretRect(int x, int y, unsigned width, unsigned height);

    typedef TArray<TWeakObjectPtr<UCoherentUIGTBaseComponent>> WeakCoherentUIGTComponentsArray;
    static WeakCoherentUIGTComponentsArray::TIterator GetUCoherentUIGTBaseComponentIterator(UWorld* world);

    Coherent::UIGT::ViewRenderer* GetViewRenderer() const;

    bool bWasMouseOnUILastFrame;

protected:
    void CreateView(const Coherent::UIGT::ViewInfo& info, const FString& url, bool PaintToBackBuffer = false);
    ListenerPtr Listener;
    RenderWrapperPtr RenderWrapper;

private:
    friend class TCoherentUIGTViewListener<UCoherentUIGTBaseComponent>;

    void SetReadyForBindings();
    void OnCallback(const char* eventName, const Coherent::UIGT::EventArguments& arguments);

    void OnLiveViewSizeRequested(const FString& name, int32& width, int32& height);
    void OnLiveViewActivate(const FString& name, bool active);
    void OnCursorChanged(Coherent::UIGT::CursorType Cursor);

    void OnAudioStreamCreated(int id, int bitDepth, int channels,
        float samplingRate);
    void OnAudioStreamClosed(int id);
    void OnAudioStreamPlay(int id);
    void OnAudioStreamPause(int id);
    void OnAudioDataReceived(int id, int samples, float** pcm,
        int channels);
    void OnAudioStreamEnded(int id);

    UPROPERTY(Transient)
    UCoherentUIGTAudioWrapper* AudioWrapper;

    FCaretRect CaretRect;
    ACoherentUIGTSystem* SystemActor;
    Coherent::UIGT::UISystemRenderer* SystemRenderer;

    bool bIsLoadingMeshData;

#if defined(COHERENT_UI_GT_UE4_413_SUPPORT)
    bool bHasMeshData;
#else
    FThreadSafeBool bHasMeshData;
#endif

    void LoadMeshData(const TArray<TWeakObjectPtr<UStaticMeshComponent>>& Meshes);

    unsigned PendingLayout;

public:
#if defined(COHERENT_UI_GT_UE4_418_SUPPORT)
    DECLARE_FUNCTION(execCreateDataModelFromStruct)
    {
        if (!IsReadyForBindings())
        {
            return;
        }
        P_GET_PROPERTY(UStrProperty, Name);

        Stack.StepCompiledIn<UStructProperty>(NULL);
        void* ArgAddress = Stack.MostRecentPropertyAddress;
        UStructProperty* Prop = Cast<UStructProperty>(Stack.MostRecentProperty);

        if (Prop)
        {
            CoherentUIGTDataBindingHelpers::CreateModel(GetView(), Name, ArgAddress, Prop->Struct);
        }
        P_FINISH;
    }

    DECLARE_FUNCTION(execUpdateWholeDataModelFromStruct)
    {
        if (!IsReadyForBindings())
        {
            return;
        }

        Stack.StepCompiledIn<UStructProperty>(NULL);
        void* ArgAddress = Stack.MostRecentPropertyAddress;
        UStructProperty* Prop = Cast<UStructProperty>(Stack.MostRecentProperty);
        CoherentUIGTDataBindingHelpers::UpdateWholeModel(GetView(), ArgAddress, Prop->Struct);
        P_FINISH;
    }
#else
    //declared here and defined in the cpp file
    DECLARE_FUNCTION(execCreateDataModelFromStruct);
    DECLARE_FUNCTION(execUpdateWholeDataModelFromStruct);
#endif
};

struct FCohComponentViewState
{
    typedef UCoherentUIGTBaseComponent::ListenerPtr ListenerPtr;
    typedef UCoherentUIGTBaseComponent::RenderWrapperPtr RenderWrapperPtr;

    ListenerPtr Listener;
    RenderWrapperPtr RenderWrapper;

    FCohComponentViewState()
    {}

    FCohComponentViewState(ListenerPtr InListener, RenderWrapperPtr InRenderWrapper)
        : Listener(InListener)
        , RenderWrapper(InRenderWrapper)
    {}

    Coherent::UIGT::View* GetView()
    {
        return RenderWrapper->GetView();
    }

    void DestroyRenderWrapper()
    {
        if (RenderWrapper.IsValid())
        {
            RenderWrapper->BeginDestroy();
            RenderWrapper->WaitForFinishDestroy();
            RenderWrapper->FinishDestroy();
        }
    }
};