UE4 Slate的语法初步分析

最新推荐文章于 2024-05-27 22:38:41 发布
最新推荐文章于 2024-05-27 22:38:41 发布
阅读量1.1k 收藏 3
点赞数 1
文章标签： ue4
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/l474013263/article/details/121779107
版权

我们用一个具体的Slate的例子来分析语法.

首先我们新建个EditorStandaloneWindow类型的插件,命名为PlantMonster,在PlantMonster.cpp中有一个TSharedRef FPlantMonsterModule::OnSpawnPluginTab(const FSpawnTabArgs& SpawnTabArgs)的方法.方法中使用了 SNew(SDockTab) 宏. 准备工作结束,下面我们一步一步开始分析.

  1. 首先我们对 SDockTab.h 中出现的宏来分析.
    ① SLATE_BEGIN_ARGS 宏替换后如下
    `
/**
 * Widget authors can use SLATE_BEGIN_ARGS and SLATE_END_ARS to add support
 * for widget construction via SNew and SAssignNew.
 * e.g.
 * 
 *    SLATE_BEGIN_ARGS( SMyWidget )
 *         , _PreferredWidth( 150.0f )
 *         , _ForegroundColor( FLinearColor::White )
 *         {}
 *
 *         SLATE_ATTRIBUTE(float, PreferredWidth)
 *         SLATE_ATTRIBUTE(FSlateColor, ForegroundColor)
 *    SLATE_END_ARGS()
 */
#define SLATE_BEGIN_ARGS( SDockTab) \
	public: \
	struct FArguments : public TSlateBaseNamedArgs<SDockTab> \
	{ \
		typedef FArguments FArguments; \
		FORCENOINLINE FArguments()`

这个宏,在 SDockTab 类中,声明了一个嵌套类(资料:https://blog.csdn.net/Poo_Chai/article/details/91596538 https://blog.csdn.net/liyuanbhu/article/details/43897979 )FArguments,
这个 FArguments 类,继承模板类 TSlateBaseNamedArgs,具体类型后TSlateBaseNamedArgs定义如下

/** Base class for named arguments. Provides settings necessary for all widgets. */
template<typename SDockTab>
struct TSlateBaseNamedArgs
{
	TSlateBaseNamedArgs()
	: _ToolTipText()
	, _ToolTip()
	, _Cursor( TOptional<EMouseCursor::Type>() )
	, _IsEnabled( true )
	, _Visibility( EVisibility::Visible )
	, _RenderOpacity(1.0f)
	, _ForceVolatile( false )
	, _Clipping( EWidgetClipping::Inherit )
	, _FlowDirectionPreference( EFlowDirectionPreference::Inherit )
	, _RenderTransform( )
	, _RenderTransformPivot( FVector2D::ZeroVector )
	, _AccessibleParams()
	, _AccessibleText()
	{
	}

	/** Used by the named argument pattern as a safe way to 'return *this' for call-chaining purposes. */
	SDockTab::FArguments& Me()
	{
		return *(static_cast<SDockTab::FArguments*>(this));
	}

	/** Add metadata to this widget. */
	SDockTab::FArguments& AddMetaData(TSharedRef<ISlateMetaData> InMetaData)
	{
		MetaData.Add(InMetaData);
		return Me();
	}

	/** Add metadata to this widget - convenience method - 1 argument */
	template<typename MetaDataType, typename Arg0Type>
	SDockTab::FArguments& AddMetaData(Arg0Type InArg0)
	{
		MetaData.Add(MakeShared<MetaDataType>(InArg0));
		return Me();
	}

	/** Add metadata to this widget - convenience method - 2 arguments */
	template<typename MetaDataType, typename Arg0Type, typename Arg1Type>
	SDockTab::FArguments& AddMetaData(Arg0Type InArg0, Arg1Type InArg1)
	{
		MetaData.Add(MakeShared<MetaDataType>(InArg0, InArg1));
		return Me();
	}

	SLATE_ATTRIBUTE( FText, ToolTipText )
	SLATE_ARGUMENT( TSharedPtr<IToolTip>, ToolTip )
	SLATE_ATTRIBUTE( TOptional<EMouseCursor::Type>, Cursor )
	SLATE_ATTRIBUTE( bool, IsEnabled )
	SLATE_ATTRIBUTE( EVisibility, Visibility )
	SLATE_ARGUMENT( float, RenderOpacity )
	SLATE_ARGUMENT( bool, ForceVolatile )
	SLATE_ARGUMENT( EWidgetClipping, Clipping )
	SLATE_ARGUMENT( EFlowDirectionPreference, FlowDirectionPreference)
	SLATE_ATTRIBUTE( TOptional<FSlateRenderTransform>, RenderTransform )
	SLATE_ATTRIBUTE( FVector2D, RenderTransformPivot )
	SLATE_ARGUMENT( FName, Tag )
	SLATE_ARGUMENT(TOptional<FAccessibleWidgetData>, AccessibleParams)
	SLATE_ATTRIBUTE(FText, AccessibleText)

	TArray<TSharedRef<ISlateMetaData>> MetaData;
};

下面分析 TSlateBaseNamedArgs(FArguments的父类) 类中的SLATE_ATTRIBUTE 宏 ,其中一个例子
SLATE_ATTRIBUTE( FText, ToolTipText ) 其宏替换后的结果如下:

/**
 * Use this macro to add a attribute to the declaration of your widget.
 * An attribute can be a value or a function.
 */
#define SLATE_ATTRIBUTE( FText, ToolTipText ) \
		TAttribute< FText > _ToolTipText; \
		SDockTab::FArguments& ToolTipText( const TAttribute< FText >& InAttribute ) \
		{ \
			_ToolTipText = InAttribute; \
			return this->Me(); \
		} \
	\
		/* Bind attribute with delegate to a global function
		 * NOTE: We use a template here to avoid 'typename' issues when hosting attributes inside templated classes */ \
		template< typename StaticFuncPtr > \
		SDockTab::FArguments& ToolTipText_Static( StaticFuncPtr InFunc )	\
		{ \
			_ToolTipText = TAttribute< FText >::Create( TAttribute< FText >::FGetter::CreateStatic( InFunc ) ); \
			return this->Me(); \
		} \
		template< typename Var1Type > \
		SDockTab::FArguments& ToolTipText_Static( typename TAttribute< FText >::FGetter::template TStaticDelegate_OneVar< Var1Type >::FFuncPtr InFunc, Var1Type Var1 )	\
		{ \
			_ToolTipText = TAttribute< FText >::Create( TAttribute< FText >::FGetter::CreateStatic( InFunc, Var1 ) ); \
			return this->Me(); \
		} \
		template< typename Var1Type, typename Var2Type > \
		SDockTab::FArguments& ToolTipText_Static( typename TAttribute< FText >::FGetter::template TStaticDelegate_TwoVars< Var1Type, Var2Type >::FFuncPtr InFunc, Var1Type Var1, Var2Type Var2 )	\
		{ \
			_ToolTipText = TAttribute< FText >::Create( TAttribute< FText >::FGetter::CreateStatic( InFunc, Var1, Var2 ) ); \
			return this->Me(); \
		} \
		template< typename Var1Type, typename Var2Type, typename Var3Type > \
		SDockTab::FArguments& ToolTipText_Static( typename TAttribute< FText >::FGetter::template TStaticDelegate_ThreeVars< Var1Type, Var2Type, Var3Type >::FFuncPtr InFunc, Var1Type Var1, Var2Type Var2, Var3Type Var3 )	\
		{ \
			_ToolTipText = TAttribute< FText >::Create( TAttribute< FText >::FGetter::CreateStatic( InFunc, Var1, Var2, Var3 ) ); \
			return this->Me(); \
		} \
		template< typename Var1Type, typename Var2Type, typename Var3Type, typename Var4Type > \
		SDockTab::FArguments& ToolTipText_Static( typename TAttribute< FText >::FGetter::template TStaticDelegate_FourVars< Var1Type, Var2Type, Var3Type, Var4Type >::FFuncPtr InFunc, Var1Type Var1, Var2Type Var2, Var3Type Var3, Var4Type Var4 )	\
		{ \
			_ToolTipText = TAttribute< FText >::Create( TAttribute< FText >::FGetter::CreateStatic( InFunc, Var1, Var2, Var3, Var4 ) ); \
			return this->Me(); \
		} \
	\
		/* Bind attribute with delegate to a lambda
		 * technically this works for any functor types, but lambdas are the primary use case */ \
		SDockTab::FArguments& ToolTipText_Lambda(TFunction< FText(void) >&& InFunctor) \
		{ \
			_ToolTipText = TAttribute< FText >::Create(Forward<TFunction< FText(void) >>(InFunctor)); \
			return this->Me(); \
		} \
	\
		/* Bind attribute with delegate to a raw C++ class method */ \
		template< class UserClass >	\
		SDockTab::FArguments& ToolTipText_Raw( UserClass* InUserObject, typename TAttribute< FText >::FGetter::template TRawMethodDelegate_Const< UserClass >::FMethodPtr InFunc )	\
		{ \
			_ToolTipText = TAttribute< FText >::Create( TAttribute< FText >::FGetter::CreateRaw( InUserObject, InFunc ) ); \
			return this->Me(); \
		} \
		template< class UserClass, typename Var1Type >	\
		SDockTab::FArguments& ToolTipText_Raw( UserClass* InUserObject, typename TAttribute< FText >::FGetter::template TRawMethodDelegate_OneVar_Const< UserClass, Var1Type  >::FMethodPtr InFunc, Var1Type Var1 )	\
		{ \
			_ToolTipText = TAttribute< FText >::Create( TAttribute< FText >::FGetter::CreateRaw( InUserObject, InFunc, Var1 ) ); \
			return this->Me(); \
		} \
		template< class UserClass, typename Var1Type, typename Var2Type >	\
		SDockTab::FArguments& ToolTipText_Raw( UserClass* InUserObject, typename TAttribute< FText >::FGetter::template TRawMethodDelegate_TwoVars_Const< UserClass, Var1Type, Var2Type >::FMethodPtr InFunc, Var1Type Var1, Var2Type Var2 )	\
		{ \
			_ToolTipText = TAttribute< FText >::Create( TAttribute< FText >::FGetter::CreateRaw( InUserObject, InFunc, Var1, Var2 ) ); \
			return this->Me(); \
		} \
		template< class UserClass, typename Var1Type, typename Var2Type, typename Var3Type >	\
		SDockTab::FArguments& ToolTipText_Raw( UserClass* InUserObject, typename TAttribute< FText >::FGetter::template TRawMethodDelegate_ThreeVars_Const< UserClass, Var1Type, Var2Type, Var3Type >::FMethodPtr InFunc, Var1Type Var1, Var2Type Var2, Var3Type Var3 )	\
		{ \
			_ToolTipText = TAttribute< FText >::Create( TAttribute< FText >::FGetter::CreateRaw( InUserObject, InFunc, Var1, Var2, Var3 ) ); \
			return this->Me(); \
		} \
		template< class UserClass, typename Var1Type, typename Var2Type, typename Var3Type, typename Var4Type >	\
		SDockTab::FArguments& ToolTipText_Raw( UserClass* InUserObject, typename TAttribute< FText >::FGetter::template TRawMethodDelegate_FourVars_Const< UserClass, Var1Type, Var2Type, Var3Type, Var4Type >::FMethodPtr InFunc, Var1Type Var1, Var2Type Var2, Var3Type Var3, Var4Type Var4 )	\
		{ \
			_ToolTipText = TAttribute< FText >::Create( TAttribute< FText >::FGetter::CreateRaw( InUserObject, InFunc, Var1, Var2, Var3, Var4 ) ); \
			return this->Me(); \
		} \
	\
		/* Bind attribute with delegate to a shared pointer-based class method.  Slate mostly uses shared pointers so we use an overload for this type of binding. */ \
		template< class UserClass >	\
		SDockTab::FArguments& ToolTipText( TSharedRef< UserClass > InUserObjectRef, typename TAttribute< FText >::FGetter::template TSPMethodDelegate_Const< UserClass >::FMethodPtr InFunc )	\
		{ \
			_ToolTipText = TAttribute< FText >( InUserObjectRef, InFunc ); \
			return this->Me(); \
		} \
		template< class UserClass, typename Var1Type >	\
		SDockTab::FArguments& ToolTipText( TSharedRef< UserClass > InUserObjectRef, typename TAttribute< FText >::FGetter::template TSPMethodDelegate_OneVar_Const< UserClass, Var1Type >::FMethodPtr InFunc, Var1Type Var1 )	\
		{ \
			_ToolTipText = TAttribute< FText >::Create( TAttribute< FText >::FGetter::CreateSP( InUserObjectRef, InFunc, Var1 ) ); \
			return this->Me(); \
		} \
		template< class UserClass, typename Var1Type, typename Var2Type >	\
		SDockTab::FArguments& ToolTipText( TSharedRef< UserClass > InUserObjectRef, typename TAttribute< FText >::FGetter::template TSPMethodDelegate_TwoVars_Const< UserClass, Var1Type, Var2Type >::FMethodPtr InFunc, Var1Type Var1, Var2Type Var2 )	\
		{ \
			_ToolTipText = TAttribute< FText >::Create( TAttribute< FText >::FGetter::CreateSP( InUserObjectRef, InFunc, Var1, Var2 ) ); \
			return this->Me(); \
		} \
		template< class UserClass, typename Var1Type, typename Var2Type, typename Var3Type >	\
		SDockTab::FArguments& ToolTipText( TSharedRef< UserClass > InUserObjectRef, typename TAttribute< FText >::FGetter::template TSPMethodDelegate_ThreeVars_Const< UserClass, Var1Type, Var2Type, Var3Type >::FMethodPtr InFunc, Var1Type Var1, Var2Type Var2, Var3Type Var3 )	\
		{ \
			_ToolTipText = TAttribute< FText >::Create( TAttribute< FText >::FGetter::CreateSP( InUserObjectRef, InFunc, Var1, Var2, Var3 ) ); \
			return this->Me(); \
		} \
		template< class UserClass, typename Var1Type, typename Var2Type, typename Var3Type, typename Var4Type >	\
		SDockTab::FArguments& ToolTipText( TSharedRef< UserClass > InUserObjectRef, typename TAttribute< FText >::FGetter::template TSPMethodDelegate_FourVars_Const< UserClass, Var1Type, Var2Type, Var3Type, Var4Type >::FMethodPtr InFunc, Var1Type Var1, Var2Type Var2, Var3Type Var3, Var4Type Var4 )	\
		{ \
			_ToolTipText = TAttribute< FText >::Create( TAttribute< FText >::FGetter::CreateSP( InUserObjectRef, InFunc, Var1, Var2, Var3, Var4 ) ); \
			return this->Me(); \
		} \
	\
		/* Bind attribute with delegate to a shared pointer-based class method.  Slate mostly uses shared pointers so we use an overload for this type of binding. */ \
		template< class UserClass >	\
		SDockTab::FArguments& ToolTipText( UserClass* InUserObject, typename TAttribute< FText >::FGetter::template TSPMethodDelegate_Const< UserClass >::FMethodPtr InFunc )	\
		{ \
			_ToolTipText = TAttribute< FText >::Create( TAttribute< FText >::FGetter::CreateSP( InUserObject, InFunc ) ); \
			return this->Me(); \
		} \
		template< class UserClass, typename Var1Type >	\
		SDockTab::FArguments& ToolTipText( UserClass* InUserObject, typename TAttribute< FText >::FGetter::template TSPMethodDelegate_OneVar_Const< UserClass, Var1Type >::FMethodPtr InFunc, Var1Type Var1 )	\
		{ \
			_ToolTipText = TAttribute< FText >::Create( TAttribute< FText >::FGetter::CreateSP( InUserObject, InFunc, Var1 ) ); \
			return this->Me(); \
		} \
		template< class UserClass, typename Var1Type, typename Var2Type >	\
		SDockTab::FArguments& ToolTipText( UserClass* InUserObject, typename TAttribute< FText >::FGetter::template TSPMethodDelegate_TwoVars_Const< UserClass, Var1Type, Var2Type >::FMethodPtr InFunc, Var1Type Var1, Var2Type Var2 )	\
		{ \
			_ToolTipText = TAttribute< FText >::Create( TAttribute< FText >::FGetter::CreateSP( InUserObject, InFunc, Var1, Var2 ) ); \
			return this->Me(); \
		} \
		template< class UserClass, typename Var1Type, typename Var2Type, typename Var3Type >	\
		SDockTab::FArguments& ToolTipText( UserClass* InUserObject, typename TAttribute< FText >::FGetter::template TSPMethodDelegate_ThreeVars_Const< UserClass, Var1Type, Var2Type, Var3Type >::FMethodPtr InFunc, Var1Type Var1, Var2Type Var2, Var3Type Var3 )	\
		{ \
			_ToolTipText = TAttribute< FText >::Create( TAttribute< FText >::FGetter::CreateSP( InUserObject, InFunc, Var1, Var2, Var3 ) ); \
			return this->Me(); \
		} \
		template< class UserClass, typename Var1Type, typename Var2Type, typename Var3Type, typename Var4Type >	\
		SDockTab::FArguments& ToolTipText( UserClass* InUserObject, typename TAttribute< FText >::FGetter::template TSPMethodDelegate_FourVars_Const< UserClass, Var1Type, Var2Type, Var3Type, Var4Type >::FMethodPtr InFunc, Var1Type Var1, Var2Type Var2, Var3Type Var3, Var4Type Var4 )	\
		{ \
			_ToolTipText = TAttribute< FText >::Create( TAttribute< FText >::FGetter::CreateSP( InUserObject, InFunc, Var1, Var2, Var3, Var4 ) ); \
			return this->Me(); \
		} \
	\
		/* Bind attribute with delegate to a UObject-based class method */ \
		template< class UserClass >	\
		SDockTab::FArguments& ToolTipText_UObject( UserClass* InUserObject, typename TAttribute< FText >::FGetter::template TUObjectMethodDelegate_Const< UserClass >::FMethodPtr InFunc )	\
		{ \
			_ToolTipText = TAttribute< FText >::Create( TAttribute< FText >::FGetter::CreateUObject( InUserObject, InFunc ) ); \
			return this->Me(); \
		} \
		template< class UserClass, typename Var1Type >	\
		SDockTab::FArguments& ToolTipText_UObject( UserClass* InUserObject, typename TAttribute< FText >::FGetter::template TUObjectMethodDelegate_OneVar_Const< UserClass, Var1Type >::FMethodPtr InFunc, Var1Type Var1 )	\
		{ \
			_ToolTipText = TAttribute< FText >::Create( TAttribute< FText >::FGetter::CreateUObject( InUserObject, InFunc, Var1 ) ); \
			return this->Me(); \
		} \
		template< class UserClass, typename Var1Type, typename Var2Type  >	\
		SDockTab::FArguments& ToolTipText_UObject( UserClass* InUserObject, typename TAttribute< FText >::FGetter::template TUObjectMethodDelegate_TwoVars_Const< UserClass, Var1Type, Var2Type >::FMethodPtr InFunc, Var1Type Var1, Var2Type Var2 )	\
		{ \
			_ToolTipText = TAttribute< FText >::Create( TAttribute< FText >::FGetter::CreateUObject( InUserObject, InFunc, Var1, Var2 ) ); \
			return this->Me(); \
		} \
		template< class UserClass, typename Var1Type, typename Var2Type, typename Var3Type >	\
		SDockTab::FArguments& ToolTipText_UObject( UserClass* InUserObject, typename TAttribute< FText >::FGetter::template TUObjectMethodDelegate_ThreeVars_Const< UserClass, Var1Type, Var2Type, Var3Type >::FMethodPtr InFunc, Var1Type Var1, Var2Type Var2, Var3Type Var3 )	\
		{ \
			_ToolTipText = TAttribute< FText >::Create( TAttribute< FText >::FGetter::CreateUObject( InUserObject, InFunc, Var1, Var2, Var3 ) ); \
			return this->Me(); \
		} \
		template< class UserClass, typename Var1Type, typename Var2Type, typename Var3Type, typename Var4Type >	\
		SDockTab::FArguments& ToolTipText_UObject( UserClass* InUserObject, typename TAttribute< FText >::FGetter::template TUObjectMethodDelegate_FourVars_Const< UserClass, Var1Type, Var2Type, Var3Type, Var4Type >::FMethodPtr InFunc, Var1Type Var1, Var2Type Var2, Var3Type Var3, Var4Type Var4 )	\
		{ \
			_ToolTipText = TAttribute< FText >::Create( TAttribute< FText >::FGetter::CreateUObject( InUserObject, InFunc, Var1, Var2, Var3, Var4 ) ); \
			return this->Me(); \
		}

所以 SLATE_ATTRIBUTE 宏为 TSlateBaseNamedArgs(FArguments的父类) 类定义了TAttribute< FText >类型的成员变量_ToolTipText以及不同参数类型成员函数ToolTipText_Static

另外要说明一点的是 :在 TAttribute(Attribute.h) 模板类中有 使用了这样一个宏

	/**
	 * Attribute 'getter' delegate
	 *
	 * ObjectType GetValue() const
	 *
	 * @return  The attribute's value
	 */
	DECLARE_DELEGATE_RetVal( ObjectType, FGetter );

它的定义如下

#define DECLARE_DELEGATE_RetVal( ReturnValueType, DelegateName ) FUNC_DECLARE_DELEGATE( DelegateName, ReturnValueType )

宏 FUNC_DECLARE_DELEGATE 的定义如下

/** Declare the user's delegate object */
// NOTE: The last parameter is variadic and is used as the 'template args' for this delegate's classes (__VA_ARGS__)
#define FUNC_DECLARE_DELEGATE( DelegateName, ... ) \
	typedef TBaseDelegate<__VA_ARGS__> DelegateName;

所以 DECLARE_DELEGATE_RetVal( ObjectType, FGetter );宏替换之后就是

typedef TBaseDelegate<ObjectType> FGetter ;

因此 FGetter 就是TBaseDelegate – (TBaseDelegate 的父类为 FDelegateBase),换句话说 FGetter 就是 SDockTab 类中的 FArguments 类中的 TAttribute 类中的 类型为TBaseDelegate 的类名.
有关Delegate的具体实现过程,之后再分析

好,下面继续回到SLATE_ATTRIBUTE宏,在宏 SLATE_ATTRIBUTE( FText, ToolTipText ) 中实现的一个如下函数

template< typename Var1Type > \
SDockTab::FArguments& ToolTipText_Static( typename TAttribute< FText >::FGetter::template TStaticDelegate_OneVar< Var1Type >::FFuncPtr InFunc, Var1Type Var1 )	\
{ \
	_ToolTipText = TAttribute< FText >::Create( TAttribute< FText >::FGetter::CreateStatic( InFunc, Var1 ) ); \
	return this->Me(); \
} \

其中,TStaticDelegate_OneVar 是 TBaseDelegate 类中的内嵌类,这个TStaticDelegate_OneVar 类的父类为 TBaseStaticDelegateInstance,template TStaticDelegate_OneVar< Var1Type >::FFuncPtr InFunc 中的template表示后边跟着的是一个函数模板指针，
这个函数
SDockTab::FArguments& ToolTipText_Static( typename TAttribute< FText >::FGetter::template TStaticDelegate_OneVar< Var1Type >::FFuncPtr InFunc, Var1Type Var1 )
的功能就是给SDockTab::FArguments的 TAttribute< FText >类型的 _ToolTipText字段初始化

下面分析 SLATE_ARGUMENT 宏 SLATE_ARGUMENT( TSharedPtr, ToolTip ) 宏替换后

/**
 * Use this macro to declare a slate argument.
 * Arguments differ from attributes in that they can only be values
 */
#define SLATE_ARGUMENT( TSharedPtr<IToolTip>, ToolTip ) \
		SharedPtr<IToolTip> _ToolTip; \
		FArguments& ToolTip( SharedPtr<IToolTip> InArg ) \
		{ \
			_ToolTip = InArg; \
			return this->Me(); \
		}

这个宏的作用就是声明一个SharedPtr类型(共享指针)的字段 _ToolTip,并给出初始化方法
--------------------- 以上是对 FArguments 的父类 TSlateBaseNamedArgs中的宏分析 -----
下面对SDockTab.h中的宏分析
SLATE_DEFAULT_SLOT( FArguments, Content )的定义,宏替换后为

#define SLATE_DEFAULT_SLOT( DeclarationType, SlotName ) \
		SLATE_NAMED_SLOT(DeclarationType, SlotName) ; \
		DeclarationType & operator[]( const TSharedRef<SWidget> InChild ) \
		{ \
			_##SlotName.Widget = InChild; \
			return *this; \
		}

其中 SLATE_NAMED_SLOT 的定义 宏替换后如下

/**
 * Use this macro to add support for named slot properties such as Content and Header. See NamedSlotProperty for more details.
 *
 * NOTE: If you're using this within a widget class that is templated, then you might have to specify a full name for the declaration.
 *       For example: SLATE_NAMED_SLOT( typename SSuperWidget<T>::Declaration, Content )
 */
#define SLATE_NAMED_SLOT( FArguments, Content ) \
		NamedSlotProperty< FArguments > Content() \
		{ \
			return NamedSlotProperty< FArguments >( *this, _Content ); \
		} \
		TAlwaysValidWidget _Content; \

所以

宏替换之后  SLATE_DEFAULT_SLOT 如下
#define SLATE_DEFAULT_SLOT( FArguments, Content ) \
		NamedSlotProperty< FArguments > Content() \
		{ \
			return NamedSlotProperty< FArguments >( *this, _Content ); \
		} \
		TAlwaysValidWidget _Content; \
		FArguments & operator[]( const TSharedRef<SWidget> InChild ) \
		{ \
			_Content.Widget = InChild; \
			return *this; \
		}

其中 NamedSlotProperty 类的定义 具体类型替换后如下

/**
 * We want to be able to do:
 * SNew( ContainerWidget )
 * .SomeContentArea()
 * [
 *   // Child widgets go here
 * ]
 *
 * NamedSlotProperty is a helper that will be returned by SomeContentArea().
 */
template<class FArguments> 
struct NamedSlotProperty
{
	NamedSlotProperty( FArguments& InOwnerDeclaration, TAlwaysValidWidget& ContentToSet )
		: OwnerDeclaration( InOwnerDeclaration )
		, SlotContent(ContentToSet)
	{}

	FArguments & operator[]( const TSharedRef<SWidget>& InChild )
	{
		SlotContent.Widget = InChild;
		return OwnerDeclaration;
	}

	FArguments & OwnerDeclaration;
	TAlwaysValidWidget & SlotContent;
};

这个 NamedSlotProperty 类重写了操作符[],使之能够添加子widget ,这个类的字段 SlotContent 的类型为 TAlwaysValidWidget 其定义如下

/** A widget reference that is always a valid pointer; defaults to SNullWidget */
struct TAlwaysValidWidget
{
	TAlwaysValidWidget()
	: Widget(SNullWidget::NullWidget)
	{
	}

	TSharedRef<SWidget> Widget;
};

所以 SLATE_DEFAULT_SLOT( FArguments, Content ) 这个宏的作用就是在
SDockTab类中的FArguments类中定义 了一个返回值类型为 NamedSlotProperty< FArguments > 的方法 Content() , 声明了一个类型为 TAlwaysValidWidget 的字段 _Content, 重写了操作符 [] (注意NamedSlotProperty也重写了操作符[] )

下面分析宏 SLATE_EVENT( FOnTabClosedCallback, OnTabClosed ) (#define SLATE_EVENT( DelegateName, EventName )) 其宏替换后

TabClosedCallback::template TSPMethodDelegate_OneVar_Const< UserClass, Var1Type >::FMethodPtr InFunc, Var1Type Var1 )	\
		{ \
			_OnTabClosed = FOnTabClosedCallback::CreateSP( InUserObject, InFunc, Var1 ); \
			return *this; \
		} \
		template< class UserClass, typename Var1Type, typename Var2Type >	\
		FArguments& OnTabClosed( UserClass* InUserObject, typename FOnTabClosedCallback::template TSPMethodDelegate_TwoVars< UserClass, Var1Type, Var2Type >::FMethodPtr InFunc, Var1Type Var1, Var2Type Var2 )	\
		{ \
			_OnTabClosed = FOnTabClosedCallback::CreateSP( InUserObject, InFunc, Var1, Var2 ); \
			return *this; \
		} \
		template< class UserClass, typename Var1Type, typename Var2Type >	\
		FArguments& OnTabClosed( UserClass* InUserObject, typename FOnTabClosedCallback::template TSPMethodDelegate_TwoVars_Const< UserClass, Var1Type, Var2Type >::FMethodPtr InFunc, Var1Type Var1, Var2Type Var2 )	\
		{ \
			_OnTabClosed = FOnTabClosedCallback::CreateSP( InUserObject, InFunc, Var1, Var2 ); \
			return *this; \
		} \
		template< class UserClass, typename Var1Type, typename Var2Type, typename Var3Type >	\
		FArguments& OnTabClosed( UserClass* InUserObject, typename FOnTabClosedCallback::template TSPMethodDelegate_ThreeVars< UserClass, Var1Type, Var2Type, Var3Type >::FMethodPtr InFunc, Var1Type Var1, Var2Type Var2, Var3Type Var3 )	\
		{ \
			_OnTabClosed = FOnTabClosedCallback::CreateSP( InUserObject, InFunc, Var1, Var2, Var3 ); \
			return *this; \
		} \
		template< class UserClass, typename Var1Type, typename Var2Type, typename Var3Type >	\
		FArguments& OnTabClosed( UserClass* InUserObject, typename FOnTabClosedCallback::template TSPMethodDelegate_ThreeVars_Const< UserClass, Var1Type, Var2Type, Var3Type >::FMethodPtr InFunc, Var1Type Var1, Var2Type Var2, Var3Type Var3 )	\
		{ \
			_OnTabClosed = FOnTabClosedCallback::CreateSP( InUserObject, InFunc, Var1, Var2, Var3 ); \
			return *this; \
		} \
		template< class UserClass, typename Var1Type, typename Var2Type, typename Var3Type, typename Var4Type >	\
		FArguments& OnTabClosed( UserClass* InUserObject, typename FOnTabClosedCallback::template TSPMethodDelegate_FourVars< UserClass, Var1Type, Var2Type, Var3Type, Var4Type >::FMethodPtr InFunc, Var1Type Var1, Var2Type Var2, Var3Type Var3, Var4Type Var4 )	\
		{ \
			_OnTabClosed = FOnTabClosedCallback::CreateSP( InUserObject, InFunc, Var1, Var2, Var3, Var4 ); \
			return *this; \
		} \
		template< class UserClass, typename Var1Type, typename Var2Type, typename Var3Type, typename Var4Type >	\
		FArguments& OnTabClosed( UserClass* InUserObject, typename FOnTabClosedCallback::template TSPMethodDelegate_FourVars_Const< UserClass, Var1Type, Var2Type, Var3Type, Var4Type >::FMethodPtr InFunc, Var1Type Var1, Var2Type Var2, Var3Type Var3, Var4Type Var4 )	\
		{ \
			_OnTabClosed = FOnTabClosedCallback::CreateSP( InUserObject, InFunc, Var1, Var2, Var3, Var4 ); \
			return *this; \
		} \
		\
		/* Set event delegate to a UObject-based class method */ \
		template< class UserClass >	\
		FArguments& OnTabClosed_UObject( UserClass* InUserObject, typename FOnTabClosedCallback::template TUObjectMethodDelegate< UserClass >::FMethodPtr InFunc )	\
		{ \
			_OnTabClosed = FOnTabClosedCallback::CreateUObject( InUserObject, InFunc ); \
			return *this; \
		} \
		template< class UserClass >	\
		FArguments& OnTabClosed_UObject( UserClass* InUserObject, typename FOnTabClosedCallback::template TUObjectMethodDelegate_Const< UserClass >::FMethodPtr InFunc )	\
		{ \
			_OnTabClosed = FOnTabClosedCallback::CreateUObject( InUserObject, InFunc ); \
			return *this; \
		} \
		template< class UserClass, typename Var1Type >	\
		FArguments& OnTabClosed_UObject( UserClass* InUserObject, typename FOnTabClosedCallback::template TUObjectMethodDelegate_OneVar< UserClass, Var1Type >::FMethodPtr InFunc, Var1Type Var1 )	\
		{ \
			_OnTabClosed = FOnTabClosedCallback::CreateUObject( InUserObject, InFunc, Var1 ); \
			return *this; \
		} \
		template< class UserClass, typename Var1Type >	\
		FArguments& OnTabClosed_UObject( UserClass* InUserObject, typename FOnTabClosedCallback::template TUObjectMethodDelegate_OneVar_Const< UserClass, Var1Type >::FMethodPtr InFunc, Var1Type Var1 )	\
		{ \
			_OnTabClosed = FOnTabClosedCallback::CreateUObject( InUserObject, InFunc, Var1 ); \
			return *this; \
		} \
		template< class UserClass, typename Var1Type, typename Var2Type >	\
		FArguments& OnTabClosed_UObject( UserClass* InUserObject, typename FOnTabClosedCallback::template TUObjectMethodDelegate_TwoVars< UserClass, Var1Type, Var2Type >::FMethodPtr InFunc, Var1Type Var1, Var2Type Var2 )	\
		{ \
			_OnTabClosed = FOnTabClosedCallback::CreateUObject( InUserObject, InFunc, Var1, Var2 ); \
			return *this; \
		} \
		template< class UserClass, typename Var1Type, typename Var2Type >	\
		FArguments& OnTabClosed_UObject( UserClass* InUserObject, typename FOnTabClosedCallback::template TUObjectMethodDelegate_TwoVars_Const< UserClass, Var1Type, Var2Type >::FMethodPtr InFunc, Var1Type Var1, Var2Type Var2 )	\
		{ \
			_OnTabClosed = FOnTabClosedCallback::CreateUObject( InUserObject, InFunc, Var1, Var2 ); \
			return *this; \
		} \
		template< class UserClass, typename Var1Type, typename Var2Type, typename Var3Type >	\
		FArguments& OnTabClosed_UObject( UserClass* InUserObject, typename FOnTabClosedCallback::template TUObjectMethodDelegate_ThreeVars< UserClass, Var1Type, Var2Type, Var3Type >::FMethodPtr InFunc, Var1Type Var1, Var2Type Var2, Var3Type Var3 )	\
		{ \
			_OnTabClosed = FOnTabClosedCallback::CreateUObject( InUserObject, InFunc, Var1, Var2, Var3 ); \
			return *this; \
		} \
		template< class UserClass, typename Var1Type, typename Var2Type, typename Var3Type >	\
		FArguments& OnTabClosed_UObject( UserClass* InUserObject, typename FOnTabClosedCallback::template TUObjectMethodDelegate_ThreeVars_Const< UserClass, Var1Type, Var2Type, Var3Type >::FMethodPtr InFunc, Var1Type Var1, Var2Type Var2, Var3Type Var3 )	\
		{ \
			_OnTabClosed = FOnTabClosedCallback::CreateUObject( InUserObject, InFunc, Var1, Var2, Var3 ); \
			return *this; \
		} \
		template< class UserClass, typename Var1Type, typename Var2Type, typename Var3Type, typename Var4Type >	\
		FArguments& OnTabClosed_UObject( UserClass* InUserObject, typename FOnTabClosedCallback::template TUObjectMethodDelegate_FourVars< UserClass, Var1Type, Var2Type, Var3Type, Var4Type >::FMethodPtr InFunc, Var1Type Var1, Var2Type Var2, Var3Type Var3, Var4Type Var4 )	\
		{ \
			_OnTabClosed = FOnTabClosedCallback::CreateUObject( InUserObject, InFunc, Var1, Var2, Var3, Var4 ); \
			return *this; \
		} \
		template< class UserClass, typename Var1Type, typename Var2Type, typename Var3Type, typename Var4Type >	\
		FArguments& OnTabClosed_UObject( UserClass* InUserObject, typename FOnTabClosedCallback::template TUObjectMethodDelegate_FourVars_Const< UserClass, Var1Type, Var2Type, Var3Type, Var4Type >::FMethodPtr InFunc, Var1Type Var1, Var2Type Var2, Var3Type Var3, Var4Type Var4 )	\
		{ \
			_OnTabClosed = FOnTabClosedCallback::CreateUObject( InUserObject, InFunc, Var1, Var2, Var3, Var4 ); \
			return *this; \
		} \
		\
		FOnTabClosedCallback _OnTabClosed; \

这个宏 SLATE_EVENT( FOnTabClosedCallback, OnTabClosed ) 的作用就是 声明了一个 FOnTabClosedCallback 类型的字段_OnTabClosed,并给出了一堆初始化它的方法,FOnTabClosedCallback 类型又是由 在SDockableTab.h中的宏 DECLARE_DELEGATE_OneParam(FOnTabClosedCallback, TSharedRef); 生成的 , 又是个Delegate,与FGetter不同的是 :用的是不同参数的TBaseDelegate模板类

最后分析 SLATE_END_ARGS()

#define SLATE_END_ARGS() \
	};

就是给 SLATE_BEGIN_ARGS 补全一对{}

-----------------------以上是对 SDockTab.h 中出现的宏的分析-----------------------
下面 我们回到文章的开头 ,我们说在 , 在函数 TSharedRef FPlantMonsterModule::OnSpawnPluginTab(const FSpawnTabArgs& SpawnTabArgs) 中 出现了 SNew(SDockTab) ,
我们对SNew进行分析,SNew 宏替换后为

/**
 * Slate widgets are constructed through SNew and SAssignNew.
 * e.g.
 *      
 *     TSharedRef<SButton> MyButton = SNew(SButton);
 *        or
 *     TSharedPtr<SButton> MyButton;
 *     SAssignNew( MyButton, SButton );
 *
 * Using SNew and SAssignNew ensures that widgets are populated
 */

#define SNew( SDockTab, ... ) \
	MakeTDecl<SDockTab>( "SDockTab", __FILE__, __LINE__, RequiredArgs::MakeRequiredArgs(__VA_ARGS__) ) <<= TYPENAME_OUTSIDE_TEMPLATE SDockTab::FArguments()

先说 MakeTDecl(“SDockTab”, FILE, LINE, RequiredArgs::MakeRequiredArgs(VA_ARGS)) 中的参数 RequiredArgs::MakeRequiredArgs(VA_ARGS)

在命名空间RequiredArgs中 定义并实现了不同参数的 MakeRequiredArgs 方法, 返回值也与参数的个数相应 ,SNew(SDockTab)中参数个数为0个 因此 RequiredArgs::MakeRequiredArgs(VA_ARGS) 返回的是一个 RequiredArgs::T0RequiredArgs() 对象

其中 MakeTDecl 的定义 具体类型替换后为

template<typename SDockTab, typename RequiredArgs::T0RequiredArgs>
TDecl<SDockTab, RequiredArgs::T0RequiredArgs> MakeTDecl(const ANSICHAR* InType, const ANSICHAR* InFile, int32 OnLine, RequiredArgs::T0RequiredArgs&& InRequiredArgs)
{
	return TDecl<SDockTab, RequiredArgs::T0RequiredArgs>(InType, InFile, OnLine, Forward<RequiredArgs::T0RequiredArgs>(InRequiredArgs));
}

其中 TDecl 的定义 具体类型替换后为

/**
 * Utility class used during widget instantiation.
 * Performs widget allocation and construction.
 * Ensures that debug info is set correctly.
 * Returns TSharedRef to widget.
 *
 * @see SNew
 * @see SAssignNew
 */
template<class SDockTab, typename RequiredArgs::T0RequiredArgs>
struct TDecl
{
	TDecl( const ANSICHAR* InType, const ANSICHAR* InFile, int32 OnLine, RequiredArgs::T0RequiredArgs&& InRequiredArgs )
		: _Widget( TWidgetAllocator<SDockTab, TIsDerivedFrom<SDockTab, SUserWidget>::IsDerived >::PrivateAllocateWidget() )
		, _RequiredArgs(InRequiredArgs)
	{
		_Widget->SetDebugInfo( InType, InFile, OnLine, sizeof(SDockTab) );
	}

	/**
	 * Initialize OutVarToInit with the widget that is being constructed.
	 * @see SAssignNew
	 */
	template<class ExposeAsSDockTab>
	TDecl& Expose( TSharedPtr<ExposeAsSDockTab>& OutVarToInit )
	{
		OutVarToInit = _Widget;
		return *this;
	}

	/**
	 * Initialize OutVarToInit with the widget that is being constructed.
	 * @see SAssignNew
	 */
	template<class ExposeAsSDockTab>
	TDecl& Expose( TSharedRef<ExposeAsSDockTab>& OutVarToInit )
	{
		OutVarToInit = _Widget;
		return *this;
	}

	/**
	 * Initialize a WEAK OutVarToInit with the widget that is being constructed.
	 * @see SAssignNew
	 */
	template<class ExposeAsSDockTab>
	TDecl& Expose( TWeakPtr<ExposeAsSDockTab>& OutVarToInit )
	{
		OutVarToInit = _Widget;
		return *this;
	}

	/**
	 * Complete widget construction from InArgs.
	 *
	 * @param InArgs  NamedArguments from which to construct the widget.
	 *
	 * @return A reference to the widget that we constructed.
	 */
	TSharedRef<SDockTab> operator<<=( const typename SDockTab::FArguments& InArgs ) const
	{
		//@todo UMG: This should be removed in favor of all widgets calling their superclass construct.
		_Widget->SWidgetConstruct(
			InArgs._ToolTipText,
			InArgs._ToolTip,
			InArgs._Cursor,
			InArgs._IsEnabled,
			InArgs._Visibility,
			InArgs._RenderOpacity,
			InArgs._RenderTransform,
			InArgs._RenderTransformPivot,
			InArgs._Tag,
			InArgs._ForceVolatile,
			InArgs._Clipping,
			InArgs._FlowDirectionPreference,
			InArgs._AccessibleText.IsSet() ? FAccessibleWidgetData(InArgs._AccessibleText) : InArgs._AccessibleParams,
			InArgs.MetaData );

		_RequiredArgs.CallConstruct(_Widget, InArgs);

		return _Widget;
	}

	const TSharedRef<SDockTab> _Widget;
	RequiredArgs::T0RequiredArgs& _RequiredArgs;
};

在构造函数TDecl中有这样的一个方法 TWidgetAllocator<SDockTab, TIsDerivedFrom<SDockTab, SUserWidget>::IsDerived >::PrivateAllocateWidget() 这个方法就是返回一个TSharedRef的共享指针,我们分析构造函数其中的类
模板类 TIsDerivedFrom,具体化参数后的定义为

/** Is type DerivedType inherited from SUserWidget. */
template<typename SDockTab, typename SUserWidget>
struct TIsDerivedFrom
{
	// Different size types so we can compare their sizes later.
	typedef char No[1];
	typedef char Yes[2];

	// Overloading Test() s.t. only calling it with something that is
	// a SUserWidget (or inherited from the SUserWidget) will return a Yes.
	static Yes& Test( SUserWidget* );
	static Yes& Test( const SUserWidget* );
	static No& Test( ... );

	// Makes a SDockTab ptr.
	static SDockTab* SDockTabPtr(){ return nullptr ;}

	public:
	// Test the derived type pointer. If it inherits from SUserWidget, the Test( SUserWidget* ) 
	// will be chosen. If it does not, Test( ... ) will be chosen.
	static const bool Value = sizeof(Test( SDockTabPtr() )) == sizeof(Yes);

	static const bool IsDerived = Value;
};

模板类 TWidgetAllocator,具体化参数后的定义为

/** Normal widgets are allocated directly by the TDecl. */
template<typename SDockTab, bool IsDerived>
struct TWidgetAllocator
{
	static TSharedRef<SDockTab> PrivateAllocateWidget()
	{
		return MakeShared<SDockTab>();
	}
};

由上分析 宏 SNew( SDockTab, … ) 可以看成

#define SNew( SDockTab, ... ) \
TDecl<class SDockTab, typename RequiredArgs::T0RequiredArgs>() <<= TYPENAME_OUTSIDE_TEMPLATE SDockTab::FArguments()

TYPENAME_OUTSIDE_TEMPLATE 的定义如下

#if !defined(__clang__)		// Clang expects typename outside template
	#define TYPENAME_OUTSIDE_TEMPLATE
#endif

C/C++:函数名前引用一个空的宏定义 (https://blog.csdn.net/qq_30015903/article/details/88039320)
最后说操作符重载 <<= ,这个操作符是在 TDecl 类中重载的,具体类型替换后

/**
	 * Complete widget construction from InArgs.
	 *
	 * @param InArgs  NamedArguments from which to construct the widget.
	 *
	 * @return A reference to the widget that we constructed.
	 */
	TSharedRef<SDockTab> operator<<=( const typename SDockTab::FArguments& InArgs ) const
	{
		//@todo UMG: This should be removed in favor of all widgets calling their superclass construct.
		_Widget->SWidgetConstruct(
			InArgs._ToolTipText,
			InArgs._ToolTip,
			InArgs._Cursor,
			InArgs._IsEnabled,
			InArgs._Visibility,
			InArgs._RenderOpacity,
			InArgs._RenderTransform,
			InArgs._RenderTransformPivot,
			InArgs._Tag,
			InArgs._ForceVolatile,
			InArgs._Clipping,
			InArgs._FlowDirectionPreference,
			InArgs._AccessibleText.IsSet() ? FAccessibleWidgetData(InArgs._AccessibleText) : InArgs._AccessibleParams,
			InArgs.MetaData );

		_RequiredArgs.CallConstruct(_Widget, InArgs);

		return _Widget;
	}

所以宏SNew 就是返回一个 初始化后的TSharedRef 共享引用

追风ぁPanda
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
UE4 Slate 特殊语法
qq_24951423的博客
03-15 3428
UE Slate 特殊语法分析 简述 UE4 的Slate系统有很多奇怪的语法，创建新的SWidget对象时，语法中会包含SNew，.XXX() , +XXX 和 [XXX]类型的语法 。 在自定义SWidget类的时候，会需要用到SLATE_BEGIN_ARGS , SLATE_END_ARGS等语法，并且需要实现Construct方法， 这些特殊的语法和规则，都是UE4通过宏定义，运算符重载来...
ue4 SlateUI讲解
10-25
ue4 SlateUI讲解。中文教程，内容详细。（凑字数字数）
UE4自定义资源编辑器开发-Slate语法
一个游戏开发的博客
06-22 783
UE4自定义资源编辑器开发-Slate语法
【UE Slate】 虚幻引擎Slate开发快速入门
最新发布
hhw_hhw的博客
05-27 2050
创建自定义控件类：继承自或，具体取决于你的控件是否包含子控件。继承自SWidget并添加了一些额外的功能，如支持包含子控件。public:// 使用ChildSlot定义控件的内容ChildSlot"))private:// 按钮点击事件处理函数"));解释构造函数和方法Construct方法用于初始化控件。和宏定义控件的构造参数。ChildSlot"))是按钮点击事件的处理函数。使用表示事件已处理。"));自定义控件的使用。
UE4 Slate概述
痞子龙3D编程
01-06 1万+
Slate用户界面架构 On this page: 概述声明式语法构成风格输入输出布局图元用户驱动的布局开发者工具引擎访问 概述 Slate 是一种完全自定义的、平台无关的用户界面架构，其设计目的是使得构建工具及应用程序（比如虚幻编辑器）的用户界面或者游戏中的用户界面变得更加有趣、高效。它结合了一种可以轻松设计、布局及风格化组件的声明式语法，使得
UE4 C++ Slate
qq_43021038的博客
10-12 1924
UE4的大部分编辑器界面都是Slate构建的，包括一些插件也是由Slate构建。Slate是一个分辨率自适应的相对布局界面系统，为了完成这样的目的，slate实际上采用了一个两次排布的“思路”。(一)、首先是递归计算每个控件的大小，父控件会根据子控件来计算自己的大小。(二)、根据控件大小，计算出每个控件的绘制位置。
UE4 Slate, Hello
痞子龙3D编程
01-06 2629
Rate this Article: 4.33  (3 votes) Approved for Versions:4.8 Some or all of the information on this page is inconsistent, irrelevant or confusing. Please help clean it u
UE4自定义GameDebugTool中显示的数据
11-27
2. **UI界面**：UE4支持多种UI系统，如Slate（基于C++的UI框架）或Blueprints。在自定义GameDebugTool中，你可以使用Slate创建一个控制台或者面板，显示收集到的数据。Slate组件如SBox、STextBlock、SImage等可用于...
UE4小地图制作demo
09-19
这需要使用UE4的UI系统，包括Slate蓝图和材质表达式，将小地图渲染到UI组件上。 学习这个"UE4小地图制作demo"，你将了解如何结合使用蓝图节点来实现这些功能。你可能需要研究以下技术： 1. **蓝图事件图**：这是...
KantanCharts:UE4 插件提供简单的 UMGSlate 图表绘制
05-30
《KantanCharts：UE4插件轻松实现UMG Slate图表绘制》 KantanCharts是一款针对Unreal Engine 4（简称UE4）开发的插件，它专为游戏开发者和交互式体验设计师提供了一种简单易用的方式来绘制UMG（Unreal Motion ...
ue4_download_image
02-11
12. **用户界面**：在UI中显示下载的图片，可能需要使用Slate或UMG（Unreal Motion Graphics），这是UE4的用户界面框架。 以上这些是“ue4_download_image”这个主题可能涉及的一些技术点。在实际项目中，开发者...
UE4 Slate一 开篇
u011718663的博客
06-08 3万+
原创文章，转载请注明出处。 点击观看下一篇《UE4 Slate二 用UMG思想去理解Slate》 这里写目录标题前言Slate是什么？为什么要了解Slate？提前需要了解的模块(将对Slate学习很有帮助) 前言 Slate相关文章，使用引擎版本4.25.4源码版. 一共11篇文章。网上Slate的文章介绍很少，所以在这里做一下该部分的文章并记录一下。同时也希望能帮助到大家。 Slate是什么？ 一套GUI架构，它是虚幻引擎的UI架构。我们打开编辑器看到的界面，可以说95%以上(高概猜测数值, 甚至100.
UE4 Slate HUD 学习笔记
liuzhimu2018的博客
10-29 474
UE4预定义了有些Widget相应时间如 FOnClicked 这个在文件#include "Framework/SlateDelegates.h"中
UE4插件与编辑器Slate
人宅
01-15 2553
教程使用软件：Visual Studio2017 、UE4 4.20和4.19版本引擎 UE4插件与编辑器Slate源文链接 哈喽，大家好，我叫人宅，很高兴和大家分享一下我们这套教程。 我们的UE4课程路线从应用层，也逐渐往UE4底层走。 今天给大家推出一套UE4引擎底层入门课程，就是这部 —— UE4插件和Slate. 该教程我们会详细分析Slate架构原理以及UE4底层的元编程细...
UE4 创建自定义 Slate UI 控件
Aparnol的博客
05-14 3718
简单介绍 UE4 Slate，和创建方法
UE4 Slate三 SlateUI代码讲解
热门推荐
u011718663的博客
06-09 3万+
原创文章，转载请注明出处。 点击观看上一篇《UE4 Slate二 用UMG思想去理解Slate+Slate编码》 点击观看下一篇《UE4 Slate四 SlateUI如何做动画》 虚幻引擎 SlateUI介绍1>前言2>该继承自哪个基类来写呢？SCompoundWidget/SPanel/SLeafWidget2.1>基类:SUserWidget或者是SCompoundWidget2.2>基类:SPanel2.3>基类:SLeafWidget3>该如何新建一个S类组件呢.
UE4 将 Slate控件封装成 UWidget
Aparnol的博客
05-15 1985
简单介绍并展示如何将一个Slate控件封装成UMG控件
UE4c++ Slate整套学习流程（源码编译+Slate框架+SlateViewer）
c++、UE
09-22 4056
对于Slate入门的学习流程，希望大家耐心观看
UE4 Slate初步探索
qq_40337804的博客
07-27 530
SLATE_BEGIN_ARGS(SXJS_ScrollBox),这个宏构造了一个FArguments的结构体。 SLATE_STYLE_ARGUMENT、SLATE_ARGUMENT、SLATE_EVENT、SLATE_ATTRIBUTE，都是给这个结构体增加变量。 当Snew或者SAssignNew这个类的时候，设置好参数，会由 把这些参数传入，最后调用 设置参数，结构体FArguments& Inargs里的变量只起到传递作用，要在构造的类里，自己再新建变量来保存对应的值...
UE4 SlateUI详解：从FViewport到Slate基础与高级应用
本文档深入讲解了Unreal Engine 4 (UE4) 的SlateUI系统，包括基础知识、SlateUI的基本概念和技术细节。首先，我们从FViewport和UGameViewportClient这两个核心组件开始，FViewport是负责视口渲染的低级接口，它利用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值