void LoadEffectResources(IDirect3DDevice9 *m_pDevice)
{
	//Calculate sight mesh (a simple quad)
	D3DXCreateMeshFVF(2, 4, D3DXMESH_MANAGED, SimpleVertex::FVF, m_pDevice, &billboardMesh);

	//Create 4 vertices
	SimpleVertex* v = 0;
	billboardMesh->LockVertexBuffer(0,(void**)&v);
	v[0] = SimpleVertex(D3DXVECTOR3(-0.5f, 0.0f, 0.5f), D3DXVECTOR3(0.0f, 1.0f, 0.0f), D3DXVECTOR2(0, 0));
	v[1] = SimpleVertex(D3DXVECTOR3( 0.5f, 0.0f, 0.5f), D3DXVECTOR3(0.0f, 1.0f, 0.0f), D3DXVECTOR2(1, 0));
	v[2] = SimpleVertex(D3DXVECTOR3(-0.5f, 0.0f, -0.5f),D3DXVECTOR3(0.0f, 1.0f, 0.0f), D3DXVECTOR2(0, 1));
	v[3] = SimpleVertex(D3DXVECTOR3( 0.5f, 0.0f, -0.5f),D3DXVECTOR3(0.0f, 1.0f, 0.0f), D3DXVECTOR2(1, 1));
	billboardMesh->UnlockVertexBuffer();

	//Create 2 faces
	WORD* indices = 0;
	billboardMesh->LockIndexBuffer(0,(void**)&indices);	
	indices[0] = 0; indices[1] = 1; indices[2] = 2;
	indices[3] = 1; indices[4] = 3; indices[5] = 2;
	billboardMesh->UnlockIndexBuffer();

	//Set Attributes for the 2 faces
	DWORD *att = 0;
	billboardMesh->LockAttributeBuffer(0,&att);
	att[0] = 0; att[1] = 0;
	billboardMesh->UnlockAttributeBuffer();

	//Sight MTRL
	memset(&whiteMtrl, 0, sizeof(D3DMATERIAL9));
	whiteMtrl.Diffuse = whiteMtrl.Ambient = D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f);

	//Load Shaders
	effectVertexShader.Init(m_pDevice, "shaders/effect.vs", VERTEX_SHADER);
	effectPixelShader.Init(m_pDevice, "shaders/effect.ps", PIXEL_SHADER);

	//Get constants
	effectMatW = effectVertexShader.GetConstant("matW");
	effectMatVP = effectVertexShader.GetConstant("matVP");
	effectVCol = effectVertexShader.GetConstant("vertexColor");

	//Create Sprite
	D3DXCreateSprite(m_pDevice, &sprite);

	//Load textures
	D3DXCreateTextureFromFile(m_pDevice, "textures/runes.dds", &runesTexture);
	D3DXCreateTextureFromFile(m_pDevice, "textures/cloud.dds", &cloudTexture);
	D3DXCreateTextureFromFile(m_pDevice, "textures/fireball.dds", &fireballTexture);
	D3DXCreateTextureFromFile(m_pDevice, "textures/lensflare.dds", &lensflareTexture);
}

bool ProgramShaderCache::CompileShader ( SHADER& shader, const char* vcode, const char* pcode )
{
	GLuint vsid = CompileSingleShader(GL_VERTEX_SHADER, vcode);
	GLuint psid = CompileSingleShader(GL_FRAGMENT_SHADER, pcode);

	if(!vsid || !psid)
	{
		glDeleteShader(vsid);
		glDeleteShader(psid);
		return false;
	}

	GLuint pid = shader.glprogid = glCreateProgram();;

	glAttachShader(pid, vsid);
	glAttachShader(pid, psid);

	if (g_ogl_config.bSupportsGLSLCache)
		glProgramParameteri(pid, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL_TRUE);

	shader.SetProgramBindings();

	glLinkProgram(pid);

	// original shaders aren't needed any more
	glDeleteShader(vsid);
	glDeleteShader(psid);

	GLint linkStatus;
	glGetProgramiv(pid, GL_LINK_STATUS, &linkStatus);
	GLsizei length = 0;
	glGetProgramiv(pid, GL_INFO_LOG_LENGTH, &length);
	if (linkStatus != GL_TRUE || (length > 1 && DEBUG_GLSL))
	{
		GLsizei charsWritten;
		GLchar* infoLog = new GLchar[length];
		glGetProgramInfoLog(pid, length, &charsWritten, infoLog);
		ERROR_LOG(VIDEO, "Program info log:\n%s", infoLog);
		char szTemp[MAX_PATH];
		sprintf(szTemp, "%sbad_p_%d.txt", File::GetUserPath(D_DUMP_IDX).c_str(), num_failures++);
		std::ofstream file;
		OpenFStream(file, szTemp, std::ios_base::out);
		file << s_glsl_header << vcode << s_glsl_header << pcode << infoLog;
		file.close();

		if(linkStatus != GL_TRUE)
			PanicAlert("Failed to link shaders!\nThis usually happens when trying to use Dolphin with an outdated GPU or integrated GPU like the Intel GMA series.\n\nIf you're sure this is Dolphin's error anyway, post the contents of %s along with this error message at the forums.\n\nDebug info (%s, %s, %s):\n%s",
				szTemp,
				g_ogl_config.gl_vendor,
				g_ogl_config.gl_renderer,
				g_ogl_config.gl_version,
				infoLog);

		delete [] infoLog;
	}
	if (linkStatus != GL_TRUE)
	{
		// Compile failed
		ERROR_LOG(VIDEO, "Program linking failed; see info log");

		// Don't try to use this shader
		glDeleteProgram(pid);
		return false;
	}

	shader.SetProgramVariables();

	return true;
}

namespace TextureConverter
{

using OGL::TextureCache;

static GLuint s_texConvFrameBuffer[2] = {0,0};
static GLuint s_srcTexture = 0; // for decoding from RAM
static GLuint s_dstTexture = 0; // for encoding to RAM

const int renderBufferWidth = EFB_WIDTH * 4;
const int renderBufferHeight = 1024;

static SHADER s_rgbToYuyvProgram;
static int s_rgbToYuyvUniform_loc;

static SHADER s_yuyvToRgbProgram;

// Not all slots are taken - but who cares.
const u32 NUM_ENCODING_PROGRAMS = 64;
static SHADER s_encodingPrograms[NUM_ENCODING_PROGRAMS];
static int s_encodingUniforms[NUM_ENCODING_PROGRAMS];

static GLuint s_PBO = 0; // for readback with different strides

static void CreatePrograms()
{
	/* TODO: Accuracy Improvements
	 *
	 * This shader doesn't really match what the GameCube does internally in the
	 * copy pipeline.
	 *  1. It uses OpenGL's built in filtering when yscaling, someone could work
	 *     out how the copypipeline does it's filtering and implement it correctly
	 *     in this shader.
	 *  2. Deflickering isn't implemented, a futher filtering over 3 lines.
	 *     Isn't really needed on non-interlaced monitors (and would lower quality;
	 *     But hey, accuracy!)
	 *  3. Flipper's YUYV conversion implements a 3 pixel horizontal blur on the
	 *     UV channels, centering the U channel on the Left pixel and the V channel
	 *     on the Right pixel.
	 *     The current implementation Centers both UV channels at the same place
	 *     inbetween the two Pixels, and only blurs over these two pixels.
	 */
	// Output is BGRA because that is slightly faster than RGBA.
	const char *VProgramRgbToYuyv =
		"out vec2 uv0;\n"
		"uniform vec4 copy_position;\n" // left, top, right, bottom
		"SAMPLER_BINDING(9) uniform sampler2DArray samp9;\n"
		"void main()\n"
		"{\n"
		"	vec2 rawpos = vec2(gl_VertexID&1, gl_VertexID&2);\n"
		"	gl_Position = vec4(rawpos*2.0-1.0, 0.0, 1.0);\n"
		"	uv0 = mix(copy_position.xy, copy_position.zw, rawpos) / vec2(textureSize(samp9, 0).xy);\n"
		"}\n";
	const char *FProgramRgbToYuyv =
		"SAMPLER_BINDING(9) uniform sampler2DArray samp9;\n"
		"in vec2 uv0;\n"
		"out vec4 ocol0;\n"
		"void main()\n"
		"{\n"
		"	vec3 c0 = texture(samp9, vec3(uv0 - dFdx(uv0) * 0.25, 0.0)).rgb;\n"
		"	vec3 c1 = texture(samp9, vec3(uv0 + dFdx(uv0) * 0.25, 0.0)).rgb;\n"
		"	vec3 c01 = (c0 + c1) * 0.5;\n"
		"	vec3 y_const = vec3(0.257,0.504,0.098);\n"
		"	vec3 u_const = vec3(-0.148,-0.291,0.439);\n"
		"	vec3 v_const = vec3(0.439,-0.368,-0.071);\n"
		"	vec4 const3 = vec4(0.0625,0.5,0.0625,0.5);\n"
		"	ocol0 = vec4(dot(c1,y_const),dot(c01,u_const),dot(c0,y_const),dot(c01, v_const)) + const3;\n"
		"}\n";
	ProgramShaderCache::CompileShader(s_rgbToYuyvProgram, VProgramRgbToYuyv, FProgramRgbToYuyv);
	s_rgbToYuyvUniform_loc = glGetUniformLocation(s_rgbToYuyvProgram.glprogid, "copy_position");

	/* TODO: Accuracy Improvements
	 *
	 * The YVYU to RGB conversion here matches the RGB to YUYV done above, but
	 * if a game modifies or adds images to the XFB then it should be using the
	 * same algorithm as the flipper, and could result in slight color inaccuracies
	 * when run back through this shader.
	 */
	const char *VProgramYuyvToRgb =
		"void main()\n"
		"{\n"
		"	vec2 rawpos = vec2(gl_VertexID&1, gl_VertexID&2);\n"
		"	gl_Position = vec4(rawpos*2.0-1.0, 0.0, 1.0);\n"
		"}\n";
	const char *FProgramYuyvToRgb =
		"SAMPLER_BINDING(9) uniform sampler2D samp9;\n"
		"in vec2 uv0;\n"
		"out vec4 ocol0;\n"
		"void main()\n"
		"{\n"
		"	ivec2 uv = ivec2(gl_FragCoord.xy);\n"
			// We switch top/bottom here. TODO: move this to screen blit.
		"	ivec2 ts = textureSize(samp9, 0);\n"
		"	vec4 c0 = texelFetch(samp9, ivec2(uv.x>>1, ts.y-uv.y-1), 0);\n"
		"	float y = mix(c0.r, c0.b, (uv.x & 1) == 1);\n"
		"	float yComp = 1.164 * (y - 0.0625);\n"
		"	float uComp = c0.g - 0.5;\n"
		"	float vComp = c0.a - 0.5;\n"
		"	ocol0 = vec4(yComp + (1.596 * vComp),\n"
		"		yComp - (0.813 * vComp) - (0.391 * uComp),\n"
//.........这里部分代码省略.........

bool ProgramShaderCache::CompileShader(SHADER& shader, const char* vcode, const char* pcode, const char* gcode)
{
	GLuint vsid = CompileSingleShader(GL_VERTEX_SHADER, vcode);
	GLuint psid = CompileSingleShader(GL_FRAGMENT_SHADER, pcode);

	// Optional geometry shader
	GLuint gsid = 0;
	if (gcode)
		gsid = CompileSingleShader(GL_GEOMETRY_SHADER, gcode);

	if (!vsid || !psid || (gcode && !gsid))
	{
		glDeleteShader(vsid);
		glDeleteShader(psid);
		glDeleteShader(gsid);
		return false;
	}

	GLuint pid = shader.glprogid = glCreateProgram();

	glAttachShader(pid, vsid);
	glAttachShader(pid, psid);
	if (gsid)
		glAttachShader(pid, gsid);

	if (g_ogl_config.bSupportsGLSLCache)
		glProgramParameteri(pid, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL_TRUE);

	shader.SetProgramBindings();

	glLinkProgram(pid);

	// original shaders aren't needed any more
	glDeleteShader(vsid);
	glDeleteShader(psid);
	glDeleteShader(gsid);

	GLint linkStatus;
	glGetProgramiv(pid, GL_LINK_STATUS, &linkStatus);
	GLsizei length = 0;
	glGetProgramiv(pid, GL_INFO_LOG_LENGTH, &length);
	if (linkStatus != GL_TRUE || (length > 1 && DEBUG_GLSL))
	{
		GLsizei charsWritten;
		GLchar* infoLog = new GLchar[length];
		glGetProgramInfoLog(pid, length, &charsWritten, infoLog);
		ERROR_LOG(VIDEO, "Program info log:\n%s", infoLog);

		std::string filename = StringFromFormat("%sbad_p_%d.txt", File::GetUserPath(D_DUMP_IDX).c_str(), num_failures++);
		std::ofstream file;
		OpenFStream(file, filename, std::ios_base::out);
		file << s_glsl_header << vcode << s_glsl_header << pcode;
		if (gcode)
			file << s_glsl_header << gcode;
		file << infoLog;
		file.close();

		if (linkStatus != GL_TRUE)
		{
			PanicAlert("Failed to link shaders: %s\n"
			           "Debug info (%s, %s, %s):\n%s",
			           filename.c_str(),
			           g_ogl_config.gl_vendor, g_ogl_config.gl_renderer, g_ogl_config.gl_version, infoLog);
		}

		delete [] infoLog;
	}
	if (linkStatus != GL_TRUE)
	{
		// Compile failed
		ERROR_LOG(VIDEO, "Program linking failed; see info log");

		// Don't try to use this shader
		glDeleteProgram(pid);
		return false;
	}

	shader.SetProgramVariables();

	return true;
}

void EFFECT::PreRender()
{
	//Enable alpha blending
	m_pDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
	m_pDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
	m_pDevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
	m_pDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
	m_pDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, true);
	m_pDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
	m_pDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_ONE );
	m_pDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
	m_pDevice->SetRenderState(D3DRS_ZWRITEENABLE, false);
	m_pDevice->SetRenderState(D3DRS_LIGHTING, false);

	//Set vertex shader variables
	D3DXMATRIX view, proj;
	m_pDevice->GetTransform(D3DTS_VIEW, &view);
	m_pDevice->GetTransform(D3DTS_PROJECTION, &proj);
	
	effectVertexShader.SetMatrix(effectMatVP, view * proj);
	effectVertexShader.SetVector4(effectVCol, m_color);

	//Set material
	m_pDevice->SetMaterial(&whiteMtrl);

	//enable Shaders
	effectVertexShader.Begin();
	effectPixelShader.Begin();
}

void EFFECT::PostRender()
{
	//Reset renderstates
	m_pDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, false);
	m_pDevice->SetRenderState(D3DRS_ZWRITEENABLE, true);
	m_pDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW);

	//Disable shaders
	effectVertexShader.End();
	effectPixelShader.End();
}

// Should be scale free.
void DecodeToTexture(u32 xfbAddr, int srcWidth, int srcHeight, GLuint destTexture)
{
	u8* srcAddr = Memory::GetPointer(xfbAddr);
	if (!srcAddr)
	{
		WARN_LOG(VIDEO, "Tried to decode from invalid memory address");
		return;
	}

	g_renderer->ResetAPIState(); // reset any game specific settings

	OpenGL_BindAttributelessVAO();

	// switch to texture converter frame buffer
	// attach destTexture as color destination
	FramebufferManager::SetFramebuffer(s_texConvFrameBuffer[1]);
	FramebufferManager::FramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_ARRAY, destTexture, 0);

	// activate source texture
	// set srcAddr as data for source texture
	glActiveTexture(GL_TEXTURE9);
	glBindTexture(GL_TEXTURE_2D, s_srcTexture);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, srcWidth / 2, srcHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, srcAddr);
	g_sampler_cache->BindNearestSampler(9);

	glViewport(0, 0, srcWidth, srcHeight);
	s_yuyvToRgbProgram.Bind();

	glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

	FramebufferManager::SetFramebuffer(0);

	g_renderer->RestoreAPIState();
}

void Shutdown()
{
	glDeleteTextures(1, &s_srcTexture);
	glDeleteTextures(1, &s_dstTexture);
	glDeleteBuffers(1, &s_PBO);
	glDeleteFramebuffers(2, s_texConvFrameBuffer);

	s_rgbToYuyvProgram.Destroy();
	s_yuyvToRgbProgram.Destroy();

	for (auto& program : s_encodingPrograms)
		program.Destroy();

	s_srcTexture = 0;
	s_dstTexture = 0;
	s_PBO = 0;
	s_texConvFrameBuffer[0] = 0;
	s_texConvFrameBuffer[1] = 0;
}

void EFFECT_SPELL::Render()
{
	PreRender();

	if(billboardMesh)
	{
		//Spinning quad
		m_pDevice->SetTexture(0, runesTexture);
		effectVertexShader.SetMatrix(effectMatW, m_t1.GetWorldMatrix());
		billboardMesh->DrawSubset(0);

		//Cloud
		m_pDevice->SetTexture(0, cloudTexture);
		for(int i=0;i<10;i++)
		{
			effectVertexShader.SetMatrix(effectMatW, m_c[i].GetWorldMatrix());
			billboardMesh->DrawSubset(0);
		}
	}

	PostRender();
}

void EncodeToRamYUYV(GLuint srcTexture, const TargetRectangle& sourceRc, u8* destAddr, u32 dstWidth, u32 dstStride, u32 dstHeight)
{
	g_renderer->ResetAPIState();

	s_rgbToYuyvProgram.Bind();

	glUniform4f(s_rgbToYuyvUniform_loc, static_cast<float>(sourceRc.left), static_cast<float>(sourceRc.top),
		static_cast<float>(sourceRc.right), static_cast<float>(sourceRc.bottom));

	// We enable linear filtering, because the GameCube does filtering in the vertical direction when
	// yscale is enabled.
	// Otherwise we get jaggies when a game uses yscaling (most PAL games)
	EncodeToRamUsingShader(srcTexture, destAddr, dstWidth * 2, dstHeight, dstStride, true);
	FramebufferManager::SetFramebuffer(0);
	TextureCache::DisableStage(0);
	g_renderer->RestoreAPIState();
}