C++ SetShaderParameters函数代码示例

bool DeferredShader::RenderSkyBox(ID3D11DeviceContext* deviceContext, int indexCount, XMMATRIX &worldMatrix, XMMATRIX &viewMatrix,
	XMMATRIX& projectionMatrix, ID3D11ShaderResourceView* texture, int Startlocation)
{
	bool result;


	// Set the shader parameters that it will use for rendering.
	result = SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, texture);
	if (!result)
	{
		return false;
	}

	// Now render the prepared buffers with the shader.
	// Set the vertex and pixel shaders that will be used to render.
	deviceContext->VSSetShader(m_vertexShaderSkyBox, NULL, 0);
	deviceContext->PSSetShader(m_pixelShaderSkyBox, NULL, 0);

	// Set the sampler states in the pixel shader.
	deviceContext->PSSetSamplers(0, 1, &m_sampleStateWrap);

	// Render the geometry.
	deviceContext->DrawIndexed(indexCount, Startlocation, 0);

	return true;
}

bool ProjectionLightMapShaderClass::Render(
	ID3D11DeviceContext* deviceContext,
	int indexCount,
	XMMATRIX &worldMatrix,
	XMMATRIX &viewMatrix,
	XMMATRIX &projectionMatrix,
	ID3D11ShaderResourceView* texture,
	XMFLOAT4 &ambientColour,
	XMFLOAT4 &diffuseColour,
	XMFLOAT3 &lightPosition,
	XMMATRIX &projTexViewMatrix,
	XMMATRIX &projTexProjectionMatrix,
	ID3D11ShaderResourceView* projectionTexture){
	bool result;

	//set shader params
	result = SetShaderParameters(
		deviceContext,
		worldMatrix,
		viewMatrix,
		projectionMatrix,
		texture,
		ambientColour,
		diffuseColour,
		lightPosition,
		projTexViewMatrix,
		projTexProjectionMatrix,
		projectionTexture);
	if (!result) return false;

	//render prepped buffers with shader
	RenderShader(deviceContext, indexCount);

	return true;
}

void FoliageShaderClass::Render(ID3D10Device* device, int vertexCount, int instanceCount, D3DXMATRIX viewMatrix, D3DXMATRIX projectionMatrix, ID3D10ShaderResourceView* texture)
{
	SetShaderParameters(viewMatrix, projectionMatrix, texture);
	RenderShader(device, vertexCount, instanceCount);

	return;
}

	void MultiTextureShader::Render(Graphics* graphics)
	{
		SetShaderParameters(graphics);

		// render the buffers
		RenderShader(graphics);
	}

HRESULT LightShader::RenderOrdinary(ID3D11DeviceContext* deviceContext,
						 int indexCount,
						 D3DXMATRIX worldMatrix,
						 D3DXMATRIX viewMatrix, 
						 D3DXMATRIX projectionMatrix)
{
	HRESULT result;

	// Set the shader parameters that it will use for rendering.
	result = SetShaderParameters(deviceContext,
		worldMatrix,
		viewMatrix, 
		projectionMatrix,
		false);
	if(FAILED(result)) { return result; }

	// Now render the prepared buffers with the shader.
	result = TextureShader::RenderOrdinary(deviceContext,
											indexCount,
											worldMatrix,
											viewMatrix, 
											projectionMatrix);
	if(FAILED(result)) { return result; }

	return result;
}

void Sprite::Render()
{
    if (!ShouldDraw())
        return;

    UpdateTexture();

    SetBlendingMode(BlendingMode);

    // Assign our matrix.
    SetShaderParameters(ColorInvert, AffectedByLightning, Centered, false, BlackToTransparent);

    Mat4 Mat = GetMatrix();
    WindowFrame.SetUniform(U_MVP, &(Mat[0][0]));

    // Set the color.
    WindowFrame.SetUniform(U_COLOR, Red, Green, Blue, Alpha);

    SetTexturedQuadVBO(UvBuffer);
    DoQuadDraw();

    DrawLighten();

    FinalizeDraw();
}

void Line::Render()
{
    Mat4 Identity;
    UpdateVBO();

    glDisable(GL_DEPTH_TEST);
    glBindTexture(GL_TEXTURE_2D, 0);

    // Set the color.
    SetShaderParameters(false, false, false, false, false, true);

    WindowFrame.SetUniform(U_COLOR, R, G, B, A);
    WindowFrame.SetUniform(U_MVP, &(Identity[0][0]));

    // Assign position attrib. pointer
    lnvbo->Bind();
    glVertexAttribPointer(WindowFrame.EnableAttribArray(A_POSITION), 2, GL_FLOAT, GL_FALSE, 0, 0);

    ColorBuffer->Bind();
    glVertexAttribPointer(WindowFrame.EnableAttribArray(A_COLOR), 4, GL_FLOAT, GL_FALSE, sizeof(float) * 4, 0);

    glDrawArrays(GL_LINES, 0, 2);

    WindowFrame.DisableAttribArray(A_POSITION);
    WindowFrame.DisableAttribArray(A_COLOR);

    Image::ForceRebind();

    glEnable(GL_DEPTH_TEST);
}

bool ParticleShaderClass::Render(
	ID3D11DeviceContext* deviceContext,
	int indexCount,
	D3DXMATRIX worldMatrix,
	D3DXMATRIX viewMatrix,
	D3DXMATRIX projectionMatrix,
	ID3D11ShaderResourceView* texture
	)
{
	bool result;

	result = SetShaderParameters( //set the shader parameters that it will use for rendering
		deviceContext,
		worldMatrix,
		viewMatrix,
		projectionMatrix,
		texture
		);
	if(!result)
	{
		return false;
	}

	RenderShader(deviceContext, indexCount); //render the prepared buffers with the shader

	return true;
}

	void AlphaMapShader::Render(Graphics* graphics)
	{

		SetShaderParameters(graphics);

		RenderShader(graphics);
	}

bool CSLightD::Render(ID3D11DeviceContext *devicecontext,int indexCount,XMMATRIX worldmat,XMMATRIX viewmat,XMMATRIX projmat,ID3D11ShaderResourceView *texture,XMFLOAT3 lightDir,XMFLOAT4 diffuseCol,XMFLOAT4 ambientCol)
{
	if(!SetShaderParameters(devicecontext,worldmat,viewmat,projmat,texture,lightDir,diffuseCol,ambientCol))
		return false;
	RenderShader(devicecontext,indexCount);
	return true;
}

//------------------------------------------------------------------------------
/// Sets parameter values from configuration file.
void SetShaderParametersFromFile( GLuint program, const char* fileName )
{
	std::ifstream in( fileName );
	if( !in ) throw ShaderParameterException( std::string( "Cannot open file " ) + fileName );
	ShaderParameters params = ReadShaderParameters( in );
	SetShaderParameters( program, params );
}

bool DXFrame::ShadersDLights::Render(ID3D11DeviceContext* deviceContext,
											int indexCount,
											D3DXMATRIX worldMatrix,
											D3DXMATRIX viewMatrix, 
											D3DXMATRIX projectionMatrix,
											ID3D11ShaderResourceView* texture,
											D3DXVECTOR3 lightDirection, 
											D3DXVECTOR4 diffuseColor)
{
	if (!SetShaderParameters(	deviceContext,
								worldMatrix,
								viewMatrix,
								projectionMatrix,
								texture,
								lightDirection,
								diffuseColor))
		return false;

	deviceContext->IASetInputLayout(m_Layout);
	deviceContext->VSSetShader(m_VertexShader, NULL, 0);
	deviceContext->PSSetShader(m_PixelShader, NULL, 0);
	deviceContext->PSSetSamplers(0, 1, &m_SampleState);
	deviceContext->DrawIndexed(indexCount, 0, 0);
	return true;
}

// Takes the required variables to set the shader parameters and render the buffers using the shader file
void LightShaderClass::Render(ID3D10Device* device, int indexCount, int vertexCount, int instanceCount, D3DXMATRIX worldMatrix, D3DXMATRIX viewMatrix, D3DXMATRIX projectionMatrix, 
							  ID3D10ShaderResourceView** textureArray, D3DXVECTOR3 lightDirection, D3DXVECTOR4 ambientColor, D3DXVECTOR4 diffuseColor, D3DXVECTOR3 cameraPosition,
								D3DXVECTOR4 specularColor, float specularPower){
	
	SetShaderParameters(worldMatrix, viewMatrix, projectionMatrix, textureArray, lightDirection, ambientColor, diffuseColor, cameraPosition, specularColor, specularPower);
	RenderShader(device, indexCount, vertexCount, instanceCount);
	return;
}

bool ColorShader::Render(ID3D11DeviceContext *deviceContext, int indexCount, DirectX::XMMATRIX worldMatrix, DirectX::XMMATRIX viewMatrix, DirectX::XMMATRIX projectionMatrix)
{
	if (!SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix))
		return false;
	RenderShader(deviceContext, indexCount);

	return true;
}

bool TextureShaderClass::Render(HWND hwnd, ID3D11DeviceContext* deviceContext, int indexCount, XMMATRIX& worldMatrix, XMMATRIX& viewMatrix, XMMATRIX& projectionMatrix, ID3D11ShaderResourceView* texture, float blend, XMFLOAT4 hueColor, bool xFlip, bool yFlip){
	bool result = SetShaderParameters(hwnd, deviceContext, worldMatrix, viewMatrix, projectionMatrix, texture, blend, hueColor, xFlip, yFlip);
	if (!result){
		return false;
	}
	RenderShader(deviceContext, indexCount);
	return true;
}