GBitmap *AtlasTexChunk::loadDDSIntoGBitmap(const U8 *ddsBuffer, U32 ddsBufferSize)
{
D3DXIMAGE_INFO info;
D3D9Assert(GFXD3DX.D3DXGetImageInfoFromFileInMemory(ddsBuffer, ddsBufferSize, &info),
"AtlasTexChunk::loadDDSIntoGBitmap - failed to get image info.");
IDirect3DSurface9 *surf = NULL;
D3D9Assert(((GFXD3D9Device*)GFX)->getDevice()->CreateOffscreenPlainSurface(
info.Width, info.Height, info.Format, D3DPOOL_SCRATCH, &surf, NULL),
"AtlasTexChunk::loadDDSIntoGBitmap - failed to allocate scratch surface.");
// We want JPEGs, let's convert it in a klunky way...
D3D9Assert(GFXD3DX.D3DXLoadSurfaceFromFileInMemory(surf, NULL, NULL,
ddsBuffer, ddsBufferSize, NULL,
D3DX_DEFAULT, 0, NULL),
"AtlasTexChunk::loadDDSIntoGBitmap - D3DX failed to load from buffer.");
ID3DXBuffer *buff = NULL;
D3D9Assert(GFXD3DX.D3DXSaveSurfaceToFileInMemory(&buff, D3DXIFF_PNG, surf, NULL, NULL),
"AtlasTexChunk::loadDDSIntoGBitmap - D3DX failed to save back to buffer.");
MemStream ms(buff->GetBufferSize(), buff->GetBufferPointer(), true, false);
GBitmap *bitmap = new GBitmap[1];
bitmap->readBitmap( "png", ms );
// Cleanup!
buff->Release();
surf->Release();
return bitmap;
}
void AtlasTexChunk::writeDDS(Stream *s)
{
// Load the DDS into a texture, then use D3DX to write it out.
GFXTexHandle tex;
tex.set(dds, &GFXDefaultStaticDiffuseProfile, false, avar("%s - %s", __FUNCTION__, ( const char* ) dds->mSourcePath.getFullPath() ) );
GFXD3D9TextureObject *gdto = (GFXD3D9TextureObject *)tex.getPointer();
// Write to buffer.
ID3DXBuffer *buffer = NULL;
GFXD3DX.D3DXSaveTextureToFileInMemory(&buffer, D3DXIFF_DDS, gdto->getTex(), NULL);
// And write that buffer... to a stream. Ho ho ho!
s->write(buffer->GetBufferSize(), buffer->GetBufferPointer());
}
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
}
fResult f2dRenderDeviceImpl::SaveScreen(f2dStream* pStream)
{
if(m_bDevLost)
return FCYERR_ILLEGAL;
if(!pStream || !pStream->CanWrite() || !pStream->CanResize())
return FCYERR_INVAILDPARAM;
IDirect3DSurface9* pSurface = NULL;
HRESULT tHR = m_pDev->CreateOffscreenPlainSurface(GetBufferWidth(), GetBufferHeight(),
D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &pSurface, NULL);
if(FAILED(tHR))
{
m_pEngine->ThrowException(fcyWin32COMException("f2dRenderDeviceImpl::SaveScreen", "CreateOffscreenPlainSurface Failed.", tHR));
return FCYERR_INTERNALERR;
}
if(FAILED(m_pDev->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &pSurface)))
{
FCYSAFEKILL(pSurface);
return FCYERR_INTERNALERR;
}
ID3DXBuffer* pDataBuffer = NULL;
tHR = m_API.DLLEntry_D3DXSaveSurfaceToFileInMemory(&pDataBuffer, D3DXIFF_PNG, pSurface, NULL, NULL);
FCYSAFEKILL(pSurface);
if(FAILED(tHR))
{
m_pEngine->ThrowException(fcyWin32COMException("f2dRenderDeviceImpl::SaveScreen", "D3DXSaveSurfaceToFileInMemory Failed.", tHR));
return FCYERR_INTERNALERR;
}
// 保存到流
if(FCYFAILED(pStream->WriteBytes((fcData)pDataBuffer->GetBufferPointer(), pDataBuffer->GetBufferSize(), NULL)))
{
FCYSAFEKILL(pDataBuffer);
return FCYERR_INTERNALERR;
}
FCYSAFEKILL(pDataBuffer);
return FCYERR_OK;
}
HRESULT MyCreateEffectFromFile(TCHAR *fName, DWORD dwShaderFlags, ID3D11Device *pDevice, ID3DX11Effect **pEffect)
{
char fNameChar[1024];
CharToOem(fName, fNameChar);
ID3DXBuffer *pShader;
HRESULT hr;
ID3DXBuffer *pErrors;
if (FAILED(D3DXCompileShaderFromFileA(fNameChar, NULL, NULL, NULL, "fx_5_0", 0, &pShader, &pErrors, NULL)))
{
MessageBoxA(NULL, (char *)pErrors->GetBufferPointer(), "Error", MB_OK);
return E_FAIL;
}
V_RETURN(D3DX11CreateEffectFromMemory(pShader->GetBufferPointer(), pShader->GetBufferSize(), dwShaderFlags, pDevice, pEffect));
SAFE_RELEASE(pErrors);
SAFE_RELEASE(pShader);
return S_OK;
}
int l_Image_Save( lua_State* L )
{
ImageData* imgData = lua_checkimage( L, 1 );
const char* fileName = lua_tostring( L, 2 );
if( !imgData || !fileName )
{
lua_pushstring( L, "Wrong parameters to Image_Save functions" );
lua_error( L );
return 0;
}
LPDIRECT3DTEXTURE9 texture;
D3DLOCKED_RECT rect;
D3DFORMAT dxFormat = (D3DFORMAT)imgData->format->d3dformat;
if( dxFormat == D3DFMT_DXT1 || dxFormat == D3DFMT_DXT3 || dxFormat == D3DFMT_DXT5 )
dxFormat = D3DFMT_A8R8G8B8;
g_pd3dDevice->CreateTexture( imgData->width, imgData->height, 1, 0, dxFormat, D3DPOOL_MANAGED, &texture, 0 );
texture->LockRect(0, &rect, 0, 0 );
memcpy( rect.pBits, imgData->imgData, imgData->width * imgData->height * imgData->format->bytesPerPixel );
texture->UnlockRect( 0 );
if( imgData->format->d3dformat == D3DFMT_DXT1 || imgData->format->d3dformat == D3DFMT_DXT3 || imgData->format->d3dformat == D3DFMT_DXT5 )
{
ID3DXBuffer* dxBuffer;
LPDIRECT3DTEXTURE9 outTexture;
D3DXSaveTextureToFileInMemory( &dxBuffer, D3DXIFF_BMP, texture, 0 );
D3DXCreateTextureFromFileInMemoryEx( g_pd3dDevice, dxBuffer->GetBufferPointer(), dxBuffer->GetBufferSize(), imgData->width, imgData->height, 0, 0, (D3DFORMAT)imgData->format->d3dformat, D3DPOOL_SCRATCH, D3DX_DEFAULT, D3DX_DEFAULT, 0, 0, 0, &outTexture );
D3DXSaveTextureToFile( fileName, extToFormat(fileName), outTexture, 0 );
outTexture->Release();
}else
{
D3DXSaveTextureToFile( fileName, extToFormat(fileName), texture, 0 );
}
texture->Release();
return 0;
}
fResult f2dRenderDeviceImpl::SaveTexture(f2dStream* pStream, f2dTexture2D* pTex)
{
if(m_bDevLost)
return FCYERR_ILLEGAL;
if(!pStream || !pTex || !pStream->CanWrite() || !pStream->CanResize())
return FCYERR_INVAILDPARAM;
IDirect3DSurface9* pSurface = NULL;
if(pTex->IsDynamic())
((IDirect3DTexture9*)((f2dTexture2DDynamic*)pTex)->GetHandle())->GetSurfaceLevel(0, &pSurface);
else if(pTex->IsRenderTarget())
{
pSurface = ((f2dTexture2DRenderTarget*)pTex)->GetSurface();
pSurface->AddRef();
}
else
((IDirect3DTexture9*)((f2dTexture2DStatic*)pTex)->GetHandle())->GetSurfaceLevel(0, &pSurface);
if(!pSurface)
return FCYERR_INTERNALERR;
ID3DXBuffer* pDataBuffer = NULL;
HRESULT tHR = m_API.DLLEntry_D3DXSaveSurfaceToFileInMemory(&pDataBuffer, D3DXIFF_PNG, pSurface, NULL, NULL);
FCYSAFEKILL(pSurface);
if(FAILED(tHR))
{
m_pEngine->ThrowException(fcyWin32COMException("f2dRenderDeviceImpl::SaveTexture", "D3DXSaveSurfaceToFileInMemory Failed.", tHR));
return FCYERR_INTERNALERR;
}
// 保存到流
if(FCYFAILED(pStream->WriteBytes((fcData)pDataBuffer->GetBufferPointer(), pDataBuffer->GetBufferSize(), NULL)))
{
FCYSAFEKILL(pDataBuffer);
return FCYERR_INTERNALERR;
}
FCYSAFEKILL(pDataBuffer);
return FCYERR_OK;
}
bool TerrainLodMap2::save( DataSectionPtr parentSection, const std::string& name ) const
{
BW_GUARD;
bool ok = false;
// copy texture to a file buffer in memory
ID3DXBuffer* pBuffer = NULL;
HRESULT hr = D3DXSaveTextureToFileInMemory( &pBuffer, D3DXIFF_DDS,
pLodMap_.pComObject(), NULL );
if (SUCCEEDED(hr))
{
// copy buffer to binary block
BinaryPtr pBlock = new BinaryBlock( pBuffer->GetBufferPointer(),
pBuffer->GetBufferSize(), "BinaryBlock/TerrainPhotographer" );
pBuffer->Release();
// write binary block to data section
ok = parentSection->writeBinary( name, pBlock );
}
return ok;
}
bool StripifyMeshSubset(ID3DXMesh* mesh,
DWORD attribId,
ostream& meshfile)
{
// TODO: Fall back to tri lists if the strip size is too small
// TODO: Detect when a tri fan should be used instead of a tri list
// Convert to tri strips
IDirect3DIndexBuffer9* indices = NULL;
DWORD numIndices = 0;
ID3DXBuffer* strips = NULL;
DWORD numStrips = 0;
HRESULT hr;
hr = D3DXConvertMeshSubsetToStrips(mesh,
attribId,
0,
&indices,
&numIndices,
&strips,
&numStrips);
if (FAILED(hr))
{
cout << "Stripify failed\n";
return false;
}
cout << "Converted to " << numStrips << " strips\n";
cout << "Strip buffer size: " << strips->GetBufferSize() << '\n';
if (numStrips != strips->GetBufferSize() / 4)
{
cout << "Strip count is incorrect!\n";
return false;
}
bool index32 = false;
{
D3DINDEXBUFFER_DESC desc;
indices->GetDesc(&desc);
if (desc.Format == D3DFMT_INDEX32)
{
index32 = true;
}
else if (desc.Format == D3DFMT_INDEX16)
{
index32 = false;
}
else
{
cout << "Bad index format. Strange.\n";
return false;
}
}
void* indexData = NULL;
hr = indices->Lock(0, 0, &indexData, D3DLOCK_READONLY);
if (FAILED(hr))
{
cout << "Failed to lock index buffer: " << D3DErrorString(hr) << '\n';
return false;
}
{
DWORD* stripLengths = reinterpret_cast<DWORD*>(strips->GetBufferPointer());
int k = 0;
for (int i = 0; i < numStrips; i++)
{
if (stripLengths[i] == 0)
{
cout << "Bad triangle strip (length == 0) in mesh!\n";
return false;
}
if (index32)
{
DWORD* indices = reinterpret_cast<DWORD*>(indexData) + k;
int fanStart = checkForFan(stripLengths[i], indices);
if (fanStart != 1)
{
DumpTriStrip(stripLengths[i], indices, (int) attribId,
meshfile);
}
else
{
DumpTriStripAsFan(stripLengths[i], indices, (int) attribId,
fanStart, meshfile);
}
}
else
{
WORD* indices = reinterpret_cast<WORD*>(indexData) + k;
int fanStart = checkForFan(stripLengths[i], indices);
if (fanStart != 1)
{
DumpTriStrip(stripLengths[i], indices, (int) attribId,
meshfile);
}
else
{
DumpTriStripAsFan(stripLengths[i], indices, (int) attribId,
fanStart, meshfile);
}
}
k += stripLengths[i] + 2;
}
cout << "k=" << k << ", numIndices=" << numIndices;
if (index32)
cout << ", 32-bit indices\n";
else
cout << ", 16-bit indices\n";
}
return true;
}
bool DevEffect::GetPrecompiledBinary(
vector<char> &data, const char *id, const char *path, const char *bpath,
vector<D3DXMACRO> ¯os, byte hash[16], vector<byte> &bin)
{
ID3DXEffectCompiler *fxc = NULL;
ID3DXBuffer *binbuff = NULL;
ID3DXBuffer *errors = NULL;
if(_load_scrambled(bpath,*(vector<byte>*)&bin) && bin.size()>16)
{
if(memcmp(&bin[0],hash,16)==0)
{
bin.erase(bin.begin(),bin.begin()+16);
return true;
}
}
for(int pass=0;pass<2;pass++)
{
HRESULT r;
bool error;
if( pass == 0 )
{
r = D3DXCreateEffectCompiler(&data[0],(DWORD)data.size(),¯os[0],NULL,
compile_flags,&fxc,&errors);
error = !fxc;
}
else
{
r = fxc->CompileEffect(compile_flags,&binbuff,&errors);
error = !binbuff;
}
if(FAILED(r) || errors || error)
{
if(errors)
{
last_error = format("%s:%s: %s",path,id,(char*)errors->GetBufferPointer());
if(!(flags&FXF_NO_ERROR_POPUPS))
if(MessageBox(NULL,last_error.c_str(),format("%s:%s",path,id).c_str(),MB_OKCANCEL)==IDCANCEL)
ExitProcess(0);
errors->Release();
if(fxc) fxc->Release();
if(binbuff) binbuff->Release();
return false;
}
else
{
last_error = format("%s:%s: Unknown error!",path,id);
if(!(flags&FXF_NO_ERROR_POPUPS))
if(MessageBox(NULL,last_error.c_str(),format("%s:%s",path,id).c_str(),MB_OKCANCEL)==IDCANCEL)
ExitProcess(0);
if(fxc) fxc->Release();
if(binbuff) binbuff->Release();
return false;
}
}
}
bin.clear();
bin.insert(bin.end(),hash,hash+16);
bin.insert(bin.end(),(byte*)binbuff->GetBufferPointer(),((byte*)binbuff->GetBufferPointer())+binbuff->GetBufferSize());
fxc->Release();
binbuff->Release();
_save_scrambled(bpath,bin);
bin.erase(bin.begin(),bin.begin()+16);
return true;
}
int Dx9Effect::create( gd::GraphicsDevice* device, const void* data, int size )
{
assert( device );
destroy();
m_dev = static_cast<Dx9GraphicsDevice*>( device );
m_dev->resetRenderState();
// compile effect description
ID3DXBuffer* xerr = 0;
D3DXMACRO* defines = 0;
ID3DXInclude* includeLoader = 0;
ID3DXEffectPool* effectPool = 0;
DWORD flags = D3DXSHADER_PACKMATRIX_COLUMNMAJOR;
//#ifdef _DEBUG
flags |= D3DXSHADER_DEBUG;
//#endif
HRESULT hr = D3DXCreateEffect( m_dev->d3dDevice(), data, size, defines, includeLoader, flags, effectPool, &m_fx, &xerr );
// get compilation errors
if ( xerr )
{
if ( hr != D3D_OK )
{
char* xerrmsg = (char*)xerr->GetBufferPointer();
int xerrmsglen = xerr->GetBufferSize();
delete[] m_err; m_err = 0;
m_err = new char[xerrmsglen+1];
m_err[xerrmsglen] = 0;
strncpy( m_err, xerrmsg, xerrmsglen );
}
xerr->Release();
xerr = 0;
}
// report errors
if ( hr != D3D_OK )
{
error( "Failed to compile effect description: %s", m_err );
return gd::ERROR_EFFECTCOMPILATIONERROR;
}
// select technique to be used
D3DXHANDLE tech;
hr = m_fx->FindNextValidTechnique( 0, &tech );
if ( hr != D3D_OK )
{
error( "Dx9Effect.FindNextValidTechnique failed: %s", toString(hr) );
setError( "Effect is not supported by the graphics device." );
return gd::ERROR_EFFECTUNSUPPORTED;
}
// select the technique
hr = m_fx->SetTechnique( tech );
if ( hr != D3D_OK )
{
error( "Dx9Effect.SetTechnique failed: %s", toString(hr) );
setError( "Effect is not supported by the graphics device." );
return gd::ERROR_EFFECTUNSUPPORTED;
}
// enum parameters
D3DXEFFECT_DESC fxDesc;
hr = m_fx->GetDesc( &fxDesc );
m_params = fxDesc.Parameters;
return gd::ERROR_NONE;
}
HRESULT KG3DGraphicsEngine::ScreenShotImpl()
{
HRESULT hResult = E_FAIL;
HRESULT hRetCode = E_FAIL;
IDirect3DSurface9* pFrameSurface = NULL;
IDirect3DTexture9* pTextureSys = NULL;
ID3DXBuffer* pBuffer = NULL;
D3DVIEWPORT9 ViewPort;
RECT RectView;
ASSERT(m_eShotImageType != D3DXIFF_FORCE_DWORD);
hRetCode = g_pd3dDevice->GetRenderTarget(0, &pFrameSurface);
KG_COM_PROCESS_ERROR(hRetCode);
g_pd3dDevice->GetViewport(&ViewPort);
SetRect(&RectView, ViewPort.X, ViewPort.Y, ViewPort.X + ViewPort.Width, ViewPort.Y + ViewPort.Height);
if (m_eShotImageType == D3DXIFF_JPG)
{
D3DSURFACE_DESC SurfaceDesc;
D3DLOCKED_RECT LockRect;
hRetCode = D3DXSaveSurfaceToFileInMemory(&pBuffer, D3DXIFF_BMP, pFrameSurface, NULL, &RectView);
KG_COM_PROCESS_ERROR(hRetCode);
hRetCode = D3DXCreateTextureFromFileInMemoryEx(g_pd3dDevice,
pBuffer->GetBufferPointer(),
pBuffer->GetBufferSize(),
ViewPort.Width,
ViewPort.Height,
1,
0,
D3DFMT_A8R8G8B8,
D3DPOOL_SCRATCH,
D3DX_DEFAULT,
D3DX_DEFAULT,
0,
NULL,
NULL,
&pTextureSys);
KG_COM_PROCESS_ERROR(hRetCode);
/*
hRetCode = D3DXSaveSurfaceToFile(TEXT("__temp_shot.bmp"), D3DXIFF_BMP, pFrameSurface, NULL, &RectView);
KG_COM_PROCESS_ERROR(hRetCode);
hRetCode = D3DXCreateTextureFromFileEx(g_pd3dDevice,
TEXT("__temp_shot.bmp"),
ViewPort.Width,
ViewPort.Height,
1,
0,
D3DFMT_A8R8G8B8,
D3DPOOL_SCRATCH,
D3DX_DEFAULT,
D3DX_DEFAULT,
0,
NULL,
NULL,
&pTextureSys);
KG_COM_PROCESS_ERROR(hRetCode); */
pTextureSys->GetLevelDesc(0, &SurfaceDesc);
if (SUCCEEDED(pTextureSys->LockRect(0, &LockRect, NULL, D3DLOCK_NOSYSLOCK)))
{
struct _Rgba { BYTE r; BYTE g; BYTE b; BYTE a;};
struct _Rgb { BYTE b; BYTE g; BYTE r; };
_Rgb* pRgb = new _Rgb[SurfaceDesc.Height * SurfaceDesc.Width];
for (UINT v = 0; v < SurfaceDesc.Height; ++v)
{
_Rgba* pRgba = (_Rgba*)((BYTE*)LockRect.pBits + LockRect.Pitch * v);
for (UINT u = 0; u < SurfaceDesc.Width; ++u)
{
pRgb[v * SurfaceDesc.Width + u].r = pRgba[u].r;
pRgb[v * SurfaceDesc.Width + u].g = pRgba[u].g;
pRgb[v * SurfaceDesc.Width + u].b = pRgba[u].b;
}
}
JpegFile::RGBToJpegFile(m_szShotPath, (BYTE*)pRgb, SurfaceDesc.Width, SurfaceDesc.Height, TRUE, m_nShotImageQuty);
delete[] pRgb;
pTextureSys->UnlockRect(0);
}
else
{
KG_PROCESS_ERROR(FALSE);
}
}
else
{
hRetCode = D3DXSaveSurfaceToFile(m_szShotPath, m_eShotImageType, pFrameSurface, NULL, &RectView);
KG_COM_PROCESS_ERROR(hRetCode);
}
hResult = S_OK;
Exit0 :
SAFE_RELEASE(pBuffer);
SAFE_RELEASE(pTextureSys);
SAFE_RELEASE(pFrameSurface);
return hResult;
}
/*
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;
}
static HRESULT create_shader (
LPCSTR const pTarget,
DWORD const* buffer,
u32 const buffer_size,
LPCSTR const file_name,
void*& result,
bool const disasm
)
{
HRESULT _result = E_FAIL;
if (pTarget[0] == 'p') {
SPS* sps_result = (SPS*)result;
_result = HW.pDevice->CreatePixelShader(buffer, &sps_result->ps);
if ( !SUCCEEDED(_result) ) {
Log ("! PS: ", file_name);
Msg ("! CreatePixelShader hr == 0x%08x", _result);
return E_FAIL;
}
LPCVOID data = NULL;
_result = D3DXFindShaderComment (buffer,MAKEFOURCC('C','T','A','B'),&data,NULL);
if (SUCCEEDED(_result) && data)
{
LPD3DXSHADER_CONSTANTTABLE pConstants = LPD3DXSHADER_CONSTANTTABLE(data);
sps_result->constants.parse (pConstants,0x1);
}
else
{
Log ("! PS: ", file_name);
Msg ("! D3DXFindShaderComment hr == 0x%08x", _result);
}
}
else {
SVS* svs_result = (SVS*)result;
_result = HW.pDevice->CreateVertexShader(buffer, &svs_result->vs);
if ( !SUCCEEDED(_result) ) {
Log ("! VS: ", file_name);
Msg ("! CreatePixelShader hr == 0x%08x", _result);
return E_FAIL;
}
LPCVOID data = NULL;
_result = D3DXFindShaderComment (buffer,MAKEFOURCC('C','T','A','B'),&data,NULL);
if (SUCCEEDED(_result) && data)
{
LPD3DXSHADER_CONSTANTTABLE pConstants = LPD3DXSHADER_CONSTANTTABLE(data);
svs_result->constants.parse (pConstants,0x2);
}
else
{
Log ("! VS: ", file_name);
Msg ("! D3DXFindShaderComment hr == 0x%08x", _result);
}
}
if (disasm)
{
ID3DXBuffer* disasm = 0;
D3DXDisassembleShader(LPDWORD(buffer), FALSE, 0, &disasm );
string_path dname;
strconcat (sizeof(dname),dname,"disasm\\",file_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;
}
int APIENTRY WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow)
{
WNDCLASS wc;
wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
wc.lpfnWndProc = (WNDPROC) MainWindowProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = hInstance;
wc.hIcon = NULL;
wc.hCursor = LoadCursor(NULL, MAKEINTRESOURCE(IDC_ARROW));
wc.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH);
wc.lpszMenuName = NULL;
wc.lpszClassName = "xtocmod";
if (RegisterClass(&wc) == 0)
{
MessageBox(NULL,
"Failed to register the window class.", "Fatal Error",
MB_OK | MB_ICONERROR);
return NULL;
}
DWORD windowStyle = (WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU |
WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX);
g_mainWindow = CreateWindow("xtocmod",
"xtocmod",
windowStyle,
CW_USEDEFAULT,
CW_USEDEFAULT,
300, 300,
NULL,
NULL,
hInstance,
NULL);
if (g_mainWindow == NULL)
{
MessageBox(NULL,
"Error creating application window.", "Fatal Error",
MB_OK | MB_ICONERROR);
}
//ShowWindow(g_mainWindow, SW_SHOW);
SetForegroundWindow(g_mainWindow);
SetFocus(g_mainWindow);
// Initialize D3D
g_d3d = Direct3DCreate9(D3D_SDK_VERSION);
if (g_d3d == NULL)
{
ShowD3DErrorMessage("Initializing D3D", 0);
return 1;
}
D3DPRESENT_PARAMETERS presentParams;
ZeroMemory(&presentParams, sizeof(presentParams));
presentParams.Windowed = TRUE;
presentParams.SwapEffect = D3DSWAPEFFECT_COPY;
#if 0
presentParams.BackBufferWidth = 300;
presentParams.BackBufferHeight = 300;
presentParams.BackBufferCount = 1;
presentParams.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
presentParams.Windowed = TRUE;
#endif
HRESULT hr = g_d3d->CreateDevice(D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL,
g_mainWindow,
D3DCREATE_HARDWARE_VERTEXPROCESSING,
&presentParams,
&g_d3dDev);
if (FAILED(hr))
{
ShowD3DErrorMessage("Creating D3D device", hr);
//return 1;
}
string inputFilename(lpCmdLine);
string outputFilename(inputFilename, 0, inputFilename.rfind('.'));
outputFilename += ".cmod";
ID3DXMesh* mesh = NULL;
ID3DXBuffer* adjacency = NULL;
ID3DXBuffer* materialBuf = NULL;
ID3DXBuffer* effects = NULL;
DWORD numMaterials;
hr = D3DXLoadMeshFromX(inputFilename.c_str(),
0,
g_d3dDev,
&adjacency,
&materialBuf,
&effects,
&numMaterials,
&mesh);
if (FAILED(hr))
{
ShowD3DErrorMessage("Loading mesh from X file", hr);
return 1;
}
DWORD numVertices = mesh->GetNumVertices();
DWORD numFaces = mesh->GetNumFaces();
cout << "vertices: " << numVertices << '\n';
cout << "faces: " << numFaces << '\n';
cout << "adjacency buffer size: " << adjacency->GetBufferSize() << '\n';
ofstream meshfile(outputFilename.c_str());
// Output the header
meshfile << "#celmodel__ascii\n\n";
cout << "numMaterials=" << numMaterials << '\n';
D3DXMATERIAL* materials = reinterpret_cast<D3DXMATERIAL*>(materialBuf->GetBufferPointer());
for (DWORD mat = 0; mat < numMaterials; mat++)
{
meshfile << "material\n";
meshfile << "diffuse " << materials[mat].MatD3D.Diffuse << '\n';
//meshfile << "emissive " << materials[mat].MatD3D.Emissive << '\n';
meshfile << "specular " << materials[mat].MatD3D.Specular << '\n';
meshfile << "specpower " << materials[mat].MatD3D.Power << '\n';
meshfile << "opacity " << materials[mat].MatD3D.Diffuse.a << '\n';
meshfile << "end_material\n\n";
}
// Vertex format
D3DVERTEXELEMENT9 declElements[MAX_FVF_DECL_SIZE];
hr = mesh->GetDeclaration(declElements);
if (FAILED(hr))
{
ShowD3DErrorMessage("Checking vertex declaration", hr);
return 1;
}
DWORD stride = D3DXGetDeclVertexSize(declElements, 0);
VertexAttribute vertexMap[VertexAttribute::MaxAttribute];
CreateVertexAttributeMap(declElements, vertexMap);
meshfile << "mesh\n\n";
DumpVertexDescription(vertexMap, meshfile);
ID3DXMesh* optMesh = NULL;
ID3DXBuffer* vertexRemap = NULL;
DWORD* faceRemap = new DWORD[numFaces];
DWORD* optAdjacency = new DWORD[numFaces * 3];
hr = mesh->Optimize(D3DXMESHOPT_COMPACT | D3DXMESHOPT_STRIPREORDER,
//D3DXMESHOPT_VERTEXCACHE |
reinterpret_cast<DWORD*>(adjacency->GetBufferPointer()),
optAdjacency,
faceRemap,
&vertexRemap,
&optMesh);
if (FAILED(hr))
{
ShowD3DErrorMessage("Optimize failed: ", hr);
return 1;
}
// Attribute table
DWORD attribTableSize = 0;
hr = optMesh->GetAttributeTable(NULL, &attribTableSize);
if (FAILED(hr))
{
ShowD3DErrorMessage("Querying attribute table size", hr);
return 1;
}
D3DXATTRIBUTERANGE* attribTable = NULL;
if (attribTableSize > 0)
{
attribTable = new D3DXATTRIBUTERANGE[attribTableSize];
hr = optMesh->GetAttributeTable(attribTable, &attribTableSize);
if (FAILED(hr))
{
ShowD3DErrorMessage("Getting attribute table", hr);
return 1;
}
}
cout << "Attribute table size: " << attribTableSize << '\n';
if (attribTableSize == 1)
{
cout << "Attribute id: " << attribTable[0].AttribId << '\n';
}
if (!DumpMeshVertices(optMesh, vertexMap, stride, meshfile))
return 1;
// output the indices
for (DWORD attr = 0; attr < attribTableSize; attr++)
{
StripifyMeshSubset(optMesh, attr, meshfile);
}
meshfile << "\nend_mesh\n";
#if 0
IDirect3DIndexBuffer9* indices = NULL;
hr = mesh->GetIndexBuffer(&indices);
#endif
#if 0
// No message loop required for this app
MSG msg;
GetMessage(&msg, NULL, 0u, 0u);
while (msg.message != WM_QUIT)
{
GetMessage(&msg, NULL, 0u, 0u);
TranslateMessage(&msg);
DispatchMessage(&msg);
}
#endif
return 0;
}
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 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;
if (pDefines) {
// transfer existing defines
for (;;def_it++) {
if (0==pDefines[def_it].Name) break;
defines[def_it] = pDefines[def_it];
}
}
// options
if (o.forceskinw) {
defines[def_it].Name = "SKIN_COLOR";
defines[def_it].Definition = "1";
def_it ++;
}
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 ++;
R_ASSERT (def_it<128);
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 (sizeof(dname),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;
}
