• Advertisement
  • Popular Tags

  • Popular Now

  • Advertisement
  • Similar Content

    • By isu diss
      How do I fill the gap between sky and terrain? Scaling the terrain or procedural terrain rendering?

    • By Jiraya
      For a 2D game, does using a float2 for position increases performance in any way?
      I know that in the end the vertex shader will have to return a float4 anyway, but does using a float2 decreases the amount of data that will have to be sent from the CPU to the GPU?
    • By ucfchuck
      I am feeding in 16 bit unsigned integer data to process in a compute shader and i need to get a standard deviation.
      So I read in a series of samples and push them into float arrays
      float vals1[9], vals2[9], vals3[9], vals4[9]; int x = 0,y=0; for ( x = 0; x < 3; x++) { for (y = 0; y < 3; y++) { vals1[3 * x + y] = (float) (asuint(Input1[threadID.xy + int2(x - 1, y - 1)].x)); vals2[3 * x + y] = (float) (asuint(Input2[threadID.xy + int2(x - 1, y - 1)].x)); vals3[3 * x + y] = (float) (asuint(Input3[threadID.xy + int2(x - 1, y - 1)].x)); vals4[3 * x + y] = (float) (asuint(Input4[threadID.xy + int2(x - 1, y - 1)].x)); } } I can send these values out directly and the data is as expected

      Output1[threadID.xy] = (uint) (vals1[4] ); Output2[threadID.xy] = (uint) (vals2[4] ); Output3[threadID.xy] = (uint) (vals3[4] ); Output4[threadID.xy] = (uint) (vals4[4] ); however if i do anything to that data it is destroyed.
      If i add a
      vals1[4] = vals1[4]/2; 
      or a
      vals1[4] = vals[1]-vals[4];
      the data is gone and everything comes back 0.
      How does one go about converting a uint to a float and performing operations on it and then converting back to a rounded uint?
    • By fs1
      I have been trying to see how the ID3DInclude, and how its methods Open and Close work.
      I would like to add a custom path for the D3DCompile function to search for some of my includes.
      I have not found any working example. Could someone point me on how to implement these functions? I would like D3DCompile to look at a custom C:\Folder path for some of the include files.
    • By stale
      I'm continuing to learn more about terrain rendering, and so far I've managed to load in a heightmap and render it as a tessellated wireframe (following Frank Luna's DX11 book). However, I'm getting some really weird behavior where a large section of the wireframe is being rendered with a yellow color, even though my pixel shader is hard coded to output white. 

      The parts of the mesh that are discolored changes as well, as pictured below (mesh is being clipped by far plane).

      Here is my pixel shader. As mentioned, I simply hard code it to output white:
      float PS(DOUT pin) : SV_Target { return float4(1.0f, 1.0f, 1.0f, 1.0f); } I'm completely lost on what could be causing this, so any help in the right direction would be greatly appreciated. If I can help by providing more information please let me know.
  • Advertisement
  • Advertisement
Sign in to follow this  

DX11 Pixel shader does not seem to run.

This topic is 898 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts



I am new to directx programming and i am having some problems drawing my models to screen.


i am trying to impliment the DrawInstanced tutorial from rastertek : http://www.rastertek.com/dx11tut37.html into my game engine. but i am having trouble where the model is not being drawn to my screen. in the image below you can see that it is calling the vertex shader but not the pixel shader.


The pixel shader is not set to null so it should be called but as far as i can see it is not.


the code below is my messy attempt to go as bare bones as possible and no other calls ar made any ware else other than the usual clear screen stuff.

#include "TestGameState.h"

#include "DirectX\DX_ScreenHandler.h"
#include "DirectX\Texture\DX_Texture.h" 
#include "DirectX\Shader\DX_Shader.h" //just the load (LoadShaderFile) function is used

#include <DirectXMath.h>
using namespace DirectX;

ID3D11Buffer* m_vertexBuffer;
ID3D11Buffer* m_instanceBuffer;
int m_vertexCount;
int m_instanceCount;
DX_Texture* m_Texture;


ID3D11InputLayout*	InputLayout;		 // the pointer to the input layout
//ID3D11Buffer*		ConstantBuffer; = m_matrixBuffer      // the constant buffer interface
ID3D11VertexShader*	VertexShader;        // the pointer to the vertex shader
ID3D11PixelShader*	PixelShader;         // the pointer to the pixel shader
ID3D11Buffer* m_matrixBuffer;
ID3D11SamplerState* m_sampleState;

D3D11_INPUT_ELEMENT_DESC polygonLayout[3];
unsigned int numElements;
D3D11_BUFFER_DESC matrixBufferDesc;
D3D11_SAMPLER_DESC samplerDesc;

struct VertexType
	XMFLOAT3 position;
	XMFLOAT2 texture;

struct InstanceType
	XMFLOAT3 position;

struct MatrixBufferType
	XMMATRIX world;
	XMMATRIX projection;

bool InitModel()
	ID3D11Device* device = TheDXScreen::Instance().GetDevice();

	VertexType* vertices;
	InstanceType* instances;
	D3D11_BUFFER_DESC vertexBufferDesc, instanceBufferDesc;
	D3D11_SUBRESOURCE_DATA vertexData, instanceData;
	HRESULT result;

	// Set the number of vertices in the vertex array.
	m_vertexCount = 3;

	// Create the vertex array.
	vertices = new VertexType[m_vertexCount];
	if (!vertices)
		return false;

	// Load the vertex array with data.
	vertices[0].position = XMFLOAT3(-1.0f, -1.0f, 0.0f);  // Bottom left.
	vertices[0].texture = XMFLOAT2(0.0f, 1.0f);

	vertices[1].position = XMFLOAT3(0.0f, 1.0f, 0.0f);  // Top middle.
	vertices[1].texture = XMFLOAT2(0.5f, 0.0f);

	vertices[2].position = XMFLOAT3(1.0f, -1.0f, 0.0f);  // Bottom right.
	vertices[2].texture = XMFLOAT2(1.0f, 1.0f);

	// Set up the description of the static vertex buffer.
	vertexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
	vertexBufferDesc.ByteWidth = sizeof(VertexType) * m_vertexCount;
	vertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
	vertexBufferDesc.CPUAccessFlags = 0;
	vertexBufferDesc.MiscFlags = 0;
	vertexBufferDesc.StructureByteStride = 0;

	// Give the subresource structure a pointer to the vertex data.
	vertexData.pSysMem = vertices;
	vertexData.SysMemPitch = 0;
	vertexData.SysMemSlicePitch = 0;

	// Now create the vertex buffer.
	result = device->CreateBuffer(&vertexBufferDesc, &vertexData, &m_vertexBuffer);
	if (FAILED(result))
		return false;

	// Release the vertex array now that the vertex buffer has been created and loaded.
	delete[] vertices;
	vertices = 0;

	// Set the number of instances in the array.
	m_instanceCount = 4;

	// Create the instance array.
	instances = new InstanceType[m_instanceCount];
	if (!instances)
		return false;

	// Load the instance array with data.
	instances[0].position = XMFLOAT3(-1.5f, -1.5f, 5.0f);
	instances[1].position = XMFLOAT3(-1.5f, 1.5f, 5.0f);
	instances[2].position = XMFLOAT3(1.5f, -1.5f, 5.0f);
	instances[3].position = XMFLOAT3(1.5f, 1.5f, 5.0f);

	// Set up the description of the instance buffer.
	instanceBufferDesc.Usage = D3D11_USAGE_DEFAULT;
	instanceBufferDesc.ByteWidth = sizeof(InstanceType) * m_instanceCount;
	instanceBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
	instanceBufferDesc.CPUAccessFlags = 0;
	instanceBufferDesc.MiscFlags = 0;
	instanceBufferDesc.StructureByteStride = 0;

	// Give the subresource structure a pointer to the instance data.
	instanceData.pSysMem = instances;
	instanceData.SysMemPitch = 0;
	instanceData.SysMemSlicePitch = 0;

	// Create the instance buffer.
	result = device->CreateBuffer(&instanceBufferDesc, &instanceData, &m_instanceBuffer);
	if (FAILED(result))
		return false;

	// Release the instance array now that the instance buffer has been created and loaded.
	delete[] instances;
	instances = 0;

	return true;

bool Shader()
	ID3D11Device* device = TheDXScreen::Instance().GetDevice();

	byte* VSData = nullptr;
	int VSSize = 0;

	byte* PSData = nullptr;
	int PSSize = 0;

	bool VSCompiled = DX_Shader::LoadShaderFile("InstancedVertexShader.cso", VSData, VSSize);
	bool PSCompiled = DX_Shader::LoadShaderFile("InstancedPixelShader.cso", PSData, PSSize);

	if (!VSCompiled || !PSCompiled)
		return false;

	// encapsulate both shaders into shader objects
	device->CreateVertexShader(VSData, VSSize, NULL, &VertexShader);
	device->CreatePixelShader(PSData, PSSize, NULL, &PixelShader);

	// Create the vertex input layout description.
	// This setup needs to match the VertexType stucture in the ModelClass and in the shader.
	polygonLayout[0].SemanticName = "POSITION";
	polygonLayout[0].SemanticIndex = 0;
	polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
	polygonLayout[0].InputSlot = 0;
	polygonLayout[0].AlignedByteOffset = 0;
	polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
	polygonLayout[0].InstanceDataStepRate = 0;

	polygonLayout[1].SemanticName = "TEXCOORD";
	polygonLayout[1].SemanticIndex = 0;
	polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT;
	polygonLayout[1].InputSlot = 0;
	polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
	polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
	polygonLayout[1].InstanceDataStepRate = 0;

	polygonLayout[2].SemanticName = "TEXCOORD";
	polygonLayout[2].SemanticIndex = 1;
	polygonLayout[2].Format = DXGI_FORMAT_R32G32B32_FLOAT;
	polygonLayout[2].InputSlot = 1;
	polygonLayout[2].AlignedByteOffset = 0;
	polygonLayout[2].InputSlotClass = D3D11_INPUT_PER_INSTANCE_DATA;
	polygonLayout[2].InstanceDataStepRate = 1;

	// Get a count of the elements in the layout.
	numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);

	HRESULT result = device->CreateInputLayout(polygonLayout, numElements, VSData, VSSize, &InputLayout);

	if (FAILED(result))
		return false;

	// Release the vertex shader buffer and pixel shader buffer since they are no longer needed.
	delete VSData;
	VSData = nullptr;

	delete PSData;
	PSData = nullptr;

	// Setup the description of the dynamic matrix constant buffer that is in the vertex shader.
	matrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
	matrixBufferDesc.ByteWidth = sizeof(MatrixBufferType);
	matrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
	matrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
	matrixBufferDesc.MiscFlags = 0;
	matrixBufferDesc.StructureByteStride = 0;

	// Create the constant buffer pointer so we can access the vertex shader constant buffer from within this class.
	result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer);
	if (FAILED(result))
		return false;

	// Create a texture sampler state description.
	samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
	samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
	samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
	samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
	samplerDesc.MipLODBias = 0.0f;
	samplerDesc.MaxAnisotropy = 1;
	samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
	samplerDesc.BorderColor[0] = 0;
	samplerDesc.BorderColor[1] = 0;
	samplerDesc.BorderColor[2] = 0;
	samplerDesc.BorderColor[3] = 0;
	samplerDesc.MinLOD = 0;
	samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;

	// Create the texture sampler state.
	result = device->CreateSamplerState(&samplerDesc, &m_sampleState);
	if (FAILED(result))
		return false;

	return true;

void TestGameState::Initialize()

	//init model & texture
	bool res = InitModel();

	if (res == false)
		throw "whaa epic fail";

	m_Texture = new DX_Texture();
	res = m_Texture->Initialize(L"roguelikeSheet_transparent.png");

	if (res == false)
		throw "whaa epic fail";

	res = Shader();

	if (res == false)
		throw "whaa epic fail";


void TestGameState::Destroy()

void TestGameState::Pause()

void TestGameState::Resume()

void TestGameState::Update()

// Camera rotation
static float lookatZ = 0;
static float lookatY = 0;
static float Zoom = 10;

void TestGameState::Draw()
	ID3D11Device* device = TheDXScreen::Instance().GetDevice();
	ID3D11DeviceContext* deviceContext = TheDXScreen::Instance().GetContext();

	lookatZ += 0.0001f;


	// calculate the world matrices
	XMMATRIX worldMatrix = DirectX::XMMatrixIdentity();//DirectX::XMMatrixRotationY(Time);

													// calculate the view transformation
													//XMVECTOR vecCamPosition = DirectX::XMVectorSet(0, 0, -10, 0);
	XMVECTOR vecCamPosition = DirectX::XMVectorSet((cosf(lookatZ) * Zoom), sinf(lookatY) * Zoom, (sinf(lookatZ) * Zoom), 0);
	XMVECTOR vecCamLookAt = XMVectorSet(0, 0, 0, 0);
	XMVECTOR vecCamUp = XMVectorSet(0, 1, 0, 0);
	XMMATRIX viewMatrix = XMMatrixLookAtLH(vecCamPosition, vecCamLookAt, vecCamUp);

	// calculate the projection transformation
	//CoreWindow^ Window = CoreWindow::GetForCurrentThread();    // get the window pointer
	XMMATRIX projectionMatrix = XMMatrixPerspectiveFovLH(
		XMConvertToRadians(45),                                      // the field of view
		(FLOAT)TheDXScreen::Instance().GetScreenSize().Width / (FLOAT)TheDXScreen::Instance().GetScreenSize().Height,  // aspect ratio
		1,                                                           // the near view-plane

	//do stuff

	// Put the model vertex and index buffers on the graphics pipeline to prepare them for drawing.
	unsigned int strides[2];
	unsigned int offsets[2];
	ID3D11Buffer* bufferPointers[2];

	// Set the buffer strides.
	strides[0] = sizeof(VertexType);
	strides[1] = sizeof(InstanceType);

	// Set the buffer offsets.
	offsets[0] = 0;
	offsets[1] = 0;

	// Set the array of pointers to the vertex and instance buffers.
	bufferPointers[0] = m_vertexBuffer;
	bufferPointers[1] = m_instanceBuffer;

	// Set the vertex buffer to active in the input assembler so it can be rendered.
	deviceContext->IASetVertexBuffers(0, 2, bufferPointers, strides, offsets);

	// Set the type of primitive that should be rendered from this vertex buffer, in this case triangles.

	// Render the model using the texture shader.

	// Set the shader parameters that it will use for rendering.
		HRESULT result;
		D3D11_MAPPED_SUBRESOURCE mappedResource;
		MatrixBufferType* dataPtr;
		unsigned int bufferNumber;

		// Lock the constant buffer so it can be written to.
		result = deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
		if (FAILED(result))
			int fail = 0;//break point

		// Get a pointer to the data in the constant buffer.
		dataPtr = (MatrixBufferType*)mappedResource.pData;

		// Copy the matrices into the constant buffer.
		dataPtr->world = worldMatrix;
		dataPtr->view = viewMatrix;
		dataPtr->projection = projectionMatrix;

		// Unlock the constant buffer.
		deviceContext->Unmap(m_matrixBuffer, 0);

		// Set the position of the constant buffer in the vertex shader.
		bufferNumber = 0;

		// Now set the constant buffer in the vertex shader with the updated values.
		deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_matrixBuffer);

		// Set shader texture resource in the pixel shader.

	// Now render the prepared buffers with the shader.
		// Set the vertex and pixel shaders that will be used to render this triangle.
		deviceContext->VSSetShader(VertexShader, nullptr, 0);
		deviceContext->PSSetShader(PixelShader, nullptr, 0);

		// Set the vertex input layout.

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

		// Render the triangle.
		deviceContext->DrawInstanced(m_vertexCount, m_instanceCount, 0, 0);


if you need any more information please let me know, thanks for the help.



i had a look at microsofts attempt to help 

https://msdn.microsoft.com/en-us/library/jj191650.aspx but i am pretty sure this is not my problem.


and this seems to be the problem i am having but i do not understand the solution "OMSetBlendState" i am not using that


Edited by precious roy

Share this post

Link to post
Share on other sites

Post the shader code


Edit: Not from the tutorial, but what you are using in your project

Edited by ExErvus

Share this post

Link to post
Share on other sites

thats the thing it is the same code. i even tried just outputting a color but still nothing. i can add my whole vs project if that will help?


It should compile if you have the windows sdk installed. 


TestGameState.cpp is where all the magic happens 

Edited by precious roy

Share this post

Link to post
Share on other sites

There are a number of reasons that the pixel shader won't run.  Usually it is because your geometry is culled after the vertex shader by the rasterizer because of back face culling or clipping due to the geometry being outside the normalized view frustum.


In general, it isn't possible to execute without a pixel shader in D3D11.  Are you getting any error messages on the debug output?  If not, be sure that you have the debug device created - it is your first line of defense against any types of errors.

Share this post

Link to post
Share on other sites

Jason Z: i am setting up "debug device" 

	UINT createDeviceFlags = 0;
#ifdef _DEBUG
	createDeviceFlags |= D3D11_CREATE_DEVICE_DEBUG;

I am pretty sure that is what you mean. and i am not getting any errors.


the only message i am getting is 

D3D11 WARNING: ID3D11DeviceContext::Draw: The Pixel Shader unit expects a Sampler to be set at Slot 0, but none is bound. This is perfectly valid, as a NULL Sampler maps to default Sampler state. However, the developer may not want to rely on the defaults.  [ EXECUTION WARNING #352: DEVICE_DRAW_SAMPLER_NOT_SET]


but it should still work.

Share this post

Link to post
Share on other sites
Sign in to follow this  

  • Advertisement