ParticleManager.cpp

#include "Defines.h"
#include "ParticleManager.h"
#include "Shaders.h"

ParticleManager::ParticleManager(ID3D11Device* device, ID3D11ShaderResourceView* SRV, int numberOfParticles, Camera& camera, vector_3 orgin, vector_3 sizeofArea):
	movement()
{
	this->numberOfParticles = numberOfParticles;
	//if not a multiple of 8, make it
	if (numberOfParticles % 8 != 0) 
	{
		numberOfParticles += (8 - (numberOfParticles % 8));
	}

	createShaders(device);
	//load a Compute shader
	loadComputeShader("ParticleCS.cso", device, computeShaderUpdate);  
	trpConstantBuffer.time.element = 0;
	for (int i = 0; i < numberOfParticles; i++) 
	{
		particles.push_back(point(vector_3(
			Randomizer(orgin.x - sizeofArea.x, orgin.x + sizeofArea.x),
			Randomizer(orgin.y - sizeofArea.y, orgin.y + sizeofArea.y),
			Randomizer(orgin.z - sizeofArea.z, orgin.z + sizeofArea.z))
		)
		);
	}
	this->SRV = SRV;

	CreateVertexConstantBuffer(device, this->VertexConstantBuffer, camera);  // change names of buffers in this class?
	CreateGeometryConstantBuffer(device, this->GeoConstantBuffer);
	CreatePixelConstantBuffer(device, this->PixelConstantBuffer);
	CreateConstBuffer(device, this->CConstantBuffer, sizeof(CB_stuff), &trpConstantBuffer);

	D3D11_BUFFER_DESC bufferDesc;
	bufferDesc.ByteWidth = sizeof(point) * numberOfParticles;
	bufferDesc.Usage = D3D11_USAGE_DEFAULT;
	bufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER | D3D11_BIND_UNORDERED_ACCESS;
	bufferDesc.CPUAccessFlags = 0;
	bufferDesc.StructureByteStride = 0;
	bufferDesc.MiscFlags = 0;

	D3D11_SUBRESOURCE_DATA data;
	data.pSysMem = particles.data();
	data.SysMemPitch = 0;
	data.SysMemSlicePitch = 0;

	if (FAILED(device->CreateBuffer(&bufferDesc, &data, &bufferManager))) 
	{
		std::cout << "ERROR! CANNOT CEATE BUFFERMANAGER" << std::endl;
		return;
	}

	D3D11_UNORDERED_ACCESS_VIEW_DESC UavDescription;
	UavDescription.Format = DXGI_FORMAT_R32_FLOAT;
	UavDescription.ViewDimension = D3D11_UAV_DIMENSION_BUFFER;
	UavDescription.Buffer.FirstElement = 0;
	UavDescription.Buffer.NumElements = numberOfParticles * 3;
	UavDescription.Buffer.Flags = 0;
	if (FAILED(device->CreateUnorderedAccessView(bufferManager, &UavDescription, &particleUAV)))
	{
		std::cout << "ERROR! CANNOT CREATE BUFFER FROM UAV" << std::endl;
		return;
	}
}

ParticleManager::~ParticleManager()
{
	if (computeShaderUpdate != nullptr) 
	{
		computeShaderUpdate->Release();
	}
	if (particleUAV != nullptr) 
	{
		particleUAV->Release();
	}
	if (bufferManager != nullptr)
	{
		bufferManager->Release();
	}
	if (GeoConstantBuffer != nullptr) 
	{
		GeoConstantBuffer->Release();
	}
	if (PixelConstantBuffer != nullptr) 
	{
		PixelConstantBuffer->Release();
	}
	if (VertexConstantBuffer != nullptr) 
	{
		VertexConstantBuffer->Release();
	}
	if (CConstantBuffer != nullptr) 
	{
		CConstantBuffer->Release();
	}
	if (pShader != nullptr)
	{
		pShader->Release();
	}
	if (vShader != nullptr)
	{
		vShader->Release();
	}
	if (geoShader != nullptr)
	{
		geoShader->Release();
	}
}

void ParticleManager::Update(float dt, ID3D11DeviceContext* context)
{
	this->trpConstantBuffer.time.element = dt;
	this->trpConstantBuffer.random.element = Randomizer(-1.0f, 1.0f);

	//time to dispatch stuff
	context->CSSetShader(computeShaderUpdate, nullptr, 0);
	context->CSSetConstantBuffers(0, 1, &CConstantBuffer);
	context->CSSetUnorderedAccessViews(0, 1, &particleUAV, nullptr);
	context->Dispatch((UINT)this->particles.size() / 8, 1, 1);//calculate how many groups are needed

	//nullify uav bruv
	ID3D11UnorderedAccessView* uavNull = nullptr;
	context->CSSetUnorderedAccessViews(0, 1, &uavNull, nullptr);
}

void ParticleManager::ShaderUpdater(ID3D11DeviceContext* context, Camera& camera)
{
	vector_3 scale(1, 1, 1);
	XMMATRIX XMscale(
		scale.x, 0.0f, 0.0f, 0.0f,
		0.0f, scale.y, 0.0f, 0.0f,
		0.0f, 0.0f, scale.z, 0.0f,
		0.0f, 0.0f, 0.0f, 1.0f
	);
	//transform positions with matrix
	XMMATRIX XMtrans(
		1.0f, 0.0f, 0.0f, 0.0f,
		0.0f, 1.0f, 0.0f, 0.0f,
		0.0f, 0.0f, 1.0f, 0.0f,
		position.x, position.y, position.z, 1.0f
	);

	XMMATRIX transScale = (XMscale * XMtrans);

	D3D11_SUBRESOURCE_DATA InitData;
	VertexCb vcb = {};
	vcb.projection.element = camera.GetPerspectiveMatrix();
	vcb.view.element = camera.GetViewMatrix();


	vcb.transform.element = transScale;
	
	//time to change the VS cBuffer
	D3D11_MAPPED_SUBRESOURCE resource;

	context->Map(VertexConstantBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &resource);
	memcpy(resource.pData, &vcb, sizeof(VertexCb));
	context->Unmap(VertexConstantBuffer, 0);
	ZeroMemory(&resource, sizeof(D3D11_MAPPED_SUBRESOURCE));

	//GeometryConstBuffer
	GeoCb geoConstantBuffer = {
		{0,0,0,0},
		{0,0,0,0},
	};

	//uv schtuff
	geoConstantBuffer.uvCords.element[0] = movement.uv().xyz.x;
	geoConstantBuffer.uvCords.element[1] = movement.uv().xyz.y;
	geoConstantBuffer.uvCords.element[2] = movement.uv().xyz.z;
	geoConstantBuffer.uvCords.element[3] = movement.uv().w;

	context->Map(GeoConstantBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &resource);
	memcpy(resource.pData, &geoConstantBuffer, sizeof(GeoCb));
	context->Unmap(GeoConstantBuffer, 0);
	ZeroMemory(&resource, sizeof(D3D11_MAPPED_SUBRESOURCE));


	//update computeshader constant buffer
	context->Map(CConstantBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &resource);
	memcpy(resource.pData, &trpConstantBuffer, sizeof(CB_stuff));
	context->Unmap(CConstantBuffer, 0);
	ZeroMemory(&resource, sizeof(D3D11_MAPPED_SUBRESOURCE));
}

void ParticleManager::Draw(ID3D11DeviceContext* context, ID3D11InputLayout* layout)
{
	UINT offset = 0;
	static UINT strid = sizeof(point);
	
	context->IASetInputLayout(layout);
	context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_POINTLIST);
	context->VSSetShader(vShader, nullptr, 0);
	context->GSSetShader(geoShader, nullptr, 0);  
	context->PSSetShader(pShader, nullptr, 0);
	context->HSSetShader(nullptr, nullptr, 0);
	context->DSSetShader(nullptr, nullptr, 0);

	context->PSSetShaderResources(0, 1, &SRV);

	context->VSSetConstantBuffers(0, 1, &VertexConstantBuffer);
	context->GSSetConstantBuffers(0, 1, &GeoConstantBuffer);
	context->PSSetConstantBuffers(0, 1, &PixelConstantBuffer);

	context->IASetVertexBuffers(0, 1, &this->bufferManager, &strid, &offset);
	context->Draw(this->numberOfParticles, 0);
}

std::string ParticleManager::GetVShaderData()
{
	return this->vertexShaderByteCode;
}

void ParticleManager::createShaders(ID3D11Device* device)
{
	std::string shaderData;
	std::ifstream reader;
	std::string shaderByteCode;


	// Geometry shader
	reader.open("x64/Debug/ParticleGS.cso", std::ios::binary | std::ios::beg);

	if (!reader.is_open())
	{
		std::cout << "ERROR! COULD NOT OPEN FILE!: x64/Debug/ParticleGS.cso" << std::endl;
		return;
	}

	reader.seekg(0, std::ios::end);
	shaderData.reserve(static_cast<unsigned int>(reader.tellg()));
	reader.seekg(0, std::ios::beg);
	shaderData.assign((std::istreambuf_iterator<char>(reader)), std::istreambuf_iterator<char>());

	HRESULT hr = device->CreateGeometryShader(shaderData.c_str(), shaderData.length(), nullptr, &geoShader);
	if FAILED(hr)
	{
		MessageBox(NULL, L"Couldn't create geometry shader!", L"SHADER ERROR", MB_OK);
		return;
	}

	shaderData.clear();
	reader.close();


	//vertex shader
	reader.open("x64/Debug/ParticleVS.cso", std::ios::binary | std::ios::beg);

	if (!reader.is_open())
	{
		std::cout << "ERROR! COULD NOT OPEN FILE!: x64/Debug/ParticleVS.cso" << std::endl;
		return;
	}

	reader.seekg(0, std::ios::end);
	shaderData.reserve(static_cast<unsigned int>(reader.tellg()));
	reader.seekg(0, std::ios::beg);
	shaderData.assign((std::istreambuf_iterator<char>(reader)), std::istreambuf_iterator<char>());

	hr = device->CreateVertexShader(shaderData.c_str(), shaderData.length(), nullptr, &vShader);
	if FAILED(hr)
	{
		MessageBox(NULL, L"Couldn't create vertex shader!", L"SHADER ERROR", MB_OK);
		return;
	}
	vertexShaderByteCode = shaderData;
	shaderData.clear();
	reader.close();

	//pixel shader
	//reader.open("x64/Debug/ParticlePS.cso", std::ios::binary | std::ios::beg);
	reader.open("x64/Debug/DeferredPS.cso", std::ios::binary | std::ios::beg);

	if (!reader.is_open())
	{
		std::cout << "ERROR! COULD NOT OPEN FILE!: x64/Debug/DeferredPS.cso" << std::endl;
		return;
	}

	reader.seekg(0, std::ios::end);
	shaderData.reserve(static_cast<unsigned int>(reader.tellg()));
	reader.seekg(0, std::ios::beg);
	shaderData.assign((std::istreambuf_iterator<char>(reader)), std::istreambuf_iterator<char>());

	hr = device->CreatePixelShader(shaderData.c_str(), shaderData.length(), nullptr, &pShader);
	if FAILED(hr)
	{
		MessageBox(NULL, L"Couldn't create pixel shader!", L"SHADER ERROR", MB_OK);
		return;
	}

	shaderData.clear();
	reader.close();
}