bluflame/hgplus/sdfparticles/shaders.h

#ifdef _DEBUG
#include <process.h>
#include <io.h>
#include <stdio.h>
HANDLE shaderCompileEvent;
static char** lastShader;
static __time64_t shaderChangedDate;
#define shaderDir ""
#define shaderFile "test.hlsl"

char* ReadFile(char* name, SIZE_T* fileLen)
{
	FILE *file = 0;
	char *buffer = 0;

	//Open file
	fopen_s(&file, name, "rb");
	if (!file)
	{
		printf("Unable to open file %s\n", name);
		return 0;
	}

	//Get file length
	fseek(file, 0, SEEK_END);
	*fileLen = ftell(file);
	fseek(file, 0, SEEK_SET);

	//Allocate memory
	buffer = (char *)malloc(*fileLen + 1);
	if (!buffer)
	{
		fprintf(stderr, "Memory error!\n");
		fclose(file);
		return 0;
	}

	//Read file contents into buffer
	fread(buffer, *fileLen, 1, file);
	fclose(file);

	return buffer;
}

void log(char* text)
{
	printf(text);
	OutputDebugStringA(text);
}

DWORD WINAPI filemon(void* args)
{
	while (true)
	{
		_finddata_t fdata;
		long hfile = _findfirst(shaderFile, &fdata);
		if (hfile != -1)
		{
			if (fdata.time_write != shaderChangedDate)
			{
				shaderChangedDate = fdata.time_write;
				::SetEvent(shaderCompileEvent);
			}
			_findclose(hfile);
		}
		::Sleep(100);
	}
	return 0;
}

void InitShader()
{
	_finddata_t fdata;
	long hfile = _findfirst(shaderFile, &fdata);
	if (hfile != -1)
	{
		shaderChangedDate = fdata.time_write;
		_findclose(hfile);
	}
}

#endif

#ifdef _DEBUG
#ifdef SHADER_DEBUG
#define CompileShader(entryPoint, profile) CompileShaderD(shaderDir entryPoint ".cso", entryPoint, profile);
#else
#define CompileShader(entryPoint, profile) CompileShaderD(shaderFile, entryPoint, profile);
#endif

void CompileShaderD(char* fileName, char* entryPoint, char* profile)
{
#ifdef SHADER_DEBUG
	shaderCode = ReadFile(fileName, &shaderSize);
#else
	ID3DBlob* errorBlob;
	SIZE_T blobLength = 0;
	auto blob = ReadFile(fileName, &blobLength);
	d3dCompile(blob, blobLength, shaderFile, NULL, NULL, entryPoint, profile, 0, 0, &shaderBlob, &errorBlob);
	if (errorBlob != NULL)
	{
		auto error = errorBlob->GetBufferPointer();
		OutputDebugStringA((char*)error);
		if (shaderBlob == 0)
		{
			printf("Error compiling shader: ");
			printf((char*)error);
			printf("\n");
			ExitProcess(-1);
		}
	}
	if (shaderBlob != 0)
	{
		shaderSize = shaderBlob->GetBufferSize();
		shaderCode = shaderBlob->GetBufferPointer();
	}
#endif
}

#else
#define CompileShader(entryPoint, profile) CompileShaderR(entryPoint, profile);

#pragma code_seg(".CompileShader")
void CompileShaderR(char* entryPoint, char* profile)
{
#ifndef COMPRESS
	ID3DBlob* errorBlob;
	d3dCompile(Shader_hlsl, sizeof(Shader_hlsl), NULL, NULL, NULL, entryPoint, profile, 0, 0, &shaderBlob, &errorBlob);
	if (errorBlob != NULL)
	{
		auto error = errorBlob->GetBufferPointer();
		OutputDebugStringA((char*)error);
	}
#else
	d3dCompile(Shader_hlsl, sizeof(Shader_hlsl), NULL, NULL, NULL, entryPoint, profile, 0, 0, &shaderBlob, NULL);
#endif
	//if (shaderBlob != 0)
	{
		shaderSize = shaderBlob->GetBufferSize();
		shaderCode = shaderBlob->GetBufferPointer();
	}
};
#endif

#pragma data_seg(".vs_5_0")
static char vs_5_0[] = "vs_5_0";

#pragma data_seg(".gs_5_0")
static char gs_5_0[] = "gs_5_0";

#pragma data_seg(".ds_5_0")
static char ds_5_0[] = "ds_5_0";

#pragma data_seg(".hs_5_0")
static char hs_5_0[] = "hs_5_0";

#pragma data_seg(".ps_5_0")
static char ps_5_0[] = "ps_5_0";

#pragma data_seg(".ps_5_0")
static char cs_5_0[] = "cs_5_0";

#pragma code_seg(".CreateShaders")
void CreateShaders()
{
	HINSTANCE hl = LoadLibraryA(d3dcompiler);
	if (!hl)
	{
		d3dcompiler[13] = '3';
		hl = LoadLibraryA(d3dcompiler);
	}
	d3dCompile = (pD3DCompile)GetProcAddress(hl, "D3DCompile");

	CompileShader("init", cs_5_0);
	device->CreateComputeShader(shaderCode, shaderSize, 0, &initShader);

	CompileShader("update", cs_5_0);
	device->CreateComputeShader(shaderCode, shaderSize, 0, &updateShader);

	CompileShader("pvs", vs_5_0);
	device->CreateVertexShader(shaderCode, shaderSize, 0, &particleVertexShader);

	CompileShader("pgs", gs_5_0);
	device->CreateGeometryShader(shaderCode, shaderSize, 0, &particleGeometryShader);

	CompileShader("pps", ps_5_0);
	device->CreatePixelShader(shaderCode, shaderSize, 0, &particlePixelShader);

	CompileShader("rvs", vs_5_0);
	device->CreateVertexShader(shaderCode, shaderSize, 0, &raymarchingVertexShader);

	CompileShader("rps", ps_5_0);
	device->CreatePixelShader(shaderCode, shaderSize, 0, &raymarchingPixelShader);

	//---
	// Compile postprocessing shaders
	//---
	CompileShader("csDistortChroma", cs_5_0);
	device->CreateComputeShader(shaderCode, shaderSize, 0, &csDistortChroma);

	CompileShader("csRadialBlur", cs_5_0);
	device->CreateComputeShader(shaderCode, shaderSize, 0, &csRadialBlur);

	CompileShader("csCircumferentialBlur", cs_5_0);
	device->CreateComputeShader(shaderCode, shaderSize, 0, &csCircumferentialBlur);

	CompileShader("csStreaks", cs_5_0);
	device->CreateComputeShader(shaderCode, shaderSize, 0, &csStreaks);

	CompileShader("csLensDirt", cs_5_0);
	device->CreateComputeShader(shaderCode, shaderSize, 0, &csLensDirt);

	CompileShader("csBlurH", cs_5_0);
	device->CreateComputeShader(shaderCode, shaderSize, 0, &csBlurH);

	CompileShader("csBlurV", cs_5_0);
	device->CreateComputeShader(shaderCode, shaderSize, 0, &csBlurV);

	CompileShader("csGhosts", cs_5_0);
	device->CreateComputeShader(shaderCode, shaderSize, 0, &csGhosts);

	CompileShader("csMerge", cs_5_0);
	device->CreateComputeShader(shaderCode, shaderSize, 0, &csMerge);

}