//-------------------------------------------------------------
// Name: InitDeviceObjects()
// Desc: ����̽��� ���������� �ʱ�ȭ
// �����ӹ��� ���˰� ����̽� ������ ���ѵڿ� ȣ��
// ���⼭ Ȯ���� �� DeleteDeviceObjects()���� ����
//-------------------------------------------------------------
HRESULT CMyD3DApplication::InitDeviceObjects()
{
HRESULT hr;
LPD3DXBUFFER pCode;
// ---------------------------------------------------------
// �� �ȼ����̴� ����
// ---------------------------------------------------------
if( FAILED( hr = D3DXAssembleShaderFromFile(
_T("PixelShader.psh"),
NULL, NULL, 0, &pCode, NULL ) ) ){
return hr;
}
SAFE_RELEASE( m_pPixelShader );
if (FAILED( hr = m_pd3dDevice->CreatePixelShader(
(DWORD*)pCode->GetBufferPointer(),
&m_pPixelShader ) ) )
return hr;
SAFE_RELEASE( pCode );
// ---------------------------------------------------------
// �������̴� ����
// ---------------------------------------------------------
// ���_�錾�I�u�W�F�N�g�̐���
D3DVERTEXELEMENT9 decl[] = {
{ 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT,
D3DDECLUSAGE_POSITION, 0 },
D3DDECL_END()
};
if( FAILED( hr = m_pd3dDevice->CreateVertexDeclaration( decl, &m_pVertexDeclaration ) ) ) {
return hr;
}
// ���̴� �б�
if( FAILED( hr = D3DXAssembleShaderFromFile(
_T("VertexShader.vsh"), NULL, NULL, 0, &pCode, NULL ))) {
return hr;
}
// �������̴� ����
hr = m_pd3dDevice->CreateVertexShader(
(DWORD*)pCode->GetBufferPointer(),
&m_pVertexShader );
pCode->Release();
if( FAILED(hr) ) return hr;
// ��Ʈ
m_pFont->InitDeviceObjects( m_pd3dDevice );
return S_OK;
}
bool CD3D8ShaderMaterialRenderer::createPixelShader(const c8* pxsh)
{
if (!pxsh)
return true;
#if defined( _IRR_XBOX_PLATFORM_)
return false;
#else
// compile shader
LPD3DXBUFFER code = 0;
LPD3DXBUFFER errors = 0;
#ifdef _IRR_D3D_NO_SHADER_DEBUGGING
// compile shader without debug info
D3DXAssembleShader(pxsh, (UINT)strlen(pxsh), 0, 0, &code, &errors);
#else
// compile shader and emitt some debug informations to
// make it possible to debug the shader in visual studio
static int irr_dbg_file_nr = 0;
++irr_dbg_file_nr;
char tmp[32];
sprintf(tmp, "irr_d3d8_dbg_shader_%d.psh", irr_dbg_file_nr);
FILE* f = fopen(tmp, "wb");
fwrite(pxsh, strlen(pxsh), 1, f);
fflush(f);
fclose(f);
D3DXAssembleShaderFromFile(tmp, D3DXASM_DEBUG, 0, &code, &errors);
#endif
if (errors)
{
// print out compilation errors.
os::Printer::log("Pixel shader compilation failed:", ELL_ERROR);
os::Printer::log((c8*)errors->GetBufferPointer(), ELL_ERROR);
if (code)
code->Release();
errors->Release();
return false;
}
if (FAILED(pID3DDevice->CreatePixelShader((DWORD*)code->GetBufferPointer(), &PixelShader)))
{
os::Printer::log("Could not create pixel shader.", ELL_ERROR);
code->Release();
return false;
}
code->Release();
return true;
#endif
}
int ZPSMgr::Add( char *fname, DWORD fvf )
{
D3DVERTEXELEMENT9 decl[MAX_FVF_DECL_SIZE];
if( Get( fname ) ) return 1;
ZPSTable* p = new ZPSTable;
p->name = fname;
// FVF를 사용해서 정점선언값을 자동으로 채워넣는다
D3DXDeclaratorFromFVF( fvf, decl );
// 정점선언값으로 m_pShaderDecl을 생성한다.
m_pDev->CreateVertexDeclaration( decl, &p->pDecl );
LPD3DXBUFFER pCode;
// 정점쉐이더 파일을 읽어와서 정점쉐이더 인터페이스를 생성한다.
if( FAILED( D3DXAssembleShaderFromFile( fname, NULL, NULL, 0, &pCode, NULL ) ) )
return 0;
m_pDev->CreatePixelShader( (DWORD*)pCode->GetBufferPointer(), &p->pShader );
S_REL( pCode );
m_PSTable.push_back( p );
return 1;
}
void* LcD3D_BuildShaderFromFile(PDEV pDev, char* sStrFile, char* sShader)
{
HRESULT hr;
DWORD dFlag = 0;
#if defined( _DEBUG ) || defined( DEBUG )
dFlag |= D3DXSHADER_DEBUG;
#endif
LPD3DXBUFFER pAsm = NULL;
LPD3DXBUFFER pErr = NULL;
void* pShd = NULL;
hr = D3DXAssembleShaderFromFile(
sStrFile
, NULL
, NULL
, dFlag
, &pAsm
, &pErr);
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;
}
HRESULT plDXVertexShader::ICreate(plDXPipeline* pipe)
{
fHandle = nil; // in case something goes wrong.
fPipe = nil;
ISetError(nil);
#ifdef HS_DEBUGGING
DWORD flags = D3DXSHADER_DEBUG | D3DXSHADER_SKIPOPTIMIZATION;
#else // HS_DEBUGGING
DWORD flags = 0;
#endif // HS_DEBUGGING
// We could store the compiled buffer and skip the assembly step
// if we need to recreate the shader (e.g. on device lost).
// But whatever.
DWORD* shaderCodes = nil;
HRESULT hr = S_OK;
if( plShaderTable::LoadFromFile() || !fOwner->GetDecl()->GetCodes() )
{
if( fOwner->GetDecl()->GetFileName() )
{
LPD3DXBUFFER compiledShader = nil;
LPD3DXBUFFER compilationErrors = nil;
hr = D3DXAssembleShaderFromFile(
fOwner->GetDecl()->GetFileName(),
NULL, NULL, flags,
&compiledShader,
&compilationErrors);
if( FAILED(hr) )
{
return IOnError(hr, compilationErrors
? reinterpret_cast<const char *>(compilationErrors->GetBufferPointer())
: "File not found");
}
shaderCodes = (DWORD*)(compiledShader->GetBufferPointer());
}
}
if( !shaderCodes )
{
shaderCodes = (DWORD*)(fOwner->GetDecl()->GetCodes());
}
if( !shaderCodes )
return IOnError(-1, "No file and no compiled codes");
hr = pipe->GetD3DDevice()->CreateVertexShader(shaderCodes, &fHandle);
if( FAILED(hr) )
return IOnError(hr, "Error on CreateVertexShader");
hsAssert(fHandle, "No error, but no vertex shader handle. Grrrr.");
fPipe = pipe;
return S_OK;
}
HRESULT CD3D9ShaderMaterialRenderer::stubD3DXAssembleShaderFromFile(LPCSTR pSrcFile,
CONST D3DXMACRO* pDefines, LPD3DXINCLUDE pInclude, DWORD Flags,
LPD3DXBUFFER* ppShader, LPD3DXBUFFER* ppErrorMsgs)
{
// 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 D3DXAssembleShaderFromFile(pSrcFile, pDefines, pInclude, Flags,
ppShader, ppErrorMsgs);
#else
{
// try to load shader functions from the dll and print error if failed.
// D3DXAssembleShaderFromFileA signature
typedef HRESULT (WINAPI *AssembleShaderFromFileFunction)(LPCSTR pSrcFile,
CONST D3DXMACRO* pDefines, LPD3DXINCLUDE pInclude, DWORD Flags,
LPD3DXBUFFER* ppShader, LPD3DXBUFFER* ppErrorMsgs);
static bool LoadFailed = false;
static AssembleShaderFromFileFunction pFn = 0;
if (!pFn && !LoadFailed)
{
// try to load dll
core::stringc strDllName = "d3dx9_";
strDllName += (int)D3DX_SDK_VERSION;
strDllName += ".dll";
HMODULE hMod = LoadLibrary(strDllName.c_str());
if (hMod)
pFn = (AssembleShaderFromFileFunction)GetProcAddress(hMod, "D3DXAssembleShaderFromFileA");
if (!pFn)
{
LoadFailed = true;
os::Printer::log("Could not load shader function D3DXAssembleShaderFromFileA from dll, shaders disabled",
strDllName.c_str(), ELL_ERROR);
}
}
if (pFn)
{
// call already loaded function
return (*pFn)(pSrcFile, pDefines, pInclude, Flags, ppShader, ppErrorMsgs);
}
}
#endif // D3DX_SDK_VERSION < 24
return 0;
}
PixelShader::PixelShader(LPDIRECT3DDEVICE9 pDevice, LPCWSTR fileName)
{
m_pDevice = pDevice;
m_pDevice->CreateVertexDeclaration(Declaration, &m_pVD);
LPD3DXBUFFER code = NULL;
D3DXAssembleShaderFromFile(fileName, 0, 0, 0, &code, 0);
m_pDevice->CreatePixelShader((DWORD*) code->GetBufferPointer(), &m_pPShader);
code->Release();
}
HRESULT InitPS()
{
LPD3DXBUFFER pCode;
// simple.vs 파일을 읽어와서 정점쉐이더 인터페이스를 생성한다.
if( FAILED( D3DXAssembleShaderFromFile( "simple.ps", NULL, NULL, 0, &pCode, NULL ) ) )
return E_FAIL;
g_pd3dDevice->CreatePixelShader( (DWORD*)pCode->GetBufferPointer(), &g_pPS);
S_REL( pCode );
return S_OK;
}
int uPixelShader::LoadPS(char *filename, char *pixelprog)
{
int er=0;
// Create the pixel shader.
LPD3DXBUFFER pCode; // assembled shader code
LPD3DXBUFFER pError;
if(hPixelShader!=NULL) pd->DeletePixelShader( hPixelShader);
if(filename==NULL)
D3DXAssembleShader( pixelprog, strlen(pixelprog), 0, NULL, &pCode, &pError ); // assemble shader code
else
{
if( D3DXAssembleShaderFromFile( filename, 0, NULL, &pCode, &pError) != D3D_OK)er=1; // assemble shader code
}
if(pError!=NULL)
{
char text[150];
char* error_text = new char[pError->GetBufferSize()+1];
memcpy(error_text,pError->GetBufferPointer(),pError->GetBufferSize());
error_text[pError->GetBufferSize()]=NULL;
pError->Release();
if(filename!=NULL)
sprintf( text, "ERROR in pixel shader: %s", filename);
else
sprintf( text, "ERROR in pixel shader: %s");
MessageBox(hWnd, error_text, text, MB_OK);
delete [] error_text;
hPixelShader = NULL;
return 0;
}
else if(er==1)
{
MessageBox(hWnd, filename, english ? "Couldn't find file for pixel shader":"Nenajdeny subor pre pixel shader", MB_OK);
return 0;
}
if( pd->CreatePixelShader( (DWORD*)pCode->GetBufferPointer(), &hPixelShader )
== D3D_OK )
{
pCode->Release();
return 1;
}
pCode->Release();
MessageBox(hWnd, filename, english ? "ERROR in pixel shader":"Chyba pri nacitavani pixel shader", MB_OK);
return 0;
}
bool RSManager::getOverrideShader(UINT32 hash, const char *directory, LPD3DXBUFFER *ppBuffer) {
char fileNameBuffer[64];
sprintf_s(fileNameBuffer, "%s/%08x.asm", directory, hash);
const char * fileName = GetDirectoryFile(fileNameBuffer);
if (fileExists(fileName)) {
SDLOG(1, "Shader override: %s\n", fileName);
LPD3DXBUFFER errors = nullptr;
HRESULT assembleResult = D3DXAssembleShaderFromFile(fileName, nullptr, nullptr, 0, ppBuffer, &errors);
if (assembleResult != D3D_OK) {
SDLOG(0, "Failed to assemble replacement shader:\n%s\n", errors->GetBufferPointer());
}
SAFERELEASE(errors);
return assembleResult == D3D_OK;
}
return false;
}
HRESULT InitVS()
{
D3DVERTEXELEMENT9 decl[MAX_FVF_DECL_SIZE];
// FVF를 사용해서 정점선언값을 자동으로 채워넣는다
D3DXDeclaratorFromFVF( MYVERTEX::FVF, decl );
// 정점선언값으로 g_pDecl을 생성한다.
g_pd3dDevice->CreateVertexDeclaration( decl, &g_pDecl );
LPD3DXBUFFER pCode;
// simple.vs 파일을 읽어와서 정점쉐이더 인터페이스를 생성한다.
if( FAILED( D3DXAssembleShaderFromFile( "simple.vs", NULL, NULL, 0, &pCode, NULL ) ) )
return E_FAIL;
g_pd3dDevice->CreateVertexShader( (DWORD*)pCode->GetBufferPointer(), &g_pVS);
S_REL( pCode );
return S_OK;
}
INT TShd::CreatePixelShader(PDEV pDev)
{
HRESULT hr= -1;
DWORD dFlag = 0;
#if defined( _DEBUG ) || defined( DEBUG )
dFlag |= D3DXSHADER_DEBUG;
#endif
LPD3DXBUFFER pAsm = NULL;
LPD3DXBUFFER pErr = NULL;
if(0==strlen(sPxl))
return -1;
hr = D3DXAssembleShaderFromFile(sPxl, 0, 0, dFlag, &pAsm, &pErr );
if(FAILED(hr))
{
if(pErr)
{
char* sErr = (char*)pErr->GetBufferPointer();
LcD3D_GetDxError(hr, sErr);
pErr->Release();
}
else
LcD3D_GetDxError(hr);
return hr;
}
hr = pDev->CreatePixelShader( (DWORD*)pAsm->GetBufferPointer(), &pPxl);
pAsm->Release();
if( FAILED(hr) )
{
LcD3D_GetDxError(hr);
return hr;
}
return hr;
}
bool CPixelShader::CreateFromDiskFile(const char* c_szFileName)
{
Destroy();
LPD3DXBUFFER lpd3dxShaderBuffer;
LPD3DXBUFFER lpd3dxErrorBuffer;
if (FAILED(
D3DXAssembleShaderFromFile(c_szFileName, 0, NULL, &lpd3dxShaderBuffer, &lpd3dxErrorBuffer)
))
return false;
CDirect3DXBuffer shaderBuffer(lpd3dxShaderBuffer);
CDirect3DXBuffer errorBuffer(lpd3dxErrorBuffer);
if (FAILED(ms_lpd3dDevice->CreatePixelShader((DWORD*)shaderBuffer.GetPointer(), &m_handle)))
return false;
return true;
}
// Assemble shader using DX runtime
HRESULT U2Dx9ShaderMgr::LoadAndAssembleShader( U2Dx9ShaderDesc * pDesc )
{
HRESULT hr = S_OK;
FAIL_IF_NULL( pDesc );
FreeShader( pDesc );
LPD3DXBUFFER pbufShader, pbufErrors;
//flags:
// D3DXSHADER_DEBUG
// D3DXSHADER_SKIPVALIDATION
// D3DXSHADER_SKIPOPTIMIZATION
hr = D3DXAssembleShaderFromFile( pDesc->m_szShaderDefFile.c_str(),
NULL, // D3DXMACRO defines
NULL, // LPD3DXINcLUDE include, NULL = do #include
0, // flags
&pbufShader,
&pbufErrors );
if( FAILED( hr ))
{
FMsg("U2Dx9ShaderMgr::LoadAndAssembleShader( U2Dx9ShaderDesc * pDesc ) Errors:\n");
if( pbufErrors != NULL )
{
HandleErrorString( (TCHAR*) pbufErrors->GetBufferPointer() );
}
else
{
FMsg("Error buffer is NULL!\n");
}
SAFE_RELEASE( pbufShader );
BREAK_AND_RET_VAL_IF_FAILED( hr );
}
hr = CreateShader( pbufShader, pDesc->m_type, pDesc );
if( FAILED(hr) )
{
FMsg("LoadAndAssembleShader( U2Dx9ShaderDesc * pDesc ) couldn't create shader : %s\n", pDesc->m_szShaderDefFile.c_str() );
}
return( hr );
}
static int assemble_shader(wchar_t *filename)
{
LPD3DXBUFFER shader;
wchar_t fname[MAX_PATH];
int rc;
FILE *outfp;
rc = D3DXAssembleShaderFromFile(filename, NULL, NULL, 0, &shader, NULL);
if (rc != D3D_OK)
return 1;
_wsplitpath_s(filename, NULL, 0, NULL, 0, fname, 250, NULL, 0);
lstrcatW(fname, L".out");
if ((rc = _wfopen_s(&outfp, fname, L"wb")))
return rc;
fwrite(shader->GetBufferPointer(), 1, shader->GetBufferSize(), outfp);
fclose(outfp);
return 0;
}
//-------------------------------------------------------------
// Name: InitDeviceObjects()
// Desc: 디바이스가 생성된후의 초기화
// 프레임버퍼 포맷과 디바이스 종류가 변한뒤에 호출
// 여기서 확보한 메모리는 DeleteDeviceObjects()에서 해제
//-------------------------------------------------------------
HRESULT CMyD3DApplication::InitDeviceObjects()
{
HRESULT hr;
LPD3DXBUFFER pCode;
// ---------------------------------------------------------
// ★ 정점셰이더 생성
// ---------------------------------------------------------
// 정점선언 오브젝트 생성
D3DVERTEXELEMENT9 decl[] = {
{ 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT,
D3DDECLUSAGE_POSITION, 0 },
D3DDECL_END()
};
if( FAILED( hr = m_pd3dDevice->CreateVertexDeclaration( decl, &m_pVertexDeclaration ) ) ) {
return hr;
}
// 셰이더 읽기
if( FAILED( hr = D3DXAssembleShaderFromFile(
_T("VertexShader.vsh"), NULL, NULL, 0, &pCode, NULL ))) {
return hr;
}
// 정점 셰이더 생성
hr = m_pd3dDevice->CreateVertexShader(
(DWORD*)pCode->GetBufferPointer(),
&m_pVertexShader );
pCode->Release();
if( FAILED(hr) ) return hr;
// 폰트
m_pFont->InitDeviceObjects( m_pd3dDevice );
return S_OK;
}
HRESULT IDX8PixelVertexShaderImp::LoadAndCompileShader()
{
// VertexShader Instructions
DWORD dwDecl[] =
{
D3DVSD_STREAM(0),
D3DVSD_REG(0, D3DVSDT_FLOAT3),
D3DVSD_REG(1, D3DVSDT_FLOAT3),
D3DVSD_END()
};
HRESULT hr;
TCHAR *vertexShaderPath = FindMapFile(map->GetVertexShaderFile());
if(!vertexShaderPath)
{
return E_FAIL;
}
hr = D3DXAssembleShaderFromFile(vertexShaderPath , 0, NULL, &pCode, NULL);
if (dwVertexShader) {
pd3dDevice->DeleteVertexShader(dwVertexShader);
}
if(FAILED(hr))
{
return E_FAIL;
}
hr = pd3dDevice->CreateVertexShader(dwDecl, (LPDWORD)pCode->GetBufferPointer(), &dwVertexShader, 0);
return hr;
}
int main()
{
std::cout << "###############################################" << std::endl;
std::cout << "Running Shader AutoCompile...\n\n";
char aShaderDir[] = "Shader ASM\\*";
std::ofstream ShaderHeader("include\\Shader.h");
ShaderHeader << "// Auto generated shader opcodes\n\n";
WIN32_FIND_DATA FData;
HANDLE hSearch = FindFirstFile(aShaderDir, &FData);
do
{
if(FData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
continue;
// get ending
std::string Filename(FData.cFileName);
std::string Ending = Filename.substr(Filename.find_last_of('.')+1);
std::string FileWithoutEnding = Filename.substr(0, Filename.find_last_of('.'));
if(Ending == "psh" || Ending == "vsh")
{
bool PixelShader = Ending == "psh";
if(PixelShader)
std::cout << "Found Pixelshader \"" << FData.cFileName << "\" .. compiling .." << std::endl;
else
std::cout << "Found Vertexshader \"" << FData.cFileName << "\" .. compiling .." << std::endl;
ShaderHeader << "// " << Filename << ":" << std::endl;
LPD3DXBUFFER pBuffer = nullptr;
LPD3DXBUFFER pErrors = nullptr;
D3DXAssembleShaderFromFile((std::string("Shader ASM\\") + FData.cFileName).c_str(), 0, 0, D3DXSHADER_OPTIMIZATION_LEVEL1, &pBuffer, &pErrors);
if(pErrors == nullptr && pBuffer)
{
std::cout << "Succeded!" << std::endl;
ShaderHeader << "const DWORD g_a" << FileWithoutEnding << (PixelShader ? "PS" : "VS") << "[] = { ";
DWORD* pDWORDs = static_cast<DWORD*>(pBuffer->GetBufferPointer());
unsigned int NumTocken = pBuffer->GetBufferSize() / sizeof(DWORD);
for(unsigned int i=0; i<NumTocken-1; ++i)
ShaderHeader << pDWORDs[i] << ", ";
ShaderHeader << pDWORDs[NumTocken-1] << " };\n\n";
}
else
{
if(pErrors)
std::cout << "Some errors occured:\n" << static_cast<char*>(pErrors->GetBufferPointer()) << std::endl << std::endl;
else
std::cout << "Some errors occured: - No description - \n\n";
}
std::cout << std::endl;
}
} while(FindNextFile(hSearch,&FData));
ShaderHeader.close();
std::cout << "Shader AutoCompile finished!" << std::endl;
std::cout << "###############################################\n\n";
}
HRESULT SampleShaderPluginVertexShader::InitValid(Mesh *mesh, INode *node)
{
HRESULT hr = S_OK;
m_pINode = node;
// Create a vertex shader for doing the effect
LPD3DXBUFFER *ppCode = &pCode;
LPD3DXBUFFER pBuffer = NULL;
//! VertexShader Declarations
//! VertexShader Constants
Constants.SetCount(20);
//! set up the material vertex color ...
D3DMATERIAL8 mtrl;
ZeroMemory( &mtrl, sizeof(D3DMATERIAL8) );
mtrl.Diffuse.r = mtrl.Ambient.r = m_MtlColor.r;
mtrl.Diffuse.g = mtrl.Ambient.g = m_MtlColor.g;
mtrl.Diffuse.b = mtrl.Ambient.b = m_MtlColor.b;
mtrl.Diffuse.a = mtrl.Ambient.a = 1.0f;
pd3dDevice->SetMaterial( &mtrl );
pd3dDevice->SetRenderState( D3DRS_LIGHTING, TRUE );
pd3dDevice->SetRenderState( D3DRS_AMBIENT, 0xffffffff );
/*!
* D3DXAssembleShader
* Assembles an ASCII description of a shader into binary form, where the shader source is in memory.
*
* @param pSrcData : [in] Pointer to the source code.
* @param SrcDataLen : [in] Size of the source code, in bytes.
* @param Flags : [in] A combination of the following flags, specifying assembly options.
* D3DXASM_DEBUG Inserts debugging information as comments in the assembled shader.
* D3DXASM_SKIPVALIDATION Do not validate the generated code against known capabilities and constraints. This option is recommended only when assembling a shader you know will function (that is, the shader has been assembled before without this option.)
* @param ppConstants : [out] Returns a pointer to an ID3DXBuffer interface, representing the returned constant declarations. These constants are returned as a vertex shader declaration fragment. It is up to the application to insert the contents of this buffer into their declaration. For pixel shaders this parameter is meaningless because constant declarations are included in the assembled shader. This parameter is ignored if it is NULL.
* @param ppCompiledShader : [out] Returns a pointer to an ID3DXBuffer interface, representing the returned compiled object code. This parameter is ignored if it is NULL.
* @param ppCompilationErrors : [out] Returns a pointer to an ID3DXBuffer interface, representing the returned ASCII error messages. This parameter is ignored if it is NULL.
*
* @return HRESULT :
HRESULT D3DXAssembleShader(
LPCVOID pSrcData,
UINT SrcDataLen,
DWORD Flags,
LPD3DXBUFFER* ppConstants,
LPD3DXBUFFER* ppCompiledShader,
LPD3DXBUFFER* ppCompilationErrors
);
*/
//! Specify the vertex format that the vertex shader will be using for doing the effect
DWORD dwVertexFormatDefinition[] =
{
D3DVSD_STREAM( 0 ), D3DVSD_REG( 0, D3DVSDT_FLOAT3 ), // v0 = Position
D3DVSD_REG( 1, D3DVSDT_FLOAT3 ), // v1 = Normal
D3DVSD_END()
};
#if 0
TCHAR *vertexShaderPath = FindMapFile("ambient.njv");
hr = D3DXAssembleShaderFromFile(vertexShaderPath , 0, NULL, &pCode, NULL);
#else
hr = D3DXAssembleShader( SurfaceShader , sizeof(SurfaceShader)-1 , 0 , NULL , &pCode , NULL );
#endif
hr = pd3dDevice->CreateVertexShader(dwVertexFormatDefinition,(LPDWORD)pCode->GetBufferPointer(), &dwVertexShader, 0);
initDone = true;
return hr;
}
HRESULT U2Dx9ShaderMgr::LoadAndAssembleShader( const TCHAR * file_name,
U2Dx9ShaderDesc::ShaderType ShaderType,
ShaderIndex * outIndex,
bool bVerbose )
{
// assemble shader using DX runtime
HRESULT hr = S_OK;
MSG_BREAK_AND_RET_VAL_IF( ms_pD3DDev==NULL, TEXT("U2Dx9ShaderMgr::LoadAndAssembleShader(..) U2Dx9ShaderMgr not initialized!\n"), E_FAIL );
/*
//@@@@@ this is mixing up the shaders
// Check to see if shader has already been loaded & created
ShaderIndex index;
if( IsShaderLoaded( strFilePath, & index ))
{
FDebug("Shader [%s] already assembled and has index %u\n", strFilePath.c_str(), index );
*outIndex = index;
return( S_OK );
}
//*/
U2Dx9ShaderDesc* pDesc = U2_NEW U2Dx9ShaderDesc();
LPD3DXBUFFER pbufShader, pbufErrors;
//flags:
// D3DXSHADER_DEBUG
// D3DXSHADER_SKIPVALIDATION
// D3DXSHADER_SKIPOPTIMIZATION
hr = D3DXAssembleShaderFromFile( file_name,
NULL, // D3DXMACRO defines
NULL, // LPD3DXINcLUDE include, NULL = do #include
0, // flags
&pbufShader,
&pbufErrors );
if( FAILED( hr ))
{
FMsg("U2Dx9ShaderMgr::LoadAndAssembleShader Errors:\n");
if( pbufErrors != NULL )
{
HandleErrorString( (TCHAR*) pbufErrors->GetBufferPointer() );
}
else
{
FMsg("Error buffer is NULL!\n");
}
SAFE_RELEASE( pbufShader );
BREAK_AND_RET_VAL_IF_FAILED( hr );
}
hr = CreateShader( pbufShader, ShaderType, pDesc );
pDesc->m_szShaderDefFile = file_name;
pDesc->m_szShaderObjFile = TEXT("");
pDesc->m_type = ShaderType;
m_shaders.push_back( *pDesc );
* outIndex = (ShaderIndex) m_shaders.size() - 1;
m_shaderIndices.push_back( *outIndex );
return( hr );
}
bool InitVertexShader()
{
#if DIRECTX_VERSION == 8
// shader decl
DWORD decl[] =
{
D3DVSD_STREAM(0),
D3DVSD_REG(0, D3DVSDT_FLOAT3 ), // D3DVSDE_POSITION
D3DVSD_REG(1, D3DVSDT_FLOAT3 ), // D3DVSDE_NORMAL
D3DVSD_REG(2, D3DVSDT_D3DCOLOR ), // D3DVSDE_DIFFUSE
D3DVSD_REG(3, D3DVSDT_FLOAT2 ), // D3DVSDE_TEXCOORD0
D3DVSD_END()
};
#else
D3DVERTEXELEMENT9 decl[] =
{
{ 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 },
{ 0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL, 0 },
{ 0, 24, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0 },
{ 0, 28, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 },
D3DDECL_END()
};
#endif
LPD3DXBUFFER pCode;
LPD3DXBUFFER ppCompilationErrors;
HRESULT res;
#ifdef _DEBUG
#if DIRECTX_VERSION == 8
LPD3DXBUFFER ppConstants;
res = D3DXAssembleShaderFromFile("shader.vsh", D3DXASM_DEBUG, &ppConstants, &pCode, &ppCompilationErrors);
#else
res = D3DXAssembleShaderFromFileA("D:\\n64developing\\RiceVideo\\shaderdx9.vsh", NULL, NULL, D3DXSHADER_DEBUG, &pCode, &ppCompilationErrors);
//res = D3DXAssembleShaderFromFileA("D:\\n64developing\\RiceVideo\\shaderdx9-2.vsh", NULL, NULL, D3DXSHADER_DEBUG, &pCode, &ppCompilationErrors);
#endif
#else
#if DIRECTX_VERSION == 8
LPD3DXBUFFER ppConstants;
res = D3DXAssembleShader(shaderstr, strlen(shaderstr), 0, &ppConstants, &pCode, &ppCompilationErrors);
#else
res = D3DXAssembleShader(shaderstr2, strlen(shaderstr2), NULL, NULL, D3DXSHADER_DEBUG, &pCode, &ppCompilationErrors);
#endif
#endif
if( CDXGraphicsContext::IsResultGood(res,true) )
{
#if DIRECTX_VERSION == 8
res = g_pD3DDev->CreateVertexShader( decl, (DWORD*)pCode->GetBufferPointer(), &gVertexShader, 0 );
#else
res = g_pD3DDev->CreateVertexShader( (DWORD*)pCode->GetBufferPointer(), &gVertexShader );
//FILE *fp = fopen("D:\\n64developing\\RiceVideo\\shaderdx9.vso","rb");
//BYTE buf[4000];
//int num = fread(buf, 1, 4000, fp);
//res = g_pD3DDev->CreateVertexShader( (DWORD*)buf, &gVertexShader );
//fclose(fp);
#endif
pCode->Release();
if( !CDXGraphicsContext::IsResultGood(res,true) )
return false;
res = g_pD3DDev->SetVertexShader( gVertexShader );
InitVertexShaderConstants();
return true;
}
else
{
if( ppCompilationErrors )
{
char* str = (char*)(ppCompilationErrors->GetBufferPointer());
TRACE0(str);
}
return false;
}
}
bool CD3D8ShaderMaterialRenderer::createVertexShader(const char* vtxsh, E_VERTEX_TYPE type)
{
if (!vtxsh)
return true;
// compile shader
#if defined( _IRR_XBOX_PLATFORM_)
return false;
#else
LPD3DXBUFFER code = 0;
LPD3DXBUFFER errors = 0;
#ifdef _IRR_D3D_NO_SHADER_DEBUGGING
// compile shader without debug info
D3DXAssembleShader(vtxsh, (UINT)strlen(vtxsh), 0, 0, &code, &errors);
#else
// compile shader and emitt some debug informations to
// make it possible to debug the shader in visual studio
static int irr_dbg_file_nr = 0;
++irr_dbg_file_nr;
char tmp[32];
sprintf(tmp, "irr_d3d8_dbg_shader_%d.vsh", irr_dbg_file_nr);
FILE* f = fopen(tmp, "wb");
fwrite(vtxsh, strlen(vtxsh), 1, f);
fflush(f);
fclose(f);
D3DXAssembleShaderFromFile(tmp, D3DXASM_DEBUG, 0, &code, &errors);
#endif
if (errors)
{
// print out compilation errors.
os::Printer::log("Vertex shader compilation failed:", ELL_ERROR);
os::Printer::log((c8*)errors->GetBufferPointer(), ELL_ERROR);
if (code)
code->Release();
errors->Release();
return false;
}
DWORD* decl = 0;
DWORD dwStdDecl[] =
{
D3DVSD_STREAM(0),
D3DVSD_REG(0, D3DVSDT_FLOAT3), // position 0
D3DVSD_REG(1, D3DVSDT_FLOAT3), // normal 1
D3DVSD_REG(2, D3DVSDT_D3DCOLOR ),// color 2
D3DVSD_REG(3, D3DVSDT_FLOAT2 ), // tex1 3
D3DVSD_REG(4, D3DVSDT_FLOAT2 ), // tex2 4
D3DVSD_END()
};
DWORD dwTngtDecl[] =
{
D3DVSD_STREAM(0),
D3DVSD_REG(0 , D3DVSDT_FLOAT3), // position 0
D3DVSD_REG(1 , D3DVSDT_FLOAT3), // normal 1
D3DVSD_REG(2 , D3DVSDT_D3DCOLOR ),// color 2
D3DVSD_REG(3 , D3DVSDT_FLOAT2 ), // tex1 3
D3DVSD_REG(4, D3DVSDT_FLOAT3 ), // tangent 4
D3DVSD_REG(5, D3DVSDT_FLOAT3 ), // binormal 5
D3DVSD_END()
};
if (type == EVT_TANGENTS)
decl = dwTngtDecl;
else
decl = dwStdDecl;
if (FAILED(pID3DDevice->CreateVertexShader(decl,
(DWORD*)code->GetBufferPointer(), &VertexShader, 0)))
{
os::Printer::log("Could not create vertex shader.", ELL_ERROR);
code->Release();
return false;
}
code->Release();
return true;
#endif
}
int main(int argc, char* argv[])
{
if( argc < 2 )
{
printf("%s <file0> <file1> ...\n", argv[0]);
return 0;
}
const char* const * nameList = 0L;
int numNames = 0;
if( !_stricmp(argv[1], "all") )
{
// Cut and paste enum and add kNumEnumNames to end
// so you don't have to count.
enum {
vs_WaveFixedFin6,
ps_WaveFixed,
vs_CompCosines,
ps_CompCosines,
vs_ShoreLeave6,
ps_ShoreLeave6,
vs_WaveRip,
ps_WaveRip,
vs_WaveDec1Lay,
vs_WaveDec2Lay11,
vs_WaveDec2Lay12,
vs_WaveDecEnv,
ps_CbaseAbase,
ps_CalphaAbase,
ps_CalphaAMult,
ps_CalphaAadd,
ps_CaddAbase,
ps_CaddAMult,
ps_CaddAAdd,
ps_CmultAbase,
ps_CmultAMult,
ps_CmultAAdd,
ps_WaveDecEnv,
vs_WaveGraph2,
ps_WaveGraph,
vs_WaveGridFin,
ps_WaveGrid,
vs_BiasNormals,
ps_BiasNormals,
vs_ShoreLeave7,
vs_WaveRip7,
ps_MoreCosines,
vs_WaveDec1Lay_7,
vs_WaveDec2Lay11_7,
vs_WaveDec2Lay12_7,
vs_WaveDecEnv_7,
vs_WaveFixedFin7,
vs_GrassShader,
ps_GrassShader,
vs_RiftDistortAssembly,
ps_RiftDistortAssembly,
kNumEnumNames
};
// Just copy in the enum and use Replace on
// vs_ => "vs_
// ps_ => "ps_
// , => ",
const char* kEnumNames[kNumEnumNames] = {
"vs_WaveFixedFin6",
"ps_WaveFixed",
"vs_CompCosines",
"ps_CompCosines",
"vs_ShoreLeave6",
"ps_ShoreLeave6",
"vs_WaveRip",
"ps_WaveRip",
"vs_WaveDec1Lay",
"vs_WaveDec2Lay11",
"vs_WaveDec2Lay12",
"vs_WaveDecEnv",
"ps_CbaseAbase",
"ps_CalphaAbase",
"ps_CalphaAMult",
"ps_CalphaAadd",
"ps_CaddAbase",
"ps_CaddAMult",
"ps_CaddAAdd",
"ps_CmultAbase",
"ps_CmultAMult",
"ps_CmultAAdd",
"ps_WaveDecEnv",
"vs_WaveGraph2",
"ps_WaveGraph",
"vs_WaveGridFin",
"ps_WaveGrid",
"vs_BiasNormals",
"ps_BiasNormals",
"vs_ShoreLeave7",
"vs_WaveRip7",
"ps_MoreCosines",
"vs_WaveDec1Lay_7",
"vs_WaveDec2Lay11_7",
"vs_WaveDec2Lay12_7",
"vs_WaveDecEnv_7",
"vs_WaveFixedFin7",
"vs_GrassShader",
"ps_GrassShader",
"vs_RiftDistortAssembly",
"ps_RiftDistortAssembly"
};
nameList = kEnumNames;
numNames = kNumEnumNames;
}
else
{
nameList = argv+1;
numNames = argc-1;
}
int i;
for( i = 0; i < numNames; i++ )
{
const char* name = nameList[i];
char varName[512];
strcpy(varName, name);
char* p = strrchr(varName, '.');
if( p )
*p = 0;
char inFile[512];
sprintf(inFile, "%s.inl", varName);
char outFile[512];
sprintf(outFile, "%s.h", varName);
printf("Processing %s into %s\n", name, outFile);
FILE* fp = fopen(outFile, "w");
if( !fp )
{
printf("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n");
printf("Error opening file %s for output\n");
printf("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n");
continue;
}
LPD3DXBUFFER compiledShader = 0L;
LPD3DXBUFFER compilationErrors = 0L;
DWORD flags = 0;
LPD3DXINCLUDE include = 0L;
HRESULT hr = D3DXAssembleShaderFromFile(
inFile,
0L,
include,
flags,
&compiledShader,
&compilationErrors);
if( FAILED(hr) )
{
printf("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n");
printf(compilationErrors ? (char*)compilationErrors->GetBufferPointer() : "File not found");
continue;
}
sprintf(inFile, "sha/%s.inl", varName);
ICreateHeader(varName, inFile, fp, compiledShader);
fclose(fp);
}
return 0;
}
