月光林地

openssl req -nodes -newkey rsa:2048 -keyout 192.168.2.110.key -out 192.168.2.110.csr

bool UTestLib::V_LoadStringFromFile(const FString& FileName, const FString& RelativePath, FString& result)
{
	if (!FileName.IsEmpty())
	{
		FString file=FPaths::ProjectContentDir()+RelativePath+FileName;
		return  FFileHelper::LoadFileToString(result,*file);				
		
	}
	return false;
}
bool UTestLib::V_SaveStringToFile(const FString& FileName, const FString& RelativePath, const FString& string)
{

	if (!FileName.IsEmpty())
	{
		FString file = FPaths::ProjectContentDir() + RelativePath + FileName;
		return  FFileHelper::SaveStringToFile(string,*file);

	}
	return false;
}

class UEdGraph* GraphObj;//图表实例的类型，定义了该图表的行为（例如保存图表
TSharedPtr<class SGraphEditor> GraphEdSlate;//图表编辑器的Slate类型

GraphObj=NewObject<UEdGraph>();
GraphObj->AddToRoot();
GraphObj->Schema=UTestGraphSchema::StaticClass();//自定义的schema类，刚开始可以先使用默认的UGraphSchema即可显示基础图表
GraphEdSlate=SNew(SGraphEditor)
    .GraphToEdit(GraphObj);

return SNew(SDockTab)
		.TabRole(ETabRole::NomadTab)
		[
			// Put your tab content here!
			SNew(SBox)
			.HAlign(HAlign_Fill)
			.VAlign(VAlign_Fill)
			[
				GraphEdSlate.ToSharedRef()//需要转成ref
			]
		];

UEdGraphNode* FTestGraphSchemaAction::PerformAction(class UEdGraph* ParentGraph, UEdGraphPin* FromPin, const FVector2D Location, bool bSelectNewNode /* = true */)
{
	UEdGraphNode* resNode=nullptr;
	if (NodeHello)
	{
		const FScopedTransaction Trans(LOCTEXT("FF","Hello:NewNode"));
		ParentGraph->Modify();
		if (FromPin!=nullptr)
		{
			FromPin->Modify();
		}
		NodeHello->Rename(TEXT("TEST"),ParentGraph);
		ParentGraph->AddNode(NodeHello,true,bSelectNewNode);

		NodeHello->CreateNewGuid();//唯一标识
		NodeHello->PostPlacedNewNode();//初始化
		NodeHello->AllocateDefaultPins();//针脚
		NodeHello->AutowireNewNode(FromPin);//自动创建节点

		NodeHello->NodePosX=Location.X;
		NodeHello->NodePosY = Location.Y;

		NodeHello->SetFlags(RF_Transactional);

		resNode=NodeHello;
	}

	return resNode;

}

void UTestGraphSchema::GetGraphContextActions(FGraphContextMenuBuilder& ContextMenuBuilder) const
{
	TSharedPtr<FTestGraphSchemaAction> NewNodeAction(new 
	FTestGraphSchemaAction(LOCTEXT("11","GraphNode"), 
	LOCTEXT("Desc","TestNodeDesc"), //desc
	LOCTEXT("NewGraphText","Add Hello Node"),//hover
	0));

	NewNodeAction->NodeHello=NewObject<UTestNode_Hello>(ContextMenuBuilder.OwnerOfTemporaries/*存储节点*/);
	ContextMenuBuilder.AddAction(NewNodeAction);

}

void UTestGraphSchema::GetContextMenuActions(class UToolMenu* Menu, class UGraphNodeContextMenuContext* Context) const
{
	if (Context->Pin)
	{
		{
			FToolMenuSection& Section = Menu->AddSection("TestGraphSchemaNodeActions", LOCTEXT("PinActionsMenuHeader", "Pin Actions ___"));
			// Only display the 'Break Links' option if there is a link to break!
			if (Context->Pin->LinkedTo.Num() > 0)
			{
				Section.AddMenuEntry(FGraphEditorCommands::Get().BreakPinLinks);

				// add sub menu for break link to
				if (Context->Pin->LinkedTo.Num() > 1)
				{
					Section.AddSubMenu(
						"BreakLinkTo",
						LOCTEXT("BreakLinkTo", "Break Link To..."),
						LOCTEXT("BreakSpecificLinks", "Break a specific link..."),		
						{}
						);
				}				
			}
		}
	}
	else
	if (Context->Node)
	{
		{
			FToolMenuSection& Section = Menu->AddSection("TestGraphSchemaNodeActions", LOCTEXT("ClassActionsMenuHeader", "Node Actions"));
			Section.AddMenuEntry(FGenericCommands::Get().Delete);
			Section.AddMenuEntry(FGenericCommands::Get().Cut);
			Section.AddMenuEntry(FGenericCommands::Get().Copy);
			Section.AddMenuEntry(FGenericCommands::Get().Duplicate);

			Section.AddMenuEntry(FGraphEditorCommands::Get().BreakNodeLinks);
		}
	}
	Super::GetContextMenuActions(Menu, Context);
}

UENUM()
enum ECanCreateConnectionResponse
{
	/** 多对多 */
	CONNECT_RESPONSE_MAKE,

	/*不能连接，默认 */
	CONNECT_RESPONSE_DISALLOW,

	/** 多对一 */
	CONNECT_RESPONSE_BREAK_OTHERS_A,

	/** 一对多 */
	CONNECT_RESPONSE_BREAK_OTHERS_B,

	/** 一对一 */
	CONNECT_RESPONSE_BREAK_OTHERS_AB,

	/** Make the connection via an intermediate cast node, or some other conversion node. */
	CONNECT_RESPONSE_MAKE_WITH_CONVERSION_NODE,

	CONNECT_RESPONSE_MAX,
};

virtual const FPinConnectionResponse CanCreateConnection(const UEdGraphPin* A, const UEdGraphPin* B) const
	{
		return FPinConnectionResponse(CONNECT_RESPONSE_BREAK_OTHERS_A, TEXT("Not 2 by this schema"));
	}

class FConnectionDrawingPolicy* UTestGraphSchema::CreateConnectionDrawingPolicy(int32 InBackLayerID, int32 InFrontLayerID, float InZoomFactor, const FSlateRect& InClippingRect, class FSlateWindowElementList& InDrawElements, class UEdGraph* InGraphObj) const
{
	return new FTestConnectionDrawingPolicy(InBackLayerID,InFrontLayerID,InZoomFactor,InClippingRect,InDrawElements, InGraphObj);
}

void UTestNode_Hello::AllocateDefaultPins()
{
	CreatePin(EGPD_Input,"HelloNodeInput_Bool",FName(),TEXT("bool"));
	CreatePin(EGPD_Input, "HelloNodeInput_Color", FName(), TEXT("color"));
	CreatePin(EGPD_Input, "HelloNodeInput_Enum", FName(), TEXT("enum"));
	CreatePin(EGPD_Input, "HelloNodeInput_Exec", FName(), TEXT("exec"));
	CreatePin(EGPD_Input, "HelloNodeInput_NameList", FName(), TEXT("namelist"));
	CreatePin(EGPD_Input, "HelloNodeInput_Object", FName(), TEXT("obj"));
	CreatePin(EGPD_Input, "HelloNodeInput_String", FName(), TEXT("str"));
	CreatePin(EGPD_Input, "HelloNodeInput_Vector4", FName(), TEXT("v4"));
	CreatePin(EGPD_Input, "HelloNodeInput_Integer", FName(), TEXT("int"));
	CreatePin(EGPD_Input, "HelloNodeInput_Vector2", FName(), TEXT("v2"));

	CreatePin(EGPD_Output, "HelloNodeInput_1", FName(), TEXT("1"));
	CreatePin(EGPD_Output, "HelloNodeInput_2", FName(), TEXT("2"));
	CreatePin(EGPD_Output, "HelloNodeInput_3", FName(), TEXT("3"));
	CreatePin(EGPD_Output, "HelloNodeInput_4", FName(), TEXT("4"));
	CreatePin(EGPD_Output, "HelloNodeInput_5", FName(), TEXT("5"));
}

FText UTestNode_Hello::GetNodeTitle(ENodeTitleType::Type TitleType) const
{
	return FText::FromString("Hello !");
}

void Construct(const FArguments& InArgs, UEdGraphNode* InNode);//构造跟默认slate不一样
virtual void UpdateGraphNode()override;//刷新节点
virtual void CreatePinWidgets()override;//创建pin的ui显示
virtual void AddPin( const TSharedRef<SGraphPin>& PinToAdd )override;//添加pin，不重写就使用默认的(一个圆点)
protected:
	TSharedPtr<class SBox> PinBox;

GraphNode= InNode;//自带的变量,存储对应的UEdGraphNode
this->SetCursor(EMouseCursor::GrabHand);//鼠标样式
this->UpdateGraphNode();

void STestNode::UpdateGraphNode()
{
    //清空所有的Pin和box
	InputPins.Empty();
	OutputPins.Empty();
	RightNodeBox.Reset();
	LeftNodeBox.Reset();
	//从style得到icon
	const FSlateBrush* nodeIcon=FEditorStyle::GetBrush(TEXT("Graph.StateNode.Icon"));

//用此方法创建一个视图
	this->GetOrAddSlot(ENodeZone::Center)
		.HAlign(HAlign_Center)
		.VAlign(VAlign_Center)
		[
			SAssignNew(PinBox,SBox)
			.VAlign(VAlign_Fill)
			.HAlign(HAlign_Fill)
			[
				SNew(SBorder)
				.BorderBackgroundColor_Lambda([&]()
			{
				FSlateColor color(FLinearColor(1,1,1));
				return color;
			})
        //注释代码可以手动设置图片
		//.BorderImage_Lambda([&]()
		//	{
		//	const FVector2D iconSize(64.0,64.0);
		//	return FTestGraphStyle::GetImageBrush(TEXT("ButtonIcon_40x"),iconSize);
		//	})	
			[
                //添加2个自带的NodeBox，注意顺序需要先左后右
				SNew(SHorizontalBox)
				+SHorizontalBox::Slot()
				.HAlign(HAlign_Fill)
				.VAlign(VAlign_Fill)
				.AutoWidth()
				[
					SAssignNew(LeftNodeBox,SVerticalBox)
				]
			+ SHorizontalBox::Slot()
				.HAlign(HAlign_Fill)
				.VAlign(VAlign_Fill)
				.AutoWidth()
				[
					SAssignNew(RightNodeBox,SVerticalBox)
				]

			]

			]


		];

//设置顶层box尺寸
		PinBox->SetWidthOverride(400);
		PinBox->SetHeightOverride(600);
//创建PinWidget
		CreatePinWidgets();
}

//手动指定所有Pin
void STestNode::CreatePinWidgets()
{
    UTestNode_Hello* helloNode=CastChecked<UTestNode_Hello>(GraphNode);
	if (helloNode)
    {
        //全部的Pin都指定为STestPin
        for (auto p : helloNode->Pins)
		{
			TSharedPtr<SGraphPin> pin = SNew(STestPin, p);
			pin->SetIsEditable(IsEditable);//把Node的可编辑性赋予Pin
			this->AddPin(pin.ToSharedRef());//添加pin
		}
    }
}

//使用系统的Pin
//用一个宏快速定义
//注意宏里的newPin对应的是第15行创建的指针变量
//顺序对应的是UEdGraphNode中创建的Pin
#define RESET_PIN(STestPin,GraphPinObj,...)\
		newPin = SNew(STestPin,GraphPinObj,__VA_ARGS__);\
		newPin->SetIsEditable(IsEditable);\
		this->AddPin(newPin.ToSharedRef());
void STestNode::CreatePinWidgets()
{
    static TArray<TSharedPtr<FName>> nameList;
	nameList.Add(MakeShareable(new FName("player")));
	nameList.Add(MakeShareable(new FName("monster")));
	nameList.Add(MakeShareable(new FName("ai")));

	TSharedPtr<SGraphPin> newPin=nullptr;
	RESET_PIN(SGraphPinBool,helloNode->Pins[0]);
	RESET_PIN(SGraphPinColor, helloNode->Pins[1]);
	RESET_PIN(SGraphPinEnum, helloNode->Pins[2]);
	RESET_PIN(SGraphPinExec, helloNode->Pins[3]);
	RESET_PIN(SGraphPinNameList, helloNode->Pins[4],nameList);
	RESET_PIN(SGraphPinObject, helloNode->Pins[5]);
	RESET_PIN(SGraphPinString, helloNode->Pins[6]);
	RESET_PIN(SGraphPinVector4, helloNode->Pins[7]);
	RESET_PIN(SGraphPinInteger, helloNode->Pins[8]);
	RESET_PIN(SGraphPinVector2D, helloNode->Pins[9]);
	RESET_PIN(SGraphPinClass, helloNode->Pins[10]);
	RESET_PIN(STestPin, helloNode->Pins[11]);
	RESET_PIN(STestPin, helloNode->Pins[12]);
	RESET_PIN(STestPin, helloNode->Pins[13]);
	RESET_PIN(STestPin, helloNode->Pins[14]);
}

void STestNode::AddPin(const TSharedRef<SGraphPin>& PinToAdd)
{
    //设置owner
	PinToAdd->SetOwner(SharedThis(this));
	//得到对应的Obj
	const UEdGraphPin* PinObj = PinToAdd->GetPinObj();
    //设置可见性
	if (PinObj&&PinObj->bAdvancedView)
	{
		PinToAdd->SetVisibility(TAttribute<EVisibility>(PinToAdd, &SGraphPin::IsPinVisibleAsAdvanced));
	}
#if CUSTOM_PIN
    //如果是自定义的Pin就设置缩放，用系统自带的就不需要了
	PinToAdd->SetDesiredSizeScale(FVector2D(16, 16));
#endif

//判断是输入和是输出节点
	if (PinToAdd->GetDirection() == EEdGraphPinDirection::EGPD_Input)
	{
        //添加到左边盒子里
		LeftNodeBox->AddSlot()
			.HAlign(HAlign_Fill)
			.VAlign(VAlign_Fill)
			.FillHeight(1.0f)
			.Padding(20.0f, 0)
			[
				PinToAdd
			];
        //添加到InputPins数组里
		InputPins.Add(PinToAdd);
	}
	else if (PinToAdd->GetDirection() == EEdGraphPinDirection::EGPD_Output)
	{
		RightNodeBox->AddSlot()
			.HAlign(HAlign_Right)
			.VAlign(VAlign_Center)
			.FillHeight(1.0f)
			.Padding(-30.0f, 0.f)
			[
				PinToAdd
			];
		OutputPins.Add(PinToAdd);
	}
}

//.h
FTestConnectionDrawingPolicy(int32 InBackLayerID, //线ID
	int32 InFrontLayerID, //箭头ID
	float InZoomFactor, //缩放
	const FSlateRect& InClippingRect,//视口裁剪 
	FSlateWindowElementList& InDrawElements,//绘制元素
	UEdGraph* InGraphObj);
/*
protected:
	UEdGraph* EdGraphObj;
	TMap<UEdGraph*, int32>EdNodeWidgetMap;*/

//cpp
FTestConnectionDrawingPolicy::FTestConnectionDrawingPolicy(int32 InBackLayerID, int32 InFrontLayerID, float InZoomFactor, const FSlateRect& InClippingRect, FSlateWindowElementList& InDrawElements , UEdGraph* InGraphObj)
:FConnectionDrawingPolicy(InBackLayerID,InFrontLayerID,InZoomFactor,InClippingRect,InDrawElements),EdGraphObj(InGraphObj)
{

}

void FTestConnectionDrawingPolicy::DetermineWiringStyle(UEdGraphPin* OutputPin, UEdGraphPin* InputPin, /*inout*/ FConnectionParams& Params)
{
	Params.WireThickness=3;//宽度
	Params.WireColor=FLinearColor::Green;//颜色
	if (HoveredPins.Num()>0)
	{
		ApplyHoverDeemphasis(OutputPin,InputPin, Params.WireThickness = 3, Params.WireColor);//此方法显示拖动效果
	}
}

//绘制直线+流动的泡泡
void FTestConnectionDrawingPolicy::DrawConnection(int32 LayerId, const FVector2D& Start, const FVector2D& End, const FConnectionParams& Params)
{
	const FVector2D delta=End-Start;
	const FVector2D DirDelta=delta.GetSafeNormal();
	//变成直线
	FSlateDrawElement::MakeDrawSpaceSpline(
	DrawElementsList,
	LayerId,
	Start,DirDelta,
	End,DirDelta,
	Params.WireThickness,
	ESlateDrawEffect::None,
	Params.WireColor
	);
	//使用气泡
    //底线一堆算法就是为了MakeBox
	if (bUseBubble)
	{
		FInterpCurve<float> SplineCurve;
		float splineLength=MakeSplineReparamTable(Start,DirDelta,End,DirDelta,SplineCurve);

		const float BubbleSpacing=32*ZoomFactor;
		const float BubbleSpeed=64*ZoomFactor;
		const FVector2D BubbleSize=BubbleImage->ImageSize*ZoomFactor*0.1*Params.WireThickness;

		float deltaTime=FPlatformTime::Seconds()-GStartTime;
		const float BubbleOffset=FMath::Fmod(deltaTime*BubbleSpeed,BubbleSpacing);
		const int32 num=FMath::CeilToInt(splineLength-BubbleSpacing);

		for (int32 i=0;i<num;i++)
		{
			const float dis = float(i)*BubbleSpacing+BubbleOffset;
			if (dis<splineLength)
			{
				const float alpha=SplineCurve.Eval(dis,0);
				FVector2D bubblePos=FMath::CubicInterp(Start,DirDelta,End,DirDelta,alpha);
				bubblePos-= BubbleSize*0.5;

				FSlateDrawElement::MakeBox(DrawElementsList,LayerId,
				FPaintGeometry(bubblePos,BubbleSize,ZoomFactor),
				BubbleImage,
				ESlateDrawEffect::None,
				Params.WireColor
				);
			}
		}
	}
}

virtual TSharedPtr<class SGraphNode> CreateNode(class UEdGraphNode* Node) const { return NULL; }
virtual TSharedPtr<class SGraphPin> CreatePin(class UEdGraphPin* Pin) const { return NULL; }
    virtual class FConnectionDrawingPolicy* CreateConnectionPolicy(const class UEdGraphSchema* Schema, int32 InBackLayerID, int32 InFrontLayerID, float ZoomFactor, const class FSlateRect& InClippingRect, class FSlateWindowElementList& InDrawElements, class UEdGraph* InGraphObj) const { return nullptr; }

TSharedPtr<class SGraphNode> FTestNodeFactory::CreateNode(class UEdGraphNode* Node) const
{
	if (UTestNode_Hello* nd=Cast<UTestNode_Hello>(Node))
	{
		return SNew(STestNode,nd);
	}
	return nullptr;
}
TSharedPtr<class SGraphPin> FTestNodePinFactory::CreatePin(class UEdGraphPin* Pin) const
{
	if (UTestNode_Hello* nd=Cast<UTestNode_Hello>(Pin->GetOuter()))
	{
		return SNew(STestPin,Pin);
	}
	return nullptr;
}
class FConnectionDrawingPolicy* FTestConnectionFactory::CreateConnectionPolicy(const class UEdGraphSchema* Schema, int32 InBackLayerID, int32 InFrontLayerID, float ZoomFactor, const class FSlateRect& InClippingRect, class FSlateWindowElementList& InDrawElements, class UEdGraph* InGraphObj) const
{
	if (Schema->IsA(UTestGraphSchema::StaticClass()))
	{
		return new FTestConnectionDrawingPolicy(InBackLayerID,InFrontLayerID,ZoomFactor,InClippingRect,InDrawElements, InGraphObj);
	}
	return nullptr;
}

FEdGraphUtilities::RegisterVisualNodeFactory(MakeShareable(new FTestNodeFactory));
FEdGraphUtilities::RegisterVisualPinConnectionFactory(MakeShareable(new FTestConnectionFactory));
FEdGraphUtilities::RegisterVisualPinFactory(MakeShareable(new FTestNodePinFactory));

//virtual class FConnectionDrawingPolicy* CreateConnectionDrawingPolicy(int32 InBackLayerID, int32 InFrontLayerID, float InZoomFactor, const FSlateRect& InClippingRect, class FSlateWindowElementList& InDrawElements, class UEdGraph* InGraphObj)const override;

UMyEngineSubsystem MySubsystem = GEngine->GetEngineSubsystem<UMyEngineSubsystem>();

UMyEditorSubsystem MySubsystem = GEditor->GetEditorSubsystem<UMyEditorSubsystem>();

UGameInstance* GameInstance = ...;
UMyGameSubsystem* MySubsystem = GameInstance->GetSubsystem<UMyGameSubsystem>();

ULocalPlayer* LocalPlayer = ...;
UMyPlayerSubsystem * MySubsystem = LocalPlayer->GetSubsystem();

//返回false就不会自动创建
virtual bool ShouldCreateSubsystem(UObject* Outer) const override { return true; }
//初始化
virtual void Initialize(FSubsystemCollectionBase& Collection)override;
//卸载
virtual void Deinitialize()override;

void UMyGameInstanceSubsystem::Initialize(FSubsystemCollectionBase& Collection)
{
	UE_LOG(LogTemp,Log,TEXT("MySubsystem Initialize!!!!"));
}
void UMyGameInstanceSubsystem::Deinitialize()
{
	UE_LOG(LogTemp, Log, TEXT("MySubsystem Deinitialize!!!!"));
}

UFUNCTION(BlueprintCallable)
		void TestPrint();
UPROPERTY(BlueprintReadWrite,EditAnywhere)
		int32 Number=0;

void UMyGameInstanceSubsystem::TestPrint()
{
	UE_LOG(LogTemp,Log,TEXT("Number= %d !!"),Number);
}

//存有CPU为构建美珍命令列表所需的资源
//其中的数据将依程序而异,取决于实际绘制所需的资源
struct FrameResource
{
public:
    
    FrameResource(ID3D12Device* device, UINT passCount, UINT objectCount);
    FrameResource(const FrameResource& rhs) = delete;
    FrameResource& operator=(const FrameResource& rhs) = delete;
    ~FrameResource();

    // CPU未结束命令分配器中所有命令执行之前,不能重置
    //因此每一帧都要有他们自己的命令分配器
    Microsoft::WRL::ComPtr<ID3D12CommandAllocator> CmdListAlloc;

    //在GPU完成引用此常量缓冲区的命令之前,我们不能对他进行更新
    //因此每一帧都要有他们自己的常量缓冲区
    std::unique_ptr<UploadBuffer<PassConstants>> PassCB = nullptr;
    std::unique_ptr<UploadBuffer<ObjectConstants>> ObjectCB = nullptr;

    // 通过围栏值将命令标记到此围栏点,这是我们可以检测到GPU是否还在使用这些帧资源
    UINT64 Fence = 0;
};

FrameResource::FrameResource(ID3D12Device* device, UINT passCount, UINT objectCount)
{
    ThrowIfFailed(device->CreateCommandAllocator(
        D3D12_COMMAND_LIST_TYPE_DIRECT,
		IID_PPV_ARGS(CmdListAlloc.GetAddressOf())));

    PassCB = std::make_unique<UploadBuffer<PassConstants>>(device, passCount, true);
    ObjectCB = std::make_unique<UploadBuffer<ObjectConstants>>(device, objectCount, true);
}

const int gNumFrameResources = 3;
std::vector<std::unique_ptr<FrameResource>> mFrameResources;
 FrameResource* mCurrFrameResource = nullptr;
 int mCurrFrameResourceIndex = 0;

void ShapesApp::BuildFrameResources()
{
    for(int i = 0; i < gNumFrameResources; ++i)
    {
        mFrameResources.push_back(std::make_unique<FrameResource>(md3dDevice.Get(),
            1, (UINT)mAllRitems.size()));
    }
}

void ShapesApp::Update(const GameTimer& gt)
{

    // 循环获取帧资源数组中的元素
    mCurrFrameResourceIndex = (mCurrFrameResourceIndex + 1) % gNumFrameResources;
    mCurrFrameResource = mFrameResources[mCurrFrameResourceIndex].get();
    //GPU是否执行完所有命令?
    //如果还没有就令CPU等待,直到GPU完成所有命令的执行并且抵达这个围栏点
     if(mCurrFrameResource->Fence != 0 && mFence->GetCompletedValue() < mCurrFrameResource->Fence)
    {
        HANDLE eventHandle = CreateEventEx(nullptr, false, false, EVENT_ALL_ACCESS);
        ThrowIfFailed(mFence->SetEventOnCompletion(mCurrFrameResource->Fence, eventHandle));
        WaitForSingleObject(eventHandle, INFINITE);
        CloseHandle(eventHandle);
    }     
}    

void ShapesApp::Draw(const GameTimer& gt)
{
    //.....构建命令列表
    
    //增加围栏点,将命令标记到此围栏点
     mCurrFrameResource->Fence = ++mCurrentFence;
    //向命令列表添加一条指令来设置一个新的围栏点
    //由于当前的GPU正在执行绘制命令,所以在GPU处理完Signal()函数之前的所有命令以前,并不会设置新的围栏点
     mCommandQueue->Signal(mFence.Get(), mCurrentFence);
}

struct RenderItem
{
	RenderItem() = default;

    // 描述了局部空间相对于世界空间的矩阵
    //定义了物体位于世界空间的位置,朝向和大小
    XMFLOAT4X4 World = MathHelper::Identity4x4();

	// 用dirty flag来标志物体的相关数据已经发生改变,意味着我们次数需要更新常量缓冲区
    // 由于每个帧资源中都有一个物体常量缓冲区,所以需要对每个帧资源进行更新
    //即,当修改物体数据时,应当按NumFramesDirty= gNumFrameReousreces进行设置,从而使每个帧资源都更新
	int NumFramesDirty = gNumFrameResources;

	// 该索引指向的GPU常量缓冲区对应当前渲染项中的物体常量缓冲区
	UINT ObjCBIndex = -1;

	MeshGeometry* Geo = nullptr;

    //图元拓扑
    D3D12_PRIMITIVE_TOPOLOGY PrimitiveType = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST;

    // DrawIndexedInstanced方法的参数
    UINT IndexCount = 0;
    UINT StartIndexLocation = 0;
    int BaseVertexLocation = 0;
};

//着色器
cbuffer cbPass : register(b1)
{
    float4x4 gView;
    float4x4 gInvView;
    float4x4 gProj;
    float4x4 gInvProj;
    float4x4 gViewProj;
    float4x4 gInvViewProj;
    float3 gEyePosW;
    float cbPerObjectPad1;
    float2 gRenderTargetSize;
    float2 gInvRenderTargetSize;
    float gNearZ;
    float gFarZ;
    float gTotalTime;
    float gDeltaTime;
};

//与之对应的常量缓冲区数据结构
struct PassConstants
{
    DirectX::XMFLOAT4X4 View = MathHelper::Identity4x4();
    DirectX::XMFLOAT4X4 InvView = MathHelper::Identity4x4();
    DirectX::XMFLOAT4X4 Proj = MathHelper::Identity4x4();
    DirectX::XMFLOAT4X4 InvProj = MathHelper::Identity4x4();
    DirectX::XMFLOAT4X4 ViewProj = MathHelper::Identity4x4();
    DirectX::XMFLOAT4X4 InvViewProj = MathHelper::Identity4x4();
    DirectX::XMFLOAT3 EyePosW = { 0.0f, 0.0f, 0.0f };
    float cbPerObjectPad1 = 0.0f;
    DirectX::XMFLOAT2 RenderTargetSize = { 0.0f, 0.0f };
    DirectX::XMFLOAT2 InvRenderTargetSize = { 0.0f, 0.0f };
    float NearZ = 0.0f;
    float FarZ = 0.0f;
    float TotalTime = 0.0f;
    float DeltaTime = 0.0f;
};

void ShapesApp::UpdateObjectCBs(const GameTimer& gt)
{
	auto currObjectCB = mCurrFrameResource->ObjectCB.get();
	for(auto& e : mAllRitems)
	{
		// 只对发生常量改变的缓冲区刷新
		if(e->NumFramesDirty > 0)
		{
			XMMATRIX world = XMLoadFloat4x4(&e->World);

			ObjectConstants objConstants;
			XMStoreFloat4x4(&objConstants.World, XMMatrixTranspose(world));

			currObjectCB->CopyData(e->ObjCBIndex, objConstants);

			// 还需要对下一个FrameResource更新
			e->NumFramesDirty--;
		}
	}
}

void ShapesApp::UpdateMainPassCB(const GameTimer& gt)
{
	XMMATRIX view = XMLoadFloat4x4(&mView);
	XMMATRIX proj = XMLoadFloat4x4(&mProj);

	XMMATRIX viewProj = XMMatrixMultiply(view, proj);
	XMMATRIX invView = XMMatrixInverse(&XMMatrixDeterminant(view), view);
	XMMATRIX invProj = XMMatrixInverse(&XMMatrixDeterminant(proj), proj);
	XMMATRIX invViewProj = XMMatrixInverse(&XMMatrixDeterminant(viewProj), viewProj);

	XMStoreFloat4x4(&mMainPassCB.View, XMMatrixTranspose(view));
	XMStoreFloat4x4(&mMainPassCB.InvView, XMMatrixTranspose(invView));
	XMStoreFloat4x4(&mMainPassCB.Proj, XMMatrixTranspose(proj));
	XMStoreFloat4x4(&mMainPassCB.InvProj, XMMatrixTranspose(invProj));
	XMStoreFloat4x4(&mMainPassCB.ViewProj, XMMatrixTranspose(viewProj));
	XMStoreFloat4x4(&mMainPassCB.InvViewProj, XMMatrixTranspose(invViewProj));
	mMainPassCB.EyePosW = mEyePos;
	mMainPassCB.RenderTargetSize = XMFLOAT2((float)mClientWidth, (float)mClientHeight);
	mMainPassCB.InvRenderTargetSize = XMFLOAT2(1.0f / mClientWidth, 1.0f / mClientHeight);
	mMainPassCB.NearZ = 1.0f;
	mMainPassCB.FarZ = 1000.0f;
	mMainPassCB.TotalTime = gt.TotalTime();
	mMainPassCB.DeltaTime = gt.DeltaTime();

	auto currPassCB = mCurrFrameResource->PassCB.get();
	currPassCB->CopyData(0, mMainPassCB);
}

VertexOut VS(VertexIn vin)
{
	VertexOut vout;
	
	// Transform to homogeneous clip space.
    float4 posW = mul(float4(vin.PosL, 1.0f), gWorld);
    vout.PosH = mul(posW, gViewProj);
	
	// Just pass vertex color into the pixel shader.
    vout.Color = vin.Color;
    
    return vout;
}

void ShapesApp::BuildRootSignature()
{
    // 创建2个描述
    CD3DX12_DESCRIPTOR_RANGE cbvTable0;
    cbvTable0.Init(D3D12_DESCRIPTOR_RANGE_TYPE_CBV, 1, 0);

    CD3DX12_DESCRIPTOR_RANGE cbvTable1;
    cbvTable1.Init(D3D12_DESCRIPTOR_RANGE_TYPE_CBV, 1, 1);

	// 2个成员的描述符表
	CD3DX12_ROOT_PARAMETER slotRootParameter[2];

	// 创建根CBV
    slotRootParameter[0].InitAsDescriptorTable(1, &cbvTable0);
    slotRootParameter[1].InitAsDescriptorTable(1, &cbvTable1);


	CD3DX12_ROOT_SIGNATURE_DESC rootSigDesc(2, slotRootParameter, 0, nullptr, 
        D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT);
//*************************
}

class GeometryGenerator
{
public:

    using uint16 = std::uint16_t;
    using uint32 = std::uint32_t;

	struct Vertex
	{
		Vertex(){}
        Vertex(
            const DirectX::XMFLOAT3& p, 
            const DirectX::XMFLOAT3& n, 
            const DirectX::XMFLOAT3& t, 
            const DirectX::XMFLOAT2& uv) :
            Position(p), 
            Normal(n), 
            TangentU(t), 
            TexC(uv){}
		Vertex(
			float px, float py, float pz, 
			float nx, float ny, float nz,
			float tx, float ty, float tz,
			float u, float v) : 
            Position(px,py,pz), 
            Normal(nx,ny,nz),
			TangentU(tx, ty, tz), 
            TexC(u,v){}

        DirectX::XMFLOAT3 Position;
        DirectX::XMFLOAT3 Normal;
        DirectX::XMFLOAT3 TangentU;
        DirectX::XMFLOAT2 TexC;
	};

	struct MeshData
	{
		std::vector<Vertex> Vertices;
        std::vector<uint32> Indices32;

        std::vector<uint16>& GetIndices16()
        {
			if(mIndices16.empty())
			{
				mIndices16.resize(Indices32.size());
				for(size_t i = 0; i < Indices32.size(); ++i)
					mIndices16[i] = static_cast<uint16>(Indices32[i]);
			}

			return mIndices16;
        }

	private:
		std::vector<uint16> mIndices16;
	};

//创建盒子
    MeshData CreateBox(float width, float height, float depth, uint32 numSubdivisions);

//创建球体
    MeshData CreateSphere(float radius, uint32 sliceCount, uint32 stackCount);
//创建以给定的半径创建一个以原点为中心的地层
    MeshData CreateGeosphere(float radius, uint32 numSubdivisions);

///创建一个平行于y轴并以原点为中心的圆柱体。
///上下半径可以变化以形成各种圆锥形状，而不是真实的圆柱体。 切片和堆栈参数控制镶嵌的程度。
    MeshData CreateCylinder(float bottomRadius, float topRadius, float height, uint32 sliceCount, uint32 stackCount);
    
//在xz平面中以m行和n列为中心创建一个mxn网格,在具有指定宽度和深度的原点。
    MeshData CreateGrid(float width, float depth, uint32 m, uint32 n);

//创建与屏幕对齐的四边形。 这对于后期处理和屏幕效果很有用。
    MeshData CreateQuad(float x, float y, float w, float h, float depth);

private:
	void Subdivide(MeshData& meshData);
    Vertex MidPoint(const Vertex& v0, const Vertex& v1);
    void BuildCylinderTopCap(float bottomRadius, float topRadius, float height, uint32 sliceCount, uint32 stackCount, MeshData& meshData);
    void BuildCylinderBottomCap(float bottomRadius, float topRadius, float height, uint32 sliceCount, uint32 stackCount, MeshData& meshData);
};

void GeometryGenerator::Subdivide(MeshData& meshData)
{
		//       v1
		//       *
		//      / \
		//     /   \
		//  m0*-----*m1
		//   / \   / \
		//  /   \ /   \
		// *-----*-----*
		// v0    m2     v2
		//****我里个去*****

		//保存一份拷贝
	MeshData inputCopy=meshData;
	meshData.Vertices.resize(0);
	meshData.Indices32.reserve(0);//清空

	uint32 numTris =(uint32)inputCopy.Indices32.size()/3; //三角形数量
	for (uint32 i=0;i<numTris;++i)
	{
		Vertex v0 = inputCopy.Vertices[inputCopy.Indices32[i * 3 + 0]];
		Vertex v1 = inputCopy.Vertices[inputCopy.Indices32[i * 3 + 1]];
		Vertex v2 = inputCopy.Vertices[inputCopy.Indices32[i * 3 + 2]];


		//创建中间点
		Vertex m0 = MidPoint(v0, v1);
		Vertex m1 = MidPoint(v1, v2);
		Vertex m2 = MidPoint(v0, v2);

		//添加新的几何体
		meshData.Vertices.push_back(v0); // 0
		meshData.Vertices.push_back(v1); // 1
		meshData.Vertices.push_back(v2); // 2
		meshData.Vertices.push_back(m0); // 3
		meshData.Vertices.push_back(m1); // 4
		meshData.Vertices.push_back(m2); // 5

		meshData.Indices32.push_back(i * 6 + 0);
		meshData.Indices32.push_back(i * 6 + 3);
		meshData.Indices32.push_back(i * 6 + 5);

		meshData.Indices32.push_back(i * 6 + 3);
		meshData.Indices32.push_back(i * 6 + 4);
		meshData.Indices32.push_back(i * 6 + 5);

		meshData.Indices32.push_back(i * 6 + 5);
		meshData.Indices32.push_back(i * 6 + 4);
		meshData.Indices32.push_back(i * 6 + 2);

		meshData.Indices32.push_back(i * 6 + 3);
		meshData.Indices32.push_back(i * 6 + 1);
		meshData.Indices32.push_back(i * 6 + 4);
	}

}

Vertex GeometryGenerator::MidPoint(const Vertex& v0, const Vertex& v1)
{
	XMVECTOR p0 = XMLoadFloat3(&v0.Position);
	XMVECTOR p1 = XMLoadFloat3(&v1.Position);

	XMVECTOR n0 = XMLoadFloat3(&v0.Normal);
	XMVECTOR n1 = XMLoadFloat3(&v1.Normal);
	
	XMVECTOR tan0 = XMLoadFloat3(&v0.TangentU);
	XMVECTOR tan1 = XMLoadFloat3(&v1.TangentU);

	XMVECTOR tex0 = XMLoadFloat2(&v0.TexC);
	XMVECTOR tex1 = XMLoadFloat2(&v1.TexC);

	//计算中间数据
	XMVECTOR pos=0.5f*(p0+p1);
	XMVECTOR normal=XMVector3Normalize(0.5f*(n0+n1));
	XMVECTOR tangent = XMVector3Normalize(0.5f*(tan0 + tan1));
	XMVECTOR tex = 0.5f*(tex0 + tex1);

	Vertex v;
	XMStoreFloat3(&v.Position,pos);
	XMStoreFloat3(&v.Normal, normal);
	XMStoreFloat3(&v.TangentU, tangent);
	XMStoreFloat2(&v.TexC, tex);

	return v;

}

GeometryGenerator::MeshData GeometryGenerator::CreateBox(float width, float height, float depth, uint32 numSubdivisions)
{
	MeshData meshData;

	/*
	构建顶点
	*/

	Vertex v[24];
	float w2 = 0.5f*width;
	float h2 = 0.5f*height;
	float d2 = 0.5f*depth;

	// 前面
	v[0] = Vertex(-w2, -h2, -d2, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f);
	v[1] = Vertex(-w2, +h2, -d2, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f);
	v[2] = Vertex(+w2, +h2, -d2, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f);
	v[3] = Vertex(+w2, -h2, -d2, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f);

	// 后面
	v[4] = Vertex(-w2, -h2, +d2, 0.0f, 0.0f, 1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 1.0f);
	v[5] = Vertex(+w2, -h2, +d2, 0.0f, 0.0f, 1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f);
	v[6] = Vertex(+w2, +h2, +d2, 0.0f, 0.0f, 1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f);
	v[7] = Vertex(-w2, +h2, +d2, 0.0f, 0.0f, 1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f);

	// 顶部面
	v[8] = Vertex(-w2, +h2, -d2, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f);
	v[9] = Vertex(-w2, +h2, +d2, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f);
	v[10] = Vertex(+w2, +h2, +d2, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f);
	v[11] = Vertex(+w2, +h2, -d2, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f);

	// 底部面
	v[12] = Vertex(-w2, -h2, -d2, 0.0f, -1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f, 1.0f);
	v[13] = Vertex(+w2, -h2, -d2, 0.0f, -1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f);
	v[14] = Vertex(+w2, -h2, +d2, 0.0f, -1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f);
	v[15] = Vertex(-w2, -h2, +d2, 0.0f, -1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f);

	// 左边面
	v[16] = Vertex(-w2, -h2, +d2, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f);
	v[17] = Vertex(-w2, +h2, +d2, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f);
	v[18] = Vertex(-w2, +h2, -d2, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f);
	v[19] = Vertex(-w2, -h2, -d2, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f);

	// 右边面
	v[20] = Vertex(+w2, -h2, -d2, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f);
	v[21] = Vertex(+w2, +h2, -d2, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
	v[22] = Vertex(+w2, +h2, +d2, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f);
	v[23] = Vertex(+w2, -h2, +d2, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f);


	meshData.Vertices.assign(&v[0],&v[24]);



	/*
	构建序列
	*/

	uint32 i[36];

	// Fill in the front face index data
	i[0] = 0; i[1] = 1; i[2] = 2;
	i[3] = 0; i[4] = 2; i[5] = 3;

	// Fill in the back face index data
	i[6] = 4; i[7] = 5; i[8] = 6;
	i[9] = 4; i[10] = 6; i[11] = 7;

	// Fill in the top face index data
	i[12] = 8; i[13] = 9; i[14] = 10;
	i[15] = 8; i[16] = 10; i[17] = 11;

	// Fill in the bottom face index data
	i[18] = 12; i[19] = 13; i[20] = 14;
	i[21] = 12; i[22] = 14; i[23] = 15;

	// Fill in the left face index data
	i[24] = 16; i[25] = 17; i[26] = 18;
	i[27] = 16; i[28] = 18; i[29] = 19;

	// Fill in the right face index data
	i[30] = 20; i[31] = 21; i[32] = 22;
	i[33] = 20; i[34] = 22; i[35] = 23;

	meshData.Indices32.assign(&i[0],&i[36]);


	//细分
	numSubdivisions = std::min<uint32>(numSubdivisions,6u);

	for (uint32 i = 0;i<numSubdivisions;++i)
	{
		Subdivide(meshData);//细分
	}
	return meshData;
}

GeometryGenerator::MeshData GeometryGenerator::CreateSphere(float radius, uint32 sliceCount, uint32 stackCount)
{	
	MeshData meshData;

	Vertex topVertex(0.0f,+radius, 0.0f, 0.0f, +1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f);//顶部顶点
	Vertex bottomVertex(0.0f, -radius, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f);//底部顶点

	meshData.Vertices.push_back(topVertex);//添加顶部顶点

	float phiStep = XM_PI/stackCount;//水平面分段
	float thetaStep=2.0f*XM_PI/sliceCount;//竖直面分段

	for (uint32 i=0;i<=stackCount-1;++i)
	{
		float phi = i*phiStep;//yaw角度

		for (uint32 j = 0 ;j<=sliceCount;++j)
		{
			float theta=j*thetaStep;//pitch角度
			
			Vertex v;

			v.Position.x = radius*sinf(phi)*cosf(theta);
			v.Position.y = radius * cosf(phi);
			v.Position.z = radius * sinf(phi)*sinf(theta);

			v.TangentU.x = -radius * sinf(phi)*sinf(theta);
			v.TangentU.y = 0.0f;
			v.TangentU.z = +radius * sinf(phi)*cosf(theta);

			XMVECTOR T = XMLoadFloat3(&v.TangentU);
			XMStoreFloat3(&v.TangentU, XMVector3Normalize(T));

			XMVECTOR p = XMLoadFloat3(&v.Position);
			XMStoreFloat3(&v.Normal, XMVector3Normalize(p));

			v.TexC.x = theta / XM_2PI;
			v.TexC.y = phi / XM_PI;

			meshData.Vertices.push_back(v);
		}
	}

	//最底下一个顶点
	meshData.Vertices.push_back(bottomVertex);




	//顶部面所有点的索引
	for (uint32 i = 1; i <= sliceCount; ++i)
	{
		meshData.Indices32.push_back(0);
		meshData.Indices32.push_back(i + 1);
		meshData.Indices32.push_back(i);
	}

	uint32 baseIndex = 1;
	uint32 ringVertexCount = sliceCount + 1;
	//高度细分数量-2，因为顶部底部不算在内
	for (uint32 i = 0; i < stackCount - 2; ++i)
	{
		for (uint32 j = 0; j < sliceCount; ++j)
		{
			meshData.Indices32.push_back(baseIndex + i * ringVertexCount + j);
			meshData.Indices32.push_back(baseIndex + i * ringVertexCount + j + 1);
			meshData.Indices32.push_back(baseIndex + (i + 1)*ringVertexCount + j);

			meshData.Indices32.push_back(baseIndex + (i + 1)*ringVertexCount + j);
			meshData.Indices32.push_back(baseIndex + i * ringVertexCount + j + 1);
			meshData.Indices32.push_back(baseIndex + (i + 1)*ringVertexCount + j + 1);
		}
	}

	//底部的点的序号
	uint32 southPoleIndex = (uint32)meshData.Vertices.size() - 1;
	baseIndex = southPoleIndex - ringVertexCount;
	//底部面所有索引
	for (uint32 i = 0; i < sliceCount; ++i)
	{
		meshData.Indices32.push_back(southPoleIndex);
		meshData.Indices32.push_back(baseIndex + i);
		meshData.Indices32.push_back(baseIndex + i + 1);
	}

	return meshData;
}