UE5 Lyra中的UI层级与资产管理

最新推荐文章于 2024-04-26 16:33:52 发布
最新推荐文章于 2024-04-26 16:33:52 发布
阅读量2.7k 收藏 9
点赞数 2
分类专栏： UE5 Lary 文章标签： ui ue5 c++ Lary
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40026009/article/details/125544396
版权

一、外部接入接口：UGameUIManagerSubsystem

主要用来从GameInstance获取玩家的加入退出和销毁通知，并传入UGameUIPolicy
DefaultUIPolicyClass在DefaultGame.ini中进行配置

UPROPERTY(config, EditAnywhere)
TSoftClassPtr<UGameUIPolicy> DefaultUIPolicyClass;
void UGameUIManagerSubsystem::Initialize(FSubsystemCollectionBase& Collection)
{
   if (!CurrentPolicy && !DefaultUIPolicyClass.IsNull()){
      TSubclassOf<UGameUIPolicy> PolicyClass = DefaultUIPolicyClass.LoadSynchronous();
      SwitchToPolicy(NewObject<UGameUIPolicy>(this, PolicyClass));}
}
void UGameUIManagerSubsystem::NotifyPlayerAdded(UCommonLocalPlayer* LocalPlayer){
   if (ensure(LocalPlayer) && CurrentPolicy){
      CurrentPolicy->NotifyPlayerAdded(LocalPlayer);
   }}

void UGameUIManagerSubsystem::NotifyPlayerRemoved(UCommonLocalPlayer* LocalPlayer){
   if (LocalPlayer && CurrentPolicy){
      CurrentPolicy->NotifyPlayerRemoved(LocalPlayer);
   }}

二、对内总管：UGameUIPolicy

用来自动控制·UPrimaryGameLayout·不同情况下(主要是Player的改动)的创建与销毁
LayoutClass可以由GameUIPolicy的蓝图实例来指定

UPROPERTY(EditAnywhere)
TSoftClassPtr<UPrimaryGameLayout> LayoutClass;

void UGameUIPolicy::NotifyPlayerAdded(UCommonLocalPlayer* LocalPlayer){
   LocalPlayer->OnPlayerControllerSet.AddWeakLambda(this, [this](UCommonLocalPlayer* LocalPlayer, APlayerController* PlayerController){
      NotifyPlayerRemoved(LocalPlayer);
      if (FRootViewportLayoutInfo* LayoutInfo = RootViewportLayouts.FindByKey(LocalPlayer)){
         AddLayoutToViewport(LocalPlayer, LayoutInfo->RootLayout);
         LayoutInfo->bAddedToViewport = true;}
      else{
         CreateLayoutWidget(LocalPlayer);}
   });

   if (FRootViewportLayoutInfo* LayoutInfo = RootViewportLayouts.FindByKey(LocalPlayer)){
      AddLayoutToViewport(LocalPlayer, LayoutInfo->RootLayout);
      LayoutInfo->bAddedToViewport = true;}
   else{
      CreateLayoutWidget(LocalPlayer);
   }}
   
void UGameUIPolicy::CreateLayoutWidget(UCommonLocalPlayer* LocalPlayer)
{
   if (APlayerController* PlayerController = LocalPlayer->GetPlayerController(GetWorld())){
      TSubclassOf<UPrimaryGameLayout> LayoutWidgetClass = GetLayoutWidgetClass(LocalPlayer);
      if (ensure(LayoutWidgetClass && !LayoutWidgetClass->HasAnyClassFlags(CLASS_Abstract))){
         UPrimaryGameLayout* NewLayoutObject = CreateWidget<UPrimaryGameLayout>(PlayerController, LayoutWidgetClass);
         RootViewportLayouts.Emplace(LocalPlayer, NewLayoutObject, true);
         AddLayoutToViewport(LocalPlayer, NewLayoutObject);
      }}
}

三、Layout分层管理：UPrimaryGameLayout

作为游戏的主UI，负责对整个UI框架逻辑的管理，包括栈状态机、Layout、动态加载等。不参与布局与响应逻辑。继承自UCommonUserWidget

UPROPERTY(Transient, meta = (Categories = "UI.Layer"))
TMap<FGameplayTag, UCommonActivatableWidgetContainerBase*> Layers;

template <typename ActivatableWidgetT = UCommonActivatableWidget>
TSharedPtr<FStreamableHandle> PushWidgetToLayerStackAsync(FGameplayTag LayerName, bool bSuspendInputUntilComplete, TSoftClassPtr<UCommonActivatableWidget> ActivatableWidgetClass, TFunction<void(EAsyncWidgetLayerState, ActivatableWidgetT*)> StateFunc)
{
   static_assert(TIsDerivedFrom<ActivatableWidgetT, UCommonActivatableWidget>::IsDerived, "Only CommonActivatableWidgets can be used here");

   static FName NAME_PushingWidgetToLayer("PushingWidgetToLayer");
   const FName SuspendInputToken = bSuspendInputUntilComplete ? UCommonUIExtensions::SuspendInputForPlayer(GetOwningPlayer(), NAME_PushingWidgetToLayer) : NAME_None;

   FStreamableManager& StreamableManager = UAssetManager::Get().GetStreamableManager();
   TSharedPtr<FStreamableHandle> StreamingHandle = StreamableManager.RequestAsyncLoad(ActivatableWidgetClass.ToSoftObjectPath(), FStreamableDelegate::CreateWeakLambda(this,
      [this, LayerName, ActivatableWidgetClass, StateFunc, SuspendInputToken]()
      {
         UCommonUIExtensions::ResumeInputForPlayer(GetOwningPlayer(), SuspendInputToken);

         ActivatableWidgetT* Widget = PushWidgetToLayerStack<ActivatableWidgetT>(LayerName, ActivatableWidgetClass.Get(), [StateFunc](ActivatableWidgetT& WidgetToInit) {
            StateFunc(EAsyncWidgetLayerState::Initialize, &WidgetToInit);
         });

         StateFunc(EAsyncWidgetLayerState::AfterPush, Widget);
      })
   );

   // Setup a cancel delegate so that we can resume input if this handler is canceled.
   StreamingHandle->BindCancelDelegate(FStreamableDelegate::CreateWeakLambda(this,
      [this, StateFunc, SuspendInputToken]()
      {
         UCommonUIExtensions::ResumeInputForPlayer(GetOwningPlayer(), SuspendInputToken);
         StateFunc(EAsyncWidgetLayerState::Canceled, nullptr);
      })
   );

   return StreamingHandle;
}
template <typename ActivatableWidgetT = UCommonActivatableWidget>
ActivatableWidgetT* PushWidgetToLayerStack(FGameplayTag LayerName, UClass* ActivatableWidgetClass, TFunctionRef<void(ActivatableWidgetT&)> InitInstanceFunc)
{
   static_assert(TIsDerivedFrom<ActivatableWidgetT, UCommonActivatableWidget>::IsDerived, "Only CommonActivatableWidgets can be used here");

   if (UCommonActivatableWidgetContainerBase* Layer = GetLayerWidget(LayerName))
   {
      return Layer->AddWidget<ActivatableWidgetT>(ActivatableWidgetClass, InitInstanceFunc);
   }

   return nullptr;
}

void UPrimaryGameLayout::RegisterLayer(FGameplayTag LayerTag, UCommonActivatableWidgetContainerBase* LayerWidget)
{
   if (!IsDesignTime()){
      //过渡相关
      LayerWidget->OnTransitioningChanged.AddUObject(this, &UPrimaryGameLayout::OnWidgetStackTransitioning);
      LayerWidget->SetTransitionDuration(0.0);
      
      Layers.Add(LayerTag, LayerWidget);}
}

bSuspendInputUntilComplete：在ui加载完成前暂停布局，防止玩家按下delete等误操作
RegisterLayer注册新的LayerWidget容器到PrimaryWidget中，并将Tag作为Key
在这里插入图片描述

PushWidgetToLayerStackAsync将UCommonActivatableWidget异步载入后推入对应Tag的UCommonActivatableWidgetContainerBase容器(目前是Stack)中
蓝图节点中与之对应的Task：PushContentTolayerForPlayer
在这里插入图片描述

由此，实现了UI的动态加载以及层级显示问题
蓝图实例W_OverallUILayout
仅用于确定层级和Layer注册
在这里插入图片描述
在这里插入图片描述

四、Widget管理容器：UCommonActivatableWidgetContainerBase

Widget基础容器、Layout层级管理来使用一个Container就是一层Layout，而不再使用优先级
继承自UWidget，不参与布局与响应逻辑。

所有参数：
UPROPERTY(Transient)
TArray<UCommonActivatableWidget*> WidgetList;
UPROPERTY(Transient)
FUserWidgetPool GeneratedWidgetsPool;
UPROPERTY(Transient)
UCommonActivatableWidget* DisplayedWidget;

TSharedPtr<SCommonAnimatedSwitcher> MySwitcher;
TSharedPtr<SOverlay> MyOverlay;
TSharedPtr<SSpacer> MyInputGuard;

UPROPERTY(EditAnywhere, Category = Transition)
ECommonSwitcherTransition TransitionType;
UPROPERTY(EditAnywhere, Category = Transition)
ETransitionCurve TransitionCurveType;
UPROPERTY(EditAnywhere, Category = Transition)
float TransitionDuration = 0.4f;
  1. 容器WidgetList、GeneratedWidgetsPool与DisplayedWidget
    WidgetList：存储激活的Widget
    GeneratedWidgetsPool：存储整个Widget池并负责Widget的动态创建与销毁，DisplayedWidget受MySwitcher确定当前顶层的Widget
  2. UI布局
    MySwitcher：储存并显示位于顶部的SWidget，其在变化时会更新DisplayedWidget为对应的Widget
    MyOverlay：UI的顶层布局
    MyInputGuard：布局的一部分，没有细看
  3. 过渡动画参数
    不表

AddWidget

template <typename ActivatableWidgetT = UCommonActivatableWidget>
ActivatableWidgetT* AddWidget(TSubclassOf<UCommonActivatableWidget> ActivatableWidgetClass)
{
   // Don't actually add the widget if the cast will fail
   if (ActivatableWidgetClass && ActivatableWidgetClass->IsChildOf<ActivatableWidgetT>()){
      return Cast<ActivatableWidgetT>(AddWidgetInternal(ActivatableWidgetClass, [](UCommonActivatableWidget&) {}));
   }
   return nullptr;
}
UCommonActivatableWidget* UCommonActivatableWidgetContainerBase::AddWidgetInternal(TSubclassOf<UCommonActivatableWidget> ActivatableWidgetClass, TFunctionRef<void(UCommonActivatableWidget&)> InitFunc)
{
   if (UCommonActivatableWidget* WidgetInstance = GeneratedWidgetsPool.GetOrCreateInstance(ActivatableWidgetClass)){
      InitFunc(*WidgetInstance);
      RegisterInstanceInternal(*WidgetInstance);
      return WidgetInstance;
   }
   return nullptr;
}
void UCommonActivatableWidgetContainerBase::RegisterInstanceInternal(UCommonActivatableWidget& NewWidget)
{
   if (ensure(!WidgetList.Contains(&NewWidget))){
      WidgetList.Add(&NewWidget);
      OnWidgetAddedToList(NewWidget);
}}
void UCommonActivatableWidgetStack::OnWidgetAddedToList(UCommonActivatableWidget& AddedWidget)
{
  unimplamentation();
}}

首先创建(已有则略过)并添加Widget的实例到GeneratedWidgetsPool中，然后注册进WidgetList中。
可以看到，GeneratedWidgetsPool和WidgetList都仅仅是用于存储Widget本体与其对应SWidget的容器，都无法控制容器中Widget的显示与隐藏。所以在这里Widget仅仅是进入了容器，但对Widget的进一步处理被设置为unimplamentation.
GeneratedWidgetsPool仅仅传入的参数仅仅是Class，如果有多个实例的话不确定会返回哪一个，详情请看GeneratedWidgetsPool

RemoveWidget

void UCommonActivatableWidgetContainerBase::RemoveWidget(UCommonActivatableWidget& WidgetToRemove)
{
   if (&WidgetToRemove == GetActiveWidget()){
      // To remove the active widget, just deactivate it (if it's already deactivated, then we're already in the process of ditching it)
      if (WidgetToRemove.IsActivated()){
         WidgetToRemove.DeactivateWidget();}
      else{
         bRemoveDisplayedWidgetPostTransition = true;
      }}
   else{
      // Otherwise if the widget isn't actually being shown right now, yank it right on out
      TSharedPtr<SWidget> CachedWidget = WidgetToRemove.GetCachedWidget();
      if (CachedWidget && MySwitcher){
         ReleaseWidget(CachedWidget.ToSharedRef());
      }}
}
void UCommonActivatableWidgetContainerBase::ReleaseWidget(const TSharedRef<SWidget>& WidgetToRelease)
{
   if (UCommonActivatableWidget* ActivatableWidget = ActivatableWidgetFromSlate(WidgetToRelease)){
      GeneratedWidgetsPool.Release(ActivatableWidget, true);
      WidgetList.Remove(ActivatableWidget);}
   if (MySwitcher->RemoveSlot(WidgetToRelease) != INDEX_NONE){
      ReleasedWidgets.Add(WidgetToRelease);
      if (ReleasedWidgets.Num() == 1){
         FTSTicker::GetCoreTicker().AddTicker(FTickerDelegate::CreateWeakLambda(this,
            [this](float){
               QUICK_SCOPE_CYCLE_COUNTER(STAT_UCommonActivatableWidgetContainerBase_ReleaseWidget);
               ReleasedWidgets.Reset();
               return false;
            }));}}
}
void UCommonActivatableWidgetContainerBase::HandleActiveWidgetDeactivated(UCommonActivatableWidget* DeactivatedWidget)
{
   if (ensure(DeactivatedWidget == DisplayedWidget) && MySwitcher && MySwitcher->GetActiveWidgetIndex() > 0){
      DisplayedWidget->OnDeactivated().RemoveAll(this);
      MySwitcher->TransitionToIndex(MySwitcher->GetActiveWidgetIndex() - 1);
   }
}

void UCommonActivatableWidgetContainerBase::HandleActiveIndexChanged(int32 ActiveWidgetIndex)
{
   // 1
   while (MySwitcher->GetNumWidgets() - 1 > ActiveWidgetIndex){
      TSharedPtr<SWidget> WidgetToRelease = MySwitcher->GetWidget(MySwitcher->GetNumWidgets() - 1);
      if (ensure(WidgetToRelease)){
         ReleaseWidget(WidgetToRelease.ToSharedRef());
      }}

   //2. Also remove the widget that we just transitioned away from if desired
   if (DisplayedWidget && bRemoveDisplayedWidgetPostTransition)
   {
      if (TSharedPtr<SWidget> DisplayedSlateWidget = DisplayedWidget->GetCachedWidget())
      {
         ReleaseWidget(DisplayedSlateWidget.ToSharedRef());
      }
   }
   bRemoveDisplayedWidgetPostTransition = false;

   // Activate the widget that's now being displayed
   DisplayedWidget = ActivatableWidgetFromSlate(MySwitcher->GetActiveWidget());
   if (DisplayedWidget)
   {
      SetVisibility(ESlateVisibility::SelfHitTestInvisible);

      DisplayedWidget->OnDeactivated().AddUObject(this, &UCommonActivatableWidgetContainerBase::HandleActiveWidgetDeactivated, DisplayedWidget);
      DisplayedWidget->ActivateWidget();

      if (UWorld* MyWorld = GetWorld())
      {
         FTimerManager& TimerManager = MyWorld->GetTimerManager();
         TimerManager.SetTimerForNextTick(FSimpleDelegate::CreateWeakLambda(this, [this]() { InvalidateLayoutAndVolatility(); }));
      }
   }
   else
   {
      SetVisibility(ESlateVisibility::Collapsed);
   }

   OnDisplayedWidgetChanged().Broadcast(DisplayedWidget);
}
  • 如果是正在激活的,则根据是否是可激活执行取消激活或者标记关闭。否则进行Release，将Widget从GeneratedWidgetsPool和WidgetList移除，并从MySwitcher中进行移除，最后将该Widget对应的的SWidget扔进ReleasedWidgets中。
  • MySwitcher决定了Widget的显示层级。添加时并没有规定进入MySwitcher的方式，而不管什么方式进入MySwitcher的，移除的时候都一样。
    Release时将MySwitcher的ActiveIndex设置为其所在的下一层，而**TransitionToIndex()**会执行绑定的HandleActiveIndexChanged。

HandleActiveIndexChanged：

  1. 将当前激活Index之上的Widget都Deactive
  2. 如果需要的话我们也release刚刚显示的Widget?(需要查看别的地方)
  3. 激活现在在MySwitcher中激活的Widget。这里对DisplayedWidget进行了赋值

ClearWidget

void UCommonActivatableWidgetContainerBase::ClearWidgets()
{
   SetSwitcherIndex(0);
}
void UCommonActivatableWidgetContainerBase::SetSwitcherIndex(int32 TargetIndex, bool bInstantTransition /*= false*/)
{
if (MySwitcher && MySwitcher->GetActiveWidgetIndex() != TargetIndex){
   if (DisplayedWidget){
      DisplayedWidget->OnDeactivated().RemoveAll(this);
      if (DisplayedWidget->IsActivated()){
         DisplayedWidget->DeactivateWidget();
      }
      else if (MySwitcher->GetActiveWidgetIndex() != 0)
      {
         // The displayed widget has already been deactivated by something other than us, so it should be removed from the container
         // We still need it to remain briefly though until we transition to the new index - then we can remove this entry's slot
         bRemoveDisplayedWidgetPostTransition = true;
      }
   }

   MySwitcher->TransitionToIndex(TargetIndex, bInstantTransition);
}
}

首先将正在激活的Widget关闭，然后设置MySwitcher的Index为0。

GetActiveWidget

UCommonActivatableWidget* UCommonActivatableWidgetContainerBase::GetActiveWidget() const
{
   return MySwitcher ? ActivatableWidgetFromSlate(MySwitcher->GetActiveWidget()) : nullptr;
}

返回MySwitcher的ActiveWidget，而不是自己存储的DisplayedWidget
可以看出显示的主导在于MySwitcher而不是另外两个容器

UCommonActivatableWidgetStack

将进入MySwitcher的方式设置为栈
给栈提供了一个RootWidget

UPROPERTY(EditAnywhere, Category = Content)
TSubclassOf<UCommonActivatableWidget> RootContentWidgetClass;
UPROPERTY(Transient)
UCommonActivatableWidget* RootContentWidget;

void UCommonActivatableWidgetStack::SynchronizeProperties()
{
   Super::SynchronizeProperties();
   
#if WITH_EDITOR
   if (IsDesignTime() && RootContentWidget && RootContentWidget->GetClass() != RootContentWidgetClass){
      // At design time, account for the possibility of the preview class changing
      if (RootContentWidget->GetCachedWidget()){
         MySwitcher->GetChildSlot(0)->DetachWidget();}

      RootContentWidget = nullptr;}
#endif

   if (!RootContentWidget && RootContentWidgetClass){
      // Establish the root content as the blank 0th slot content
      RootContentWidget = CreateWidget<UCommonActivatableWidget>(this, RootContentWidgetClass);
      MySwitcher->GetChildSlot(0)->AttachWidget(RootContentWidget->TakeWidget());
      SetVisibility(ESlateVisibility::SelfHitTestInvisible);
   }
}

void UCommonActivatableWidgetStack::OnWidgetAddedToList(UCommonActivatableWidget& AddedWidget)
{
   if (MySwitcher){
      MySwitcher->AddSlot() [AddedWidget.TakeWidget()];
      SetSwitcherIndex(MySwitcher->GetNumWidgets() - 1);
   }
}

SynchronizeProperties：
编辑器下如果RootContentWidget与RootContentWidgetClass的类型不同，直接Detach，见英文注释
如果当前还没有RootContentWidget则创建并放置到MySwitcher的首位
OnWidgetAddedToList：
实现基类没有处理的添加到MySwitcher问题，直接将Widget放入，并设置SwitcherIndex为新放入的Widget

UCommonActivatableWidgetQueue

将Widget进入MySwitcher的方式设置为队列

void UCommonActivatableWidgetQueue::OnWidgetAddedToList(UCommonActivatableWidget& AddedWidget)
{
   if (MySwitcher){
      // Insert after the empty slot 0 and before the already queued widgets
      MySwitcher->AddSlot(1) [AddedWidget.TakeWidget()];

      if (MySwitcher->GetNumWidgets() == 2)
      {
         // The queue was empty, so we'll show this one immediately
         SetSwitcherIndex(1);
      }
      else if (DisplayedWidget && !DisplayedWidget->IsActivated() && MySwitcher->GetNumWidgets() == 3)
      {
         //The displayed widget is on its way out and we should not be going to 0 anymore, we should go to the new one
         SetSwitcherIndex(1, true); //and get there fast, we need to finish and evict the old widget before anything else happens
      }

   }
}

将Widget插入到index1(index0一直为空)，如果之前队列为空则直接显示，之前队列还存在一个但已经Deactive也可以直接显示

总结：

该容器一方面负责了Widget的创建与缓存，另一方面也使用Switch来对容器中UI的显示进行了控制。位于Switch顶层的UI则显示，保证了容器中UI是互斥的，而Pool保证了UI在被Switch移除且Deactive后不被销毁。
而Widget加入时并没有确定进入Switch的方式，而将其放入了子类中实现。
Stack与Queue分别定义了两种进入Switch的方式

五、Widget池：FUserWidgetPool

一个管理Widget创建与销毁的池，主要用Active和Deactive池来存储不同状态下的Widget
细节以后再看

六、用于管理Widget显示的UI：SCommonAnimatedSwitcher

一个实现了过渡动画的SwitcherUI，不表

卅秋
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
UE5 官方案例LyraStarter 全特性详解 0.专栏介绍
CloudHuCoding
06-24 1732
随着`UE5`的正式推出,伴随而来非常多的新特性,这些新特性不仅仅对美术有很大的帮助,对于程序员来说也大有裨益.官方一直致力于推广这些新特性,因此制作出了`LyraStarter`这个案例,想要将所有的特性囊括其中,从而帮助开发者更好地掌握引擎的使用,将`UE5`应用到极致. 本专栏可以辅助大家更好的掌握这些新特性,毕竟官方的精力是有限的,一方面要做引擎研发和开发者服务,另一方面还要做堡垒之夜和Epic Games平台,所以很难细致入微地把所有的新功能教会大家.......
Lyra：Lyra是Laravel的管理面板，用于引导您的应用并将想法变为现实
02-01
Lyra是使用Laravel创建的应用程序的管理面板 使用Lyra，您可以管理项目的数据库，这是通过为每个应用程序的Eloquent模型定义资源来实现的。 有一个在线演示。 现在就试试！ 文献资料 要查看文档并尝试演示，请访问...
UE4 UI界面的层级切换
weixin_42399500的博客
04-10 4440
官方项目《内容示例》中Common UI部分笔记：Common UI 分场景使用教程
开发游戏的老王
09-05 1379
Common UI给虚幻的UI系统带来了很多新特性，这些新特性往往面向不同的使用场景。目前我看到很多的Common UI教程，都是把这些特性很笼统地展示一遍，这就很容易造成初学者的困惑：“我当前做的这些工作，到底是为了实现什么？”所以本文采用分场景介绍的方式，希望能够帮初学者理清一下Common UI的工作逻辑。
UE5中简易的UI管理框架（c++版，UE5.1）
u010804261的博客
03-22 874
基于此需求，采用栈先进后出的数据接口，编写了一个简易的UI管理框架。1.支持UI的自动创建2.支持UI的按开启顺序关闭3.支持一件关闭所有UI4.支持开启当前UI后，禁用上一个UI的操作5.管理类继承自AActor类，所以支持在面板配置UI信息1.OpenUI：通过传入自定义的UI名来生成UI，如果hideLastUI为true，则隐藏上一个UI，否则，上一个UI继续显示2.CloseUI：关闭当前UI3.CloseAllUI：关闭生成的所有UI。
Google开源低位元率音讯编解码器Lyra 源码
04-15
Lyra源码
【UE4从零开始 021】控件类型介绍
本是后山人
08-19 2713
1、Common 选项 说明 边框（Border） 边框是容器控件，可以包含一个子控件，提供使用边框图像和可调节的填补将其包围起来的机会。 按钮（Button） 按钮是单子项、可点击的Primitive控件，它可实现基本交互。你可将任何其他控件放入按钮控件中，以在UI中创建一个更复杂且有趣的可点击元素。 复选框（Check Box） 借助复选框（Check Box）控件，...
UI层级分层
u014589770的博客
07-08 1002
方法一： 添加Canvas组件，勾选 Override Sorting 覆盖父物体对其的层级设置，用Sort Order来设定层级 缺点：增加了draw call 方法二： 使用SetSiblingIndex transform.SetSiblingIndex(index); 注意：SetSiblingIndex时，如果已存在相同的index时，则另外的index会被改变 ...
UE5 CommonUI初学笔记
c2146788的博客
02-21 1811
UE5CommonUI插件的初学内容
【Lyra UI】UI 玩法逻辑小结
游戏编程扯淡精粹
10-14 1702
UI 这块分两个部分：功能版逻辑 + 材质效果本篇讨论逻辑，即怎么组织UI结构，代码怎么串联事件和逻辑笔者之前并没有用UE开发过游戏，也算是从零开始，所以并不保证完整性和准确性。
UE4 C++ UMG框架搭建
qq_43021038的博客
07-15 3138
在我们使用UMG的过程中经常遇到控制UI的显示和隐藏，往往我们都会使用UI显示和隐藏，今天叫大家使用C++模块化UMG，可以灵活地控制UMG的显示和隐藏。创建C++接口interface命名为StateInterface。三、C++创建UserWidget命名为BaseStateWidget。五、创建UMG继承自刚刚创建的BaseStateWidget。四、C++创建Actor命名为UIStateManager。在C++里面写两个接口。继承接口，重写虚函数。......
Lyra-website:这是带有Lyra软件包演示的网站
04-30
Lyra是使用Laravel创建的应用程序的管理面板 使用Lyra，您可以管理项目的数据库，这是通过为每个应用程序的Eloquent模型定义资源来实现的。 有一个在线演示。 现在就试试！ 文献资料 要查看文档并尝试演示，请访问...
Google开源低位元率音讯编解码器Lyra 安卓APP lyra_android_example.apk
04-15
Google开源低位元率音讯编解码器Lyra 安卓APP lyra_android_example.apk，已完成编译，免去自己编译的烦恼
lyra说明书
10-12
lyra说明书,用户手册，关于录音室专业声卡的用户手册，全英文版的
鸿蒙开发（九）UI实战 - 线性布局实现登录界面
zhaojun的博客
04-26 502
前面我们花了很多章去讲述鸿蒙开发的UI，包括布局和控件等。本篇，我们综合使用布局和控件，完成一个简单的用户登录界面。
element-ui et -i 编译默认主题报错：ReferenceError: primordials is not defined
weixin_44799030的博客
04-24 177
看了好几个帖子，都推荐使用node 11.15.0版本（推荐用nvm包管理，非常方便）用哪个node版本下载的就用node版本卸载，否则很可能出现问题。我使用的是node 14版本。
Avalonia UI跨平台WPF
最新发布
qq_38190993的博客
04-26 162
它使用自己的渲染引擎绘制UI控件，确保在Windows、macOS、Linux、Android、iOS和WebAssembly等不同平台上具有一致的外观和行为。Avalonia是一个强大的框架，使开发人员能够使用.NET创建跨平台应用程序。
【VUE】解决 Element UI 中 el-tab 切换时 ECharts 渲染宽度问题
九日的博客
04-24 470
由于在 Tab 未激活状态下，图表的容器处于隐藏状态，ECharts 无法准确获取到其容器的尺寸，从而导致渲染错误。首先，最直接的方法是监听 Tab 切换事件，在 Tab 被激活时初始化或者重新渲染图表。另一种简易的解决方式是在 CSS 中直接为 ECharts 图表的容器设置一个固定宽度，这样即使在 Tab 未激活时，图表的容器也已经有了确定的尺寸。通过上述方法，不论是前端新手还是经验丰富的开发者，应该都能找到一种适合自己项目需求的解决方案，从而优化 ECharts 在 Element UI 的。
ue5 lyra下载
02-01
ue5 lyra是一个声音预训练模型库，可以用于合成和处理人类语音。通过ue5 lyra，用户可以轻松地创建自然、逼真的语音合成，并且可以对声音进行更高效的处理和编辑。 对于ue5 lyra的下载，用户可以通过官方网站或者相关的软件平台进行下载。在下载之前，用户需要确认自己的设备是否符合ue5 lyra的系统要求，以及是否有足够的存储空间来安装这个模型库。 一旦下载完成，用户就可以开始在自己的项目或者应用中使用ue5 lyra。通过与其他软件和工具的整合，用户可以更加方便地使用ue5 lyra来改善其声音处理和语音合成的效果。并且，ue5 lyra提供了丰富的API和文档，方便用户在使用过程中得到帮助和支持。 总的来说，ue5 lyra的下载对于有声音处理和语音合成需求的用户来说是非常有益的。它的下载和使用都相对简单，用户只需要遵循相关指引就可以轻松地获得这个模型库，并开始发挥其强大的功能。UE5 Lyra是一个非常有用的工具，可用于各种应用程序和项目中，帮助用户改善音频处理和语音合成的效果。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值