月光林地

#define GENERATED_BODY(...) BODY_MACRO_COMBINE(CURRENT_FILE_ID,_,__LINE__,_GENERATED_BODY);

#define GENERATED_BODY_LEGACY(...) BODY_MACRO_COMBINE(CURRENT_FILE_ID,_,__LINE__,_GENERATED_BODY_LEGACY);

#undef CURRENT_FILE_ID
#define CURRENT_FILE_ID AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h

NO_API AByeWorld(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get()) : Super(ObjectInitializer) { }; \

#include "UObject/ObjectMacros.h"
#include "UObject/ScriptMacros.h"

PRAGMA_DISABLE_DEPRECATION_WARNINGS
#ifdef ADVANCEFUNC_HelloWorld_generated_h
#error "HelloWorld.generated.h already included, missing '#pragma once' in HelloWorld.h"
#endif
#define ADVANCEFUNC_HelloWorld_generated_h

#define AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_SPARSE_DATA
#define AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_RPC_WRAPPERS
#define AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_RPC_WRAPPERS_NO_PURE_DECLS
#define AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_INCLASS_NO_PURE_DECLS \
private: \
	static void StaticRegisterNativesAHelloWorld(); \
	friend struct Z_Construct_UClass_AHelloWorld_Statics; \
public: \
	DECLARE_CLASS(AHelloWorld, AActor, COMPILED_IN_FLAGS(0 | CLASS_Config), CASTCLASS_None, TEXT("/Script/AdvanceFunc"), NO_API) \
	DECLARE_SERIALIZER(AHelloWorld)


#define AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_INCLASS \
private: \
	static void StaticRegisterNativesAHelloWorld(); \
	friend struct Z_Construct_UClass_AHelloWorld_Statics; \
public: \
	DECLARE_CLASS(AHelloWorld, AActor, COMPILED_IN_FLAGS(0 | CLASS_Config), CASTCLASS_None, TEXT("/Script/AdvanceFunc"), NO_API) \
	DECLARE_SERIALIZER(AHelloWorld)


#define AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_STANDARD_CONSTRUCTORS \
	/** Standard constructor, called after all reflected properties have been initialized */ \
	NO_API AHelloWorld(const FObjectInitializer& ObjectInitializer); \
	DEFINE_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL(AHelloWorld) \
	DECLARE_VTABLE_PTR_HELPER_CTOR(NO_API, AHelloWorld); \
DEFINE_VTABLE_PTR_HELPER_CTOR_CALLER(AHelloWorld); \
private: \
	/** Private move- and copy-constructors, should never be used */ \
	NO_API AHelloWorld(AHelloWorld&&); \
	NO_API AHelloWorld(const AHelloWorld&); \
public:


#define AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_ENHANCED_CONSTRUCTORS \
private: \
	/** Private move- and copy-constructors, should never be used */ \
	NO_API AHelloWorld(AHelloWorld&&); \
	NO_API AHelloWorld(const AHelloWorld&); \
public: \
	DECLARE_VTABLE_PTR_HELPER_CTOR(NO_API, AHelloWorld); \
DEFINE_VTABLE_PTR_HELPER_CTOR_CALLER(AHelloWorld); \
	DEFINE_DEFAULT_CONSTRUCTOR_CALL(AHelloWorld)


#define AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_PRIVATE_PROPERTY_OFFSET
#define AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_9_PROLOG
 //GENERATED_UCLASS_BODY定义
#define AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_GENERATED_BODY_LEGACY \
PRAGMA_DISABLE_DEPRECATION_WARNINGS \
public: \
	AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_PRIVATE_PROPERTY_OFFSET \
	AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_SPARSE_DATA \
	AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_RPC_WRAPPERS \
	AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_INCLASS \
	AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_STANDARD_CONSTRUCTORS \
public: \
PRAGMA_ENABLE_DEPRECATION_WARNINGS

//GENERATED_BODY定义
#define AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_GENERATED_BODY \
PRAGMA_DISABLE_DEPRECATION_WARNINGS \
public: \
	AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_PRIVATE_PROPERTY_OFFSET \
	AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_SPARSE_DATA \
	AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_RPC_WRAPPERS_NO_PURE_DECLS \
	AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_INCLASS_NO_PURE_DECLS \
	AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_ENHANCED_CONSTRUCTORS \
private: \
PRAGMA_ENABLE_DEPRECATION_WARNINGS


template<> ADVANCEFUNC_API UClass* StaticClass<class AHelloWorld>();
//GENERATED_BODY定义用到的ID
#undef CURRENT_FILE_ID
#define CURRENT_FILE_ID AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h


PRAGMA_ENABLE_DEPRECATION_WARNINGS

#define AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_INCLASS_NO_PURE_DECLS \
private: \
	static void StaticRegisterNativesAHelloWorld(); \
	friend struct Z_Construct_UClass_AHelloWorld_Statics; \
public: \
	DECLARE_CLASS(AHelloWorld, AActor, COMPILED_IN_FLAGS(0 | CLASS_Config), CASTCLASS_None, TEXT("/Script/AdvanceFunc"), NO_API) \
	DECLARE_SERIALIZER(AHelloWorld)


#define AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_INCLASS \
private: \
	static void StaticRegisterNativesAHelloWorld(); \
	friend struct Z_Construct_UClass_AHelloWorld_Statics; \
public: \
	DECLARE_CLASS(AHelloWorld, AActor, COMPILED_IN_FLAGS(0 | CLASS_Config), CASTCLASS_None, TEXT("/Script/AdvanceFunc"), NO_API) \
	DECLARE_SERIALIZER(AHelloWorld)

#define DEFINE_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL(TClass) \
	static void __DefaultConstructor(const FObjectInitializer& X) { new((EInternal*)X.GetObj())TClass(X); }

#define DECLARE_CLASS( TClass, TSuperClass, TStaticFlags, TStaticCastFlags, TPackage, TRequiredAPI  ) \
private: \
    TClass& operator=(TClass&&);   \
    TClass& operator=(const TClass&);   \
	TRequiredAPI static UClass* GetPrivateStaticClass(); \
public: \
	/** Bitwise union of #EClassFlags pertaining to this class.*/ \
	enum {StaticClassFlags=TStaticFlags}; \
	/** Typedef for the base class ({{ typedef-type }}) */ \
	typedef TSuperClass Super;\
	/** Typedef for {{ typedef-type }}. */ \
	typedef TClass ThisClass;\
	/** Returns a UClass object representing this class at runtime */ \
	inline static UClass* StaticClass() \
	{ \
		return GetPrivateStaticClass(); \
	} \
	/** Returns the package this class belongs in */ \
	inline static const TCHAR* StaticPackage() \
	{ \
		return TPackage; \
	} \
	/** Returns the static cast flags for this class */ \
	inline static EClassCastFlags StaticClassCastFlags() \
	{ \
		return TStaticCastFlags; \
	} \
	/** For internal use only; use StaticConstructObject() to create new objects. */ \
	inline void* operator new(const size_t InSize, EInternal InInternalOnly, UObject* InOuter = (UObject*)GetTransientPackage(), FName InName = NAME_None, EObjectFlags InSetFlags = RF_NoFlags) \
	{ \
		return StaticAllocateObject(StaticClass(), InOuter, InName, InSetFlags); \
	} \
	/** For internal use only; use StaticConstructObject() to create new objects. */ \
	inline void* operator new( const size_t InSize, EInternal* InMem ) \
	{ \
		return (void*)InMem; \
	}

#include "UObject/GeneratedCppIncludes.h"
#include "AdvanceFunc/Public/HelloWorld.h"
#ifdef _MSC_VER
#pragma warning (push)
#pragma warning (disable : 4883)
#endif
PRAGMA_DISABLE_DEPRECATION_WARNINGS
void EmptyLinkFunctionForGeneratedCodeHelloWorld() {}//忽略
// Cross Module References
	ADVANCEFUNC_API UClass* Z_Construct_UClass_AHelloWorld_NoRegister();//构造对应的没有后续的注册过程UClass对象
	ADVANCEFUNC_API UClass* Z_Construct_UClass_AHelloWorld();//在下面L61，构造AHelloWorld对应的UClass对象
	ENGINE_API UClass* Z_Construct_UClass_AActor();
	UPackage* Z_Construct_UPackage__Script_AdvanceFunc();//构造本身的UPackage对象
// End Cross Module References
	void AHelloWorld::StaticRegisterNativesAHelloWorld()//静态注册，目前是空的
	{
	}
	UClass* Z_Construct_UClass_AHelloWorld_NoRegister()
	{
		return AHelloWorld::StaticClass();
	}
	struct Z_Construct_UClass_AHelloWorld_Statics
	{
		static UObject* (*const DependentSingletons[])();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Class_MetaDataParams[];
#endif
		static const FCppClassTypeInfoStatic StaticCppClassTypeInfo;
		static const UE4CodeGen_Private::FClassParams ClassParams;
	};
	UObject* (*const Z_Construct_UClass_AHelloWorld_Statics::DependentSingletons[])() = {
		(UObject* (*)())Z_Construct_UClass_AActor,
		(UObject* (*)())Z_Construct_UPackage__Script_AdvanceFunc,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_AHelloWorld_Statics::Class_MetaDataParams[] = {
		{ "IncludePath", "HelloWorld.h" },
		{ "ModuleRelativePath", "Public/HelloWorld.h" },
	};
#endif
	const FCppClassTypeInfoStatic Z_Construct_UClass_AHelloWorld_Statics::StaticCppClassTypeInfo = {
		TCppClassTypeTraits<AHelloWorld>::IsAbstract,
	};
//构造HelloWorld的UPackage
	const UE4CodeGen_Private::FClassParams Z_Construct_UClass_AHelloWorld_Statics::ClassParams = {
		&AHelloWorld::StaticClass,
		"Engine",
		&StaticCppClassTypeInfo,
		DependentSingletons,
		nullptr,
		nullptr,
		nullptr,
		UE_ARRAY_COUNT(DependentSingletons),
		0,
		0,
		0,
		0x009000A4u,
		METADATA_PARAMS(Z_Construct_UClass_AHelloWorld_Statics::Class_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UClass_AHelloWorld_Statics::Class_MetaDataParams))
	};
	UClass* Z_Construct_UClass_AHelloWorld()
	{
		static UClass* OuterClass = nullptr;
		if (!OuterClass)
		{
			UE4CodeGen_Private::ConstructUClass(OuterClass, Z_Construct_UClass_AHelloWorld_Statics::ClassParams);
		}
		return OuterClass;
	}
	IMPLEMENT_CLASS(AHelloWorld, 1028549712); //这个比较重要,见下文
	template<> ADVANCEFUNC_API UClass* StaticClass<AHelloWorld>()
	{
		return AHelloWorld::StaticClass();
	}
////延迟注册，注入信息，在启动的时候调用
	static FCompiledInDefer Z_CompiledInDefer_UClass_AHelloWorld(Z_Construct_UClass_AHelloWorld, &AHelloWorld::StaticClass, TEXT("/Script/AdvanceFunc"), TEXT("AHelloWorld"), false, nullptr, nullptr, nullptr);
	DEFINE_VTABLE_PTR_HELPER_CTOR(AHelloWorld);//热更新相关
PRAGMA_ENABLE_DEPRECATION_WARNINGS
#ifdef _MSC_VER
#pragma warning (pop)
#endif

#define IMPLEMENT_CLASS(TClass, TClassCrc) \
	static TClassCompiledInDefer<TClass> AutoInitialize##TClass(TEXT(#TClass), sizeof(TClass), TClassCrc); \
	UClass* TClass::GetPrivateStaticClass() \
	{ \
		static UClass* PrivateStaticClass = NULL; \
		if (!PrivateStaticClass) \
		{ \
			/* this could be handled with templates, but we want it external to avoid code bloat */ \
			GetPrivateStaticClassBody( \
				StaticPackage(), \ //Package名字
				(TCHAR*)TEXT(#TClass) + 1 + ((StaticClassFlags & CLASS_Deprecated) ? 11 : 0), \
				PrivateStaticClass, \//输出引用
				StaticRegisterNatives##TClass, \
				sizeof(TClass), \
				alignof(TClass), \
				(EClassFlags)TClass::StaticClassFlags, \
				TClass::StaticClassCastFlags(), \
				TClass::StaticConfigName(), \
				(UClass::ClassConstructorType)InternalConstructor<TClass>, \
				(UClass::ClassVTableHelperCtorCallerType)InternalVTableHelperCtorCaller<TClass>, \
				&TClass::AddReferencedObjects, \
				&TClass::Super::StaticClass, \
				&TClass::WithinClass::StaticClass \
			); \
		} \
		return PrivateStaticClass; \
	}

UPROPERTY(BlueprintReadWrite)
int32 number=0;

UFUNCTION(BlueprintCallable)
void BP_Callable();

UFUNCTION(BlueprintNativeEvent)
void BP_Native(float value);

UFUNCTION(BlueprintImplementableEvent)
bool BP_Implemetable(const FString& str,int32 id);

#define AdvanceFunc_Source_AdvanceFunc_Public_ByeWorld_h_12_RPC_WRAPPERS \
	virtual void BP_Native_Implementation(float value); \
 \
	DECLARE_FUNCTION(execBP_Native) \
	{ \
		P_GET_PROPERTY(UFloatProperty,Z_Param_value); \
		P_FINISH; \
		P_NATIVE_BEGIN; \
		P_THIS->BP_Native_Implementation(Z_Param_value); \
		P_NATIVE_END; \
	} \
 \
	DECLARE_FUNCTION(execBP_Callable) \
	{ \
		P_FINISH; \
		P_NATIVE_BEGIN; \
		P_THIS->BP_Callable(); \
		P_NATIVE_END; \
	}

#define AdvanceFunc_Source_AdvanceFunc_Public_ByeWorld_h_12_RPC_WRAPPERS_NO_PURE_DECLS \
	virtual void BP_Native_Implementation(float value); \
 \
	DECLARE_FUNCTION(execBP_Native) \
	{ \
		P_GET_PROPERTY(UFloatProperty,Z_Param_value); \
		P_FINISH; \
		P_NATIVE_BEGIN; \
		P_THIS->BP_Native_Implementation(Z_Param_value); \
		P_NATIVE_END; \
	} \
 \
	DECLARE_FUNCTION(execBP_Callable) \
	{ \
		P_FINISH; \
		P_NATIVE_BEGIN; \
		P_THIS->BP_Callable(); \
		P_NATIVE_END; \
	}

#define AdvanceFunc_Source_AdvanceFunc_Public_ByeWorld_h_12_EVENT_PARMS \
	struct ByeWorld_eventBP_Implemetable_Parms \
	{ \
		FString str; \
		int32 id; \
		bool ReturnValue; \
 \
		/** Constructor, initializes return property only **/ \
		ByeWorld_eventBP_Implemetable_Parms() \
			: ReturnValue(false) \
		{ \
		} \
	}; \
	struct ByeWorld_eventBP_Native_Parms \
	{ \
		float value; \
	};

	ADVANCEFUNC_API UFunction* Z_Construct_UFunction_AByeWorld_BP_Callable();
	ADVANCEFUNC_API UFunction* Z_Construct_UFunction_AByeWorld_BP_Implemetable();
	ADVANCEFUNC_API UFunction* Z_Construct_UFunction_AByeWorld_BP_Native();
//............
//函数名字定义
	static FName NAME_AByeWorld_BP_Implemetable = FName(TEXT("BP_Implemetable"));
	bool AByeWorld::BP_Implemetable(const FString& str, int32 id)
	{
		ByeWorld_eventBP_Implemetable_Parms Parms;
		Parms.str=str;
		Parms.id=id;
		ProcessEvent(FindFunctionChecked(NAME_AByeWorld_BP_Implemetable),&Parms);
		return !!Parms.ReturnValue;
	}
	static FName NAME_AByeWorld_BP_Native = FName(TEXT("BP_Native"));
	void AByeWorld::BP_Native(float value)
	{
		ByeWorld_eventBP_Native_Parms Parms;
		Parms.value=value;
		ProcessEvent(FindFunctionChecked(NAME_AByeWorld_BP_Native),&Parms);
	}
//注册函数名字和函数指针映射，其他2个函数类同
	void AByeWorld::StaticRegisterNativesAByeWorld()
	{
		UClass* Class = AByeWorld::StaticClass();
		static const FNameNativePtrPair Funcs[] = {
			{ "BP_Callable", &AByeWorld::execBP_Callable },
			{ "BP_Native", &AByeWorld::execBP_Native },
		};
		FNativeFunctionRegistrar::RegisterFunctions(Class, Funcs, UE_ARRAY_COUNT(Funcs));
	}
//对应函数所有反射信息，其他类同
	struct Z_Construct_UFunction_AByeWorld_BP_Callable_Statics
	{
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UE4CodeGen_Private::FFunctionParams FuncParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AByeWorld_BP_Callable_Statics::Function_MetaDataParams[] = {
		{ "ModuleRelativePath", "Public/ByeWorld.h" },
	};
#endif
	const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_AByeWorld_BP_Callable_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_AByeWorld, nullptr, "BP_Callable", nullptr, nullptr, 0, nullptr, 0, RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04020401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_AByeWorld_BP_Callable_Statics::Function_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UFunction_AByeWorld_BP_Callable_Statics::Function_MetaDataParams)) };
	UFunction* Z_Construct_UFunction_AByeWorld_BP_Callable()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_AByeWorld_BP_Callable_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	//......................

	struct Z_Construct_UClass_AByeWorld_Statics
	{
		static UObject* (*const DependentSingletons[])();
		static const FClassFunctionLinkInfo FuncInfo[];
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Class_MetaDataParams[];
#endif
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_number_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_number;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const FCppClassTypeInfoStatic StaticCppClassTypeInfo;
		static const UE4CodeGen_Private::FClassParams ClassParams;
	};
	UObject* (*const Z_Construct_UClass_AByeWorld_Statics::DependentSingletons[])() = {
		(UObject* (*)())Z_Construct_UClass_AActor,
		(UObject* (*)())Z_Construct_UPackage__Script_AdvanceFunc,
	};
	const FClassFunctionLinkInfo Z_Construct_UClass_AByeWorld_Statics::FuncInfo[] = {
		{ &Z_Construct_UFunction_AByeWorld_BP_Callable, "BP_Callable" }, // 2843195228
		{ &Z_Construct_UFunction_AByeWorld_BP_Implemetable, "BP_Implemetable" }, // 3962882496
		{ &Z_Construct_UFunction_AByeWorld_BP_Native, "BP_Native" }, // 1595191378
	};
//定义UPROPERTY反射数据，（如果是TMap会有3条，本身，键，值）
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UClass_AByeWorld_Statics::NewProp_number = { "number", nullptr, (EPropertyFlags)0x0010000000000004, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(AByeWorld, number), METADATA_PARAMS(Z_Construct_UClass_AByeWorld_Statics::NewProp_number_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_AByeWorld_Statics::NewProp_number_MetaData)) };
//把所有属性加入这个数组，然后放入类的反射数据
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UClass_AByeWorld_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_AByeWorld_Statics::NewProp_number,
	};
	const FCppClassTypeInfoStatic Z_Construct_UClass_AByeWorld_Statics::StaticCppClassTypeInfo = {
		TCppClassTypeTraits<AByeWorld>::IsAbstract,
	};
	const UE4CodeGen_Private::FClassParams Z_Construct_UClass_AByeWorld_Statics::ClassParams = {
		&AByeWorld::StaticClass,
		"Engine",
		&StaticCppClassTypeInfo,
		DependentSingletons,
		FuncInfo,
		Z_Construct_UClass_AByeWorld_Statics::PropPointers,
		nullptr,
		UE_ARRAY_COUNT(DependentSingletons),
		UE_ARRAY_COUNT(FuncInfo),
		UE_ARRAY_COUNT(Z_Construct_UClass_AByeWorld_Statics::PropPointers),
		0,
		0x009000A4u,
		METADATA_PARAMS(Z_Construct_UClass_AByeWorld_Statics::Class_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UClass_AByeWorld_Statics::Class_MetaDataParams))
	};
//....................

std::vector<std::string> vec;
for(auto i = vec.begin(), i != vec.end(), ++i)
{……}

template<_typename _Tx, _typename _Ty>
{
	auto v = x * y;
	std::cout<<v<<endl;
}

auto multipy(_Tx x, _Ty y)->decltype(x * y)
	return x * y;

auto func1(int a)->bool
{}

auto a=10,b=11.0;//报错，初始化必须统一类型

int a=1;
int &b =a;
auto c=b;//c为int，去除&
auto &d=b;//d为引用
const int e=10;
auto f = e;//去除const
auto &g = e;//用&，不去除const

int arr[3] = {1, 2, 3};
auto brr = arr;      //brr 类型为int*
auto &crr = arr; //crr为数组，即crr=arr[3]

int var;
const int&& fx(); 
struct A { double x; }
const A* a = new A();

decltype(var);//int
decltype(fx());//const int&&
decltype(a->x);//double
decltype((a->x));//const double&,内部括号导致语句作为表达式而不是成员访问计算。由于a声明为 const指针，因此类型是对const double的引用。

template<typename T, typename U>
decltype(auto) myFunc(T&& t, U&& u) 
        { return forward<T>(t) + forward<U>(u); };

using namespace std;

using itType=std::vector<std::string>::iterator;

template<class T>
    using arr12=std::array<T,12>;

class Basic{
    public:
        int a;
        int b;
};
class Bulk : private Basic{
    public:
        using Basic::a;
    protected:
        using Basic::b;

class A1
{
public:
	void test(){cout<<"A1"; };
	void test(int a){cout<<a;};
};

class A2 :public A1
{
public:
	void test(){cout<<"A2";};
	using A1::test;//如果不加此行，A2将只保留test()部分，导致主函数内报错
};

int main()
{
	A2 a2;
	a2.test(11);//如果不用using，此行报错
	system("pause");
	return 0;
}

enum EnumA
{
	P1=0,
	P2=1
};
enum EnumB
{
	P1,//歧义，编译失败
	P2//歧义，编译失败
};

int main()
{
	EnumA e1=EnumA::P1;
    return 0;
}

enum class EnumA
{
	P1=0,
	P2=1
};
enum struct EnumB
{
	P1,
	P2
};

int main()
{
	EnumA e1=EnumA::P1;
	EnumB e2=EnumB::P2;
}

[capture](parameters)->return-type{body}

[](int x, int y) { return x + y; } // 隐式返回类型
[](int& x) { ++x; }   // 没有return语句 -> lambda 函数的返回类型是'void'
[]() { ++global_x; }  // 没有参数,仅访问某个全局变量
[]{ ++global_x; }     // 与上一个相同,省略了()
[](int x, int y) -> int { int z = x + y; return z; }//指示了返回值int

[]        //未定义变量.试图在Lambda内使用任何外部变量都是错误的.
[x, &y]   //x 按值捕获, y 按引用捕获.
[&]       //用到的任何外部变量都隐式按引用捕获
[=]       //用到的任何外部变量都隐式按值捕获
[&, x]    //x显式地按值捕获. 其它变量按引用捕获
[=, &z]   //z按引用捕获. 其它变量按值捕获
[this] //截取当前类中的this指针。如果已经使用了&或者=就默认添加此选项。

A1* a1=new A1();
int a2=2;
auto lambda1=[&a1,a2](int v){a1->num=v;a2++;};//错误，a2按值传递，不能修改
auto lambda1=[&a1,a2](int v)mutable {a2++;a1->num=v+a2;;};//增加mutable后可以修改，但是对原数据无影响，输出结果a1->num : 15

class plebe
{
    plebe(int);
    explicit plebe(double);
}

plebe a,b;
a=1;//隐式转换
b=0.5;//错误
b=plebe(0.5);//显式转换

class testA
{
public:
	testA() =default;
	testA(const testA& t)=default;
	~testA()=default;
	testA& operator=(const testA& t)=default;

	int num=1;
	int *p=#
};	

testA *a1= new testA(1);
testA *a2 =a1;
delete a1;//a2的p也被释放了
cout<<*a2->p<<endl;

class se
{
    int mem1=10;//类内初始化
    double mem2{123.65};//同上
}

//int &a =2;//左值引用绑定右值，fail
int b=1;//非常量左值绑定右值，ok
const int &c=b;//常量左值引用绑定非常量左值，ok
const int &d=2;//常量左值引用绑定常量左值,ok
int && f=10;//右值引用绑定右值,ok
const int &g=f;//常量左值引用绑定右值引用,ok
//int &&h=b;//右值引用绑定非常量左值，fail
int &&h=std::move(b);//move把左值转换为右值，ok
//int &&i=h;//变量是左值，h是左值,fail

// 使用裸指针赋值构造，不推荐，裸指针被释放后，shared_ptr就野了，不能完全控制裸指针的生命周期，失去了智能指针价值
int *p = new int(10);
shared_ptr<int>sp = p;
delete p; // sp将成为野指针，使用sp将crash
// 将裸指针作为匿名指针传入构造函数，一般做法，让shared_ptr接管裸指针的生命周期，更安全
shared_ptr<int>sp1(new int(10));
// 使用make_shared，推荐做法，更符合工厂模式，可以连代码中的所有new，更高效；方法的参数是用来初始化模板类
shared_ptr<int>sp2 = make_shared<int>(10);

shared_ptr<int>sp = make_shared<int>(10);
cout << sp.use_count() << endl; //输出1
shared_ptr<int> *sp1 = &sp;
cout << (*sp1).use_count() << endl; //输出依然是1
(*sp1).reset(); //sp成为野指针
cout << *sp << endl; //crash

class A {
public:
	shared_ptr<B> b;
};
class B {
public:
	weak_ptr<A> a;
};

int main()
{
	
	shared_ptr<A> spa = make_shared<A>();
	shared_ptr<B> spb = make_shared<B>();
	spa->b = spb; //spb强引用计数为2，弱引用计数为1
	spb->a = spa; //spa强引用计数为1，弱引用计数为2

	system("pause");
	return 0;
}

weak_ptr<T> w;  //空weak_ptr可以指向类型为T的对象
weak_ptr<T> w(shared_ptr sp);   //与sp指向相同对象的weak_ptr, T必须能转换为sp指向的类型
w = p;  //p可以是shared_ptr或者weak_ptr，赋值后w和p共享对象
w.reset();  //weak_ptr置为空
w.use_count();  //与w共享对象的shared_ptr的计数
w.expired();    //w.use_count()为0则返回true，否则返回false
w.lock();   //w.expired()为true，返回空的shared_ptr;否则返回指向w的shared_ptr

unique_ptr<int> p1=make_unique<int>(11);
cout<<*p1<<endl;//11
auto p2=move(p1);
cout<<*p1<<endl;//访问空指针，崩溃

double price[5]={1.1,2.2,3.3,4.4,5.5};
for(double x:prices)//也可以使用auto来申明x，编译器将自动推断
    std::cout<<x<<std::endl;

vector<list<int>> vl;//C++11开始不再强求空格

struct Vertex
{
    XMFLOAT3 Pos;
    XMFLOAT4 Color;
};

struct Vertex2
{
    XMFLOAT3 Pos;
    XMFLOAT3 Normal;
    XMFLOAT2 Tex0;
    XMFLOAT2 Tex1;
}

typedef struct D3D12_INPUT_LAYOUT_DESC
    {
    _Field_size_full_(NumElements)  const D3D12_INPUT_ELEMENT_DESC *pInputElementDescs;
    UINT NumElements;//数量
    } 	D3D12_INPUT_LAYOUT_DESC;

typedef struct D3D12_INPUT_ELEMENT_DESC
    {
    LPCSTR SemanticName;
    UINT SemanticIndex;
    DXGI_FORMAT Format;
    UINT InputSlot;
    UINT AlignedByteOffset;
    D3D12_INPUT_CLASSIFICATION InputSlotClass;
    UINT InstanceDataStepRate;
    } 	D3D12_INPUT_ELEMENT_DESC;

struct Vertex2
{
    XMFLOAT3 Pos;//偏移0字节
    XMFLOAT3 Normal;//偏移12字节
    XMFLOAT2 Tex0;//偏移24字节
    XMFLOAT2 Tex1;//偏移32字节
}

D3D12_INPUT_ELEMENT_DESC desc1 =
  {
      { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
      { "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 }
  };

D3D12_INPUT_ELEMENT_DESC desc2 =
  {
      { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
      { "NORMAL", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
    { "TEXCOORD", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 24, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
      { "TEXCOORD", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 32, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 }
  };

struct CD3DX12_RESOURCE_DESC : public D3D12_RESOURCE_DESC
{
    CD3DX12_RESOURCE_DESC()
    {}
    explicit CD3DX12_RESOURCE_DESC( const D3D12_RESOURCE_DESC& o ) :
        D3D12_RESOURCE_DESC( o )
    {}
    CD3DX12_RESOURCE_DESC( 
        D3D12_RESOURCE_DIMENSION dimension,
        UINT64 alignment,
        UINT64 width,
        UINT height,
        UINT16 depthOrArraySize,
        UINT16 mipLevels,
        DXGI_FORMAT format,
        UINT sampleCount,
        UINT sampleQuality,
        D3D12_TEXTURE_LAYOUT layout,
        D3D12_RESOURCE_FLAGS flags )
        /**********/
}

static inline CD3DX12_RESOURCE_DESC Buffer( 
       UINT64 width,
       D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
       UINT64 alignment = 0 )
   {
       return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_BUFFER, alignment, width, 1, 1, 1, 
           DXGI_FORMAT_UNKNOWN, 1, 0, D3D12_TEXTURE_LAYOUT_ROW_MAJOR, flags );
   }

// Create the actual default buffer resource.
  ThrowIfFailed(device->CreateCommittedResource(
      &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT),
      D3D12_HEAP_FLAG_NONE,
      &CD3DX12_RESOURCE_DESC::Buffer(byteSize),
D3D12_RESOURCE_STATE_COMMON,
      nullptr,
      IID_PPV_ARGS(defaultBuffer.GetAddressOf())));

Microsoft::WRL::ComPtr<ID3D12Resource> d3dUtil::CreateDefaultBuffer(
    ID3D12Device* device,
    ID3D12GraphicsCommandList* cmdList,
    const void* initData,
    UINT64 byteSize,
    Microsoft::WRL::ComPtr<ID3D12Resource>& uploadBuffer)
{
    ComPtr<ID3D12Resource> defaultBuffer;

    //创建实际的默认缓冲区资源
    ThrowIfFailed(device->CreateCommittedResource(
        &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT),
        D3D12_HEAP_FLAG_NONE,
        &CD3DX12_RESOURCE_DESC::Buffer(byteSize),
		D3D12_RESOURCE_STATE_COMMON,
        nullptr,
        IID_PPV_ARGS(defaultBuffer.GetAddressOf())));

    //为了将CPU端内存中的数据复制到缓冲区，我们就创建处于中介位置的上传堆
    ThrowIfFailed(device->CreateCommittedResource(
        &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD),
		D3D12_HEAP_FLAG_NONE,
        &CD3DX12_RESOURCE_DESC::Buffer(byteSize),
		D3D12_RESOURCE_STATE_GENERIC_READ,
        nullptr,
        IID_PPV_ARGS(uploadBuffer.GetAddressOf())));


    // 描述我们希望复制到默认缓冲区的数据
    D3D12_SUBRESOURCE_DATA subResourceData = {};
    subResourceData.pData = initData;
    subResourceData.RowPitch = byteSize;
    subResourceData.SlicePitch = subResourceData.RowPitch;

    //将数据复制到默认缓冲区的流程
    //UpdateSubresources辅助函数将数据从CPU复制到上传堆
    //再通过ID3D12CommandList::CopySubresourceRegion函数复制到mBuff中
	cmdList->ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(defaultBuffer.Get(), 
		D3D12_RESOURCE_STATE_COMMON, D3D12_RESOURCE_STATE_COPY_DEST));
    UpdateSubresources<1>(cmdList, defaultBuffer.Get(), uploadBuffer.Get(), 0, 0, 1, &subResourceData);
	cmdList->ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(defaultBuffer.Get(),
		D3D12_RESOURCE_STATE_COPY_DEST, D3D12_RESOURCE_STATE_GENERIC_READ));

    // uploadBuffer必须在调用方法以后依然存在，因为命令列表的复制操作可能未执行，等调用者复制完消息以后才可以释放


    return defaultBuffer;
}

typedef struct D3D12_SUBRESOURCE_DATA
    {
    const void *pData;//初始化缓冲区所用的数据指针
    LONG_PTR RowPitch;//对于缓冲区，此参数为欲复制数据的字节数
    LONG_PTR SlicePitch;//同上
    } 	D3D12_SUBRESOURCE_DATA;

 std::array<Vertex, 8> vertices =
    {
        Vertex({ XMFLOAT3(-1.0f, -1.0f, -1.0f), XMFLOAT4(Colors::White) }),
		Vertex({ XMFLOAT3(-1.0f, +1.0f, -1.0f), XMFLOAT4(Colors::Black) }),
		Vertex({ XMFLOAT3(+1.0f, +1.0f, -1.0f), XMFLOAT4(Colors::Red) }),
		Vertex({ XMFLOAT3(+1.0f, -1.0f, -1.0f), XMFLOAT4(Colors::Green) }),
		Vertex({ XMFLOAT3(-1.0f, -1.0f, +1.0f), XMFLOAT4(Colors::Blue) }),
		Vertex({ XMFLOAT3(-1.0f, +1.0f, +1.0f), XMFLOAT4(Colors::Yellow) }),
		Vertex({ XMFLOAT3(+1.0f, +1.0f, +1.0f), XMFLOAT4(Colors::Cyan) }),
		Vertex({ XMFLOAT3(+1.0f, -1.0f, +1.0f), XMFLOAT4(Colors::Magenta) })
    };

const UINT vbByteSize = (UINT)vertices.size() * sizeof(Vertex);
Microsoft::WRL::ComPtr<ID3D12Resource> VertexBufferGPU = nullptr;
Microsoft::WRL::ComPtr<ID3D12Resource> VertexBufferUploader = nullptr;

mBoxGeo->VertexBufferGPU = d3dUtil::CreateDefaultBuffer(md3dDevice.Get(),
		mCommandList.Get(), vertices.data(), vbByteSize, mBoxGeo->VertexBufferUploader);

typedef struct D3D12_VERTEX_BUFFER_VIEW
    {
    D3D12_GPU_VIRTUAL_ADDRESS BufferLocation;
    UINT SizeInBytes;
    UINT StrideInBytes;
    } 

//第一个参数：所用的输入槽，一般用0
//第二个参数：与输入槽绑定的缓冲区数量，即pView数组中视图的数量
//视图数组的第一个元素的地址
mCommandList->IASetVertexBuffers(0, 1, &mBoxGeo->VertexBufferView());

//参数1：每个实例绘制的顶点数
//参数2：实例化高级技术，目前给1
//参数3：第一个被绘制顶点的索引
//参数4：实例化技术，目前给0
mCommandList->DrawIndexedInstanced(
		mBoxGeo->DrawArgs["box"].IndexCount, 
		1, 0, 0, 0);

typedef struct D3D12_INDEX_BUFFER_VIEW
    {
    D3D12_GPU_VIRTUAL_ADDRESS BufferLocation;//带创建索引缓冲区虚拟地址，用ID3D12Resource::GetGUPVirtualAddress()得到
    UINT SizeInBytes;//索引缓冲区大小
    DXGI_FORMAT Format;//必须为DXGI_FORMAT_R16_UINT类型或者DXGI_FORMAT_R32_UINT
    } 

	std::array<std::uint16_t, 36> indices =
	{
		// front face
		0, 1, 2,
		0, 2, 3,

		// back face
		4, 6, 5,
		4, 7, 6,

		// left face
		4, 5, 1,
		4, 1, 0,

		// right face
		3, 2, 6,
		3, 6, 7,

		// top face
		1, 5, 6,
		1, 6, 2,

		// bottom face
		4, 0, 3,
		4, 3, 7
	};

const UINT ibByteSize = (UINT)indices.size() * sizeof(std::uint16_t);

Microsoft::WRL::ComPtr<ID3D12Resource> IndexBufferGPU = nullptr;
Microsoft::WRL::ComPtr<ID3D12Resource> IndexBufferUploader = nullptr;

mBoxGeo->IndexBufferGPU = d3dUtil::CreateDefaultBuffer(md3dDevice.Get(),
		mCommandList.Get(), indices.data(), ibByteSize, mBoxGeo->IndexBufferUploader);

//第4个参数：读取顶点之前，要为每个索引都加上的整数值
//其他参考顶点绘制
mCommandList->DrawIndexedInstanced(
		mBoxGeo->DrawArgs["box"].IndexCount, 
		1, 0, 0, 0);

mCommandList->DrawIndexedInstanced(numOfBox, 1, 0, 0, 0);
mCommandList->DrawIndexedInstanced(numOfSph, 1, firstSphIdx, firstSphIdx, 0);
mCommandList->DrawIndexedInstanced(numOfCyl, 1, firstCylIdx, firstCylIdx, 0);

cbuffer cbPerObject:register(b0)
{
    float4x4 gWorldViewProj;
}
void VS(float3 iPosL:POSITION,float4 iColor:COLOR,out float4 oPosH:SV_POSTION,out float4 oColor:COLOR)
{
    //把顶点变换到齐次裁剪空间
    oPosH = mul(float4(iPosL,1.0f),gWolrdViewProj);
    //将顶点颜色信息传至像素着色器
    oColor=iColor;
}

struct VertexIn
{
    float3 PosL:POSTION;
    float4 Color:COLOR;
};
struct VertexOut
{
    float3 PosH:SV_POSTION;
    float4 Color:COLOR;
};
VextexOut VS(VertexIn vin)
{
    VertexOut vout;
    vout.PosH=mul(float4(vin.PosL,1.0f),gWolrdViewProj);
    vout.Color=vin.Color;
    return vout;
}

struct Vertex
{
    XMFLOAT3 Pos;
    XMFLOAT4 Color;
    //XMFLOAT3 Normal;//缺少此行输入
}

 D3D12_INPUT_ELEMENT_DESC[] =
    {
        { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
        { "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
      { "NORMAL", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 24, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 }
    };

struct VertexIn
{
    float3 PosL:POSTION;
    float4 Color:COLOR;
    float3 Normal:NORMAL;
};
struct VertexOut
{
    float3 PosH:SV_POSTION;
    float4 Color:COLOR;
};

VertexOut VS(VertexIn vin){...};

struct Vertex
{
    XMFLOAT3 Pos;
    XMFLOAT4 Color;
    XMFLOAT3 Normal;
}

 D3D12_INPUT_ELEMENT_DESC[] =
    {
        { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
        { "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
      { "NORMAL", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 24, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 }
    };

struct VertexIn
{
    float3 PosL:POSTION;
    float4 Color:COLOR;
    //float3 Normal:NORMAL;//输入有多余的参数可以匹配
};
struct VertexOut
{
    float3 PosH:SV_POSTION;
    float4 Color:COLOR;
};

VertexOut VS(VertexIn vin){...};

struct Vertex
{
    XMFLOAT3 Pos;
    XMFLOAT4 Color;
    XMFLOAT3 Normal;
}

 D3D12_INPUT_ELEMENT_DESC[] =
    {
        { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
        { "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
      { "NORMAL", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 24, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 }
    };

struct VertexIn
{
    float3 PosL:POSTION;
    float4 Color:COLOR;
    int3  Normal:NORMAL;//Direct3D会对数据类型重新解释，但会报警告
};
struct VertexOut
{
    float3 PosH:SV_POSTION;
    float4 Color:COLOR;
};

VertexOut VS(VertexIn vin){...};

cbuffer cbPerObject:register(b0)
{
    float4x4 gWorldViewProj;
}
void VS(float3 iPosL:POSITION,float4 iColor:COLOR,out float4 oPosH:SV_POSTION,out float4 oColor:COLOR)
{
    //把顶点变换到齐次裁剪空间
    oPosH = mul(float4(iPosL,1.0f),gWolrdViewProj);
    //将顶点颜色信息传至像素着色器
    oColor=iColor;
}

float4 PS(float4 posH:SV_POSITION,float4 color:COLOR):SV_TARGET
{
    return color;
}

struct VertexIn
{
    float3 PosL:POSTION;
    float4 Color:COLOR;
  
};
struct VertexOut
{
    float3 PosH:SV_POSTION;
    float4 Color:COLOR;
};
VextexOut VS(VertexIn vin)
{
    VertexOut vout;
    vout.PosH=mul(float4(vin.PosL,1.0f),gWolrdViewProj);
    vout.Color=vin.Color;
    return vout;
}
float4 PS(VertexOut pin):VS_TARGET
{
    return pin.Color;
}

cbuffer cbPerObject:register(b0)
{
    float4x4 gWorldViewProj;
}

struct ObjectConstants
{
    XMFLOAT4X4 WorldViewProj = MathHelper::Identity4x4();
};

 UINT mElementByteSize = d3dUtil::CalcConstantBufferByteSize(sizeof(T));//换算使得缓冲区大小保持在256B的倍数

Microsoft::WRL::ComPtr<ID3D12Resource> mUploadBuffer;
ThrowIfFailed(device->CreateCommittedResource(
            &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD),
            D3D12_HEAP_FLAG_NONE,
            &CD3DX12_RESOURCE_DESC::Buffer(mElementByteSize*elementCount),
			D3D12_RESOURCE_STATE_GENERIC_READ,
            nullptr,
            IID_PPV_ARGS(&mUploadBuffer)));

struct ObjectConstants
{
    float4x4 gWorldViewProj;
    uint matIndex;
};
ConstantBuffer<ObjectConstants> gObjConstants : register(b0);

uint index = gObjConstants.matIndex;

Microsoft::WRL::ComPtr<ID3D12Resource> mUploadBuffer;
BYTE* mMappedData = nullptr;
//参数1：预映射的子资源，对于缓冲区来说设置为0
//参数2：指向D3D12_RANGE结构体的可选项，描述了映射范围，如果是空就对整个资源映射
//参数3：双重指针返回待映射资源书的目标内存块
ThrowIfFailed(mUploadBuffer->Map(0, nullptr, reinterpret_cast<void**>(&mMappedData)));

memcpy(mMappedData,&data,dataSizeInBytes);//用此函数将数据从系统内存复制到常量缓冲区

if(mUploadBuffer != nullptr)
    mUploadBuffer->Unmap(0,nullptr);
mMappedData = nullptr;

template<typename T>
class UploadBuffer
{
public:
    UploadBuffer(ID3D12Device* device, UINT elementCount, bool isConstantBuffer) : 
        mIsConstantBuffer(isConstantBuffer)
    {
        mElementByteSize = sizeof(T);

        //常量缓冲区的大小为256B的整数倍
        //长度者两种规格来查看常量数据
        //UINT64 SizeInBytes;//256的整数倍
        //UINT OffsetInBytes;//256的整数倍
        if(isConstantBuffer)
            mElementByteSize = d3dUtil::CalcConstantBufferByteSize(sizeof(T));

        ThrowIfFailed(device->CreateCommittedResource(
            &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD),
            D3D12_HEAP_FLAG_NONE,
            &CD3DX12_RESOURCE_DESC::Buffer(mElementByteSize*elementCount),
			D3D12_RESOURCE_STATE_GENERIC_READ,
            nullptr,
            IID_PPV_ARGS(&mUploadBuffer)));

        ThrowIfFailed(mUploadBuffer->Map(0, nullptr, reinterpret_cast<void**>(&mMappedData)));

        //只要还会需改当前的资源，我们就无需取消映射
        // 但是在资源被GPU使用期间，我们千万不可向该资源进行写操作（所以需要借助同步技术）
    }

    UploadBuffer(const UploadBuffer& rhs) = delete;
    UploadBuffer& operator=(const UploadBuffer& rhs) = delete;
    ~UploadBuffer()
    {
        if(mUploadBuffer != nullptr)
            mUploadBuffer->Unmap(0, nullptr);

        mMappedData = nullptr;
    }

    ID3D12Resource* Resource()const
    {
        return mUploadBuffer.Get();
    }

    void CopyData(int elementIndex, const T& data)
    {
        memcpy(&mMappedData[elementIndex*mElementByteSize], &data, sizeof(T));
    }

private:
    Microsoft::WRL::ComPtr<ID3D12Resource> mUploadBuffer;
    BYTE* mMappedData = nullptr;

    UINT mElementByteSize = 0;
    bool mIsConstantBuffer = false;
};

void BoxApp::OnMouseMove(WPARAM btnState, int x, int y)
{
    if((btnState & MK_LBUTTON) != 0)
    {
        // 根据鼠标的移动距离计算旋转角度，令每个像素按此角度的1/4旋转
        float dx = XMConvertToRadians(0.25f*static_cast<float>(x - mLastMousePos.x));
        float dy = XMConvertToRadians(0.25f*static_cast<float>(y - mLastMousePos.y));

        // 根据鼠标输入来更新摄像机绕立方体旋转的角度
        mTheta += dx;
        mPhi += dy;

        // 限制角度mPhi的范围
        mPhi = MathHelper::Clamp(mPhi, 0.1f, MathHelper::Pi - 0.1f);
    }
    else if((btnState & MK_RBUTTON) != 0)
    {
        // 使场景中的每个像素按鼠标移动距离的0.005倍进行缩放
        float dx = 0.005f*static_cast<float>(x - mLastMousePos.x);
        float dy = 0.005f*static_cast<float>(y - mLastMousePos.y);

        // 根据鼠标的输入更新摄像机的可视范围半径
        mRadius += dx - dy;

        // 限制可视半径范围
        mRadius = MathHelper::Clamp(mRadius, 3.0f, 15.0f);
    }

    mLastMousePos.x = x;
    mLastMousePos.y = y;
}

void BoxApp::Update(const GameTimer& gt)
{
    // 将球坐标（球面坐标）转换为笛卡尔坐标系
    float x = mRadius*sinf(mPhi)*cosf(mTheta);
    float z = mRadius*sinf(mPhi)*sinf(mTheta);
    float y = mRadius*cosf(mPhi);

    // 构建观察矩阵
    XMVECTOR pos = XMVectorSet(x, y, z, 1.0f);
    XMVECTOR target = XMVectorZero();
    XMVECTOR up = XMVectorSet(0.0f, 1.0f, 0.0f, 0.0f);

    XMMATRIX view = XMMatrixLookAtLH(pos, target, up);
    XMStoreFloat4x4(&mView, view);

    XMMATRIX world = XMLoadFloat4x4(&mWorld);
    XMMATRIX proj = XMLoadFloat4x4(&mProj);
    XMMATRIX worldViewProj = world*view*proj;

	// 用最新的 worldViewProj 矩阵来更新常量缓冲区
	ObjectConstants objConstants;
    XMStoreFloat4x4(&objConstants.WorldViewProj, XMMatrixTranspose(worldViewProj));
    mObjectCB->CopyData(0, objConstants);
}

D3D12_DESCRIPTOR_HEAP_DESC cbvHeapDesc;
   cbvHeapDesc.NumDescriptors = 1;
   cbvHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV;
   cbvHeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
cbvHeapDesc.NodeMask = 0;
   ThrowIfFailed(md3dDevice->CreateDescriptorHeap(&cbvHeapDesc,
       IID_PPV_ARGS(&mCbvHeap)));

void BoxApp::BuildConstantBuffers()
{
    //此常量缓冲区存储了绘制n个物体所需的常量数据
	std::unique_ptr<UploadBuffer<ObjectConstants>> mObjectCB = std::make_unique<UploadBuffer<ObjectConstants>>(md3dDevice.Get(), 1, true);

	UINT objCBByteSize = d3dUtil::CalcConstantBufferByteSize(sizeof(ObjectConstants));
	//缓冲区的起始地址	
	D3D12_GPU_VIRTUAL_ADDRESS cbAddress = mObjectCB->Resource()->GetGPUVirtualAddress();
    //偏移到常量缓冲区中绘制第i个物体所需的常量数据
    int boxCBufIndex = 0;
	cbAddress += boxCBufIndex*objCBByteSize;

	D3D12_CONSTANT_BUFFER_VIEW_DESC cbvDesc;
	cbvDesc.BufferLocation = cbAddress;
	cbvDesc.SizeInBytes = d3dUtil::CalcConstantBufferByteSize(sizeof(ObjectConstants));

	md3dDevice->CreateConstantBufferView(
		&cbvDesc,
		mCbvHeap->GetCPUDescriptorHandleForHeapStart());
}

//将纹理资源绑定到纹理寄存器槽0
Texture2D gDiffuseMap : register(t0);
//把下列采样器资源一次绑定到采样器槽0-5
SamplerState gsamPointWrap : register(s0);
SamplerState gsamPointClamp : register(s1);
//将常量缓冲区资源绑定到常量缓冲区寄存器槽0
cbuffer cbPerObject : register(b0)
{
    float4x4 gWorld;
    float4x4 gTexTransform;
}
//绘制每种材质所需的各种不同的常量数据
cbuffer cbMaterial : register(b2)
{
    float4 gDiffuseAlbedo;
    float3 gFresnelR0;
    float gRoughness;
    float4x4 gMatTransform;
}

oid BoxApp::BuildRootSignature()
{
	// Shader programs typically require resources as input (constant buffers,
	// textures, samplers).  The root signature defines the resources the shader
	// programs expect.  If we think of the shader programs as a function, and
	// the input resources as function parameters, then the root signature can be
	// thought of as defining the function signature.  

	// 根参数可以是根常量、根描述符或者描述符表
	CD3DX12_ROOT_PARAMETER slotRootParameter[1];

	// 创建一个只存有一个CBV的描述符表
	CD3DX12_DESCRIPTOR_RANGE cbvTable;
	cbvTable.Init(D3D12_DESCRIPTOR_RANGE_TYPE_CBV, 1, 0);//1：表中的描述符数量，0：将此段描述符区域绑定至此基准着色器寄存器
	slotRootParameter[0].InitAsDescriptorTable(1, &cbvTable);//1：描述符区域的数量；table:指向描述符区域数组的指针

	// 根签名由一组根参数构成
	CD3DX12_ROOT_SIGNATURE_DESC rootSigDesc(1, slotRootParameter, 0, nullptr, 
		D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT);

	//创建仅含一个槽位的根签名
	ComPtr<ID3DBlob> serializedRootSig = nullptr;
	ComPtr<ID3DBlob> errorBlob = nullptr;
	HRESULT hr = D3D12SerializeRootSignature(&rootSigDesc, D3D_ROOT_SIGNATURE_VERSION_1,
		serializedRootSig.GetAddressOf(), errorBlob.GetAddressOf());

	if(errorBlob != nullptr)
	{
		::OutputDebugStringA((char*)errorBlob->GetBufferPointer());
	}
	ThrowIfFailed(hr);

	ThrowIfFailed(md3dDevice->CreateRootSignature(
		0,
		serializedRootSig->GetBufferPointer(),
		serializedRootSig->GetBufferSize(),
		IID_PPV_ARGS(&mRootSignature)));
}