static bool load_program(hlsl_shader_data_t *hlsl,
void *data, unsigned idx, const char *prog, bool path_is_file)
{
d3d_video_t *d3d = (d3d_video_t*)data;
LPDIRECT3DDEVICE d3d_device_ptr = (LPDIRECT3DDEVICE)d3d->dev;
HRESULT ret, ret_fp, ret_vp;
ID3DXBuffer *listing_f = NULL;
ID3DXBuffer *listing_v = NULL;
ID3DXBuffer *code_f = NULL;
ID3DXBuffer *code_v = NULL;
if (path_is_file)
{
ret_fp = D3DXCompileShaderFromFile(prog, NULL, NULL,
"main_fragment", "ps_3_0", 0, &code_f, &listing_f, &hlsl->prg[idx].f_ctable);
ret_vp = D3DXCompileShaderFromFile(prog, NULL, NULL,
"main_vertex", "vs_3_0", 0, &code_v, &listing_v, &hlsl->prg[idx].v_ctable);
}
else
{
/* TODO - crashes currently - to do with 'end of line' of stock shader */
ret_fp = D3DXCompileShader(prog, strlen(prog), NULL, NULL,
"main_fragment", "ps_3_0", 0, &code_f, &listing_f, &hlsl->prg[idx].f_ctable );
ret_vp = D3DXCompileShader(prog, strlen(prog), NULL, NULL,
"main_vertex", "vs_3_0", 0, &code_v, &listing_v, &hlsl->prg[idx].v_ctable );
}
if (ret_fp < 0 || ret_vp < 0 || listing_v || listing_f)
{
RARCH_ERR("Cg/HLSL error:\n");
if(listing_f)
RARCH_ERR("Fragment:\n%s\n", (char*)listing_f->GetBufferPointer());
if(listing_v)
RARCH_ERR("Vertex:\n%s\n", (char*)listing_v->GetBufferPointer());
ret = false;
goto end;
}
d3d_device_ptr->CreatePixelShader((const DWORD*)code_f->GetBufferPointer(), &hlsl->prg[idx].fprg);
d3d_device_ptr->CreateVertexShader((const DWORD*)code_v->GetBufferPointer(), &hlsl->prg[idx].vprg);
code_f->Release();
code_v->Release();
end:
if (listing_f)
listing_f->Release();
if (listing_v)
listing_v->Release();
return ret;
}
TRESULT D3DWrapper::CompilePixelShader( OCShader*& shader )
{
if( NULL == shader )
return RE_FAILED;
if( NULL == shader->GetPixelShaderCode() )
return RE_FAILED;
UINT codeSize = static_cast<UINT>( strlen(shader->GetPixelShaderCode()) );
if( 0 == codeSize )
return RE_FAILED;
LPD3DXBUFFER pCode;
LPD3DXBUFFER pErrorMsgs;
HRESULT hr = D3DXCompileShader( shader->GetPixelShaderCode(), codeSize, NULL, NULL, "main", "ps_3_0", 0, &pCode, &pErrorMsgs, shader->GetConstantTablePtr() );
if(FAILED(hr))return RE_FAILED;
hr = m_pD3dDevice->CreatePixelShader( (DWORD*)pCode->GetBufferPointer(), shader->GetPixelShaderPtr() );
if(FAILED(hr))return RE_FAILED;
if(pCode)
pCode->Release();
if(pErrorMsgs)
pErrorMsgs->Release();
return RE_SUCCEED;
}
void ImageFilterPixelShaderBase::set(IDirect3DDevice9* device) {
// Create the pixel shader if not exist.
if (!getPixelShaderCache()) {
// Compile the pixel shader.
CComPtr<ID3DXBuffer> buffer;
CComPtr<ID3DXBuffer> errorMessage;
D3DXMACRO macros[1] = {0};
HRESULT result = NULL;
if (FAILED(result = D3DXCompileShader(pixelShaderCode, strlen(pixelShaderCode), macros, NULL,
"process", "ps_3_0", D3DXSHADER_PREFER_FLOW_CONTROL, &buffer, &errorMessage, NULL))) {
showError(result, (const char*)buffer->GetBufferPointer());
return;
}
// Create the pixel shader.
CComPtr<IDirect3DPixelShader9> pixelShader;
if (FAILED(result = device->CreatePixelShader((DWORD*)buffer->GetBufferPointer(), &pixelShader))) {
showError(result, NULL);
return;
}
setPixelShaderCache(pixelShader);
}
// Set the pixel shader.
HRESULT result = NULL;
if (FAILED(result = device->SetPixelShader(getPixelShaderCache()))) {
showError(result, NULL);
return;
}
CComPtr<IDirect3DSurface9> surface;
if (FAILED(result = device->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &surface))) {
showError(result, NULL);
return;
}
D3DSURFACE_DESC surfaceDesc;
memset(&surfaceDesc, 0, sizeof(surfaceDesc));
if (FAILED(result = surface->GetDesc(&surfaceDesc))) {
showError(result, NULL);
return;
}
D3DXVECTOR4 pixelShaderConstant[1];
memset(pixelShaderConstant, 0, sizeof(pixelShaderConstant));
pixelShaderConstant[0].x = surfaceDesc.Width;
pixelShaderConstant[0].y = surfaceDesc.Height;
if (FAILED(result = device->SetPixelShaderConstantF(0, (float*)pixelShaderConstant, 1))) {
showError(result, NULL);
return;
}
device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_POINT);
}
HRESULT CD3D9ShaderMaterialRenderer::stubD3DXCompileShader(LPCSTR pSrcData, UINT SrcDataLen, CONST D3DXMACRO* pDefines,
LPD3DXINCLUDE pInclude, LPCSTR pFunctionName,
LPCSTR pProfile, DWORD Flags, LPD3DXBUFFER* ppShader,
LPD3DXBUFFER* ppErrorMsgs, LPD3DXCONSTANTTABLE* ppConstantTable)
{
// wondering what I'm doing here?
// see comment in CD3D9ShaderMaterialRenderer::stubD3DXAssembleShader()
#if ( D3DX_SDK_VERSION < 24 )
// directly link functions, old d3d sdks didn't try to load external dlls
// when linking to the d3dx9.lib
#ifdef _MSC_VER
#pragma comment (lib, "d3dx9.lib")
#endif
// invoke static linked function
return D3DXCompileShader(pSrcData, SrcDataLen, pDefines, pInclude, pFunctionName, pProfile, Flags, ppShader, ppErrorMsgs, ppConstantTable);
#else
{
// try to load shader functions from the dll and print error if failed.
// D3DXCompileShader
typedef HRESULT (WINAPI *D3DXCompileShaderFunction)(LPCSTR pSrcData, UINT SrcDataLen, CONST D3DXMACRO* pDefines,
LPD3DXINCLUDE pInclude, LPCSTR pFunctionName,
LPCSTR pProfile, DWORD Flags, LPD3DXBUFFER* ppShader,
LPD3DXBUFFER* ppErrorMsgs, LPD3DXCONSTANTTABLE* ppConstantTable);
static bool LoadFailed = false;
static D3DXCompileShaderFunction pFn = 0;
if (!pFn && !LoadFailed)
{
// try to load dll
io::path strDllName = "d3dx9_";
strDllName += (int)D3DX_SDK_VERSION;
strDllName += ".dll";
HMODULE hMod = LoadLibrary(strDllName.c_str());
if (hMod)
pFn = (D3DXCompileShaderFunction)GetProcAddress(hMod, "D3DXCompileShader");
if (!pFn)
{
LoadFailed = true;
os::Printer::log("Could not load shader function D3DXCompileShader from dll, shaders disabled",
strDllName.c_str(), ELL_ERROR);
}
}
if (pFn)
{
// call already loaded function
return (*pFn)(pSrcData, SrcDataLen, pDefines, pInclude, pFunctionName, pProfile, Flags, ppShader, ppErrorMsgs, ppConstantTable);
}
}
#endif // D3DX_SDK_VERSION < 24
return 0;
}
TRESULT D3DWrapper::CompileVertexShader( OCShader*& shader )
{
if( NULL == shader )
return RE_FAILED;
if( NULL == shader->GetVertexShaderCode() )
return RE_FAILED;
UINT codeSize = static_cast<UINT>( strlen(shader->GetVertexShaderCode()) );
if( 0 == codeSize )
return RE_FAILED;
LPD3DXCONSTANTTABLE pConstantTable;
LPD3DXBUFFER pCode;
LPD3DXBUFFER pErrorMsgs;
HRESULT hr = D3DXCompileShader( shader->GetVertexShaderCode(), codeSize, NULL, NULL, "main", "vs_3_0", 0, &pCode, &pErrorMsgs, &pConstantTable );
if(FAILED(hr))return RE_FAILED;
hr = m_pD3dDevice->CreateVertexShader( (DWORD*)pCode->GetBufferPointer(), shader->GetVertexShaderPtr() );
if(FAILED(hr))return RE_FAILED;
//vector<string> constantNameList;
//if( pConstantTable )
//{
// D3DXCONSTANTTABLE_DESC constant_desc;
// pConstantTable->GetDesc( &constant_desc );
// // Get Constant list
// D3DXCONSTANT_DESC Desc;
// UINT Count;
// for( UINT i = 0; i<constant_desc.Constants; i++ )
// {
// D3DXHANDLE handle = pConstantTable->GetConstant(NULL, i);
// pConstantTable->GetConstantDesc( handle, &Desc, &Count );
// constantNameList.push_back( Desc.Name );
// }
//}
if(pCode)
pCode->Release();
if(pErrorMsgs)
pErrorMsgs->Release();
if(pConstantTable)
pConstantTable->Release();
return RE_SUCCEED;
}
ID3DXBuffer* Sprite::compileShader(const std::string& shaderSource, const std::string& entryPoint, const std::string& profile, ID3DXConstantTable** outConstantTable) const {
ID3DXBuffer* binaryShader = NULL;
CComPtr<ID3DXBuffer> shaderErrors = NULL;
DWORD flags = 0;
#ifdef _DEBUG
flags = D3DXSHADER_DEBUG;
#endif
CHECK(D3DXCompileShader(shaderSource.c_str(), shaderSource.length(), NULL, NULL, entryPoint.c_str(), profile.c_str(), flags, &binaryShader, &shaderErrors, outConstantTable),
(char*)shaderErrors->GetBufferPointer());
return binaryShader;
}
ID3DXBuffer* RendererD3D::CompileShader(void* shaderData, uint shaderDataSize, const char* entryPoint, const char* shaderProfile)
{
ID3DXBuffer* d3dshader = 0;
ID3DXBuffer* errors = 0;
HRESULT res = D3DXCompileShader((const char*)shaderData, shaderDataSize, 0, 0, entryPoint, shaderProfile, 0, &d3dshader, &errors, 0);
if( res == D3D_OK )
return d3dshader;
OutputDebugString((const char*)errors->GetBufferPointer());
return 0;
}
static sBool sCompileDX9(sCompileResult &result, sInt stype, sInt dtype, sInt flags, const sChar8 *src, sInt len, const sChar8 *name)
{
#if sCOMP_DX9_ENABLE
ID3DXBuffer *bytecode;
sRelease(result.D3D9.CTable);
sRelease(result.D3D9.Errors);
sU32 d3dflags = 0;
if(flags&sSCF_DEBUG)
d3dflags |= D3DXSHADER_DEBUG;
//if (sGetShellSwitch(L"n"))
// flags |= D3DXSHADER_SKIPOPTIMIZATION; // only use in case of emergency
const sChar8 *profile8 = GetProfile(dtype);
sChar profile[16];
sCopyString(profile,profile8,16);
// use old compiler for generating shader model 1_* code
#ifdef D3DXSHADER_USE_LEGACY_D3DX9_31_DLL
if(sMatchWildcard(L"ps_1_*",profile))
d3dflags |= D3DXSHADER_USE_LEGACY_D3DX9_31_DLL;
#endif
if(D3DXCompileShader(src,len,0,0,name,profile8,d3dflags,&bytecode,&result.D3D9.Errors,&result.D3D9.CTable)!=D3D_OK)
result.Valid = sFALSE;
else
result.Valid = sTRUE;
// print errors and warnings
if(result.D3D9.Errors)
{
ID3DXBuffer *buffer = result.D3D9.Errors;
//sInt size = buffer->GetBufferSize();
sCopyString(result.Errors,(sChar8*)buffer->GetBufferPointer(),result.Errors.Size());
}
if(!result.Valid)
{
sRelease(bytecode);
return sFALSE;
}
// get source code
sAddShaderBlob(result.ShaderBlobs,dtype,bytecode->GetBufferSize(),(const sU8*)bytecode->GetBufferPointer());
return result.Valid;
#else
return sFALSE;
#endif // sCOMP_DX9_ENABLE
}
bool
ShaderImpl_DirectX9::Compile(const char *code, int type)
{
if (!code) return false;
LPD3DXBUFFER pCode = NULL;
LPD3DXBUFFER pError = NULL;
switch(type)
{
case Shader::TYPE_VERTEX:
{
if (D3DXCompileShader(code, strlen(code), NULL, NULL, "vs_main", "vs_2_0", 0, &pCode, &pError, &_vs_constTable) < 0)
{
DEBUG_MESSAGE((char *)pError->GetBufferPointer());
return false;
}
setupConstantData(UNIFORM_VS, _vs_constTable);
DrawManager::GetDeviceHandle()->CreateVertexShader(
reinterpret_cast<DWORD*>(pCode->GetBufferPointer()), &_vertexShader);
pCode->Release();
} return true;
case Shader::TYPE_PIXEL:
{
if (D3DXCompileShader(code, strlen(code), NULL, NULL, "ps_main", "ps_3_0", 0, &pCode, &pError, &_ps_constTable) < 0)
{
DEBUG_MESSAGE((char *)pError->GetBufferPointer());
return false;
}
setupConstantData(UNIFORM_PS, _ps_constTable);
DrawManager::GetDeviceHandle()->CreatePixelShader(
reinterpret_cast<DWORD*>(pCode->GetBufferPointer()), &_pixelShader);
pCode->Release();
} return true;
default: return false;
}
}
ETOOLS_API HRESULT WINAPI
D3DX_CompileShader(
LPCSTR pSrcData,
UINT SrcDataLen,
CONST D3DXMACRO* pDefines,
LPD3DXINCLUDE pInclude,
LPCSTR pFunctionName,
LPCSTR pTarget,
DWORD Flags,
LPD3DXBUFFER* ppShader,
LPD3DXBUFFER* ppErrorMsgs,
LPD3DXCONSTANTTABLE* ppConstantTable)
{
return D3DXCompileShader(
pSrcData, SrcDataLen, pDefines, pInclude, pFunctionName,
pTarget, Flags, ppShader, ppErrorMsgs, ppConstantTable);
}
bool Blit::setShader(ShaderId source, const char *profile,
HRESULT (WINAPI IDirect3DDevice9::*createShader)(const DWORD *, D3DShaderType**),
HRESULT (WINAPI IDirect3DDevice9::*setShader)(D3DShaderType*))
{
IDirect3DDevice9 *device = getDevice();
D3DShaderType *shader;
if (mCompiledShaders[source] != NULL)
{
shader = static_cast<D3DShaderType*>(mCompiledShaders[source]);
}
else
{
ID3DXBuffer *shaderCode;
HRESULT hr = D3DXCompileShader(mShaderSource[source], strlen(mShaderSource[source]), NULL, NULL, "main", profile, 0, &shaderCode, NULL, NULL);
if (FAILED(hr))
{
ERR("Failed to compile %s shader for blit operation %d, error 0x%08X.", profile, (int)source, hr);
return false;
}
hr = (device->*createShader)(static_cast<const DWORD*>(shaderCode->GetBufferPointer()), &shader);
if (FAILED(hr))
{
shaderCode->Release();
ERR("Failed to create %s shader for blit operation %d, error 0x%08X.", profile, (int)source, hr);
return false;
}
shaderCode->Release();
mCompiledShaders[source] = shader;
}
HRESULT hr = (device->*setShader)(shader);
if (FAILED(hr))
{
ERR("Failed to set %s shader for blit operation %d, error 0x%08X.", profile, (int)source, hr);
return false;
}
return true;
}
bool Shader::CompileShader()
{
DWORD dwShaderFlags = D3DXSHADER_PARTIALPRECISION;
LPD3DXBUFFER pCode;
LPD3DXBUFFER pErrors;
int iSrcLen = strlen( m_pShaderSrc );
if ( iSrcLen == 0 )
return false;
HRESULT hr = ( D3DXCompileShader( m_pShaderSrc,
iSrcLen,
NULL, // defines
NULL, // include
"Main", // Function name
m_ShaderType == ST_PIXEL ? "ps_2_0": "vs_2_0", // profile
dwShaderFlags, // Flags
&pCode, // Output compiled shader
&pErrors, // error messages
&m_pConstantTable // constant table
) );
if( FAILED( hr ) )
{
char* errors = (char*)pErrors->GetBufferPointer();
OutputDebugStringA( errors );
return false;
}
if ( m_ShaderType == ST_PIXEL )
{
m_pPShader = Renderer::CreatePixelShader( ( DWORD* )pCode->GetBufferPointer() );
}
else
{
m_pVShader = Renderer::CreateVertexShader( ( DWORD* )pCode->GetBufferPointer() );
}
pCode->Release();
return true;
}
void mini3d::D3D9VertexShader::LoadResource(void)
{
IDirect3DDevice9* pDevice = pGraphicsService->GetDevice();
if (pDevice == 0)
return;
// If the buffer exists tear it down.
if (pShaderBuffer != 0)
{
UnloadResource();
}
// compile the shader source
ID3DXBuffer* buffer;
LPD3DXBUFFER ppErroMessage;
D3DXCompileShader((LPCSTR)pShaderBytes, sizeInBytes, 0, 0, "main", "vs_2_0", 0, &buffer, &ppErroMessage, 0);
if (ppErroMessage != 0)
{
OutputDebugStringA((char*)(ppErroMessage->GetBufferPointer()));
isDirty = true;
return;
}
if( FAILED( pDevice->CreateVertexShader((DWORD*)buffer->GetBufferPointer(), &pShaderBuffer)))
{
isDirty = true;
return;
}
buffer->Release();
isDirty = false;
// load the vertex declaration into the pool
pGraphicsService->PoolVertexDeclaration(vertexDeclaration, vertexDataCount);
}
bool CompilePixelShader(const char * code, LPDIRECT3DPIXELSHADER9 * pShader, LPD3DXCONSTANTTABLE * pShaderTable) {
LPD3DXCONSTANTTABLE shaderTable = *pShaderTable;
ID3DXBuffer* pShaderCode = NULL;
ID3DXBuffer* pErrorMsg = NULL;
HRESULT hr = -1;
#ifdef _XBOX
// Compile pixel shader.
hr = D3DXCompileShader( code,
(UINT)strlen( code ),
NULL,
NULL,
"main",
"ps_3_0",
0,
&pShaderCode,
&pErrorMsg,
pShaderTable );
#endif
if( FAILED(hr) )
{
OutputDebugStringA((CHAR*)pErrorMsg->GetBufferPointer());
DebugBreak();
return false;
}
// Create pixel shader.
pD3Ddevice->CreatePixelShader( (DWORD*)pShaderCode->GetBufferPointer(),
pShader );
pShaderCode->Release();
return true;
}
//----------------------------------------------------------------------------//
void D3D9Shader::loadFromSrc()
{
LPD3DXBUFFER pErr = NULL;
HRESULT hr = D3DXCompileShader(mSource.c_str(), static_cast<UINT>(mSource.length()),
NULL,
NULL,
mEntryName.c_str(),
mTarget.c_str(),
D3DXSHADER_PACKMATRIX_COLUMNMAJOR,
&mShaderBuffer,
&pErr,
&mpConstTable);
if(FAILED(hr))
{
String message = "Cannot compile D3D9 high-level shader " + mName + " Errors:\n" +
static_cast<const char*>(pErr->GetBufferPointer());
pErr->Release();
TITAN_EXCEPT_API( message);
}
_loadShaderFromBuffer();
}
/**
* Render the Oculus Rift View.
***/
void* OculusRenderer::Provoke(void* pThis, int eD3D, int eD3DInterface, int eD3DMethod, DWORD dwNumberConnected, int& nProvokerIndex)
{
// return if wrong call
if ((eD3D >= (int)AQU_DirectXVersion::DirectX_9_0) &&
(eD3D <= (int)AQU_DirectXVersion::DirectX_9_29))
{
if (((eD3DInterface == INTERFACE_IDIRECT3DDEVICE9) &&
(eD3DMethod == METHOD_IDIRECT3DDEVICE9_PRESENT)) ||
((eD3DInterface == INTERFACE_IDIRECT3DDEVICE9) &&
(eD3DMethod == METHOD_IDIRECT3DDEVICE9_ENDSCENE)) ||
((eD3DInterface == INTERFACE_IDIRECT3DSWAPCHAIN9) &&
(eD3DMethod == METHOD_IDIRECT3DSWAPCHAIN9_PRESENT)))
{
(pThis);
}
else return nullptr;
}
else
return nullptr;
// get input data
if (m_paInput[(int)ORN_Decommanders::LeftTexture])
m_pcTextureLeft = *(LPDIRECT3DTEXTURE9*)m_paInput[(int)ORN_Decommanders::LeftTexture];
else
m_pcTextureLeft = nullptr;
if (m_paInput[(int)ORN_Decommanders::RightTexture])
m_pcTextureRight = *(LPDIRECT3DTEXTURE9*)m_paInput[(int)ORN_Decommanders::RightTexture];
else m_pcTextureRight = nullptr;
if (m_paInput[(int)ORN_Decommanders::DistortionVertexBufferLeft])
if (*(LPDIRECT3DVERTEXBUFFER9**)m_paInput[(int)ORN_Decommanders::DistortionVertexBufferLeft])
m_pcDistortionVertexBufferLeft = **(LPDIRECT3DVERTEXBUFFER9**)m_paInput[(int)ORN_Decommanders::DistortionVertexBufferLeft];
else m_pcDistortionVertexBufferLeft = nullptr;
else m_pcDistortionVertexBufferLeft = nullptr;
if (m_paInput[(int)ORN_Decommanders::DistortionVertexBufferRight])
if (*(LPDIRECT3DVERTEXBUFFER9**)m_paInput[(int)ORN_Decommanders::DistortionVertexBufferRight])
m_pcDistortionVertexBufferRight = **(LPDIRECT3DVERTEXBUFFER9**)m_paInput[(int)ORN_Decommanders::DistortionVertexBufferRight];
else m_pcDistortionVertexBufferRight = nullptr;
else m_pcDistortionVertexBufferRight = nullptr;
if (m_paInput[(int)ORN_Decommanders::DistortionIndexBufferLeft])
if (*(LPDIRECT3DINDEXBUFFER9**)m_paInput[(int)ORN_Decommanders::DistortionIndexBufferLeft])
m_pcDistortionIndexBufferLeft = **(LPDIRECT3DINDEXBUFFER9**)m_paInput[(int)ORN_Decommanders::DistortionIndexBufferLeft];
else m_pcDistortionIndexBufferLeft = nullptr;
else m_pcDistortionIndexBufferLeft = nullptr;
if (m_paInput[(int)ORN_Decommanders::DistortionIndexBufferRight])
if (*(LPDIRECT3DINDEXBUFFER9**)m_paInput[(int)ORN_Decommanders::DistortionIndexBufferRight])
m_pcDistortionIndexBufferRight = **(LPDIRECT3DINDEXBUFFER9**)m_paInput[(int)ORN_Decommanders::DistortionIndexBufferRight];
else m_pcDistortionIndexBufferRight = nullptr;
else m_pcDistortionIndexBufferRight = nullptr;
if (m_paInput[(int)ORN_Decommanders::OculusVertexDeclaration])
if (*(LPDIRECT3DVERTEXDECLARATION9**)m_paInput[(int)ORN_Decommanders::OculusVertexDeclaration])
m_pcVertexDecl = **(LPDIRECT3DVERTEXDECLARATION9**)m_paInput[(int)ORN_Decommanders::OculusVertexDeclaration];
else m_pcVertexDecl = nullptr;
else m_pcVertexDecl = nullptr;
if (m_paInput[(int)ORN_Decommanders::DefaultEyeFovLeft])
if (*(ovrFovPort**)m_paInput[(int)ORN_Decommanders::DefaultEyeFovLeft])
m_psFOVPortLeft = *(ovrFovPort**)m_paInput[(int)ORN_Decommanders::DefaultEyeFovLeft];
else m_psFOVPortLeft = nullptr;
else m_psFOVPortLeft = nullptr;
if (m_paInput[(int)ORN_Decommanders::DefaultEyeFovRight])
if (*(ovrFovPort**)m_paInput[(int)ORN_Decommanders::DefaultEyeFovRight])
m_psFOVPortRight = *(ovrFovPort**)m_paInput[(int)ORN_Decommanders::DefaultEyeFovRight];
else m_psFOVPortRight = nullptr;
else m_psFOVPortRight = nullptr;
// get device
LPDIRECT3DDEVICE9 pcDevice = nullptr;
bool bReleaseDevice = false;
if (eD3DInterface == INTERFACE_IDIRECT3DDEVICE9)
{
pcDevice = (LPDIRECT3DDEVICE9)pThis;
}
else if (eD3DInterface == INTERFACE_IDIRECT3DSWAPCHAIN9)
{
LPDIRECT3DSWAPCHAIN9 pSwapChain = (LPDIRECT3DSWAPCHAIN9)pThis;
if (!pSwapChain)
{
OutputDebugString(L"Oculus Renderer Node : No swapchain !");
return nullptr;
}
pSwapChain->GetDevice(&pcDevice);
bReleaseDevice = true;
}
if (!pcDevice)
{
OutputDebugString(L"Oculus Renderer Node : No device !");
return nullptr;
}
// Original code (LibOVR) :
// pShaderCode = ShaderCompile("precompiledVertexShaderSrc",VertexShaderSrc,"vs_2_0");
// pShaderCode = ShaderCompile("precompiledVertexShaderTimewarpSrc",VertexShaderTimewarpSrc,"vs_3_0");
// pShaderCode = ShaderCompile("precompiledPixelShaderSrc",PixelShaderSrc,"ps_3_0");
// pixel shader created ?
if (!m_pcOculusPixelShader)
{
LPD3DXBUFFER pShader;
// compile and create shader
if (SUCCEEDED(D3DXCompileShader(PixelShaderSrc,strlen(PixelShaderSrc),NULL,NULL,"main","ps_3_0",NULL,&pShader,NULL,&m_pcOculusPixelShaderCT)))
{
OutputDebugString(L"Pixel shader compiled!");
pcDevice->CreatePixelShader((DWORD*)pShader->GetBufferPointer(), &m_pcOculusPixelShader);
}
}
// vertex shader created ?
if (!m_pcOculusVertexShader)
{
LPD3DXBUFFER pShader;
// compile and create shader
if (SUCCEEDED(D3DXCompileShader(VertexShaderSrc,strlen(VertexShaderSrc),NULL,NULL,"main","vs_2_0",NULL,&pShader,NULL,&m_pcOculusVertexShaderCT)))
{
OutputDebugString(L"Vertex shader compiled!");
pcDevice->CreateVertexShader((DWORD*)pShader->GetBufferPointer(), &m_pcOculusVertexShader);
}
}
// side by side pixel shader ?
if (!m_pcSideBySidePixelShader)
{
LPD3DXBUFFER pShader;
// compile and create shader
if (SUCCEEDED(D3DXCompileShader(PixelShaderSrcSideBySide,strlen(PixelShaderSrcSideBySide),NULL,NULL,"SBS","ps_2_0",NULL,&pShader,NULL,&m_pcSideBySidePixelShaderCT)))
{
OutputDebugString(L"Pixel shader compiled!");
pcDevice->CreatePixelShader((DWORD*)pShader->GetBufferPointer(), &m_pcSideBySidePixelShader);
}
}
// test textures created ?
if ((!m_pcTextureRightTest) || (!m_pcTextureLeftTest))
{
HMODULE hModule = GetModuleHandle(L"OculusRenderer.dll");
if (!m_pcTextureLeftTest)
{
// create a test texture
if (SUCCEEDED(D3DXCreateTextureFromResource(pcDevice, hModule, MAKEINTRESOURCE(IMG_BACKGROUND01), &m_pcTextureLeftTest)))
OutputDebugString(L"Texture created !");
else m_pcTextureLeftTest = nullptr;
}
if (!m_pcTextureRightTest)
{
// create a test texture
if (SUCCEEDED(D3DXCreateTextureFromResource(pcDevice, hModule, MAKEINTRESOURCE(IMG_BACKGROUND02), &m_pcTextureRightTest)))
OutputDebugString(L"Texture created !");
else m_pcTextureRightTest = nullptr;
}
}
// default vertex buffer ?
if (!m_pcVertexBufferDefault)
{
InitDefaultVertexBuffer(pcDevice);
if (!m_pcVertexBufferDefault) return nullptr;
}
// vertex buffers ? index buffers ? not all present ?
if ((!m_pcDistortionVertexBufferLeft) || (!m_pcDistortionVertexBufferRight) ||
(!m_pcDistortionIndexBufferLeft) || (!m_pcDistortionIndexBufferRight) ||
(!m_pcVertexDecl))
{
if (m_bBuffersConnected)
{
// clear all descriptions for safety
ZeroMemory(&m_sVertexBufferDescLeft, sizeof(D3DVERTEXBUFFER_DESC));
ZeroMemory(&m_sVertexBufferDescRight, sizeof(D3DVERTEXBUFFER_DESC));
ZeroMemory(&m_sIndexBufferDescLeft, sizeof(D3DINDEXBUFFER_DESC));
ZeroMemory(&m_sIndexBufferDescRight, sizeof(D3DINDEXBUFFER_DESC));
m_bBuffersConnected = false;
}
}
else
{
m_bBuffersConnected = true;
// vertex buffer description ? left
if (!m_sVertexBufferDescLeft.Size)
m_pcDistortionVertexBufferLeft->GetDesc(&m_sVertexBufferDescLeft);
// vertex buffer length matches oculus vertex type ?
if ((m_sVertexBufferDescLeft.Size % sizeof(ovrDistortionVertex)) != 0)
{
OutputDebugString(L"OculusRenderer Node : Connected vertex buffer size mismatch !");
return nullptr;
}
// and right
if (!m_sVertexBufferDescRight.Size)
m_pcDistortionVertexBufferRight->GetDesc(&m_sVertexBufferDescRight);
// vertex buffer length matches oculus vertex type ?
if ((m_sVertexBufferDescRight.Size % sizeof(ovrDistortionVertex)) != 0)
{
OutputDebugString(L"OculusRenderer Node : Connected vertex buffer size mismatch !");
return nullptr;
}
// index buffer ?
if ((!m_pcDistortionIndexBufferLeft) || (!m_pcDistortionIndexBufferRight))
return nullptr;
// index buffer description ?
if (!m_sIndexBufferDescLeft.Size)
{
m_pcDistortionIndexBufferLeft->GetDesc(&m_sIndexBufferDescLeft);
// index buffer length matches vertex buffer size ? TODO !!
/*if ()
{
OutputDebugString(L"OculusRenderer Node : Connected index buffer size mismatch !");
return nullptr;
}*/
}
if (!m_sIndexBufferDescRight.Size)
{
m_pcDistortionIndexBufferRight->GetDesc(&m_sIndexBufferDescRight);
// index buffer length matches vertex buffer size ? TODO !!
/*if ()
{
OutputDebugString(L"OculusRenderer Node : Connected index buffer size mismatch !");
return nullptr;
}*/
}
}
// start to render
pcDevice->BeginScene();
// save states
IDirect3DStateBlock9* pStateBlock = nullptr;
pcDevice->CreateStateBlock(D3DSBT_ALL, &pStateBlock);
// set ALL render states to default
SetAllRenderStatesDefault(pcDevice);
// set states
pcDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
pcDevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
pcDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
pcDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_CONSTANT);
pcDevice->SetTextureStageState(0, D3DTSS_CONSTANT, 0xffffffff);
pcDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
pcDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE);
pcDevice->SetRenderState(D3DRS_ZWRITEENABLE, FALSE);
pcDevice->SetSamplerState(0, D3DSAMP_SRGBTEXTURE, 0);
pcDevice->SetSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
pcDevice->SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
pcDevice->SetSamplerState(0, D3DSAMP_ADDRESSW, D3DTADDRESS_CLAMP);
pcDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_ANISOTROPIC);
pcDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_ANISOTROPIC);
pcDevice->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_NONE);
D3DCOLOR clearColor = D3DCOLOR_RGBA(0, 0, 0, 0);
pcDevice->Clear(0, NULL, D3DCLEAR_TARGET, clearColor, 0, 0);
// required fields
D3DSURFACE_DESC sSurfaceDesc;
ovrSizei sTextureSize;
ovrRecti sRenderViewport;
ovrVector2f UVScaleOffset[2];
// LEFT EYE :
// left eye, first set stream source, indices
if (m_bBuffersConnected)
{
// no timewarp here, use standard vertex shader, set pixel shader, set vertex declaration
pcDevice->SetVertexShader( m_pcOculusVertexShader);
pcDevice->SetPixelShader( m_pcOculusPixelShader );
pcDevice->SetVertexDeclaration( m_pcVertexDecl );
// set texture
if (m_pcTextureLeft)
pcDevice->SetTexture( 0, m_pcTextureLeft );
else if (m_pcTextureLeftTest)
pcDevice->SetTexture( 0, m_pcTextureLeftTest );
else pcDevice->SetTexture( 0, 0);
// get texture size
if (m_pcTextureLeft)
m_pcTextureLeft->GetLevelDesc(0, &sSurfaceDesc);
else if (m_pcTextureLeftTest)
m_pcTextureLeftTest->GetLevelDesc(0, &sSurfaceDesc);
else ZeroMemory(&sSurfaceDesc, sizeof(D3DSURFACE_DESC));
sTextureSize.w = (int)sSurfaceDesc.Width;
sTextureSize.h = (int)sSurfaceDesc.Height;
// set render viewport size the same size as the texture size (!)
sRenderViewport.Pos.x = 0;
sRenderViewport.Pos.y = 0;
sRenderViewport.Size.w = sTextureSize.w;
sRenderViewport.Size.h = sTextureSize.h;
// get and set scale and offset
if (m_psFOVPortLeft)
ovrHmd_GetRenderScaleAndOffset(*m_psFOVPortLeft, sTextureSize, sRenderViewport, UVScaleOffset);
else
ovrHmd_GetRenderScaleAndOffset(m_sDefaultFOVPortLeft, sTextureSize, sRenderViewport, UVScaleOffset);
pcDevice->SetVertexShaderConstantF( 0, ( FLOAT* )&UVScaleOffset[0], 1 );
pcDevice->SetVertexShaderConstantF( 2, ( FLOAT* )&UVScaleOffset[1], 1 );
pcDevice->SetStreamSource( 0, m_pcDistortionVertexBufferLeft,0, sizeof(ovrDistortionVertex) );
pcDevice->SetIndices( m_pcDistortionIndexBufferLeft);
// draw
pcDevice->DrawIndexedPrimitive( D3DPT_TRIANGLELIST,0,0, m_sVertexBufferDescLeft.Size / sizeof(ovrDistortionVertex) , 0, m_sIndexBufferDescLeft.Size / 6 );
}
else
{
pcDevice->SetSamplerState(1, D3DSAMP_SRGBTEXTURE, 0);
pcDevice->SetSamplerState(1, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
pcDevice->SetSamplerState(1, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
pcDevice->SetSamplerState(1, D3DSAMP_ADDRESSW, D3DTADDRESS_CLAMP);
pcDevice->SetSamplerState(1, D3DSAMP_MAGFILTER, D3DTEXF_ANISOTROPIC);
pcDevice->SetSamplerState(1, D3DSAMP_MINFILTER, D3DTEXF_ANISOTROPIC);
pcDevice->SetSamplerState(1, D3DSAMP_MIPFILTER, D3DTEXF_NONE);
// side by side render
pcDevice->SetVertexShader(NULL);
pcDevice->SetPixelShader(m_pcSideBySidePixelShader);
pcDevice->SetVertexDeclaration( NULL );
pcDevice->SetFVF(D3DFVF_TEXVERTEX);
// set textures
if (m_pcTextureLeft)
pcDevice->SetTexture( 0, m_pcTextureLeft );
else if (m_pcTextureLeftTest)
pcDevice->SetTexture( 0, m_pcTextureLeftTest );
else pcDevice->SetTexture( 0, 0);
if (m_pcTextureRight)
pcDevice->SetTexture( 1, m_pcTextureRight );
else if (m_pcTextureRightTest)
pcDevice->SetTexture( 1, m_pcTextureRightTest );
else pcDevice->SetTexture( 1, 0);
// set stream and draw
pcDevice->SetStreamSource( 0, m_pcVertexBufferDefault,0, sizeof(TEXVERTEX) );
pcDevice->DrawPrimitive(D3DPT_TRIANGLEFAN, 0, 2);
}
// RIGHT EYE:
if (m_bBuffersConnected)
{
// set texture
if (m_pcTextureRight)
pcDevice->SetTexture( 0, m_pcTextureRight );
else if (m_pcTextureRightTest)
pcDevice->SetTexture( 0, m_pcTextureRightTest );
else pcDevice->SetTexture( 0, 0);
// get texture size
if (m_pcTextureRight)
m_pcTextureRight->GetLevelDesc(0, &sSurfaceDesc);
else if (m_pcTextureRightTest)
m_pcTextureRightTest->GetLevelDesc(0, &sSurfaceDesc);
else ZeroMemory(&sSurfaceDesc, sizeof(D3DSURFACE_DESC));
sTextureSize.w = (int)sSurfaceDesc.Width;
sTextureSize.h = (int)sSurfaceDesc.Height;
// get and set scale and offset
if (m_psFOVPortRight)
ovrHmd_GetRenderScaleAndOffset(*m_psFOVPortRight, sTextureSize, sRenderViewport, UVScaleOffset);
else
ovrHmd_GetRenderScaleAndOffset(m_sDefaultFOVPortRight, sTextureSize, sRenderViewport, UVScaleOffset);
pcDevice->SetVertexShaderConstantF( 0, ( FLOAT* )&UVScaleOffset[0], 1 );
pcDevice->SetVertexShaderConstantF( 2, ( FLOAT* )&UVScaleOffset[1], 1 );
// set stream source, indices, draw
pcDevice->SetStreamSource( 0, m_pcDistortionVertexBufferRight,0, sizeof(ovrDistortionVertex) );
pcDevice->SetIndices( m_pcDistortionIndexBufferRight);
// draw
pcDevice->DrawIndexedPrimitive( D3DPT_TRIANGLELIST,0,0, m_sVertexBufferDescRight.Size / sizeof(ovrDistortionVertex) , 0, m_sIndexBufferDescRight.Size / 6 );
}
pcDevice->EndScene();
// apply and release state block
if (pStateBlock)
{
pStateBlock->Apply();
pStateBlock->Release();
}
// release device if provided by swapchain
if (bReleaseDevice) pcDevice->Release();
return nullptr;
}
static bool load_program(unsigned index, const char *prog, bool path_is_file)
{
bool ret, ret_fp, ret_vp;
ID3DXBuffer *listing_f = NULL;
ID3DXBuffer *listing_v = NULL;
ID3DXBuffer *code_f = NULL;
ID3DXBuffer *code_v = NULL;
ret = true;
ret_fp = false;
ret_vp = false;
if (prg[index].f_ctable)
prg[index].f_ctable->Release();
if (prg[index].v_ctable)
prg[index].v_ctable->Release();
if (path_is_file)
{
ret_fp = D3DXCompileShaderFromFile(prog, NULL, NULL,
"main_fragment", "ps_3_0", 0, &code_f, &listing_f, &prg[index].f_ctable);
ret_vp = D3DXCompileShaderFromFile(prog, NULL, NULL,
"main_vertex", "vs_3_0", 0, &code_v, &listing_v, &prg[index].v_ctable);
}
else
{
/* TODO - crashes currently - to do with 'end of line' of stock shader */
ret_fp = D3DXCompileShader(prog, (UINT)strlen(prog), NULL, NULL,
"main_fragment", "ps_3_0", 0, &code_f, &listing_f, &prg[index].f_ctable );
ret_vp = D3DXCompileShader(prog, (UINT)strlen(prog), NULL, NULL,
"main_vertex", "vs_3_0", 0, &code_v, &listing_v, &prg[index].v_ctable );
}
if (FAILED(ret_fp) || FAILED(ret_vp) || listing_v || listing_f)
{
RARCH_ERR("HLSL error:\n");
if(listing_f)
RARCH_ERR("Fragment:\n%s\n", (char*)listing_f->GetBufferPointer());
if(listing_v)
RARCH_ERR("Vertex:\n%s\n", (char*)listing_v->GetBufferPointer());
ret = false;
goto end;
}
if (prg[index].fprg)
prg[index].fprg->Release();
if (prg[index].vprg)
prg[index].vprg->Release();
d3d_device_ptr->CreatePixelShader((const DWORD*)code_f->GetBufferPointer(), &prg[index].fprg);
d3d_device_ptr->CreateVertexShader((const DWORD*)code_v->GetBufferPointer(), &prg[index].vprg);
code_f->Release();
code_v->Release();
end:
if (listing_f)
listing_f->Release();
if (listing_v)
listing_v->Release();
return ret;
}
D3d9Shader::D3d9Shader(const char* sourceCode, const char* version, DWORD flags, uint8_t libraryType,
const D3d9Capabilities& capabilities): code_(nullptr)
{
static const char* pixelShaderPositionDecodingFromR32f =
"float4 encodePosition(float4 position, float4 projectionParameters)"
"{"
" return (position.z / projectionParameters.w).xxxx;"
"}"
"float decodeEyeZ(float4 encodedEyeZ, float4 projectionParameters)"
"{"
" return encodedEyeZ.r * projectionParameters.w;"
"}";
static const char* pixelShaderPositionDecodingFromRGBA8 =
"float4 encodePosition(float4 position, float4 projectionParameters)"
"{"
" float4 result = float4(16777216.0, 65536.0, 256.0, 1.0) *"
" position.z / projectionParameters.w;"
" result = frac(result);"
" result -= result.xxyz * float4(0.0, 1.0 / 256.0, 1.0 / 256.0, 1.0 / 256.0);"
" return result;"
"}"
"float decodeEyeZ(float4 encodedEyeZ, float4 projectionParameters)"
"{"
" return dot(encodedEyeZ, float4(1.0 / (256.0 * 256.0 * 256.0),"
" 1.0 / (256.0 * 256.0),"
" 1.0 / 256.0, 1.0)) * projectionParameters.w;"
"}";
std::string library;
switch(libraryType)
{
case LIBRARY_VERTEX_SHADER:
library =
"float4 multiplyQuaternions(float4 quaternion0, float4 quaternion1)"
"{"
" float3 v = quaternion0.w * quaternion1.xyz +"
" quaternion0.xyz * quaternion1.w +"
" cross(quaternion0.xyz, quaternion1.xyz);"
" float4 b = quaternion0 * quaternion1;"
" float w = dot(b, float4(-1.0, -1.0, -1.0, 1.0));"
" return float4(v, w);"
"}"
"float4 rotateVector(float3 targetVector, float4 quaternion)"
"{"
" float4 q = multiplyQuaternions(quaternion,"
" float4(targetVector, 0.0));"
" return multiplyQuaternions(q, float4(-quaternion.x, -quaternion.y,"
" -quaternion.z, quaternion.w));"
"}"
"float3 transformPosition(float4 offset, float4 rotation, float3 position)"
"{"
" return offset.xyz + rotateVector(position, rotation).xyz;"
"}";
break;
case LIBRARY_PIXEL_SHADER:
if(capabilities.isR32fRenderTargetFormatSupported())
library = pixelShaderPositionDecodingFromR32f;
else
library = pixelShaderPositionDecodingFromRGBA8;
library +=
"float3 decodePosition(float4 z, float2 xy, float4 projectionParameters,"
" float4 unprojectionVector)"
"{"
" float decodedEyeZ = decodeEyeZ(z, projectionParameters);"
" float4 p = float4(xy, 1.0, 0.0);"
" float4 result = p * unprojectionVector * decodedEyeZ.xxxx;"
" return result.xyz;"
"}"
"float3 encodeNormal(float3 normal)"
"{"
" return 0.5 * normal + 0.5;"
"}"
"half3 decodeNormal(half3 encodedNormal)"
"{"
" return 2.0 * encodedNormal - 1.0;"
"}";
break;
}
std::string sourceCodeWithLibrary = library + sourceCode;
if(FAILED(D3DXCompileShader(sourceCodeWithLibrary.c_str(),
sourceCodeWithLibrary.length(),
nullptr, nullptr, "main", version,
flags, &code_, nullptr, nullptr)))
code_ = nullptr;
}
//--------------------------------------------------------------------------------------
// Name: Create()
// Desc: Creates the help class' internal objects
//--------------------------------------------------------------------------------------
HRESULT Help::Create( const PackedResource* pResource )
{
// Get access to the gamepad texture
m_pGamepadTexture = pResource->GetTexture( "GamepadTexture" );
// Load the texture used for pointing help text at specific buttons
m_pLineTexture = pResource->GetTexture( "HelpCalloutTexture" );
// Create vertex declaration
if( NULL == g_pHelpVertexDecl )
{
static const D3DVERTEXELEMENT9 decl[] =
{
{ 0, 0, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 },
{ 0, 8, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 },
D3DDECL_END()
};
if( FAILED( g_pd3dDevice->CreateVertexDeclaration( decl, &g_pHelpVertexDecl ) ) )
return E_FAIL;
}
// Create vertex shader
ID3DXBuffer* pShaderCode;
if( NULL == g_pHelpVertexShader )
{
if( FAILED( D3DXCompileShader( g_strHelpShader, strlen( g_strHelpShader ),
NULL, NULL, "HelpVertexShader", "vs.2.0", 0,
&pShaderCode, NULL, NULL ) ) )
return E_FAIL;
if( FAILED( g_pd3dDevice->CreateVertexShader( ( DWORD* )pShaderCode->GetBufferPointer(),
&g_pHelpVertexShader ) ) )
return E_FAIL;
pShaderCode->Release();
}
// Create pixel shader.
if( NULL == g_pHelpPixelShader )
{
if( FAILED( D3DXCompileShader( g_strHelpShader, strlen( g_strHelpShader ),
NULL, NULL, "HelpPixelShader", "ps.2.0", 0,
&pShaderCode, NULL, NULL ) ) )
return E_FAIL;
if( FAILED( g_pd3dDevice->CreatePixelShader( ( DWORD* )pShaderCode->GetBufferPointer(),
&g_pHelpPixelShader ) ) )
return E_FAIL;
pShaderCode->Release();
}
if( NULL == g_pDarkPixelShader )
{
if( FAILED( D3DXCompileShader( g_strHelpShader, strlen( g_strHelpShader ),
NULL, NULL, "DarkPixelShader", "ps.2.0", 0,
&pShaderCode, NULL, NULL ) ) )
return E_FAIL;
if( FAILED( g_pd3dDevice->CreatePixelShader( ( DWORD* )pShaderCode->GetBufferPointer(),
&g_pDarkPixelShader ) ) )
return E_FAIL;
pShaderCode->Release();
}
return S_OK;
}
bool DX9VertexShaderConstantsCompiler::compile( const std::string& shaderCode, const char* entryFunction, std::vector< ShaderConstantDesc >& outConstants )
{
// create a renderer
IDirect3D9* d3d9 = Direct3DCreate9( D3D_SDK_VERSION );
DX9Initializer initializer( *d3d9 );
IDirect3DDevice9* compileDevice = initializer.createNullDevice();
const char* shaderProfile = D3DXGetVertexShaderProfile( compileDevice );
DWORD flags = D3DXSHADER_DEBUG;
ID3DXBuffer* shaderBuf = NULL;
ID3DXBuffer* errorsBuf = NULL;
ID3DXConstantTable* shaderConstants = NULL;
DX9ShaderIncludeLoader includesLoader;
HRESULT res = D3DXCompileShader( shaderCode.c_str(), shaderCode.length(), NULL, &includesLoader, entryFunction, shaderProfile, flags, &shaderBuf, &errorsBuf, &shaderConstants );
// interpret the results
bool result = true;
if ( FAILED(res) || shaderBuf == NULL )
{
if ( errorsBuf != NULL )
{
std::string compilationErrors = ( const char* )errorsBuf->GetBufferPointer();
errorsBuf->Release();
m_errorMsg = std::string( "Shader compilation error: " ) + compilationErrors;
}
else
{
m_errorMsg = translateDxError( "Error while compiling a shader", res );
}
result = false;
}
else
{
std::vector< D3DXCONSTANT_DESC > constants;
ShaderConstantDesc newConstant;
result = ShaderCompilerUtils::parseConstants( shaderConstants, m_errorMsg, constants );
if ( result )
{
unsigned int constantsCount = constants.size();
for ( unsigned int i = 0; i < constantsCount; ++i )
{
if ( createConstant( constants[i], newConstant ) )
{
outConstants.push_back( newConstant );
}
}
}
}
// cleanup
if ( shaderConstants )
{
shaderConstants->Release();
}
compileDevice->Release();
d3d9->Release();
return result;
}
HRESULT OnDeviceCreate(IDirect3DDevice9* pd3dDevice)
{
HRESULT hr;
pd3dDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
pd3dDevice->SetRenderState(D3DRS_LIGHTING, FALSE);
// decl
hr = pd3dDevice->CreateVertexDeclaration(DeclElements, &g_pDecl);
KCDX_HR_FAILCHECK(hr, "pd3dDevice->CreateVertexDeclaration");
// vs
char buf[2048];
KCReadFileContent(KResMgr::GetResPath("MyDemo/TextureHLSL/texture.vsh"), buf, sizeof(buf));
LPD3DXBUFFER pShaderBuffer, pErrBuffer;
hr = D3DXCompileShader(buf, strlen(buf), NULL, NULL,
"VSShaderMain", "vs_1_1", D3DXSHADER_DEBUG, &pShaderBuffer, &pErrBuffer, &g_pVSConstantTable);
if (FAILED(hr))
{
OutputDebugString("D3DXCompileShader Err (vs): ");
OutputDebugString((char*)pErrBuffer->GetBufferPointer());
OutputDebugString("\n");
return hr;
}
hr = pd3dDevice->CreateVertexShader((DWORD*)pShaderBuffer->GetBufferPointer(), &g_pVS);
KCDX_HR_FAILCHECK(hr, "pd3dDevice->CreateVertexShader");
KSAFE_RELEASE(pShaderBuffer);
// ps
KCReadFileContent(KResMgr::GetResPath("MyDemo/TextureHLSL/texture.psh"), buf, sizeof(buf));
hr = D3DXCompileShader(buf, strlen(buf), NULL, NULL,
"PSShaderMain", "ps_2_0", D3DXSHADER_DEBUG, &pShaderBuffer, &pErrBuffer, NULL);
if (FAILED(hr))
{
OutputDebugString("D3DXCompileShader Err (ps): ");
OutputDebugString((char*)pErrBuffer->GetBufferPointer());
OutputDebugString("\n");
return hr;
}
hr = pd3dDevice->CreatePixelShader((DWORD*)pShaderBuffer->GetBufferPointer(), &g_pPS);
KCDX_HR_FAILCHECK(hr, "pd3dDevice->CreatePixelShader");
KSAFE_RELEASE(pShaderBuffer);
// texture
hr = D3DXCreateTextureFromFile(pd3dDevice, "..\\..\\Media\\MyDemo\\TextureHLSL\\face.tga", &g_pTexture);
KCDX_HR_FAILCHECK(hr, "D3DXCreateTextureFromFile");
// vertex & indices
pd3dDevice->CreateVertexBuffer(4*sizeof(CUSTOMVERTEX), D3DUSAGE_WRITEONLY, 0, D3DPOOL_MANAGED, &g_pVB, NULL);
VOID* pVertices;
g_pVB->Lock(0, sizeof(Vertices), &pVertices, 0);
memcpy(pVertices, Vertices, sizeof(Vertices));
g_pVB->Unlock();
pd3dDevice->CreateIndexBuffer(sizeof(Indices), 0, D3DFMT_INDEX16, D3DPOOL_MANAGED, &g_pIB, NULL);
VOID *pIndices;
g_pIB->Lock(0, sizeof(Indices), &pIndices, 0);
memcpy(pIndices, Indices, sizeof(Indices));
g_pIB->Unlock();
return S_OK;
}
HRESULT XTexShader:: InitShader(const char* vertexShader,const char* pixelShader,D3DDevice *pDevice)
{
//-------------------------------------------------------------------------------------
// Vertex Shader and Pixel Shader
//-------------------------------------------------------------------------------------
TextFile *vert,*pix;
vert = ResourceManager::GetInstance()->Load<TextFile>(vertexShader);
pix = ResourceManager::GetInstance()->Load<TextFile>(pixelShader);
string sVert,sPix;
sVert = vert->GetFileContents();
sPix = pix->GetFileContents();
ID3DXBuffer* pVertexShaderCode;
ID3DXBuffer* pVertexErrorMessage;
//Creating Vertex Shader
HRESULT hr = D3DXCompileShader(sVert.c_str(),strlen(sVert.c_str()),NULL,NULL,"main","vs_2_0",0,&pVertexShaderCode,&pVertexErrorMessage,NULL);
if(FAILED(hr))
{
if(pVertexErrorMessage)
OutputDebugString((char*)pVertexErrorMessage->GetBufferPointer());
return E_FAIL;
}
pDevice->CreateVertexShader((DWORD*)pVertexShaderCode->GetBufferPointer(),&m_pVertexShader);
ID3DXBuffer* pPixelShaderCode;
ID3DXBuffer* pPixelErrorMessage;
//Creating Pixel Shader
hr = D3DXCompileShader(sPix.c_str(),strlen(sPix.c_str()),NULL,NULL,"main","ps_2_0",0,&pPixelShaderCode,&pPixelErrorMessage,NULL);
if(FAILED(hr))
{
if(pPixelErrorMessage)
OutputDebugString((char*)pPixelErrorMessage->GetBufferPointer());
return E_FAIL;
}
pDevice->CreatePixelShader((DWORD*)pPixelShaderCode->GetBufferPointer(),&m_pPixelShader);
//Creating Vertex Declaration
D3DVERTEXELEMENT9 VertexElements[3]=
{
{ 0, 0,D3DDECLTYPE_FLOAT3,D3DDECLMETHOD_DEFAULT,D3DDECLUSAGE_POSITION,0},
{ 0, 12, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 },
D3DDECL_END()
};
if (FAILED(pDevice->CreateVertexDeclaration(VertexElements, &m_pVertDec)))
return S_FALSE;
if(FAILED(CreateVertBuffer()))
return S_FALSE;
return S_OK;
}
void* LcD3D_BuildHLSL(PDEV pDev, char* sHLSL, int iLen, char* sFunction, char* sShader, PDCT* pTbl/*Out*/)
{
HRESULT hr;
DWORD dFlag = 0;
#if defined( _DEBUG ) || defined( DEBUG )
dFlag |= D3DXSHADER_DEBUG;
#endif
LPD3DXBUFFER pAsm = NULL;
LPD3DXBUFFER pErr = NULL;
void* pShd = NULL;
hr = D3DXCompileShader(
sHLSL
, iLen
, NULL
, NULL
, sFunction
, sShader
, dFlag
, &pAsm
, &pErr
, pTbl);
if( FAILED(hr) )
{
if(pErr)
{
char* sErr = (char*)pErr->GetBufferPointer();
LcD3D_GetDxError(hr, sErr);
pErr->Release();
}
else
LcD3D_GetDxError(hr);
return NULL;
}
if( 0 == _strnicmp(sShader, "vs", 2))
{
PDVS pVS = NULL;
hr = pDev->CreateVertexShader( (DWORD*)pAsm->GetBufferPointer() , &pVS);
pShd = pVS;
}
else if( 0 == _strnicmp(sShader, "ps", 2))
{
PDPS pPS = NULL;
hr = pDev->CreatePixelShader( (DWORD*)pAsm->GetBufferPointer() , &pPS);
pShd = pPS;
}
pAsm->Release();
if( FAILED(hr) )
{
LcD3D_GetDxError(hr);
return NULL;
}
return pShd;
}
static bool dx9_compile_shader(ShaderCode& out_shader, const ShaderCode& source, ShaderType::type type, FileSystem* fs=NULL, const char* include_dir=NULL)
{
R_ASSERT(source.type == ShaderCodeType_Text);
HRESULT hr = S_OK;
ID3DXBuffer* error_buffer = NULL;
ID3DXBuffer* shader_buffer = NULL;
ID3DXConstantTable* constant_table = NULL;
uint32 flags = D3DXSHADER_DEBUG;
const char* profile = shader_profile_string(type);
static const char dummy_vertex_shader[] = "float4 vertex() : POSITION { return 1; }";
static const char dummy_pixel_shader[] = "float4 pixel() : COLOR { return float4(1,0,1,1); }";
DX9ShaderIncluder includer(fs, include_dir);
hr = D3DXCompileShader(source.data(), (UINT)source.size(), NULL, &includer, "main", profile, flags, &shader_buffer, &error_buffer, &constant_table );
if( hr!=S_OK && error_buffer && error_buffer->GetBufferPointer() )
{
char* tmp = (char*)error_buffer->GetBufferPointer();
R_ERROR_MESSAGE_BOX(tmp, "Shader compile error");
shader_buffer = NULL;
error_buffer = NULL;
//create dummy shader
if( type == ShaderType::Pixel )
{
hr = D3DXCompileShader(
dummy_pixel_shader, uint32(strlen(dummy_pixel_shader)), NULL, NULL, "pixel", "ps_2_0",
flags, &shader_buffer, &error_buffer, NULL );
validate_d3d_result(hr, true);
}
else if( type == ShaderType::Vertex )
{
hr = D3DXCompileShader(
dummy_vertex_shader, uint32(strlen(dummy_vertex_shader)), NULL, NULL, "vertex", "vs_2_0",
flags, &shader_buffer, &error_buffer, NULL );
validate_d3d_result(hr, true);
}
}
out_shader.type = ShaderCodeType_Binary;
out_shader.clear();
uint32 size = shader_buffer->GetBufferSize();
if( size )
{
out_shader.resize(size);
memcpy(out_shader.data(), shader_buffer->GetBufferPointer(), size);
}
if(error_buffer) error_buffer->Release();
if(shader_buffer) shader_buffer->Release();
if(constant_table) constant_table->Release();
return true;
}
bool CShaderHLSL::Create(P3D::sShaderDesc &desc)
{
const char *pData;
ULONG fsize;
IFileSystem* pFS = CRenderer::mEngine()->mFilesystem();
wchar path[P3DMAX_PATH];
wsprintf(path, P3DMAX_PATH-1, _W("shaders/%s.rshader"), desc.ShaderFile.Get());
FSFILE *fp = pFS->Load(path, (BYTE *&)pData, fsize, true);
if (!fp)
{
CON(MSG_ERR, _W("Can't open %s.hlsl shader file from data/shaders directory!"), desc.ShaderFile.Get());
return false;
}
ID3DXBuffer *pShaderBlob = NULL;
ID3DXBuffer *pErrors = NULL;
DWORD flags = D3DXSHADER_DEBUG; //D3DXSHADER_OPTIMIZATION_LEVEL3
char profile[128];
switch(desc.ShaderType)
{
case SHADERTYPE_VERTEX_SHADER:
strcpy(profile, D3DXGetVertexShaderProfile(g_pD3ddev));
break;
case SHADERTYPE_PIXEL_SHADER:
strcpy(profile, D3DXGetPixelShaderProfile(g_pD3ddev));
break;
case SHADERTYPE_GEOMETRY_SHADER:
CON(MSG_ERR, _W("DX9 does not support geometry shaders."));
return false;
default:
CON(MSG_ERR, _W("Chader creation failed. No apropriate ShaderType given."));
return false;
}
CIncludeHandler includeHandler;
D3DXMACRO Shader_Macros[] =
{
{ "DX9", NULL },
{ "SM3", NULL },
NULL
};
if(FAILED(D3DXCompileShader(
pData,
fsize,
Shader_Macros,
&includeHandler,
_W2A(desc.EntryFunction.Get()),
profile,
flags,
&pShaderBlob,
&pErrors,
&m_pConstTable
)))
{
if(pErrors) CON(MSG_ERR, _W("%s"), _A2W((char*)pErrors->GetBufferPointer()));
else CON(MSG_ERR, _W("Error description not given"));
CON(MSG_ERR, _W("Shader %s could not be compiled"), desc.ShaderFile.Get());
SAFE_RELEASE(pErrors);
return false;
}
pFS->UnLoad(fp, (BYTE *)pData);
//save to cache
fp = pFS->Open(_W("cache/shaders/hlsl"), _W("wb"));
const char* cs = (const char*)pShaderBlob->GetBufferPointer();
pFS->Write(cs, 1, pShaderBlob->GetBufferSize(), fp);
pFS->Close(fp);
bool shaderCreated = false;
switch(desc.ShaderType)
{
case SHADERTYPE_VERTEX_SHADER:
shaderCreated = SUCCEEDED(g_pD3ddev->CreateVertexShader((const DWORD*)pShaderBlob->GetBufferPointer(), &m_pVS));
break;
case SHADERTYPE_PIXEL_SHADER:
shaderCreated = SUCCEEDED(g_pD3ddev->CreatePixelShader((const DWORD*)pShaderBlob->GetBufferPointer(), &m_pPS));
break;
}
if(!shaderCreated)
{
CON(MSG_ERR, _W("Shader creation error"));
return false;
}
//set constant to their default values
m_pConstTable->SetDefaults(g_pD3ddev);
//create vertex declaration
if(desc.ShaderType == SHADERTYPE_VERTEX_SHADER)
m_pVertDecl = new CVertexDeclaration(CRenderer::cGraphicsManager()->GetVertexDescByID(desc.VertexDescID), pShaderBlob);
SAFE_RELEASE(pShaderBlob);
m_desc = desc;
CON(MSG_INFO, _W("Shader '%s' created"), desc.ShaderFile);
return true;
}
HRESULT XShader:: InitShader(const char* vertexShader,const char* pixelShader,D3DDevice *pDevice)
{
//-------------------------------------------------------------------------------------
// Vertex shader
//-------------------------------------------------------------------------------------
OutputDebugString("Came");
/*
strVertexShaderProgram =
" float4x4 matWVP : register(c0); "
" "
" struct VS_IN "
" { "
" float4 ObjPos : POSITION; " // Object space position
" float4 Color : COLOR; " // Vertex color
" }; "
" "
" struct VS_OUT "
" { "
" float4 ProjPos : POSITION; " // Projected space position
" float4 Color : COLOR; "
" }; "
" "
" VS_OUT main( VS_IN In ) "
" { "
" VS_OUT Out; "
" Out.ProjPos = mul( matWVP, In.ObjPos ); " // Transform vertex into
" Out.Color = In.Color; " // Projected space and
" return Out; " // Transfer color
" } ";
//-------------------------------------------------------------------------------------
// Pixel shader
//-------------------------------------------------------------------------------------
strPixelShaderProgram =
" float4 color : register(c2); "
" struct PS_IN "
" { "
" float4 Color : COLOR; " // Interpolated color from
" }; " // the vertex shader
" "
" float4 main( PS_IN In ) : COLOR "
" { "
" return color; " // Output color
" } ";
//////Temp Strings Need to change after resource loading is done !
*/
TextFile *vert, *pix;
vert = ResourceManager::GetInstance()->Load<TextFile>(vertexShader);
pix = ResourceManager::GetInstance()->Load<TextFile>(pixelShader);
string ver, pixe;
a = 10;
ver = vert->GetFileContents();
pixe = pix->GetFileContents();
ID3DXBuffer* pVertexShaderCode;
ID3DXBuffer* pVertexErrorMessage;
//Creating Vertex Shader
HRESULT hr = D3DXCompileShader(ver.c_str(),(UINT)strlen(ver.c_str()),NULL,NULL,"main","vs_2_0",0,&pVertexShaderCode,&pVertexErrorMessage,NULL);
if(FAILED(hr))
{
if(pVertexErrorMessage)
OutputDebugString((char*)pVertexErrorMessage->GetBufferPointer());
return E_FAIL;
}
pDevice->CreateVertexShader((DWORD*)pVertexShaderCode->GetBufferPointer(),&m_pVertexShader);
ID3DXBuffer* pPixelShaderCode;
ID3DXBuffer* pPixelErrorMessage;
//Creating Pixel Shader
hr = D3DXCompileShader(pixe.c_str(),(UINT)strlen(pixe.c_str()),NULL,NULL,"main","ps_2_0",0,&pPixelShaderCode,&pPixelErrorMessage,NULL);
if(FAILED(hr))
{
if(pPixelErrorMessage)
OutputDebugString((char*)pPixelErrorMessage->GetBufferPointer());
return E_FAIL;
}
pDevice->CreatePixelShader((DWORD*)pPixelShaderCode->GetBufferPointer(),&m_pPixelShader);
//Creating Vertex Declaration
D3DVERTEXELEMENT9 VertexElements[3]=
{
{ 0, 0,D3DDECLTYPE_FLOAT3,D3DDECLMETHOD_DEFAULT,D3DDECLUSAGE_POSITION,0},
{ 0, 12, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0 },
D3DDECL_END()
};
pDevice->CreateVertexDeclaration(VertexElements,&m_pVertDec);
return S_OK;
}
//-------------------------------------------------------------------------------------
// Name: InitScene()
// Desc: Creates the scene. First we compile our shaders. For the final version
// of a game, you should store the shaders in binary form; don't call
// D3DXCompileShader at runtime. Next, we declare the format of our
// vertices, and then create a vertex buffer. The vertex buffer is basically
// just a chunk of memory that holds vertices. After creating it, we must
// Lock()/Unlock() it to fill it. Finally, we set up our world, projection,
// and view matrices.
//-------------------------------------------------------------------------------------
HRESULT InitScene()
{
// Compile vertex shader.
ID3DXBuffer* pVertexShaderCode;
ID3DXBuffer* pVertexErrorMsg;
HRESULT hr = D3DXCompileShader( g_strVertexShaderProgram,
(UINT)strlen( g_strVertexShaderProgram ),
NULL,
NULL,
"main",
"vs_2_0",
0,
&pVertexShaderCode,
&pVertexErrorMsg,
NULL );
if( FAILED(hr) )
{
if( pVertexErrorMsg )
OutputDebugString( (char*)pVertexErrorMsg->GetBufferPointer() );
return E_FAIL;
}
// Create vertex shader.
g_pd3dDevice->CreateVertexShader( (DWORD*)pVertexShaderCode->GetBufferPointer(),
&g_pVertexShader );
// Compile pixel shader.
ID3DXBuffer* pPixelShaderCode;
ID3DXBuffer* pPixelErrorMsg;
hr = D3DXCompileShader( g_strPixelShaderProgram,
(UINT)strlen( g_strPixelShaderProgram ),
NULL,
NULL,
"main",
"ps_2_0",
0,
&pPixelShaderCode,
&pPixelErrorMsg,
NULL );
if( FAILED(hr) )
{
if( pPixelErrorMsg )
OutputDebugString( (char*)pPixelErrorMsg->GetBufferPointer() );
return E_FAIL;
}
// Create pixel shader.
g_pd3dDevice->CreatePixelShader( (DWORD*)pPixelShaderCode->GetBufferPointer(),
&g_pPixelShader );
// Define the vertex elements and
// Create a vertex declaration from the element descriptions.
D3DVERTEXELEMENT9 VertexElements[3] =
{
{ 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 },
{ 0, 12, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0 },
D3DDECL_END()
};
g_pd3dDevice->CreateVertexDeclaration( VertexElements, &g_pVertexDecl );
// Create the vertex buffer. Here we are allocating enough memory
// (from the default pool) to hold all our 3 custom vertices.
if( FAILED( g_pd3dDevice->CreateVertexBuffer( 3*sizeof(COLORVERTEX),
D3DUSAGE_WRITEONLY,
NULL,
D3DPOOL_MANAGED,
&g_pVB,
NULL ) ) )
return E_FAIL;
// Now we fill the vertex buffer. To do this, we need to Lock() the VB to
// gain access to the vertices. This mechanism is required because the
// vertex buffer may still be in use by the GPU. This can happen if the
// CPU gets ahead of the GPU. The GPU could still be rendering the previous
// frame.
COLORVERTEX g_Vertices[] =
{
{ 0.0f, -1.1547f, 0.0f, 0xffff0000 }, // x, y, z, color
{ -1.0f, 0.5777f, 0.0f, 0xff00ff00 },
{ 1.0f, 0.5777f, 0.0f, 0xffffff00 },
};
COLORVERTEX* pVertices;
if( FAILED( g_pVB->Lock( 0, 0, (void**)&pVertices, 0 ) ) )
return E_FAIL;
memcpy( pVertices, g_Vertices, 3*sizeof(COLORVERTEX) );
g_pVB->Unlock();
// Initialize the world matrix
g_matWorld = XMMatrixIdentity();
// Initialize the projection matrix
FLOAT fAspect = ( g_bWidescreen ) ? (16.0f / 9.0f) : (4.0f / 3.0f);
g_matProj = XMMatrixPerspectiveFovLH( XM_PIDIV4, fAspect, 1.0f, 200.0f );
// Initialize the view matrix
XMVECTOR vEyePt = { 0.0f, 0.0f,-7.0f, 0.0f };
XMVECTOR vLookatPt = { 0.0f, 0.0f, 0.0f, 0.0f };
XMVECTOR vUp = { 0.0f, 1.0f, 0.0f, 0.0f };
g_matView = XMMatrixLookAtLH( vEyePt, vLookatPt, vUp );
return S_OK;
}
bool CDx9FragmentProgram::bind(void)
{
if(!m_isLoad)
{
LPD3DXBUFFER errors;
LPD3DXBUFFER pBuffer;
DWORD dwShaderFlags = D3DXSHADER_PACKMATRIX_ROWMAJOR | D3DXSHADER_PREFER_FLOW_CONTROL;
#if defined( DEBUG ) || defined( _DEBUG )
dwShaderFlags |= D3DXSHADER_DEBUG;
#endif
HRESULT hr = D3DXCompileShader(
m_cCode.c_str(),
static_cast<uint>(m_cCode.size()),
NULL,
DX9_ShaderInclude::GetInst(),
m_sMain.c_str(),
"ps_2_0",
dwShaderFlags,
&pBuffer,
&errors,
&m_pConstTable);
if (FAILED(hr))
{
hr = D3DXCompileShader(
m_cCode.c_str(),
static_cast<uint>(m_cCode.size()),
NULL,
DX9_ShaderInclude::GetInst(),
m_sMain.c_str(),
"ps_3_0",
dwShaderFlags,
&pBuffer,
&errors,
&m_pConstTable);
if (FAILED(hr))
{
string message = "D3D9 Pixel Shader创建不成功 Errors:\n";
message.append(static_cast<const char*>(errors->GetBufferPointer()));
errors->Release();
OutputDebugString(message.c_str());
LogErr(GraphicErr::GetErrTypeStr(ShaderInit_Err),message);
return false;
}
}
SafeRelease(errors);
hr = m_pD3DDevice->CreatePixelShader((DWORD*)pBuffer->GetBufferPointer(),&m_pPixelShader);
SafeRelease(pBuffer);
if ( SUCCEEDED(hr))
{
m_Params.Create(m_pConstTable);
m_isLoad = true;
m_isNeedUpdateParameters = true;
}
else
{
stringstream ss;
ss << "CreatePixelShader失败: " << DXGetErrorDescription(hr);
LogErr(GraphicErr::GetErrTypeStr(ShaderInit_Err), ss.str());
return false;
}
}
if(!m_isActive)
{
m_isActive = true;
return SUCCEEDED(m_pD3DDevice->SetPixelShader(m_pPixelShader));
}
return true;
}
bool SPPixelShaderCore::Load( SPString path )
{
name = path;
SPFilePtr file = SPFileManager::GetSingleton().OpenFile(path);
if (!file)
{
SPLogHelper::WriteLog(L"[SPShader] WARNING: Failed to open shader file: " + path);
return false;
}
ID3DXBuffer* shaderBuffer = NULL;
ID3DXBuffer* errorBuffer = NULL;
LONGLONG length = file->GetFileLength();
char* pData = new char[(UINT)length];
if(!file->Read(pData, (DWORD)length))
{
SPLogHelper::WriteLog(L"[SPShader] WARNING: Failed to read shader file: " + path);
return false;
}
// Compile shader files.
HRESULT hr = D3DXCompileShader(
pData, (UINT)length, 0, 0, "Main", "ps_2_0", D3DXSHADER_DEBUG,
&shaderBuffer, &errorBuffer, &constantTable);
delete [] pData;
SPFileManager::GetSingleton().CloseFile(path);
if (errorBuffer)
{
SPLogHelper::WriteLog(L"[SPShader] WARNING: There is error in shader file: " + path);
SPLogHelper::WriteLog("[SPShader] Message: " + string((char*)errorBuffer->GetBufferPointer()));
errorBuffer->Release();
}
if (FAILED(hr))
{
SPLogHelper::WriteLog(L"[SPShader] WARNING: Failed to compile shader file: " + path);
return false;
}
// Create pixel shader.
hr = SPDevice::GetSingleton().GetD3DDevice()->CreatePixelShader(
(DWORD*)shaderBuffer->GetBufferPointer(), &pixelShader);
if (FAILED(hr))
{
SPLogHelper::WriteLog(L"[SPShader] WARNING: Failed to create pixel shader");
if (shaderBuffer)
{
shaderBuffer->Release();
shaderBuffer = NULL;
}
return false;
}
shaderBuffer->Release();
shaderBuffer = NULL;
return true;
}
/*
extern "C"
{
LPCSTR WINAPI D3DXGetPixelShaderProfile (LPDIRECT3DDEVICE9 pDevice);
LPCSTR WINAPI D3DXGetVertexShaderProfile (LPDIRECT3DDEVICE9 pDevice);
};
*/
HRESULT CRender::shader_compile (
LPCSTR name,
LPCSTR pSrcData,
UINT SrcDataLen,
void* _pDefines,
void* _pInclude,
LPCSTR pFunctionName,
LPCSTR pTarget,
DWORD Flags,
void* _ppShader,
void* _ppErrorMsgs,
void* _ppConstantTable)
{
D3DXMACRO defines [128];
int def_it = 0;
CONST D3DXMACRO* pDefines = (CONST D3DXMACRO*) _pDefines;
char c_smapsize [32];
char c_gloss [32];
// Msg("%s.%s", name, pTarget);
if (pDefines) {
// transfer existing defines
for (;; def_it++) {
if (0==pDefines[def_it].Name) break;
defines[def_it] = pDefines[def_it];
}
}
// options
{
sprintf (c_smapsize,"%d",u32(o.smapsize));
defines[def_it].Name = "SMAP_size";
defines[def_it].Definition = c_smapsize;
def_it ++ ;
}
if (o.fp16_filter) {
defines[def_it].Name = "FP16_FILTER";
defines[def_it].Definition = "1";
def_it ++ ;
}
if (o.fp16_blend) {
defines[def_it].Name = "FP16_BLEND";
defines[def_it].Definition = "1";
def_it ++ ;
}
if (o.HW_smap) {
defines[def_it].Name = "USE_HWSMAP";
defines[def_it].Definition = "1";
def_it ++ ;
}
if (o.HW_smap_PCF) {
defines[def_it].Name = "USE_HWSMAP_PCF";
defines[def_it].Definition = "1";
def_it ++ ;
}
if (o.HW_smap_FETCH4) {
defines[def_it].Name = "USE_FETCH4";
defines[def_it].Definition = "1";
def_it ++ ;
}
if (o.sjitter) {
defines[def_it].Name = "USE_SJITTER";
defines[def_it].Definition = "1";
def_it ++ ;
}
if (HW.Caps.raster_major >= 3) {
defines[def_it].Name = "USE_BRANCHING";
defines[def_it].Definition = "1";
def_it ++ ;
}
if (HW.Caps.geometry.bVTF) {
defines[def_it].Name = "USE_VTF";
defines[def_it].Definition = "1";
def_it ++ ;
}
if (o.Tshadows) {
defines[def_it].Name = "USE_TSHADOWS";
defines[def_it].Definition = "1";
def_it ++ ;
}
if (o.mblur) {
defines[def_it].Name = "USE_MBLUR";
defines[def_it].Definition = "1";
def_it ++ ;
}
if (o.sunfilter) {
defines[def_it].Name = "USE_SUNFILTER";
defines[def_it].Definition = "1";
def_it ++ ;
}
if (o.sunstatic) {
defines[def_it].Name = "USE_R2_STATIC_SUN";
defines[def_it].Definition = "1";
def_it ++ ;
}
if (o.forcegloss) {
sprintf (c_gloss,"%f",o.forcegloss_v);
defines[def_it].Name = "FORCE_GLOSS";
defines[def_it].Definition = c_gloss;
def_it ++ ;
}
if (o.forceskinw) {
defines[def_it].Name = "SKIN_COLOR";
defines[def_it].Definition = "1";
def_it ++;
}
// skinning
if (m_skinning<0) {
defines[def_it].Name = "SKIN_NONE";
defines[def_it].Definition = "1";
def_it ++ ;
}
if (0==m_skinning) {
defines[def_it].Name = "SKIN_0";
defines[def_it].Definition = "1";
def_it ++;
}
if (1==m_skinning) {
defines[def_it].Name = "SKIN_1";
defines[def_it].Definition = "1";
def_it ++;
}
if (2==m_skinning) {
defines[def_it].Name = "SKIN_2";
defines[def_it].Definition = "1";
def_it ++;
}
// finish
defines[def_it].Name = 0;
defines[def_it].Definition = 0;
def_it ++;
//
if (0==xr_strcmp(pFunctionName,"main")) {
if ('v'==pTarget[0]) pTarget = D3DXGetVertexShaderProfile (HW.pDevice); // vertex "vs_2_a"; //
else pTarget = D3DXGetPixelShaderProfile (HW.pDevice); // pixel "ps_2_a"; //
}
LPD3DXINCLUDE pInclude = (LPD3DXINCLUDE) _pInclude;
LPD3DXBUFFER* ppShader = (LPD3DXBUFFER*) _ppShader;
LPD3DXBUFFER* ppErrorMsgs = (LPD3DXBUFFER*) _ppErrorMsgs;
LPD3DXCONSTANTTABLE* ppConstantTable = (LPD3DXCONSTANTTABLE*)_ppConstantTable;
#ifdef D3DXSHADER_USE_LEGACY_D3DX9_31_DLL // December 2006 and later
HRESULT _result = D3DXCompileShader(pSrcData,SrcDataLen,defines,pInclude,pFunctionName,pTarget,Flags|D3DXSHADER_USE_LEGACY_D3DX9_31_DLL,ppShader,ppErrorMsgs,ppConstantTable);
#else
HRESULT _result = D3DXCompileShader(pSrcData,SrcDataLen,defines,pInclude,pFunctionName,pTarget,Flags,ppShader,ppErrorMsgs,ppConstantTable);
#endif
if (SUCCEEDED(_result) && o.disasm)
{
ID3DXBuffer* code = *((LPD3DXBUFFER*)_ppShader);
ID3DXBuffer* disasm = 0;
D3DXDisassembleShader (LPDWORD(code->GetBufferPointer()), FALSE, 0, &disasm );
string_path dname;
strconcat (dname,"disasm\\",name,('v'==pTarget[0])?".vs":".ps" );
IWriter* W = FS.w_open("$logs$",dname);
W->w (disasm->GetBufferPointer(),disasm->GetBufferSize());
FS.w_close (W);
_RELEASE (disasm);
}
return _result;
}
