void FSlateOpenGLRenderingPolicy::ConditionalInitializeResources()
{
	if( !bIsInitialized )
	{
		// 创建并编译Shader
		VertexShader.Create( FString::Printf( TEXT("%sShaders/StandaloneRenderer/OpenGL/SlateVertexShader.glsl"), *FPaths::EngineDir() ) );
		PixelShader.Create( FString::Printf( TEXT("%sShaders/StandaloneRenderer/OpenGL/SlateElementPixelShader.glsl"), *FPaths::EngineDir() ) );
		
		// 链接Shader程序
		ElementProgram.CreateProgram( VertexShader, PixelShader );

		// 创建默认贴图
		check( WhiteTexture == NULL );
		WhiteTexture = TextureManager->CreateColorTexture( TEXT("DefaultWhite"), FColor::White );
	}
}

void FSlateOpenGLShader::CompileShader( const FString& Filename, GLenum ShaderType )
{
	//生成ShaderID，类型为顶点或像素着色器
	ShaderID = glCreateShader( ShaderType );
	GLint CompileStatus = GL_FALSE;

	check( ShaderID );

	//加载Shader文件
	bool bFileFound = FFileHelper::LoadFileToString( Source, *Filename );
	
	//向OpenGl传入源码（Chars是做了格式化字符，过程省略）
	glShaderSource( ShaderID, 2, (const ANSICHAR**)Chars, NULL );

	//编译Shader
	glCompileShader( ShaderID );

	//获取编译状态，
	glGetShaderiv( ShaderID, GL_COMPILE_STATUS, &CompileStatus );
	if( CompileStatus == GL_FALSE )
	{
		//编译失败则移除Shader.
		glDeleteShader( ShaderID );
		ShaderID = 0;
	}
}

void FSlateOpenGLShaderProgram::LinkShaders( const FSlateOpenGLVS& VertexShader, const FSlateOpenGLPS& PixelShader )
{
	//创建着色器程序
	ProgramID = glCreateProgram();
	//向着色器程序上添加顶点与像素着色器
	glAttachShader( ProgramID, VertexShaderID );
	glAttachShader( ProgramID, PixelShaderID );

	//将用户定义属性变量与通用顶点属性索引相关联，自定义变量名定义在Shader中。
	glBindAttribLocation(ProgramID, 0, "InTexCoords");
	glBindAttribLocation(ProgramID, 1, "InPosition");
	glBindAttribLocation(ProgramID, 4, "InColor");

	//链接程序与Shader
	glLinkProgram( ProgramID );

	//获取链接状态
	glGetProgramiv( ProgramID, GL_LINK_STATUS, &LinkStatus );
	if( LinkStatus == GL_FALSE )
	{
		// Linking failed, display why.
		FString Log = GetGLSLProgramLog( ProgramID );
		checkf(false, TEXT("Failed to link GLSL program: %s"), *Log );
	}
}

void FSlateOpenGLRenderer::DrawWindows( FSlateDrawBuffer& InWindowDrawBuffer )
{
	// 按批次绘制
	for( int32 ListIndex = 0; ListIndex < WindowElementLists.Num(); ++ListIndex )
	{
		FSlateWindowElementList& ElementList = *WindowElementLists[ListIndex];

		if ( ElementList.GetWindow().IsValid() )
		{
		
			//更新顶点Buffer	
			RenderingPolicy->UpdateVertexAndIndexBuffers( BatchData );

			//OpenGL创建视口
			glViewport( Viewport->ViewportRect.Left, Viewport->ViewportRect.Top, Viewport->ViewportRect.Right, Viewport->ViewportRect.Bottom );

			//绘制一个批次的元素，里面会执行一次DrawCall
			RenderingPolicy->DrawElements( ViewMatrix*Viewport->ProjectionMatrix, WindowSize, BatchData.GetRenderBatches(), BatchData.GetRenderClipStates() );

		}
	}

}

void FSlateOpenGLRenderingPolicy::DrawElements( const FMatrix& ViewProjectionMatrix, FVector2D ViewportSize, const TArray<FSlateRenderBatch>& RenderBatches, const TArray<FSlateClippingState> RenderClipStates)
{
	// 绑定顶点缓冲（即VBO)，每个元素共享顶点Buffer
	VertexBuffer.Bind();

	//绑定着色器程序，每个元素使用相同着色器程序，内部调用glUseProgram( ProgramID )
	ElementProgram.BindProgram();

	//设定视图投影矩阵
	ElementProgram.SetViewProjectionMatrix( ViewProjectionMatrix );
	
	//关闭深度测试和剪面（深度测试用于选择性渲染片元，剪面即所有的不是正面朝向的面都会被丢弃）
	glDisable(GL_DEPTH_TEST);
	glDisable(GL_CULL_FACE);

	//设置透明度测试
#if !PLATFORM_USES_ES2 && !PLATFORM_LINUX
	glEnable(GL_ALPHA_TEST);
	glAlphaFunc( GL_GREATER, 0.0f );
#endif

	//设置颜色混合，比如透过一块红色的玻璃去看一个绿色的球时，此时就会发生颜色的混合现象
	glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
	glBlendEquation( GL_FUNC_ADD );

	//设置模板测试参数，模板测试用于过滤某些片元（模板测试是在深度测试之前进行的，可以作为一种丢弃片元的辅助方法）
	glStencilMask(0xFF);
	glStencilFunc(GL_GREATER, 0, 0xFF);
	glStencilOp(GL_KEEP, GL_INCR, GL_INCR);

	//绘制批次数据
	int32 LastClippingIndex = -1;
	for( int32 BatchIndex = 0; BatchIndex < RenderBatches.Num(); ++BatchIndex )
	{
		...
		//是否开启颜色混合，当需要绘制半透明像素时，才采用混合操作。
		if( EnumHasAllFlags(DrawFlags, ESlateBatchDrawFlag::NoBlending) )
		{
			glDisable( GL_BLEND );
		}
		else
		{
			glEnable( GL_BLEND );
		}

		// 是否开启模板测试
		glDisable(GL_STENCIL_TEST);
		if( RenderBatch.ShaderType == ESlateShader::LineSegment )
		{
			// Test that the pixels in the line segment have only been drawn once
			glEnable(GL_STENCIL_TEST);
		}

		//为每个顶点设置顶点buffer的偏移量
		glEnableVertexAttribArray(0);
		Offset = STRUCT_OFFSET( FSlateVertex, TexCoords );
		glVertexAttribPointer( 0, 4, GL_FLOAT, GL_FALSE, Stride, BUFFER_OFFSET(Stride*BaseVertexIndex+Offset) );

		glEnableVertexAttribArray(1);
		Offset = STRUCT_OFFSET( FSlateVertex, Position );
		glVertexAttribPointer( 1, 2, GL_FLOAT, GL_FALSE, Stride, BUFFER_OFFSET(Stride*BaseVertexIndex+Offset) );

		glEnableVertexAttribArray(4);
		Offset = STRUCT_OFFSET( FSlateVertex, Color );
		glVertexAttribPointer( 4, 4, GL_UNSIGNED_BYTE, GL_TRUE, Stride, BUFFER_OFFSET(Stride*BaseVertexIndex+Offset) );
		
		//绑定索引缓冲（即EBO）,在绘制图形的过程中，顶点可能会重复。
		//比如两个三角形组成了四边形，那么，必然有两个点是重复的。因此采用索引的方式，四个点即可描述四边形。
		IndexBuffer.Bind();

		//裁剪测试
		if (RenderBatch.ClippingIndex != LastClippingIndex)
		{
			LastClippingIndex = RenderBatch.ClippingIndex;

			if (RenderBatch.ClippingIndex != -1)
			{
				const FSlateClippingState& ClipState = RenderClipStates[RenderBatch.ClippingIndex];
				if (ClipState.ScissorRect.IsSet())
				{
					const FSlateClippingZone& ScissorRect = ClipState.ScissorRect.GetValue();

					glEnable(GL_SCISSOR_TEST);
					
					const float ScissorWidth = FVector2D::Distance(ScissorRect.TopLeft, ScissorRect.TopRight);
					const float ScissorHeight = FVector2D::Distance(ScissorRect.TopLeft, ScissorRect.BottomLeft);
					glScissor(ScissorRect.TopLeft.X, ViewportSize.Y - ScissorRect.BottomLeft.Y, ScissorWidth, ScissorHeight);
				}
				else
				{
					// We don't support stencil clipping on the d3d rendering policy.
					glDisable(GL_SCISSOR_TEST);
				}
			}
			else
			{
				glDisable(GL_SCISSOR_TEST);
			}
		}

		//最终绘制元素，此处有一个DrawCall
#if PLATFORM_USES_ES2
		glDrawElements(GetOpenGLPrimitiveType(RenderBatch.DrawPrimitiveType), RenderBatch.NumIndices, GL_INDEX_FORMAT, (void*)StartIndex);
#else
		// Draw all elements in batch
		glDrawRangeElements( GetOpenGLPrimitiveType(RenderBatch.DrawPrimitiveType), 0, RenderBatch.NumVertices, RenderBatch.NumIndices, GL_INDEX_FORMAT, (void*)(PTRINT)StartIndex );
#endif
		
	}

	//清除缓冲
	glDisable(GL_SCISSOR_TEST);
	glActiveTexture( GL_TEXTURE0 );
	glBindTexture( GL_TEXTURE_2D, 0 );
	glUseProgram(0);

}

void main()
{
	TexCoords = InTexCoords;

	Color.rgb = sRGBToLinear(InColor.rgb);
	Color.a = InColor.a;

    Position = vec4( InPosition, 0, 1 );
    //坐标变换， ViewProjectionMatrix由UE层传递过来。
	gl_Position = ViewProjectionMatrix * vec4( InPosition, 0, 1 );
}

void main()
{
	vec4 OutColor;

	if( ShaderType == ST_Default ){ OutColor = GetDefaultElementColor();}

	else if( ShaderType == ST_Border ){ OutColor = GetBorderElementColor();}

	else if( ShaderType == ST_Font ){ OutColor = GetFontElementColor(); }

	else{ OutColor = GetSplineElementColor(); }

	// gamma校正，亮度调节
	OutColor.rgb = GammaCorrect(OutColor.rgb);
	
	if( EffectsDisabled )
	{
		//desaturate
		vec3 LumCoeffs = vec3( 0.3, 0.59, .11 );
		float Lum = dot( LumCoeffs, OutColor.rgb );
		OutColor.rgb = mix( OutColor.rgb, vec3(Lum,Lum,Lum), .8 );
	
		vec3 Grayish = vec3(0.4, 0.4, 0.4);
	
		OutColor.rgb = mix( OutColor.rgb, Grayish, clamp( distance( OutColor.rgb, Grayish ), 0.0, 0.8)  );
	}
    //最终输出片元颜色
	gl_FragColor = OutColor.bgra;
}

	#define ENQUEUE_UNIQUE_RENDER_COMMAND_ONEPARAMETER(TypeName,ParamType1,ParamName1,ParamValue1,Code) \
		ENQUEUE_UNIQUE_RENDER_COMMAND_ONEPARAMETER_DECLARE(TypeName,ParamType1,ParamName1,ParamValue1,Code) \
		ENQUEUE_UNIQUE_RENDER_COMMAND_ONEPARAMETER_CREATE(TypeName,ParamType1,ParamValue1)

/**
 * Declares a rendering command type with 1 parameters.
 */
#define ENQUEUE_UNIQUE_RENDER_COMMAND_ONEPARAMETER_DECLARE_OPTTYPENAME(TypeName,ParamType1,ParamName1,ParamValue1,OptTypename,Code) \
	class EURCMacro_##TypeName : public FRenderCommand \
	{ \
	public: \
		EURCMacro_##TypeName(OptTypename TCallTraits<ParamType1>::ParamType In##ParamName1): \
		  ParamName1(In##ParamName1) \
		{} \
		TASK_FUNCTION(Code) \
		TASKNAME_FUNCTION(TypeName) \
	private: \
		ParamType1 ParamName1; \
	};
#define ENQUEUE_UNIQUE_RENDER_COMMAND_ONEPARAMETER_DECLARE(TypeName,ParamType1,ParamName1,ParamValue1,Code) \
	ENQUEUE_UNIQUE_RENDER_COMMAND_ONEPARAMETER_DECLARE_OPTTYPENAME(TypeName,ParamType1,ParamName1,ParamValue1,,Code)

#define ENQUEUE_UNIQUE_RENDER_COMMAND_ONEPARAMETER_CREATE(TypeName,ParamType1,ParamValue1) \
	{ \
		LogRenderCommand(TypeName); \
		if(ShouldExecuteOnRenderThread()) \
		{ \
			CheckNotBlockedOnRenderThread(); \
			TGraphTask<EURCMacro_##TypeName>::CreateTask().ConstructAndDispatchWhenReady(ParamValue1); \
		} \
		else \
		{ \
			EURCMacro_##TypeName TempCommand(ParamValue1); \
			FScopeCycleCounter EURCMacro_Scope(TempCommand.GetStatId()); \
			TempCommand.DoTask(ENamedThreads::GameThread, FGraphEventRef() ); \
		} \
	}

	class RENDERCORE_API FRenderCommand
	{
	public:
		// All render commands run on the render thread
		static ENamedThreads::Type GetDesiredThread()
		{
			check(!GIsThreadedRendering || ENamedThreads::RenderThread != ENamedThreads::GameThread);
			return ENamedThreads::RenderThread;
		}
	
		static ESubsequentsMode::Type GetSubsequentsMode()
		{
			// Don't support tasks having dependencies on us, reduces task graph overhead tracking and dealing with subsequents
			return ESubsequentsMode::FireAndForget;
		}
	};

	#define TASK_FUNCTION(Code) \
	void DoTask(ENamedThreads::Type CurrentThread, const FGraphEventRef& MyCompletionGraphEvent) \
	{ \
		FRHICommandListImmediate& RHICmdList = GetImmediateCommandList_ForRenderCommand(); \
		Code; \
	} 

	// ensure the thread has actually started and is idling
	FRenderCommandFence Fence;
	Fence.BeginFence();
	Fence.Wait();