BansheeEngine/CamelotD3D9Renderer/Source/CmD3D9GpuProgram.cpp

#include "CmD3D9GpuProgram.h"
#include "CmMatrix4.h"
#include "CmException.h"
#include "CmD3D9Mappings.h"
#include "CmD3D9RenderSystem.h"
#include "CmD3D9ResourceManager.h"
#include "CmGpuParams.h"
#include "CmAsyncOp.h"
#include "CmGpuProgramManager.h"
#include "CmD3D9HLSLParamParser.h"
#include "CmD3D9GpuProgramRTTI.h"

namespace BansheeEngine 
{
    D3D9GpuProgram::D3D9GpuProgram(const String& source, const String& entryPoint, 
		GpuProgramType gptype, GpuProgramProfile profile, const Vector<HGpuProgInclude>* includes, bool isAdjacencyInfoRequired)
		: GpuProgram(source, entryPoint, gptype, profile, includes, isAdjacencyInfoRequired),
		mMicrocode(nullptr), mColumnMajorMatrices(false), mOptimisationLevel(OPT_DEFAULT)
    { }

	D3D9GpuProgram::~D3D9GpuProgram()
	{ }

	void D3D9GpuProgram::initialize_internal()
	{
		if (!isSupported())
		{
			mIsCompiled = false;
			mCompileError = "Specified program is not supported by the current render system.";

			return;
		}

		// Populate preprocessor defines
		String stringBuffer;

		Vector<D3DXMACRO> defines;
		const D3DXMACRO* pDefines = 0;
		if (!mPreprocessorDefines.empty())
		{
			stringBuffer = mPreprocessorDefines;

			// Split preprocessor defines and build up macro array
			D3DXMACRO macro;
			String::size_type pos = 0;
			while (pos != String::npos)
			{
				macro.Name = &stringBuffer[pos];
				macro.Definition = 0;

				String::size_type start_pos = pos;

				// Find delims
				pos = stringBuffer.find_first_of(";,=", pos);

				if (start_pos == pos)
				{
					if (pos == stringBuffer.length())
					{
						break;
					}
					pos++;
					continue;
				}

				if (pos != String::npos)
				{
					// Check definition part
					if (stringBuffer[pos] == '=')
					{
						// Setup null character for macro name
						stringBuffer[pos++] = '\0';
						macro.Definition = &stringBuffer[pos];
						pos = stringBuffer.find_first_of(";,", pos);
					}
					else
					{
						// No definition part, define as "1"
						macro.Definition = "1";
					}

					if (pos != String::npos)
					{
						// Setup null character for macro name or definition
						stringBuffer[pos++] = '\0';
					}
				}
				else
				{
					macro.Definition = "1";
				}
				if (strlen(macro.Name) > 0)
				{
					defines.push_back(macro);
				}
				else
				{
					break;
				}
			}

			// Add NULL terminator
			macro.Name = 0;
			macro.Definition = 0;
			defines.push_back(macro);

			pDefines = &defines[0];
		}

		// Populate compile flags
		DWORD compileFlags = 0;
		if (mColumnMajorMatrices)
			compileFlags |= D3DXSHADER_PACKMATRIX_COLUMNMAJOR;
		else
			compileFlags |= D3DXSHADER_PACKMATRIX_ROWMAJOR;

#if CM_DEBUG_MODE
		compileFlags |= D3DXSHADER_DEBUG;
#endif
		switch (mOptimisationLevel)
		{
		case OPT_DEFAULT:
			compileFlags |= D3DXSHADER_OPTIMIZATION_LEVEL1;
			break;
		case OPT_NONE:
			compileFlags |= D3DXSHADER_SKIPOPTIMIZATION;
			break;
		case OPT_0:
			compileFlags |= D3DXSHADER_OPTIMIZATION_LEVEL0;
			break;
		case OPT_1:
			compileFlags |= D3DXSHADER_OPTIMIZATION_LEVEL1;
			break;
		case OPT_2:
			compileFlags |= D3DXSHADER_OPTIMIZATION_LEVEL2;
			break;
		case OPT_3:
			compileFlags |= D3DXSHADER_OPTIMIZATION_LEVEL3;
			break;
		}

		LPD3DXBUFFER errors = 0;

		// include handler
		LPD3DXCONSTANTTABLE constTable;

		String hlslProfile = D3D9RenderSystem::instance().getCapabilities()->gpuProgProfileToRSSpecificProfile(mProfile);

		// Compile & assemble into microcode
		HRESULT hr = D3DXCompileShader(
			mSource.c_str(),
			static_cast<UINT>(mSource.length()),
			pDefines,
			nullptr,
			mEntryPoint.c_str(),
			hlslProfile.c_str(),
			compileFlags,
			&mMicrocode,
			&errors,
			&constTable);

		if (FAILED(hr))
		{
			String message = "Cannot compile D3D9 high-level shader ";

			if (errors)
			{
				message += String(" Errors:\n") + static_cast<const char*>(errors->GetBufferPointer());
				errors->Release();
			}

			mIsCompiled = false;
			mCompileError = message;

			SAFE_RELEASE(mMicrocode);
			mMicrocode = nullptr;
		}
		else
		{
			for (UINT32 i = 0; i < D3D9RenderSystem::getResourceCreationDeviceCount(); ++i)
			{
				IDirect3DDevice9* d3d9Device = D3D9RenderSystem::getResourceCreationDevice(i);
				createInternalResources(d3d9Device);
			}

			D3D9HLSLParamParser paramParser(constTable);
			mParametersDesc = paramParser.buildParameterDescriptions();

			mIsCompiled = true;
			mCompileError = "";

			SAFE_RELEASE(constTable);
		}

		GpuProgram::initialize_internal();
	}

	void D3D9GpuProgram::destroy_internal()
	{
		SAFE_RELEASE(mMicrocode);

		GpuProgram::destroy_internal();
	}

	GpuParamsPtr D3D9GpuProgram::createParameters()
	{
		GpuParamsPtr params = cm_shared_ptr<GpuParams, PoolAlloc>(std::ref(mParametersDesc), mColumnMajorMatrices);

		return params;
	}

	void D3D9GpuProgram::createInternalResources(IDirect3DDevice9* d3d9Device)
	{
		loadFromMicrocode(d3d9Device, mMicrocode);
	}

	const String& D3D9GpuProgram::getLanguage() const
	{
		static const String language = "hlsl";

		return language;
	}

	/************************************************************************/
	/* 								SERIALIZATION                      		*/
	/************************************************************************/
	RTTITypeBase* D3D9GpuProgram::getRTTIStatic()
	{
		return D3D9GpuProgramRTTI::instance();
	}

	RTTITypeBase* D3D9GpuProgram::getRTTI() const
	{
		return D3D9GpuProgram::getRTTIStatic();
	}

	D3D9GpuVertexProgram::D3D9GpuVertexProgram(const String& source, const String& entryPoint, 
		GpuProgramProfile profile, const Vector<HGpuProgInclude>* includes, bool isAdjacencyInfoRequired)
		: D3D9GpuProgram(source, entryPoint, GPT_VERTEX_PROGRAM, profile, includes, isAdjacencyInfoRequired)
    {

    }

	D3D9GpuVertexProgram::~D3D9GpuVertexProgram()
	{	
	}

	void D3D9GpuVertexProgram::destroy_internal(void)
	{
		DeviceToVertexShaderIterator it = mMapDeviceToVertexShader.begin();

		while (it != mMapDeviceToVertexShader.end())
		{
			SAFE_RELEASE(it->second);
			++it;
		}
		mMapDeviceToVertexShader.clear();	

		D3D9GpuProgram::destroy_internal();
	}

    void D3D9GpuVertexProgram::loadFromMicrocode(IDirect3DDevice9* d3d9Device, ID3DXBuffer* microcode)
    {		 
		DeviceToVertexShaderIterator it = mMapDeviceToVertexShader.find(d3d9Device);

		if (it != mMapDeviceToVertexShader.end())
			SAFE_RELEASE(it->second);

		// Create the shader
		IDirect3DVertexShader9* pVertexShader;
		HRESULT hr;
			
		hr = d3d9Device->CreateVertexShader( 
			static_cast<DWORD*>(microcode->GetBufferPointer()), 
			&pVertexShader);

		if (FAILED(hr))
		{
			CM_EXCEPT(RenderingAPIException, "Cannot create D3D9 vertex shader from microcode");
		}

		mMapDeviceToVertexShader[d3d9Device] = pVertexShader;
    }

	void D3D9GpuVertexProgram::notifyOnDeviceCreate(IDirect3DDevice9* d3d9Device)
	{
		
	}

	void D3D9GpuVertexProgram::notifyOnDeviceDestroy(IDirect3DDevice9* d3d9Device)
	{
		DeviceToVertexShaderIterator it;

		// Find the shader of this device.
		it = mMapDeviceToVertexShader.find(d3d9Device);

		// Case shader found -> release it and erase from map.
		if (it != mMapDeviceToVertexShader.end())
		{
			SAFE_RELEASE(it->second);
			mMapDeviceToVertexShader.erase(it);
		}
	}

	IDirect3DVertexShader9* D3D9GpuVertexProgram::getVertexShader()
	{
		if (!isCompiled())
			return nullptr;

		IDirect3DDevice9* d3d9Device = D3D9RenderSystem::getActiveD3D9Device();
		DeviceToVertexShaderIterator it;

		// Find the shader of this device.
		it = mMapDeviceToVertexShader.find(d3d9Device);
		
		// Shader was not found -> load it.
		if (it == mMapDeviceToVertexShader.end())		
		{
			createInternalResources(d3d9Device);		
			it = mMapDeviceToVertexShader.find(d3d9Device);
		}
	
		return it->second;
	}

    D3D9GpuFragmentProgram::D3D9GpuFragmentProgram(const String& source, const String& entryPoint, 
		GpuProgramProfile profile, const Vector<HGpuProgInclude>* includes, bool isAdjacencyInfoRequired)
		: D3D9GpuProgram(source, entryPoint, GPT_FRAGMENT_PROGRAM, profile, includes, isAdjacencyInfoRequired)
    {

    }

	D3D9GpuFragmentProgram::~D3D9GpuFragmentProgram()
	{
	}

	void D3D9GpuFragmentProgram::destroy_internal()
	{
		DeviceToPixelShaderIterator it = mMapDeviceToPixelShader.begin();

		while (it != mMapDeviceToPixelShader.end())
		{
			SAFE_RELEASE(it->second);
			++it;
		}
		mMapDeviceToPixelShader.clear();	

		D3D9GpuProgram::destroy_internal();
	}

    void D3D9GpuFragmentProgram::loadFromMicrocode(IDirect3DDevice9* d3d9Device, ID3DXBuffer* microcode)
    {
		DeviceToPixelShaderIterator it = mMapDeviceToPixelShader.find(d3d9Device);

		if (it != mMapDeviceToPixelShader.end())
			SAFE_RELEASE(it->second);

		// Create the shader
		IDirect3DPixelShader9* pPixelShader;
		HRESULT hr;

		hr = d3d9Device->CreatePixelShader(static_cast<DWORD*>(microcode->GetBufferPointer()), &pPixelShader);

		if (FAILED(hr))
			CM_EXCEPT(RenderingAPIException, "Cannot create D3D9 pixel shader from microcode.");

		mMapDeviceToPixelShader[d3d9Device] = pPixelShader;
    }

	void D3D9GpuFragmentProgram::notifyOnDeviceCreate(IDirect3DDevice9* d3d9Device)
	{
		
	}

	void D3D9GpuFragmentProgram::notifyOnDeviceDestroy(IDirect3DDevice9* d3d9Device)
	{
		DeviceToPixelShaderIterator it;

		// Find the shader of this device.
		it = mMapDeviceToPixelShader.find(d3d9Device);

		// Case shader found -> release it and erase from map.
		if (it != mMapDeviceToPixelShader.end())
		{
			SAFE_RELEASE(it->second);
			mMapDeviceToPixelShader.erase(it);
		}
	}

	IDirect3DPixelShader9* D3D9GpuFragmentProgram::getPixelShader()
	{
		if (!isCompiled())
			return nullptr;

		IDirect3DDevice9* d3d9Device = D3D9RenderSystem::getActiveD3D9Device();
		DeviceToPixelShaderIterator it;

		// Find the shader of this device.
		it = mMapDeviceToPixelShader.find(d3d9Device);

		// Shader was not found -> load it.
		if (it == mMapDeviceToPixelShader.end())		
		{
			createInternalResources(d3d9Device);			
			it = mMapDeviceToPixelShader.find(d3d9Device);
		}

		return it->second;
	}
}